bin/ksh/emacs.c

root/bin/ksh/emacs.c
/*      $NetBSD: emacs.c,v 1.38 2018/05/08 16:37:59 kamil Exp $ */

/*
 *  Emacs-like command line editing and history
 *
 *  created by Ron Natalie at BRL
 *  modified by Doug Kingston, Doug Gwyn, and Lou Salkind
 *  adapted to PD ksh by Eric Gisin
 */
#include <sys/cdefs.h>

#ifndef lint
__RCSID("$NetBSD: emacs.c,v 1.38 2018/05/08 16:37:59 kamil Exp $");
#endif

#include "config.h"
#ifdef EMACS

#include <sys/stat.h>
#include <ctype.h>
#include <locale.h>
#include <stdbool.h>

#include "sh.h"
#include "ksh_dir.h"
#include "edit.h"

static  Area    aedit;
#define AEDIT   &aedit          /* area for kill ring and macro defns */

#undef CTRL                     /* _BSD brain damage */
#define CTRL(x)         ((x) == '?' ? 0x7F : (x) & 0x1F)        /* ASCII */
#define UNCTRL(x)       ((x) == 0x7F ? '?' : (x) | 0x40)        /* ASCII */
#define META(x)         ((x) & 0x7f)
#define ISMETA(x)       (Flag(FEMACSUSEMETA) && ((x) & 0x80))


/* values returned by keyboard functions */
#define KSTD    0
#define KEOL    1               /* ^M, ^J */
#define KINTR   2               /* ^G, ^C */

struct  x_ftab  {
        int             (*xf_func) ARGS((int c));
        const char      *xf_name;
        short           xf_flags;
};

/* index into struct x_ftab x_ftab[] - small is good */
typedef unsigned char Findex;

struct x_defbindings {
        Findex          xdb_func;       /* XFUNC_* */
        unsigned char   xdb_tab;
        unsigned char   xdb_char;
};

#define XF_ARG          1       /* command takes number prefix */
#define XF_NOBIND       2       /* not allowed to bind to function */
#define XF_PREFIX       4       /* function sets prefix */

/* Separator for completion */
#define is_cfs(c)       (c == ' ' || c == '\t' || c == '"' || c == '\'')
#define is_mfs(c)       (!(isalnum((unsigned char)c) || c == '_' || c == '$'))  /* Separator for motion */

# define CHARMASK       0xFF            /* 8-bit character mask */
# define X_NTABS        3               /* normal, meta1, meta2 */
#define X_TABSZ         (CHARMASK+1)    /* size of keydef tables etc */

/* Arguments for do_complete()
 * 0 = enumerate  M-= complete as much as possible and then list
 * 1 = complete   M-Esc
 * 2 = list       M-?
 */
typedef enum { CT_LIST,         /* list the possible completions */
                 CT_COMPLETE,   /* complete to longest prefix */
                 CT_COMPLIST    /* complete and then list (if non-exact) */
        } Comp_type;

/* { from 4.9 edit.h */
/*
 * The following are used for my horizontal scrolling stuff
 */
static char   *xbuf;            /* beg input buffer */
static char   *xend;            /* end input buffer */
static char    *xcp;            /* current position */
static char    *xep;            /* current end */
static char    *xbp;            /* start of visible portion of input buffer */
static char    *xlp;            /* last char visible on screen */
static int      x_adj_ok;
/*
 * we use x_adj_done so that functions can tell
 * whether x_adjust() has been called while they are active.
 */
static int      x_adj_done;

static int      xx_cols;
static int      x_col;
static int      x_displen;
static int      x_arg;          /* general purpose arg */
static int      x_arg_defaulted;/* x_arg not explicitly set; defaulted to 1 */

static int      xlp_valid;
/* end from 4.9 edit.h } */

static  int     x_prefix1 = CTRL('['), x_prefix2 = CTRL('X');
static  char   **x_histp;       /* history position */
static  int     x_nextcmd;      /* for newline-and-next */
static  char    *xmp;           /* mark pointer */
static  Findex   x_last_command;
static  Findex (*x_tab)[X_TABSZ];       /* key definition */
static  char    *(*x_atab)[X_TABSZ];    /* macro definitions */
static  unsigned char   x_bound[(X_TABSZ * X_NTABS + 7) / 8];
#define KILLSIZE        20
static  char    *killstack[KILLSIZE];
static  int     killsp, killtp;
static  int     x_curprefix;
static  char    *macroptr;
static  int     prompt_trunc;
static  int     prompt_skip;

static int      x_ins       ARGS((char *cp));
static void     x_delete    ARGS((int nc, int push));
static int      x_bword     ARGS((void));
static int      x_fword     ARGS((void));
static void     x_goto      ARGS((char *cp));
static void     x_bs        ARGS((int c));
static int      x_size_str  ARGS((char *cp));
static int      x_size      ARGS((int c));
static void     x_zots      ARGS((char *str));
static void     x_zotc      ARGS((int c));
static void     x_load_hist ARGS((char **hp));
static int      x_search    ARGS((char *pat, int sameline, int offset));
static int      x_match     ARGS((char *str, char *pat));
static void     x_redraw    ARGS((int limit));
static void     x_push      ARGS((int nchars));
static char *   x_mapin     ARGS((const char *cp, Area *area));
static char *   x_mapout    ARGS((int c));
static void     x_print     ARGS((int prefix, int key));
static void     x_adjust    ARGS((void));
static void     x_e_ungetc  ARGS((int c));
static int      x_e_getc    ARGS((void));
static void     x_e_putc    ARGS((int c));
static void     x_e_puts    ARGS((const char *s));
static int      x_comment   ARGS((int c));
static int      x_fold_case ARGS((int c));
static char     *x_lastcp ARGS((void));
static void     do_complete ARGS((int flags, Comp_type type));
static int      x_emacs_putbuf  ARGS((const char *s, size_t len));


/* The lines between START-FUNC-TAB .. END-FUNC-TAB are run through a
 * script (emacs-gen.sh) that generates emacs.out which contains:
 *      - function declarations for x_* functions
 *      - defines of the form XFUNC_<name> where <name> is function
 *        name, sans leading x_.
 * Note that the script treats #ifdef and { 0, 0, 0} specially - use with
 * caution.
 */
#include "emacs.out"
static const struct x_ftab x_ftab[] = {
/* @START-FUNC-TAB@ */
        { x_abort,              "abort",                        0 },
        { x_beg_hist,           "beginning-of-history",         0 },
        { x_comp_comm,          "complete-command",             0 },
        { x_comp_file,          "complete-file",                0 },
        { x_complete,           "complete",                     0 },
        { x_del_back,           "delete-char-backward",         XF_ARG },
        { x_del_bword,          "delete-word-backward",         XF_ARG },
        { x_del_char,           "delete-char-forward",          XF_ARG },
        { x_del_fword,          "delete-word-forward",          XF_ARG },
        { x_del_line,           "kill-line",                    0 },
        { x_draw_line,          "redraw",                       0 },
        { x_end_hist,           "end-of-history",               0 },
        { x_end_of_text,        "eot",                          0 },
        { x_enumerate,          "list",                         0 },
        { x_eot_del,            "eot-or-delete",                XF_ARG },
        { x_error,              "error",                        0 },
        { x_goto_hist,          "goto-history",                 XF_ARG },
        { x_ins_string,         "macro-string",                 XF_NOBIND },
        { x_insert,             "auto-insert",                  XF_ARG },
        { x_kill,               "kill-to-eol",                  XF_ARG },
        { x_kill_region,        "kill-region",                  0 },
        { x_list_comm,          "list-command",                 0 },
        { x_list_file,          "list-file",                    0 },
        { x_literal,            "quote",                        0 },
        { x_meta1,              "prefix-1",                     XF_PREFIX },
        { x_meta2,              "prefix-2",                     XF_PREFIX },
        { x_meta_yank,          "yank-pop",                     0 },
        { x_mv_back,            "backward-char",                XF_ARG },
        { x_mv_begin,           "beginning-of-line",            0 },
        { x_mv_bword,           "backward-word",                XF_ARG },
        { x_mv_end,             "end-of-line",                  0 },
        { x_mv_forw,            "forward-char",                 XF_ARG },
        { x_mv_fword,           "forward-word",                 XF_ARG },
        { x_newline,            "newline",                      0 },
        { x_next_com,           "down-history",                 XF_ARG },
        { x_nl_next_com,        "newline-and-next",             0 },
        { x_noop,               "no-op",                        0 },
        { x_prev_com,           "up-history",                   XF_ARG },
        { x_prev_histword,      "prev-hist-word",               XF_ARG },
        { x_search_char_forw,   "search-character-forward",     XF_ARG },
        { x_search_char_back,   "search-character-backward",    XF_ARG },
        { x_search_hist,        "search-history",               0 },
        { x_set_mark,           "set-mark-command",             0 },
        { x_stuff,              "stuff",                        0 },
        { x_stuffreset,         "stuff-reset",                  0 },
        { x_transpose,          "transpose-chars",              0 },
        { x_version,            "version",                      0 },
        { x_xchg_point_mark,    "exchange-point-and-mark",      0 },
        { x_yank,               "yank",                         0 },
        { x_comp_list,          "complete-list",                0 },
        { x_expand,             "expand-file",                  0 },
        { x_fold_capitalize,    "capitalize-word",              XF_ARG },
        { x_fold_lower,         "downcase-word",                XF_ARG },
        { x_fold_upper,         "upcase-word",                  XF_ARG },
        { x_set_arg,            "set-arg",                      XF_NOBIND },
        { x_comment,            "comment",                      0 },
#ifdef SILLY
        { x_game_of_life,       "play-game-of-life",            0 },
#else
        { 0, 0, 0 },
#endif
#ifdef DEBUG
        { x_debug_info,         "debug-info",                   0 },
#else
        { 0, 0, 0 },
        { 0, 0, 0 },
#endif
/* @END-FUNC-TAB@ */
    };

static  struct x_defbindings const x_defbindings[] = {
        { XFUNC_del_back,               0, CTRL('?') },
        { XFUNC_del_bword,              1, CTRL('?') },
        { XFUNC_eot_del,                0, CTRL('D') },
        { XFUNC_del_back,               0, CTRL('H') },
        { XFUNC_del_bword,              1, CTRL('H') },
        { XFUNC_del_bword,              1,      'h'  },
        { XFUNC_mv_bword,               1,      'b'  },
        { XFUNC_mv_fword,               1,      'f'  },
        { XFUNC_del_fword,              1,      'd'  },
        { XFUNC_mv_back,                0, CTRL('B') },
        { XFUNC_mv_forw,                0, CTRL('F') },
        { XFUNC_search_char_forw,       0, CTRL(']') },
        { XFUNC_search_char_back,       1, CTRL(']') },
        { XFUNC_newline,                0, CTRL('M') },
        { XFUNC_newline,                0, CTRL('J') },
        { XFUNC_end_of_text,            0, CTRL('_') },
        { XFUNC_abort,                  0, CTRL('G') },
        { XFUNC_prev_com,               0, CTRL('P') },
        { XFUNC_next_com,               0, CTRL('N') },
        { XFUNC_nl_next_com,            0, CTRL('O') },
        { XFUNC_search_hist,            0, CTRL('R') },
        { XFUNC_beg_hist,               1,      '<'  },
        { XFUNC_end_hist,               1,      '>'  },
        { XFUNC_goto_hist,              1,      'g'  },
        { XFUNC_mv_end,                 0, CTRL('E') },
        { XFUNC_mv_begin,               0, CTRL('A') },
        { XFUNC_draw_line,              0, CTRL('L') },
        { XFUNC_meta1,                  0, CTRL('[') },
        { XFUNC_meta2,                  0, CTRL('X') },
        { XFUNC_kill,                   0, CTRL('K') },
        { XFUNC_yank,                   0, CTRL('Y') },
        { XFUNC_meta_yank,              1,      'y'  },
        { XFUNC_literal,                0, CTRL('^') },
        { XFUNC_comment,                1,      '#'  },
#if defined(BRL) && defined(TIOCSTI)
        { XFUNC_stuff,                  0, CTRL('T') },
#else
        { XFUNC_transpose,              0, CTRL('T') },
#endif
        { XFUNC_complete,               1, CTRL('[') },
        { XFUNC_comp_list,              0, CTRL('I') },
        { XFUNC_comp_list,              1,      '='  },
        { XFUNC_enumerate,              1,      '?'  },
        { XFUNC_expand,                 1,      '*'  },
        { XFUNC_comp_file,              1, CTRL('X') },
        { XFUNC_comp_comm,              2, CTRL('[') },
        { XFUNC_list_comm,              2,      '?'  },
        { XFUNC_list_file,              2, CTRL('Y') },
        { XFUNC_set_mark,               1,      ' '  },
        { XFUNC_kill_region,            0, CTRL('W') },
        { XFUNC_xchg_point_mark,        2, CTRL('X') },
        { XFUNC_version,                0, CTRL('V') },
#ifdef DEBUG
        { XFUNC_debug_info,             1, CTRL('H') },
#endif
        { XFUNC_prev_histword,          1,      '.'  },
        { XFUNC_prev_histword,          1,      '_'  },
        { XFUNC_set_arg,                1,      '0'  },
        { XFUNC_set_arg,                1,      '1'  },
        { XFUNC_set_arg,                1,      '2'  },
        { XFUNC_set_arg,                1,      '3'  },
        { XFUNC_set_arg,                1,      '4'  },
        { XFUNC_set_arg,                1,      '5'  },
        { XFUNC_set_arg,                1,      '6'  },
        { XFUNC_set_arg,                1,      '7'  },
        { XFUNC_set_arg,                1,      '8'  },
        { XFUNC_set_arg,                1,      '9'  },
        { XFUNC_fold_upper,             1,      'U'  },
        { XFUNC_fold_upper,             1,      'u'  },
        { XFUNC_fold_lower,             1,      'L'  },
        { XFUNC_fold_lower,             1,      'l'  },
        { XFUNC_fold_capitalize,        1,      'C'  },
        { XFUNC_fold_capitalize,        1,      'c'  },
        /* These for ansi arrow keys: arguablely shouldn't be here by
         * default, but its simpler/faster/smaller than using termcap
         * entries.
         */
        { XFUNC_meta2,                  1,      '['  },
        { XFUNC_meta2,                  1,      'O'  },
        { XFUNC_prev_com,               2,      'A'  },
        { XFUNC_next_com,               2,      'B'  },
        { XFUNC_mv_forw,                2,      'C'  },
        { XFUNC_mv_back,                2,      'D'  },
};

int
x_emacs(buf, len)
        char *buf;
        size_t len;
{
        int     c;
        const char *p;
        int     i;
        Findex  f;

        xbp = xbuf = buf; xend = buf + len;
        xlp = xcp = xep = buf;
        *xcp = 0;
        xlp_valid = true;
        xmp = NULL;
        x_curprefix = 0;
        macroptr = (char *) 0;
        x_histp = histptr + 1;
        x_last_command = XFUNC_error;

        xx_cols = x_cols;
        x_col = promptlen(prompt, &p);
        prompt_skip = p - prompt;
        prompt_trunc = x_col - (x_cols - 3 - MIN_EDIT_SPACE);
        if (prompt_trunc > 0)
                x_col -= prompt_trunc;
        else
                prompt_trunc = 0;
        x_adj_ok = 1;
        x_displen = xx_cols - 2 - x_col;
        x_adj_done = 0;

        pprompt(prompt, prompt_trunc);

        if (x_nextcmd >= 0) {
                int off = source->line - x_nextcmd;
                if (histptr - histlist >= off)
                        x_load_hist(histptr - off);
                x_nextcmd = -1;
        }

        while (1) {
                x_flush();
                if ((c = x_e_getc()) < 0)
                        return 0;

                if (ISMETA(c)) {
                        c = META(c);
                        x_curprefix = 1;
                }

                f = x_curprefix == -1 ? XFUNC_insert
                        : x_tab[x_curprefix][c&CHARMASK];

                if (!(x_ftab[f].xf_flags & XF_PREFIX)
                    && x_last_command != XFUNC_set_arg)
                {
                        x_arg = 1;
                        x_arg_defaulted = 1;
                }
                i = c | (x_curprefix << 8);
                x_curprefix = 0;
                switch (i = (*x_ftab[f].xf_func)(i))  {
                  case KSTD:
                        if (!(x_ftab[f].xf_flags & XF_PREFIX))
                                x_last_command = f;
                        break;
                  case KEOL:
                        i = xep - xbuf;
                        return i;
                  case KINTR:   /* special case for interrupt */
                        trapsig(SIGINT);
                        x_mode(false);
                        unwind(LSHELL);
                }
        }
}

static int
x_insert(c)
        int c;
{
        char    str[2];

        /*
         *  Should allow tab and control chars.
         */
        if (c == 0)  {
                x_e_putc(BEL);
                return KSTD;
        }
        str[0] = c;
        str[1] = '\0';
        while (x_arg--)
                x_ins(str);
        return KSTD;
}

static int
x_ins_string(c)
        int c;
{
        if (macroptr)   {
                x_e_putc(BEL);
                return KSTD;
        }
        macroptr = x_atab[c>>8][c & CHARMASK];
        if (macroptr && !*macroptr) {
                /* XXX bell? */
                macroptr = (char *) 0;
        }
        return KSTD;
}

static int x_do_ins(const char *cp, int len);

static int
x_do_ins(cp, len)
        const char *cp;
        int len;
{
        if (xep+len >= xend) {
                x_e_putc(BEL);
                return -1;
        }

        memmove(xcp+len, xcp, xep - xcp + 1);
        memmove(xcp, cp, len);
        xcp += len;
        xep += len;
        return 0;
}

static int
x_ins(s)
        char    *s;
{
        char *cp = xcp;
        int     adj = x_adj_done;

        if (x_do_ins(s, strlen(s)) < 0)
                return -1;
        /*
         * x_zots() may result in a call to x_adjust()
         * we want xcp to reflect the new position.
         */
        xlp_valid = false;
        x_lastcp();
        x_adj_ok = (xcp >= xlp);
        x_zots(cp);
        if (adj == x_adj_done)  /* has x_adjust() been called? */
        {
          /* no */
          for (cp = xlp; cp > xcp; )
            x_bs(*--cp);
        }

        x_adj_ok = 1;
        return 0;
}

/*
 * this is used for x_escape() in do_complete()
 */
static int
x_emacs_putbuf(s, len)
        const char *s;
        size_t len;
{
        int rval;

        if ((rval = x_do_ins(s, len)) != 0)
                return (rval);
        return (rval);
}

static int
x_del_back(c)
        int c;
{
        int col = xcp - xbuf;

        if (col == 0)  {
                x_e_putc(BEL);
                return KSTD;
        }
        if (x_arg > col)
                x_arg = col;
        x_goto(xcp - x_arg);
        x_delete(x_arg, false);
        return KSTD;
}

static int
x_del_char(c)
        int c;
{
        int nleft = xep - xcp;

        if (!nleft) {
                x_e_putc(BEL);
                return KSTD;
        }
        if (x_arg > nleft)
                x_arg = nleft;
        x_delete(x_arg, false);
        return KSTD;
}

/* Delete nc chars to the right of the cursor (including cursor position) */
static void
x_delete(nc, push)
        int nc;
        int push;
{
        int     i,j;
        char    *cp;
        
        if (nc == 0)
                return;
        if (xmp != NULL && xmp > xcp) {
                if (xcp + nc > xmp)
                        xmp = xcp;
                else
                        xmp -= nc;
        }

        /*
         * This lets us yank a word we have deleted.
         */
        if (push)
                x_push(nc);

        xep -= nc;
        cp = xcp;
        j = 0;
        i = nc;
        while (i--)  {
                j += x_size(*cp++);
        }
        memmove(xcp, xcp+nc, xep - xcp + 1);    /* Copies the null */
        x_adj_ok = 0;                   /* don't redraw */
        x_zots(xcp);
        /*
         * if we are already filling the line,
         * there is no need to ' ','\b'.
         * But if we must, make sure we do the minimum.
         */
        if ((i = x_displen) > 0)
        {
          j = (j < i) ? j : i;
          i = j;
          while (i--)
            x_e_putc(' ');
          i = j;
          while (i--)
            x_e_putc('\b');
        }
        /*x_goto(xcp);*/
        x_adj_ok = 1;
        xlp_valid = false;
        for (cp = x_lastcp(); cp > xcp; )
                x_bs(*--cp);

        return; 
}

static int
x_del_bword(c)
        int c;
{
        x_delete(x_bword(), true);
        return KSTD;
}

static int
x_mv_bword(c)
        int c;
{
        (void)x_bword();
        return KSTD;
}

static int
x_mv_fword(c)
        int c;
{
        x_goto(xcp + x_fword());
        return KSTD;
}

static int
x_del_fword(c)
        int c;
{
        x_delete(x_fword(), true);
        return KSTD;
}

static int
x_bword()
{
        int     nc = 0;
        char *cp = xcp;

        if (cp == xbuf)  {
                x_e_putc(BEL);
                return 0;
        }
        while (x_arg--)
        {
          while (cp != xbuf && is_mfs(cp[-1]))
          {
            cp--;
            nc++;
          }
          while (cp != xbuf && !is_mfs(cp[-1]))
          {
            cp--;
            nc++;
          }
        }
        x_goto(cp);
        return nc;
}

static int
x_fword()
{
        int     nc = 0;
        char    *cp = xcp;

        if (cp == xep)  {
                x_e_putc(BEL);
                return 0;
        }
        while (x_arg--)
        {
          while (cp != xep && is_mfs(*cp))
          {
            cp++;
            nc++;
          }
          while (cp != xep && !is_mfs(*cp))
          {
            cp++;
            nc++;
          }
        }
        return nc;
}

static void
x_goto(cp)
        char *cp;
{
  if (cp < xbp || cp >= (xbp + x_displen))
  {
    /* we are heading off screen */
    xcp = cp;
    x_adjust();
  }
  else
  {
    if (cp < xcp)               /* move back */
    {
      while (cp < xcp)
        x_bs(*--xcp);
    }
    else
    {
      if (cp > xcp)             /* move forward */
      {
        while (cp > xcp)
          x_zotc(*xcp++);
      }
    }
  }
}

static void
x_bs(c)
        int c;
{
        int i;
        i = x_size(c);
        while (i--)
                x_e_putc('\b');
}

static int
x_size_str(cp)
        char *cp;
{
        int size = 0;
        while (*cp)
                size += x_size(*cp++);
        return size;
}

static int
x_size(c)
        int c;
{
        if (c=='\t')
                return 4;       /* Kludge, tabs are always four spaces. */
        if (iscntrl((unsigned char)c))          /* control char */
                return 2;
        return 1;
}

static void
x_zots(str)
        char *str;
{
  int   adj = x_adj_done;

  x_lastcp();
  while (*str && str < xlp && adj == x_adj_done)
    x_zotc(*str++);
}

static void
x_zotc(c)
        int c;
{
        if (c == '\t')  {
                /*  Kludge, tabs are always four spaces.  */
                x_e_puts("    ");
        } else if (iscntrl((unsigned char)c))  {
                x_e_putc('^');
                x_e_putc(UNCTRL(c));
        } else
                x_e_putc(c);
}

static int
x_mv_back(c)
        int c;
{
        int col = xcp - xbuf;

        if (col == 0)  {
                x_e_putc(BEL);
                return KSTD;
        }
        if (x_arg > col)
                x_arg = col;
        x_goto(xcp - x_arg);
        return KSTD;
}

static int
x_mv_forw(c)
        int c;
{
        int nleft = xep - xcp;

        if (!nleft) {
                x_e_putc(BEL);
                return KSTD;
        }
        if (x_arg > nleft)
                x_arg = nleft;
        x_goto(xcp + x_arg);
        return KSTD;
}

static int
x_search_char_forw(c)
        int c;
{
        char *cp = xcp;

        *xep = '\0';
        c = x_e_getc();
        while (x_arg--) {
            if (c < 0
               || ((cp = (cp == xep) ? NULL : strchr(cp + 1, c)) == NULL
                   && (cp = strchr(xbuf, c)) == NULL))
            {
                    x_e_putc(BEL);
                    return KSTD;
            }
        }
        x_goto(cp);
        return KSTD;
}

static int
x_search_char_back(c)
        int c;
{
        char *cp = xcp, *p;

        c = x_e_getc();
        for (; x_arg--; cp = p)
                for (p = cp; ; ) {
                        if (p-- == xbuf)
                                p = xep;
                        if (c < 0 || p == cp) {
                                x_e_putc(BEL);
                                return KSTD;
                        }
                        if (*p == c)
                                break;
                }
        x_goto(cp);
        return KSTD;
}

static int
x_newline(c)
        int c;
{
        x_e_putc('\r');
        x_e_putc('\n');
        x_flush();
        *xep++ = '\n';
        return KEOL;
}

static int
x_end_of_text(c)
        int c;
{
        return KEOL;
}

static int x_beg_hist(c) int c; { x_load_hist(histlist); return KSTD;}

static int x_end_hist(c) int c; { x_load_hist(histptr); return KSTD;}

static int x_prev_com(c) int c; { x_load_hist(x_histp - x_arg); return KSTD;}

static int x_next_com(c) int c; { x_load_hist(x_histp + x_arg); return KSTD;}
 
/* Goto a particular history number obtained from argument.
 * If no argument is given history 1 is probably not what you
 * want so we'll simply go to the oldest one.
 */
static int
x_goto_hist(c)
        int c;
{
        if (x_arg_defaulted)
                x_load_hist(histlist);
        else
                x_load_hist(histptr + x_arg - source->line);
        return KSTD;
}

static void
x_load_hist(hp)
        char **hp;
{
        int     oldsize;

        if (hp < histlist || hp > histptr) {
                x_e_putc(BEL);
                return;
        }
        x_histp = hp;
        oldsize = x_size_str(xbuf);
        strlcpy(xbuf, *hp, xend - xbuf);
        xbp = xbuf;
        xep = xcp = xbuf + strlen(xbuf);
        xlp_valid = false;
        if (xep > x_lastcp())
          x_goto(xep);
        else
          x_redraw(oldsize);
}

static int
x_nl_next_com(c)
        int     c;
{
        x_nextcmd = source->line - (histptr - x_histp) + 1;
        return (x_newline(c));
}

static int
x_eot_del(c)
        int     c;
{
        if (xep == xbuf && x_arg_defaulted)
                return (x_end_of_text(c));
        else
                return (x_del_char(c));
}

/* reverse incremental history search */
static int
x_search_hist(c)
        int c;
{
        int offset = -1;        /* offset of match in xbuf, else -1 */
        char pat [256+1];       /* pattern buffer */
        char *p = pat;
        Findex f;

        *p = '\0';
        while (1) {
                if (offset < 0) {
                        x_e_puts("\nI-search: ");
                        x_e_puts(pat);
                }
                x_flush();
                if ((c = x_e_getc()) < 0)
                        return KSTD;
                f = x_tab[0][c&CHARMASK];
                if (c == CTRL('['))
                        break;
                else if (f == XFUNC_search_hist)
                        offset = x_search(pat, 0, offset);
                else if (f == XFUNC_del_back) {
                        if (p == pat) {
                                offset = -1;
                                break;
                        }
                        if (p > pat)
                                *--p = '\0';
                        if (p == pat)
                                offset = -1;
                        else
                                offset = x_search(pat, 1, offset);
                        continue;
                } else if (f == XFUNC_insert) {
                        /* add char to pattern */
                        /* overflow check... */
                        if (p >= &pat[sizeof(pat) - 1]) {
                                x_e_putc(BEL);
                                continue;
                        }
                        *p++ = c, *p = '\0';
                        if (offset >= 0) {
                                /* already have partial match */
                                offset = x_match(xbuf, pat);
                                if (offset >= 0) {
                                        x_goto(xbuf + offset + (p - pat) - (*pat == '^'));
                                        continue;
                                }
                        }
                        offset = x_search(pat, 0, offset);
                } else { /* other command */
                        x_e_ungetc(c);
                        break;
                }
        }
        if (offset < 0)
                x_redraw(-1);
        return KSTD;
}

/* search backward from current line */
static int
x_search(pat, sameline, offset)
        char *pat;
        int sameline;
        int offset;
{
        char **hp;
        int i;

        for (hp = x_histp - (sameline ? 0 : 1) ; hp >= histlist; --hp) {
                i = x_match(*hp, pat);
                if (i >= 0) {
                        if (offset < 0)
                                x_e_putc('\n');
                        x_load_hist(hp);
                        x_goto(xbuf + i + strlen(pat) - (*pat == '^'));
                        return i;
                }
        }
        x_e_putc(BEL);
        x_histp = histptr;
        return -1;
}

/* return position of first match of pattern in string, else -1 */
static int
x_match(str, pat)
        char *str, *pat;
{
        if (*pat == '^') {
                return (strncmp(str, pat+1, strlen(pat+1)) == 0) ? 0 : -1;
        } else {
                char *q = strstr(str, pat);
                return (q == NULL) ? -1 : q - str;
        }
}

static int
x_del_line(c)
        int c;
{
        int     i, j;

        *xep = 0;
        i = xep - xbuf;
        j = x_size_str(xbuf);
        xcp = xbuf;
        x_push(i);
        xlp = xbp = xep = xbuf;
        xlp_valid = true;
        *xcp = 0;
        xmp = NULL;
        x_redraw(j);
        return KSTD;
}

static int
x_mv_end(c)
        int c;
{
        x_goto(xep);
        return KSTD;
}

static int
x_mv_begin(c)
        int c;
{
        x_goto(xbuf);
        return KSTD;
}

static int
x_draw_line(c)
        int c;
{
        x_redraw(-1);
        return KSTD;

}

/* Redraw (part of) the line.  If limit is < 0, the everything is redrawn
 * on a NEW line, otherwise limit is the screen column up to which needs
 * redrawing.
 */
static void
x_redraw(limit)
  int limit;
{
        int     i, j;
        char    *cp;
        
        x_adj_ok = 0;
        if (limit == -1)
                x_e_putc('\n');
        else
                x_e_putc('\r');
        x_flush();
        if (xbp == xbuf)
        {
          pprompt(prompt + prompt_skip, 0);
          x_col = promptlen(prompt, (const char **) 0);
        }
        x_displen = xx_cols - 2 - x_col;
        xlp_valid = false;
        cp = x_lastcp();
        x_zots(xbp);
        if (xbp != xbuf || xep > xlp)
          limit = xx_cols;
        if (limit >= 0)
        {
          if (xep > xlp)
            i = 0;                      /* we fill the line */
          else
            i = limit - (xlp - xbp);

          for (j = 0; j < i && x_col < (xx_cols - 2); j++)
            x_e_putc(' ');
          i = ' ';
          if (xep > xlp)                /* more off screen */
          {
            if (xbp > xbuf)
              i = '*';
            else
              i = '>';
          }
          else
            if (xbp > xbuf)
              i = '<';
          x_e_putc(i);
          j++;
          while (j--)
            x_e_putc('\b');
        }
        for (cp = xlp; cp > xcp; )
          x_bs(*--cp);
        x_adj_ok = 1;
        D__(x_flush();)
        return;
}

static int
x_transpose(c)
        int c;
{
        char    tmp;

        /* What transpose is meant to do seems to be up for debate. This
         * is a general summary of the options; the text is abcd with the
         * upper case character or underscore indicating the cursor position:
         *     Who                      Before  After  Before   After
         *     at&t ksh in emacs mode:  abCd    abdC   abcd_    (bell)
         *     at&t ksh in gmacs mode:  abCd    baCd   abcd_    abdc_
         *     gnu emacs:               abCd    acbD   abcd_    abdc_
         * Pdksh currently goes with GNU behavior since I believe this is the
         * most common version of emacs, unless in gmacs mode, in which case
         * it does the at&t ksh gmacs mode.
         * This should really be broken up into 3 functions so users can bind
         * to the one they want.
         */
        if (xcp == xbuf) {
                x_e_putc(BEL);
                return KSTD;
        } else if (xcp == xep || Flag(FGMACS)) {
                if (xcp - xbuf == 1) {
                        x_e_putc(BEL);
                        return KSTD;
                }
                /* Gosling/Unipress emacs style: Swap two characters before the
                 * cursor, do not change cursor position
                 */
                x_bs(xcp[-1]);
                x_bs(xcp[-2]);
                x_zotc(xcp[-1]);
                x_zotc(xcp[-2]);
                tmp = xcp[-1];
                xcp[-1] = xcp[-2];
                xcp[-2] = tmp;
        } else {
                /* GNU emacs style: Swap the characters before and under the
                 * cursor, move cursor position along one.
                 */
                x_bs(xcp[-1]);
                x_zotc(xcp[0]);
                x_zotc(xcp[-1]);
                tmp = xcp[-1];
                xcp[-1] = xcp[0];
                xcp[0] = tmp;
                x_bs(xcp[0]);
                x_goto(xcp + 1);
        }
        return KSTD;
}

static int
x_literal(c)
        int c;
{
        x_curprefix = -1;
        return KSTD;
}

static int
x_meta1(c)
        int c;
{
        x_curprefix = 1;
        return KSTD;
}

static int
x_meta2(c)
        int c;
{
        x_curprefix = 2;
        return KSTD;
}

static int
x_kill(c)
        int c;
{
        int col = xcp - xbuf;
        int lastcol = xep - xbuf;
        int ndel;

        if (x_arg_defaulted)
                x_arg = lastcol;
        else if (x_arg > lastcol)
                x_arg = lastcol;
        ndel = x_arg - col;
        if (ndel < 0) {
                x_goto(xbuf + x_arg);
                ndel = -ndel;
        }
        x_delete(ndel, true);
        return KSTD;
}

static void
x_push(nchars)
        int nchars;
{
        char    *cp = str_nsave(xcp, nchars, AEDIT);
        if (killstack[killsp])
                afree((void *)killstack[killsp], AEDIT);
        killstack[killsp] = cp;
        killsp = (killsp + 1) % KILLSIZE;
}

static int
x_yank(c)
        int c;
{
        if (killsp == 0)
                killtp = KILLSIZE;
        else
                killtp = killsp;
        killtp--;
        if (killstack[killtp] == 0)  {
                x_e_puts("\nnothing to yank");
                x_redraw(-1);
                return KSTD;
        }
        xmp = xcp;
        x_ins(killstack[killtp]);
        return KSTD;
}

static int
x_meta_yank(c)
        int c;
{
        int     len;
        if ((x_last_command != XFUNC_yank && x_last_command != XFUNC_meta_yank)
            || killstack[killtp] == 0) {
                killtp = killsp;
                x_e_puts("\nyank something first");
                x_redraw(-1);
                return KSTD;
        }
        len = strlen(killstack[killtp]);
        x_goto(xcp - len);
        x_delete(len, false);
        do {
                if (killtp == 0)
                        killtp = KILLSIZE - 1;
                else
                        killtp--;
        } while (killstack[killtp] == 0);
        x_ins(killstack[killtp]);
        return KSTD;
}

static int
x_abort(c)
        int c;
{
        /* x_zotc(c); */
        xlp = xep = xcp = xbp = xbuf;
        xlp_valid = true;
        *xcp = 0;
        return KINTR;
}

static int
x_error(c)
        int c;
{
        x_e_putc(BEL);
        return KSTD;
}

static int
x_stuffreset(c)
        int c;
{
#ifdef TIOCSTI
        (void)x_stuff(c);
        return KINTR;
#else
        x_zotc(c);
        xlp = xcp = xep = xbp = xbuf;
        xlp_valid = true;
        *xcp = 0;
        x_redraw(-1);
        return KSTD;
#endif
}

static int
x_stuff(c)
        int c;
{
#if 0 || defined TIOCSTI
        char    ch = c;
        bool    savmode = x_mode(false);

        (void)ioctl(TTY, TIOCSTI, &ch);
        (void)x_mode(savmode);
        x_redraw(-1);
#endif
        return KSTD;
}

static char *
x_mapin(cp, area)
        const char *cp;
        Area *area;
{
        char *new, *op;

        op = new = str_save(cp, area);
        while (*cp)  {
                /* XXX -- should handle \^ escape? */
                if (*cp == '^')  {
                        cp++;
                        if (*cp >= '?') /* includes '?'; ASCII */
                                *op++ = CTRL(*cp);
                        else  {
                                *op++ = '^';
                                cp--;
                        }
                } else
                        *op++ = *cp;
                cp++;
        }
        *op = '\0';

        return new;
}

static char *
x_mapout(c)
        int c;
{
        static char buf[8];
        char *p = buf;

        if (iscntrl((unsigned char)c))  {
                *p++ = '^';
                *p++ = UNCTRL(c);
        } else
                *p++ = c;
        *p = 0;
        return buf;
}

static void
x_print(prefix, key)
        int prefix, key;
{
        if (prefix == 1)
                shprintf("%s", x_mapout(x_prefix1));
        if (prefix == 2)
                shprintf("%s", x_mapout(x_prefix2));

        shprintf("%s = ", x_mapout(key));
        if (x_tab[prefix][key] != XFUNC_ins_string)
                shprintf("%s\n", x_ftab[x_tab[prefix][key]].xf_name);
        else
                shprintf("'%s'\n", x_atab[prefix][key]);
}

int
x_bind(a1, a2, macro, list)
        const char *a1, *a2;
        int macro;              /* bind -m */
        int list;               /* bind -l */
{
        Findex f;
        int prefix, key;
        char *sp = NULL;
        char *m1, *m2;

        if (x_tab == NULL) {
                bi_errorf("cannot bind, not a tty");
                return 1;
        }

        /* List function names */
        if (list) {
                for (f = 0; f < NELEM(x_ftab); f++)
                        if (x_ftab[f].xf_name
                            && !(x_ftab[f].xf_flags & XF_NOBIND))
                                shprintf("%s\n", x_ftab[f].xf_name);
                return 0;
        }

        if (a1 == NULL) {
                for (prefix = 0; prefix < X_NTABS; prefix++)
                        for (key = 0; key < X_TABSZ; key++) {
                                f = x_tab[prefix][key];
                                if (f == XFUNC_insert || f == XFUNC_error
                                    || (macro && f != XFUNC_ins_string))
                                        continue;
                                x_print(prefix, key);
                        }
                return 0;
        }

        m2 = m1 = x_mapin(a1, ATEMP);
        prefix = key = 0;
        for (;; m1++) {
                key = *m1 & CHARMASK;
                if (x_tab[prefix][key] == XFUNC_meta1)
                        prefix = 1;
                else if (x_tab[prefix][key] == XFUNC_meta2)
                        prefix = 2;
                else
                        break;
        }
        afree(m2, ATEMP);

        if (a2 == NULL) {
                x_print(prefix, key);
                return 0;
        }

        if (*a2 == 0)
                f = XFUNC_insert;
        else if (!macro) {
                for (f = 0; f < NELEM(x_ftab); f++)
                        if (x_ftab[f].xf_name
                            && strcmp(x_ftab[f].xf_name, a2) == 0)
                                break;
                if (f == NELEM(x_ftab) || x_ftab[f].xf_flags & XF_NOBIND) {
                        bi_errorf("%s: no such function", a2);
                        return 1;
                }
#if 0           /* This breaks the bind commands that map arrow keys */
                if (f == XFUNC_meta1)
                        x_prefix1 = key;
                if (f == XFUNC_meta2)
                        x_prefix2 = key;
#endif /* 0 */
        } else {
                f = XFUNC_ins_string;
                sp = x_mapin(a2, AEDIT);
        }

        if (x_tab[prefix][key] == XFUNC_ins_string && x_atab[prefix][key])
                afree((void *)x_atab[prefix][key], AEDIT);
        x_tab[prefix][key] = f;
        x_atab[prefix][key] = sp;

        /* Track what the user has bound so x_emacs_keys() won't toast things */
        if (f == XFUNC_insert)
                x_bound[(prefix * X_TABSZ + key) / 8] &=
                        ~(1 << ((prefix * X_TABSZ + key) % 8));
        else
                x_bound[(prefix * X_TABSZ + key) / 8] |=
                        (1 << ((prefix * X_TABSZ + key) % 8));

        return 0;
}

void
x_init_emacs()
{
        size_t i;
        int j;
        char *locale;

        ainit(AEDIT);
        x_nextcmd = -1;

        x_tab = (Findex (*)[X_TABSZ]) alloc(sizeofN(*x_tab, X_NTABS), AEDIT);
        for (j = 0; j < X_TABSZ; j++)
                x_tab[0][j] = XFUNC_insert;
        for (i = 1; i < X_NTABS; i++)
                for (j = 0; j < X_TABSZ; j++)
                        x_tab[i][j] = XFUNC_error;
        for (i = 0; i < NELEM(x_defbindings); i++)
                x_tab[(unsigned char)x_defbindings[i].xdb_tab][x_defbindings[i].xdb_char]
                        = x_defbindings[i].xdb_func;

        x_atab = (char *(*)[X_TABSZ]) alloc(sizeofN(*x_atab, X_NTABS), AEDIT);
        for (i = 1; i < X_NTABS; i++)
                for (j = 0; j < X_TABSZ; j++)
                        x_atab[i][j] = NULL;

        /* Determine if we can translate meta key or use 8-bit AscII 
         * XXX - It would be nice if there was a locale attribute to
         * determine if the locale is 7-bit or not.
         */
        locale = setlocale(LC_CTYPE, NULL);
        if (locale == NULL || !strcmp(locale, "C") || !strcmp(locale, "POSIX"))
                Flag(FEMACSUSEMETA) = 0;
}

static void bind_if_not_bound(int p, int k, int func);

static void
bind_if_not_bound(p, k, func)
        int p, k;
        int func;
{
        /* Has user already bound this key?  If so, don't override it */
        if (x_bound[((p) * X_TABSZ + (k)) / 8]
            & (1 << (((p) * X_TABSZ + (k)) % 8)))
                return;

        x_tab[p][k] = func;
}

void
x_emacs_keys(ec)
        X_chars *ec;
{
        if (ec->erase >= 0) {
                bind_if_not_bound(0, ec->erase, XFUNC_del_back);
                bind_if_not_bound(1, ec->erase, XFUNC_del_bword);
        }
        if (ec->kill >= 0)
                bind_if_not_bound(0, ec->kill, XFUNC_del_line);
        if (ec->werase >= 0)
                bind_if_not_bound(0, ec->werase, XFUNC_del_bword);
        if (ec->intr >= 0)
                bind_if_not_bound(0, ec->intr, XFUNC_abort);
        if (ec->quit >= 0)
                bind_if_not_bound(0, ec->quit, XFUNC_noop);
}

static int
x_set_mark(c)
        int c;
{
        xmp = xcp;
        return KSTD;
}

static int
x_kill_region(c)
        int c;
{
        int     rsize;
        char    *xr;

        if (xmp == NULL) {
                x_e_putc(BEL);
                return KSTD;
        }
        if (xmp > xcp) {
                rsize = xmp - xcp;
                xr = xcp;
        } else {
                rsize = xcp - xmp;
                xr = xmp;
        }
        x_goto(xr);
        x_delete(rsize, true);
        xmp = xr;
        return KSTD;
}

static int
x_xchg_point_mark(c)
        int c;
{
        char    *tmp;

        if (xmp == NULL) {
                x_e_putc(BEL);
                return KSTD;
        }
        tmp = xmp;
        xmp = xcp;
        x_goto( tmp );
        return KSTD;
}

static int
x_version(c)
        int c;
{
        char *o_xbuf = xbuf, *o_xend = xend;
        char *o_xbp = xbp, *o_xep = xep, *o_xcp = xcp;
        int lim = x_lastcp() - xbp;

        xbuf = xbp = xcp = ksh_version + 4;
        xend = xep = ksh_version + 4 + strlen(ksh_version + 4);
        x_redraw(lim);
        x_flush();

        c = x_e_getc();
        xbuf = o_xbuf;
        xend = o_xend;
        xbp = o_xbp;
        xep = o_xep;
        xcp = o_xcp;
        x_redraw(strlen(ksh_version));

        if (c < 0)
                return KSTD;
        /* This is what at&t ksh seems to do...  Very bizarre */
        if (c != ' ')
                x_e_ungetc(c);

        return KSTD;
}

static int
x_noop(c)
        int c;
{
        return KSTD;
}

#ifdef SILLY
static int
x_game_of_life(c)
        int c;
{
        char    newbuf [256+1];
        char    *ip, *op;
        int     i, len;

        i = xep - xbuf;
        *xep = 0;
        len = x_size_str(xbuf);
        xcp = xbp = xbuf;
        memmove(newbuf+1, xbuf, i);
        newbuf[0] = 'A';
        newbuf[i] = 'A';
        for (ip = newbuf+1, op = xbuf; --i >= 0; ip++, op++)  {
                /*  Empty space  */
                if (*ip < '@' || *ip == '_' || *ip == 0x7F)  {
                        /*  Two adults, make whoopee */
                        if (ip[-1] < '_' && ip[1] < '_')  {
                                /*  Make kid look like parents.  */
                                *op = '`' + ((ip[-1] + ip[1])/2)%32;
                                if (*op == 0x7F) /* Birth defect */
                                        *op = '`';
                        }
                        else
                                *op = ' ';      /* nothing happens */
                        continue;
                }
                /*  Child */
                if (*ip > '`')  {
                        /*  All alone, dies  */
                        if (ip[-1] == ' ' && ip[1] == ' ')
                                *op = ' ';
                        else    /*  Gets older */
                                *op = *ip-'`'+'@';
                        continue;
                }
                /*  Adult  */
                /*  Overcrowded, dies */
                if (ip[-1] >= '@' && ip[1] >= '@')  {
                        *op = ' ';
                        continue;
                }
                *op = *ip;
        }
        *op = 0;
        x_redraw(len);
        return KSTD;
}
#endif

/*
 *      File/command name completion routines
 */


static int
x_comp_comm(c)
        int c;
{
        do_complete(XCF_COMMAND, CT_COMPLETE);
        return KSTD;
}
static int
x_list_comm(c)
        int c;
{
        do_complete(XCF_COMMAND, CT_LIST);
        return KSTD;
}
static int
x_complete(c)
        int c;
{
        do_complete(XCF_COMMAND_FILE, CT_COMPLETE);
        return KSTD;
}
static int
x_enumerate(c)
        int c;
{
        do_complete(XCF_COMMAND_FILE, CT_LIST);
        return KSTD;
}
static int
x_comp_file(c)
        int c;
{
        do_complete(XCF_FILE, CT_COMPLETE);
        return KSTD;
}
static int
x_list_file(c)
        int c;
{
        do_complete(XCF_FILE, CT_LIST);
        return KSTD;
}
static int
x_comp_list(c)
        int c;
{
        do_complete(XCF_COMMAND_FILE, CT_COMPLIST);
        return KSTD;
}
static int
x_expand(c)
        int c;
{
        char **words;
        int nwords = 0;
        int start, end;
        int is_command;
        int i;

        nwords = x_cf_glob(XCF_FILE,
                xbuf, xep - xbuf, xcp - xbuf,
                &start, &end, &words, &is_command);

        if (nwords == 0) {
                x_e_putc(BEL);
                return KSTD;
        }

        x_goto(xbuf + start);
        x_delete(end - start, false);
        for (i = 0; i < nwords;) {
                if (x_escape(words[i], strlen(words[i]), x_emacs_putbuf) < 0 ||
                    (++i < nwords && x_ins(space) < 0))
                {
                        x_e_putc(BEL);
                        return KSTD;
                }
        }
        x_adjust();

        return KSTD;
}

/* type == 0 for list, 1 for complete and 2 for complete-list */
static void
do_complete(flags, type)
        int flags;      /* XCF_{COMMAND,FILE,COMMAND_FILE} */
        Comp_type type;
{
        char **words;
        int nwords;
        int start, end, nlen, olen;
        int is_command;
        int completed = 0;

        nwords = x_cf_glob(flags, xbuf, xep - xbuf, xcp - xbuf,
                            &start, &end, &words, &is_command);
        /* no match */
        if (nwords == 0) {
                x_e_putc(BEL);
                return;
        }

        if (type == CT_LIST) {
                x_print_expansions(nwords, words, is_command);
                x_redraw(0);
                x_free_words(nwords, words);
                return;
        }

        olen = end - start;
        nlen = x_longest_prefix(nwords, words);
        /* complete */
        if (nwords == 1 || nlen > olen) {
                x_goto(xbuf + start);
                x_delete(olen, false);
                x_escape(words[0], nlen, x_emacs_putbuf);
                x_adjust();
                completed = 1;
        }
        /* add space if single non-dir match */
        if ((nwords == 1) && (!ISDIRSEP(words[0][nlen - 1]))) {
                x_ins(space);
                completed = 1;
        }

        if (type == CT_COMPLIST && !completed) {
                x_print_expansions(nwords, words, is_command);
                completed = 1;
        }

        if (completed)  
                x_redraw(0);    

        x_free_words(nwords, words);
}

/* NAME:
 *      x_adjust - redraw the line adjusting starting point etc.
 *
 * DESCRIPTION:
 *      This function is called when we have exceeded the bounds
 *      of the edit window.  It increments x_adj_done so that
 *      functions like x_ins and x_delete know that we have been
 *      called and can skip the x_bs() stuff which has already
 *      been done by x_redraw.
 *
 * RETURN VALUE:
 *      None
 */

static void
x_adjust()
{
  x_adj_done++;                 /* flag the fact that we were called. */
  /*
   * we had a problem if the prompt length > xx_cols / 2
   */
  if ((xbp = xcp - (x_displen / 2)) < xbuf)
    xbp = xbuf;
  xlp_valid = false;
  x_redraw(xx_cols);
  x_flush();
}

static int unget_char = -1;

static void
x_e_ungetc(c)
        int c;
{
        unget_char = c;
}

static int
x_e_getc()
{
        int c;
        
        if (unget_char >= 0) {
                c = unget_char;
                unget_char = -1;
        } else {
                if (macroptr)  {
                        c = (unsigned char) *macroptr++;
                        if (!*macroptr)
                                macroptr = (char *) 0;
                } else
                        c = x_getc();
        }

        return c <= CHARMASK ? c : (c & CHARMASK);
}

static void
x_e_putc(c)
        int c;
{
  if (c == '\r' || c == '\n')
    x_col = 0;
  if (x_col < xx_cols)
  {
    x_putc(c);
    switch(c)
    {
    case BEL:
      break;
    case '\r':
    case '\n':
    break;
    case '\b':
      x_col--;
      break;
    default:
      x_col++;
      break;
    }
  }
  if (x_adj_ok && (x_col < 0 || x_col >= (xx_cols - 2)))
  {
    x_adjust();
  }
}

#ifdef DEBUG
static int
x_debug_info(c)
        int c;
{
        x_flush();
        shellf("\nksh debug:\n");
        shellf("\tx_col == %d,\t\tx_cols == %d,\tx_displen == %d\n",
                 x_col, xx_cols, x_displen);
        shellf("\txcp == 0x%lx,\txep == 0x%lx\n", (long) xcp, (long) xep);
        shellf("\txbp == 0x%lx,\txbuf == 0x%lx\n", (long) xbp, (long) xbuf);
        shellf("\txlp == 0x%lx\n", (long) xlp);
        shellf("\txlp == 0x%lx\n", (long) x_lastcp());
        shellf(newline);
        x_redraw(-1);
        return 0;
}
#endif

static void
x_e_puts(s)
        const char *s;
{
  int   adj = x_adj_done;

  while (*s && adj == x_adj_done)
    x_e_putc(*s++);
}

/* NAME:
 *      x_set_arg - set an arg value for next function
 *
 * DESCRIPTION:
 *      This is a simple implementation of M-[0-9].
 *
 * RETURN VALUE:
 *      KSTD
 */

static int
x_set_arg(c)
        int c;
{
        int n = 0;
        int first = 1;

        c &= CHARMASK;  /* strip command prefix */
        for (; c >= 0 && isdigit(c); c = x_e_getc(), first = 0)
                n = n * 10 + (c - '0');
        if (c < 0 || first) {
                x_e_putc(BEL);
                x_arg = 1;
                x_arg_defaulted = 1;
        } else {
                x_e_ungetc(c);
                x_arg = n;
                x_arg_defaulted = 0;
        }
        return KSTD;
}


/* Comment or uncomment the current line. */
static int
x_comment(c)
        int c;
{
        int oldsize = x_size_str(xbuf);
        int len = xep - xbuf;
        int ret = x_do_comment(xbuf, xend - xbuf, &len);

        if (ret < 0)
                x_e_putc(BEL);
        else {
                xep = xbuf + len;
                *xep = '\0';
                xcp = xbp = xbuf;
                x_redraw(oldsize);
                if (ret > 0)
                        return x_newline('\n');
        }
        return KSTD;
}


/* NAME:
 *      x_prev_histword - recover word from prev command
 *
 * DESCRIPTION:
 *      This function recovers the last word from the previous
 *      command and inserts it into the current edit line.  If a
 *      numeric arg is supplied then the n'th word from the
 *      start of the previous command is used.
 *
 *      Bound to M-.
 *
 * RETURN VALUE:
 *      KSTD
 */

static int
x_prev_histword(c)
        int c;
{
  char *rcp;
  char *cp;

  cp = *histptr;
  if (!cp)
    x_e_putc(BEL);
  else if (x_arg_defaulted) {
    rcp = &cp[strlen(cp) - 1];
    /*
     * ignore white-space after the last word
     */
    while (rcp > cp && is_cfs(*rcp))
      rcp--;
    while (rcp > cp && !is_cfs(*rcp))
      rcp--;
    if (is_cfs(*rcp))
      rcp++;
    x_ins(rcp);
  } else {
    int i;

    rcp = cp;
    /*
     * ignore white-space at start of line
     */
    while (*rcp && is_cfs(*rcp))
      rcp++;
    while (x_arg-- > 1)
    {
      while (*rcp && !is_cfs(*rcp))
        rcp++;
      while (*rcp && is_cfs(*rcp))
        rcp++;
    }
    cp = rcp;
    while (*rcp && !is_cfs(*rcp))
      rcp++;
    i = *rcp;
    *rcp = '\0';
    x_ins(cp);
    *rcp = i;
  }
  return KSTD;
}

/* Uppercase N(1) words */
static int
x_fold_upper(c)
  int c;
{
        return x_fold_case('U');
}

/* Lowercase N(1) words */
static int
x_fold_lower(c)
  int c;
{
        return x_fold_case('L');
}

/* Lowercase N(1) words */
static int
x_fold_capitalize(c)
  int c;
{
        return x_fold_case('C');
}

/* NAME:
 *      x_fold_case - convert word to UPPER/lower/Capital case
 *
 * DESCRIPTION:
 *      This function is used to implement M-U,M-u,M-L,M-l,M-C and M-c
 *      to UPPER case, lower case or Capitalize words.
 *
 * RETURN VALUE:
 *      None
 */

static int
x_fold_case(c)
        int c;
{
        char *cp = xcp;
        
        if (cp == xep) {
                x_e_putc(BEL);
                return KSTD;
        }
        while (x_arg--) {
                /*
                 * first skip over any white-space
                 */
                while (cp != xep && is_mfs(*cp))
                        cp++;
                /*
                 * do the first char on its own since it may be
                 * a different action than for the rest.
                 */
                if (cp != xep) {
                        if (c == 'L') {         /* lowercase */
                                if (isupper((unsigned char)*cp))
                                        *cp = tolower((unsigned char)*cp);
                        } else {                /* uppercase, capitialize */
                                if (islower((unsigned char)*cp))
                                        *cp = toupper((unsigned char)*cp);
                        }
                        cp++;
                }
                /*
                 * now for the rest of the word
                 */
                while (cp != xep && !is_mfs((unsigned char)*cp)) {
                        if (c == 'U') {         /* uppercase */
                                if (islower((unsigned char)*cp))
                                        *cp = toupper((unsigned char)*cp);
                        } else {                /* lowercase, capitialize */
                                if (isupper((unsigned char)*cp))
                                        *cp = tolower((unsigned char)*cp);
                        }
                        cp++;
                }
        }
        x_goto(cp);
        return KSTD;
}

/* NAME:
 *      x_lastcp - last visible char
 *
 * SYNOPSIS:
 *      x_lastcp()
 *
 * DESCRIPTION:
 *      This function returns a pointer to that  char in the
 *      edit buffer that will be the last displayed on the
 *      screen.  The sequence:
 *
 *      for (cp = x_lastcp(); cp > xcp; cp)
 *        x_bs(*--cp);
 *
 *      Will position the cursor correctly on the screen.
 *
 * RETURN VALUE:
 *      cp or NULL
 */

static char *
x_lastcp()
{
  char *rcp;
  int i;

  if (!xlp_valid)
  {
    for (i = 0, rcp = xbp; rcp < xep && i < x_displen; rcp++)
      i += x_size(*rcp);
    xlp = rcp;
  }
  xlp_valid = true;
  return (xlp);
}

#endif /* EDIT */