source: trunk/third/tcsh/tw.parse.c @ 12039

/* $Header: /afs/dev.mit.edu/source/repository/third/tcsh/tw.parse.c,v 1.1.1.2 1998-10-03 21:10:22 danw Exp $ */
/*
 * tw.parse.c: Everyone has taken a shot in this futile effort to
 *             lexically analyze a csh line... Well we cannot good
 *             a job as good as sh.lex.c; but we try. Amazing that
 *             it works considering how many hands have touched this code
 */
/*-
 * Copyright (c) 1980, 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "sh.h"

RCSID("$Id: tw.parse.c,v 1.1.1.2 1998-10-03 21:10:22 danw Exp $")

#include "tw.h"
#include "ed.h"
#include "tc.h"

#ifdef WINNT
#include "nt.const.h"
#endif /* WINNT */
#define EVEN(x) (((x) & 1) != 1)

#define DOT_NONE        0       /* Don't display dot files              */
#define DOT_NOT         1       /* Don't display dot or dot-dot         */
#define DOT_ALL         2       /* Display all dot files                */

/*  TW_NONE,           TW_COMMAND,     TW_VARIABLE,    TW_LOGNAME,      */
/*  TW_FILE,           TW_DIRECTORY,   TW_VARLIST,     TW_USER,         */
/*  TW_COMPLETION,     TW_ALIAS,       TW_SHELLVAR,    TW_ENVVAR,       */
/*  TW_BINDING,        TW_WORDLIST,    TW_LIMIT,       TW_SIGNAL        */
/*  TW_JOB,            TW_EXPLAIN,     TW_TEXT,        TW_GRPNAME       */
static void (*tw_start_entry[]) __P((DIR *, Char *)) = {
    tw_file_start,     tw_cmd_start,   tw_var_start,   tw_logname_start, 
    tw_file_start,     tw_file_start,  tw_vl_start,    tw_logname_start, 
    tw_complete_start, tw_alias_start, tw_var_start,   tw_var_start,     
    tw_bind_start,     tw_wl_start,    tw_limit_start, tw_sig_start,
    tw_job_start,      tw_file_start,  tw_file_start,  tw_grpname_start
};

static Char * (*tw_next_entry[]) __P((Char *, int *)) = {
    tw_file_next,      tw_cmd_next,    tw_var_next,    tw_logname_next,  
    tw_file_next,      tw_file_next,   tw_var_next,    tw_logname_next,  
    tw_var_next,       tw_var_next,    tw_shvar_next,  tw_envvar_next,   
    tw_bind_next,      tw_wl_next,     tw_limit_next,  tw_sig_next,
    tw_job_next,       tw_file_next,   tw_file_next,   tw_grpname_next
};

static void (*tw_end_entry[]) __P((void)) = {
    tw_dir_end,        tw_dir_end,     tw_dir_end,    tw_logname_end,
    tw_dir_end,        tw_dir_end,     tw_dir_end,    tw_logname_end, 
    tw_dir_end,        tw_dir_end,     tw_dir_end,    tw_dir_end,
    tw_dir_end,        tw_dir_end,     tw_dir_end,    tw_dir_end,
    tw_dir_end,        tw_dir_end,     tw_dir_end,    tw_grpname_end
};

/* #define TDEBUG */

/* Set to TRUE if recexact is set and an exact match is found
 * along with other, longer, matches.
 */

int curchoice = -1;

int match_unique_match = FALSE;
int non_unique_match = FALSE;
static bool SearchNoDirErr = 0; /* t_search returns -2 if dir is unreadable */

/* state so if a completion is interrupted, the input line doesn't get
   nuked */
int InsideCompletion = 0;

/* do the expand or list on the command line -- SHOULD BE REPLACED */

extern Char NeedsRedraw;        /* from ed.h */
extern int Tty_raw_mode;
extern int TermH;               /* from the editor routines */
extern int lbuffed;             /* from sh.print.c */

static  void     extract_dir_and_name   __P((Char *, Char *, Char *));
static  int      insert_meta            __P((Char *, Char *, Char *, bool));
static  Char    *tilde                  __P((Char *, Char *));
static  int      expand_dir             __P((Char *, Char *, DIR  **, COMMAND));
static  bool     nostat                 __P((Char *));
static  Char     filetype               __P((Char *, Char *));
static  int      t_glob                 __P((Char ***, int));
static  int      c_glob                 __P((Char ***));
static  int      is_prefix              __P((Char *, Char *));
static  int      is_prefixmatch         __P((Char *, Char *, int));
static  int      is_suffix              __P((Char *, Char *));
static  int      recognize              __P((Char *, Char *, int, int, int));
static  int      ignored                __P((Char *));
static  int      isadirectory           __P((Char *, Char *));
static  int      tw_collect_items       __P((COMMAND, int, Char *, Char *, 
                                             Char *, Char *, int));
static  int      tw_collect             __P((COMMAND, int, Char *, Char *, 
                                             Char **, Char *, int, DIR *));
static  Char     tw_suffix              __P((int, Char *, Char *, Char *, 
                                             Char *));
static  void     tw_fixword             __P((int, Char *, Char *, Char *, int));
static  void     tw_list_items          __P((int, int, int));
static  void     add_scroll_tab         __P((Char *));
static  void     choose_scroll_tab      __P((Char **, int));
static  void     free_scroll_tab        __P((void));
static  int      find_rows              __P((Char *[], int, int));

#ifdef notdef
/*
 * If we find a set command, then we break a=b to a= and word becomes
 * b else, we don't break a=b. [don't use that; splits words badly and
 * messes up tw_complete()]
 */
#define isaset(c, w) ((w)[-1] == '=' && \
                      ((c)[0] == 's' && (c)[1] == 'e' && (c)[2] == 't' && \
                       ((c[3] == ' ' || (c)[3] == '\t'))))
#endif

#define QLINESIZE (INBUFSIZE + 1)

/* TRUE if character must be quoted */
#define tricky(w) (cmap(w, _META | _DOL | _QF | _QB | _ESC | _GLOB) && w != '#')
/* TRUE if double quotes don't protect character */
#define tricky_dq(w) (cmap(w, _DOL | _QB))

/* tenematch():
 *      Return:
 *              > 1:    No. of items found
 *              = 1:    Exactly one match / spelling corrected
 *              = 0:    No match / spelling was correct
 *              < 0:    Error (incl spelling correction impossible)
 */
int
tenematch(inputline, num_read, command)
    Char   *inputline;          /* match string prefix */
    int     num_read;           /* # actually in inputline */
    COMMAND command;            /* LIST or RECOGNIZE or PRINT_HELP */

{
    Char    qline[QLINESIZE];
    Char    qu = 0, *pat = STRNULL;
    Char   *str_end, *cp, *wp, *wordp;
    Char   *cmd_start, *word_start, *word;
    Char   *ocmd_start = NULL, *oword_start = NULL, *oword = NULL;
    int     suf = 0;
    int     space_left;
    int     looking;            /* what we are looking for              */
    int     search_ret;         /* what search returned for debugging   */
    int     backq = 0;

    if (num_read > QLINESIZE - 1)
        return -1;
    str_end = &inputline[num_read];

    word_start = inputline;
    word = cmd_start = wp = qline;
    for (cp = inputline; cp < str_end; cp++) {
        if (!cmap(qu, _ESC)) {
            if (cmap(*cp, _QF|_ESC)) {
                if (qu == 0 || qu == *cp) {
                    qu ^= *cp;
                    continue;
                }
            }
            if (qu != '\'' && cmap(*cp, _QB)) {
                if ((backq ^= 1) != 0) {
                    ocmd_start = cmd_start;
                    oword_start = word_start;
                    oword = word;
                    word_start = cp + 1;
                    word = cmd_start = wp + 1;
                }
                else {
                    cmd_start = ocmd_start;
                    word_start = oword_start;
                    word = oword;
                }
                *wp++ = *cp;
                continue;
            }
        }
        if (iscmdmeta(*cp))
            cmd_start = wp + 1;

        /* Don't quote '/' to make the recognize stuff work easily */
        /* Don't quote '$' in double quotes */

        if (cmap(*cp, _ESC) && cp < str_end - 1 && cp[1] == HIST)
          *wp = *++cp | QUOTE;
        else if (qu && (tricky(*cp) || *cp == '~') && !(qu == '\"' && tricky_dq(*cp)))
          *wp = *cp | QUOTE;
        else
          *wp = *cp;
        if (ismetahash(*wp) /* || isaset(cmd_start, wp + 1) */)
            word = wp + 1, word_start = cp + 1;
        wp++;
        if (cmap(qu, _ESC))
            qu = 0;
      }
    *wp = 0;

#ifdef masscomp
    /*
     * Avoid a nasty message from the RTU 4.1A & RTU 5.0 compiler concerning
     * the "overuse of registers". According to the compiler release notes,
     * incorrect code may be produced unless the offending expression is
     * rewritten. Therefore, we can't just ignore it, DAS DEC-90.
     */
    space_left = QLINESIZE - 1;
    space_left -= word - qline;
#else
    space_left = QLINESIZE - 1 - (word - qline);
#endif

    /*
     *  SPECIAL HARDCODED COMPLETIONS:
     *    first word of command       -> TW_COMMAND
     *    everything else             -> TW_ZERO
     *
     */
    looking = starting_a_command(word - 1, qline) ? 
        TW_COMMAND : TW_ZERO;

    wordp = word;

#ifdef TDEBUG
    xprintf(CGETS(30, 1, "starting_a_command %d\n"), looking);
    xprintf("\ncmd_start:%S:\n", cmd_start);
    xprintf("qline:%S:\n", qline);
    xprintf("qline:");
    for (wp = qline; *wp; wp++)
        xprintf("%c", *wp & QUOTE ? '-' : ' ');
    xprintf(":\n");
    xprintf("word:%S:\n", word);
    xprintf("word:");
    /* Must be last, so wp is still pointing to the end of word */
    for (wp = word; *wp; wp++)
        xprintf("%c", *wp & QUOTE ? '-' : ' ');
    xprintf(":\n");
#endif

    if ((looking == TW_COMMAND || looking == TW_ZERO) &&
        (command == RECOGNIZE || command == LIST || command == SPELL ||
         command == RECOGNIZE_SCROLL)) {
#ifdef TDEBUG
        xprintf(CGETS(30, 2, "complete %d "), looking);
#endif
        looking = tw_complete(cmd_start, &wordp, &pat, looking, &suf);
#ifdef TDEBUG
        xprintf(CGETS(30, 3, "complete %d %S\n"), looking, pat);
#endif
    }

    switch (command) {
        Char    buffer[FILSIZ + 1], *bptr;
        Char   *slshp;
        Char   *items[2], **ptr;
        int     i, count;

    case RECOGNIZE:
    case RECOGNIZE_SCROLL:
    case RECOGNIZE_ALL:
        if (adrof(STRautocorrect)) {
            if ((slshp = Strrchr(wordp, '/')) != NULL && slshp[1] != '\0') {
                SearchNoDirErr = 1;
                for (bptr = wordp; bptr < slshp; bptr++) {
                    /*
                     * do not try to correct spelling of words containing
                     * globbing characters
                     */
                    if (isglob(*bptr)) {
                        SearchNoDirErr = 0;
                        break;
                    }
                }
            }
        }
        else
            slshp = STRNULL;
        search_ret = t_search(wordp, wp, command, space_left, looking, 1, 
                              pat, suf);
        SearchNoDirErr = 0;

        if (search_ret == -2) {
            Char    rword[FILSIZ + 1];

            (void) Strcpy(rword, slshp);
            if (slshp != STRNULL)
                *slshp = '\0';
            search_ret = spell_me(wordp, QLINESIZE - (wordp - qline), looking,
                                  pat, suf);
            if (search_ret == 1) {
                (void) Strcat(wordp, rword);
                wp = wordp + (int) Strlen(wordp);
                search_ret = t_search(wordp, wp, command, space_left,
                                      looking, 1, pat, suf);
            }
        }
        if (*wp && insert_meta(word_start, str_end, word, !qu) < 0)
            return -1;          /* error inserting */
        return search_ret;

    case SPELL:
        for (bptr = word_start; bptr < str_end; bptr++) {
            /*
             * do not try to correct spelling of words containing globbing
             * characters
             */
            if (isglob(*bptr))
                return 0;
        }
        search_ret = spell_me(wordp, QLINESIZE - (wordp - qline), looking,
                              pat, suf);
        if (search_ret == 1) {
            if (insert_meta(word_start, str_end, word, !qu) < 0)
                return -1;              /* error inserting */
        }
        return search_ret;

    case PRINT_HELP:
        do_help(cmd_start);
        return 1;

    case GLOB:
    case GLOB_EXPAND:
        (void) Strncpy(buffer, wordp, FILSIZ + 1);
        items[0] = buffer;
        items[1] = NULL;
        ptr = items;
        count = (looking == TW_COMMAND && Strchr(wordp, '/') == 0) ? 
                c_glob(&ptr) : 
                t_glob(&ptr, looking == TW_COMMAND);
        if (count > 0) {
            if (command == GLOB)
                print_by_column(STRNULL, ptr, count, 0);
            else {
                DeleteBack(str_end - word_start);/* get rid of old word */
                for (i = 0; i < count; i++)
                    if (ptr[i] && *ptr[i]) {
                        (void) quote(ptr[i]);
                        if (insert_meta(0, 0, ptr[i], 0) < 0 ||
                            InsertStr(STRspace) < 0) {
                            blkfree(ptr);
                            return -1;          /* error inserting */
                        }
                    }
            }
            blkfree(ptr);
        }
        return count;

    case VARS_EXPAND:
        if (dollar(buffer, word)) {
            if (insert_meta(word_start, str_end, buffer, !qu) < 0)
                return -1;              /* error inserting */
            return 1;
        }
        return 0;

    case PATH_NORMALIZE:
        if ((bptr = dnormalize(wordp, symlinks == SYM_IGNORE ||
                                      symlinks == SYM_EXPAND)) != NULL) {
            (void) Strcpy(buffer, bptr);
            xfree((ptr_t) bptr);
            if (insert_meta(word_start, str_end, buffer, !qu) < 0)
                return -1;              /* error inserting */
            return 1;
        }
        return 0;

    case COMMAND_NORMALIZE:
        if (!cmd_expand(wordp, buffer))
            return 0;
        if (insert_meta(word_start, str_end, buffer, !qu) < 0)
            return -1;          /* error inserting */
        return 1;

    case LIST:
    case LIST_ALL:
        search_ret = t_search(wordp, wp, LIST, space_left, looking, 1, 
                              pat, suf);
        return search_ret;

    default:
        xprintf(CGETS(30, 4, "%s: Internal match error.\n"), progname);
        return 1;

    }
} /* end tenematch */


/* t_glob():
 *      Return a list of files that match the pattern
 */
static int
t_glob(v, cmd)
    register Char ***v;
    int cmd;
{
    jmp_buf_t osetexit;

    if (**v == 0)
        return (0);
    gflag = 0, tglob(*v);
    if (gflag) {
        getexit(osetexit);      /* make sure to come back here */
        if (setexit() == 0)
            *v = globall(*v);
        resexit(osetexit);
        gargv = 0;
        if (haderr) {
            haderr = 0;
            NeedsRedraw = 1;
            return (-1);
        }
        if (*v == 0)
            return (0);
    }
    else
        return (0);

    if (cmd) {
        Char **av = *v, *p;
        int fwd, i, ac = gargc;

        for (i = 0, fwd = 0; i < ac; i++) 
            if (!executable(NULL, av[i], 0)) {
                fwd++;          
                p = av[i];
                av[i] = NULL;
                xfree((ptr_t) p);
            }
            else if (fwd) 
                av[i - fwd] = av[i];

        if (fwd)
            av[i - fwd] = av[i];
        gargc -= fwd;
        av[gargc] = NULL;
    }

    return (gargc);
} /* end t_glob */


/* c_glob():
 *      Return a list of commands that match the pattern
 */
static int
c_glob(v)
    register Char ***v;
{
    Char *pat = **v, *cmd, **av;
    Char dir[MAXPATHLEN+1];
    int flag, at, ac;

    if (pat == NULL)
        return (0);

    ac = 0;
    at = 10;
    av = (Char **) xmalloc((size_t) (at * sizeof(Char *)));
    av[ac] = NULL;

    tw_cmd_start(NULL, NULL);
    while ((cmd = tw_cmd_next(dir, &flag)) != NULL) 
        if (Gmatch(cmd, pat)) {
            if (ac + 1 >= at) {
                at += 10;
                av = (Char **) xrealloc((ptr_t) av, 
                                        (size_t) (at * sizeof(Char *)));
            }
            av[ac++] = Strsave(cmd);
            av[ac] = NULL;
        }
    tw_dir_end();
    *v = av;

    return (ac);
} /* end c_glob */


/* insert_meta():
 *      change the word before the cursor.
 *        cp must point to the start of the unquoted word.
 *        cpend to the end of it.
 *        word is the text that has to be substituted.
 *      strategy:
 *        try to keep all the quote characters of the user's input.
 *        change quote type only if necessary.
 */
static int
insert_meta(cp, cpend, word, closequotes)
    Char   *cp;
    Char   *cpend;
    Char   *word;
    bool    closequotes;
{
    Char buffer[2 * FILSIZ + 1], *bptr, *wptr;
    int in_sync = (cp != NULL);
    int qu = 0;
    int ndel = cp ? cpend - cp : 0;
    Char w, wq;

    for (bptr = buffer, wptr = word;;) {
        if (bptr > buffer + 2 * FILSIZ - 5)
            break;
          
        if (cp >= cpend)
            in_sync = 0;
        if (in_sync && !cmap(qu, _ESC) && cmap(*cp, _QF|_ESC))
            if (qu == 0 || qu == *cp) {
                qu ^= *cp;
                *bptr++ = *cp++;
                continue;
            }
        w = *wptr;
        if (w == 0)
            break;

        wq = w & QUOTE;
        w &= ~QUOTE;

        if (cmap(w, _ESC | _QF))
            wq = QUOTE;         /* quotes are always quoted */

        if (!wq && qu && tricky(w) && !(qu == '\"' && tricky_dq(w))) {
            /* We have to unquote the character */
            in_sync = 0;
            if (cmap(qu, _ESC))
                bptr[-1] = w;
            else {
                *bptr++ = (Char) qu;
                *bptr++ = w;
                if (wptr[1] == 0)
                    qu = 0;
                else
                    *bptr++ = (Char) qu;
            }
        } else if (qu && w == qu) {
            in_sync = 0;
            if (bptr > buffer && bptr[-1] == qu) {
                /* User misunderstanding :) */
                bptr[-1] = '\\';
                *bptr++ = w;
                qu = 0;
            } else {
                *bptr++ = (Char) qu;
                *bptr++ = '\\';
                *bptr++ = w;
                *bptr++ = (Char) qu;
            }
        }
        else if (wq && qu == '\"' && tricky_dq(w)) {
            in_sync = 0;
            *bptr++ = (Char) qu;
            *bptr++ = '\\';
            *bptr++ = w;
            *bptr++ = (Char) qu;
        } else if (wq && ((!qu && (tricky(w) || (w == HISTSUB && bptr == buffer))) || (!cmap(qu, _ESC) && w == HIST))) {
            in_sync = 0;
            *bptr++ = '\\';
            *bptr++ = w;
        } else {
            if (in_sync && *cp++ != w)
                in_sync = 0;
            *bptr++ = w;
        }
        wptr++;
        if (cmap(qu, _ESC))
            qu = 0;
    }
    if (closequotes && qu && !cmap(qu, _ESC))
        *bptr++ = (Char) qu;
    *bptr = '\0';
    if (ndel)
        DeleteBack(ndel);
    return InsertStr(buffer);
} /* end insert_meta */



/* is_prefix():
 *      return true if check matches initial chars in template
 *      This differs from PWB imatch in that if check is null
 *      it matches anything
 */
static int
is_prefix(check, template)
    register Char *check, *template;
{
    for (; *check; check++, template++)
        if ((*check & TRIM) != (*template & TRIM))
            return (FALSE);
    return (TRUE);
} /* end is_prefix */


/* is_prefixmatch():
 *      return true if check matches initial chars in template
 *      This differs from PWB imatch in that if check is null
 *      it matches anything
 * and matches on shortening of commands
 */
static int
is_prefixmatch(check, template, igncase)
    Char *check, *template;
    int igncase;
{
    Char MCH1, MCH2;

    for (; *check; check++, template++) {
        if ((*check & TRIM) != (*template & TRIM)) {
            MCH1 = (*check & TRIM);
            MCH2 = (*template & TRIM);
            MCH1 = Isupper(MCH1) ? Tolower(MCH1) : MCH1;
            MCH2 = Isupper(MCH2) ? Tolower(MCH2) : MCH2;
            if (MCH1 != MCH2) {
                if (!igncase && ((*check & TRIM) == '-' || 
                                 (*check & TRIM) == '.' ||
                                 (*check & TRIM) == '_')) {
                    MCH1 = MCH2 = (*check & TRIM);
                    if (MCH1 == '_') {
                        MCH2 = '-';
                    } else if (MCH1 == '-') {
                        MCH2 = '_';
                    }
                    for (;*template && (*template & TRIM) != MCH1 &&
                                       (*template & TRIM) != MCH2; template++)
                        continue;
                    if (!*template) {
                        return (FALSE);
                    }
                } else {
                    return (FALSE);
                }
            }
        }
    }
    return (TRUE);
} /* end is_prefixmatch */


/* is_suffix():
 *      Return true if the chars in template appear at the
 *      end of check, I.e., are it's suffix.
 */
static int
is_suffix(check, template)
    register Char *check, *template;
{
    register Char *t, *c;

    for (t = template; *t++;)
        continue;
    for (c = check; *c++;)
        continue;
    for (;;) {
        if (t == template)
            return 1;
        if (c == check || (*--t & TRIM) != (*--c & TRIM))
            return 0;
    }
} /* end is_suffix */


/* ignored():
 *      Return true if this is an ignored item
 */
static int
ignored(item)
    register Char *item;
{
    struct varent *vp;
    register Char **cp;

    if ((vp = adrof(STRfignore)) == NULL || (cp = vp->vec) == NULL)
        return (FALSE);
    for (; *cp != NULL; cp++)
        if (is_suffix(item, *cp))
            return (TRUE);
    return (FALSE);
} /* end ignored */



/* starting_a_command():
 *      return true if the command starting at wordstart is a command
 */
int
starting_a_command(wordstart, inputline)
    register Char *wordstart, *inputline;
{
    register Char *ptr, *ncmdstart;
    int     count;
    static  Char
            cmdstart[] = {'`', ';', '&', '(', '|', '\0'},
            cmdalive[] = {' ', '\t', '\'', '"', '<', '>', '\0'};

    /*
     * Find if the number of backquotes is odd or even.
     */
    for (ptr = wordstart, count = 0;
         ptr >= inputline;
         count += (*ptr-- == '`'))
        continue;
    /*
     * if the number of backquotes is even don't include the backquote char in
     * the list of command starting delimiters [if it is zero, then it does not
     * matter]
     */
    ncmdstart = cmdstart + EVEN(count);

    /*
     * look for the characters previous to this word if we find a command
     * starting delimiter we break. if we find whitespace and another previous
     * word then we are not a command
     * 
     * count is our state machine: 0 looking for anything 1 found white-space
     * looking for non-ws
     */
    for (count = 0; wordstart >= inputline; wordstart--) {
        if (*wordstart == '\0')
            continue;
        if (Strchr(ncmdstart, *wordstart))
            break;
        /*
         * found white space
         */
        if ((ptr = Strchr(cmdalive, *wordstart)) != NULL)
            count = 1;
        if (count == 1 && !ptr)
            return (FALSE);
    }

    if (wordstart > inputline)
        switch (*wordstart) {
        case '&':               /* Look for >& */
            while (wordstart > inputline &&
                   (*--wordstart == ' ' || *wordstart == '\t'))
                continue;
            if (*wordstart == '>')
                return (FALSE);
            break;
        case '(':               /* check for foreach, if etc. */
            while (wordstart > inputline &&
                   (*--wordstart == ' ' || *wordstart == '\t'))
                continue;
            if (!iscmdmeta(*wordstart) &&
                (*wordstart != ' ' && *wordstart != '\t'))
                return (FALSE);
            break;
        default:
            break;
        }
    return (TRUE);
} /* end starting_a_command */


/* recognize():
 *      Object: extend what user typed up to an ambiguity.
 *      Algorithm:
 *      On first match, copy full item (assume it'll be the only match)
 *      On subsequent matches, shorten exp_name to the first
 *      character mismatch between exp_name and item.
 *      If we shorten it back to the prefix length, stop searching.
 */
static int
recognize(exp_name, item, name_length, numitems, enhanced)
    Char   *exp_name, *item;
    int     name_length, numitems, enhanced;
{
    Char MCH1, MCH2;
    register Char *x, *ent;
    register int len = 0;
#ifdef WINNT
    struct varent *vp;
    int igncase;
    igncase = (vp = adrof(STRcomplete)) != NULL &&
        Strcmp(*(vp->vec), STRigncase) == 0;
#endif /* WINNT */

    if (numitems == 1) {        /* 1st match */
        copyn(exp_name, item, MAXNAMLEN);
        return (0);
    }
    if (!enhanced
#ifdef WINNT
        && !igncase
#endif /* WINNT */
    ) {
        for (x = exp_name, ent = item; *x && (*x & TRIM) == (*ent & TRIM); x++, ent++)
            len++;
    } else {
        for (x = exp_name, ent = item; *x; x++, ent++) {
            MCH1 = *x & TRIM;
            MCH2 = *ent & TRIM;
            MCH1 = Isupper(MCH1) ? Tolower(MCH1) : MCH1;
            MCH2 = Isupper(MCH2) ? Tolower(MCH2) : MCH2;
            if (MCH1 != MCH2)
                break;
            len++;
        }
        if (*x || !*ent)        /* Shorter or exact match */
            copyn(exp_name, item, MAXNAMLEN);
    }
    *x = '\0';          /* Shorten at 1st char diff */
    if (!(match_unique_match || is_set(STRrecexact) || (enhanced && *ent)) && len == name_length)       /* Ambiguous to prefix? */
        return (-1);    /* So stop now and save time */
    return (0);
} /* end recognize */


/* tw_collect_items():
 *      Collect items that match target.
 *      SPELL command:
 *              Returns the spelling distance of the closest match.
 *      else
 *              Returns the number of items found.
 *              If none found, but some ignored items were found,
 *              It returns the -number of ignored items.
 */
static int
tw_collect_items(command, looking, exp_dir, exp_name, target, pat, flags)
    COMMAND command;
    int looking;
    Char *exp_dir, *exp_name, *target, *pat;
    int flags;

{
    int done = FALSE;                    /* Search is done */
    int showdots;                        /* Style to show dot files */
    int nignored = 0;                    /* Number of fignored items */
    int numitems = 0;                    /* Number of matched items */
    int name_length = (int) Strlen(target); /* Length of prefix (file name) */
    int exec_check = flags & TW_EXEC_CHK;/* need to check executability */
    int dir_check  = flags & TW_DIR_CHK; /* Need to check for directories */
    int text_check = flags & TW_TEXT_CHK;/* Need to check for non-directories */
    int dir_ok     = flags & TW_DIR_OK;  /* Ignore directories? */
    int gpat       = flags & TW_PAT_OK;  /* Match against a pattern */
    int ignoring   = flags & TW_IGN_OK;  /* Use fignore? */
    int d = 4, nd;                       /* Spelling distance */
    Char *item, *ptr;
    Char buf[MAXPATHLEN+1];
    struct varent *vp;
    int len, enhanced;
    int cnt = 0;
    int igncase = 0;


    flags = 0;

    showdots = DOT_NONE;
    if ((ptr = varval(STRlistflags)) != STRNULL)
        while (*ptr) 
            switch (*ptr++) {
            case 'a':
                showdots = DOT_ALL;
                break;
            case 'A':
                showdots = DOT_NOT;
                break;
            default:
                break;
            }

    while (!done && (item = (*tw_next_entry[looking])(exp_dir, &flags))) {
#ifdef TDEBUG
        xprintf("item = %S\n", item);
#endif
        switch (looking) {
        case TW_FILE:
        case TW_DIRECTORY:
        case TW_TEXT:
            /*
             * Don't match . files on null prefix match
             */
            if (showdots == DOT_NOT && (ISDOT(item) || ISDOTDOT(item)))
                done = TRUE;
            if (name_length == 0 && item[0] == '.' && showdots == DOT_NONE)
                done = TRUE;
            break;

        case TW_COMMAND:
            exec_check = flags & TW_EXEC_CHK;
            dir_ok = flags & TW_DIR_OK;
            break;

        default:
            break;
        }

        if (done) {
            done = FALSE;
            continue;
        }

        switch (command) {

        case SPELL:             /* correct the spelling of the last bit */
            if (name_length == 0) {/* zero-length word can't be misspelled */
                exp_name[0] = '\0';/* (not trying is important for ~) */
                d = 0;
                done = TRUE;
                break;
            }
            if (gpat && !Gmatch(item, pat))
                break;
            /*
             * Swapped the order of the spdist() arguments as suggested
             * by eeide@asylum.cs.utah.edu (Eric Eide)
             */
            nd = spdist(target, item);  /* test the item against original */
            if (nd <= d && nd != 4) {
                if (!(exec_check && !executable(exp_dir, item, dir_ok))) {
                    (void) Strcpy(exp_name, item);
                    d = nd;
                    if (d == 0) /* if found it exactly */
                        done = TRUE;
                }
            }
            else if (nd == 4) {
                if (spdir(exp_name, exp_dir, item, target)) {
                    if (exec_check && !executable(exp_dir, exp_name, dir_ok)) 
                        break;
#ifdef notdef
                    /*
                     * We don't want to stop immediately, because
                     * we might find an exact/better match later.
                     */
                    d = 0;
                    done = TRUE;
#endif
                    d = 3;
                }
            }
            break;

        case LIST:
        case RECOGNIZE:
        case RECOGNIZE_ALL:
        case RECOGNIZE_SCROLL:

#ifdef WINNT
            igncase = (vp = adrof(STRcomplete)) != NULL && 
                Strcmp(*(vp->vec), STRigncase) == 0;
#endif /* WINNT */
            enhanced = (vp = adrof(STRcomplete)) != NULL && !Strcmp(*(vp->vec),STRenhance);
            if (enhanced || igncase) {
                if (!is_prefixmatch(target, item, igncase)) 
                    break;
            } else {
                if (!is_prefix(target, item)) 
                    break;
            }

            if (exec_check && !executable(exp_dir, item, dir_ok))
                break;

            if (dir_check && !isadirectory(exp_dir, item))
                break;

            if (text_check && isadirectory(exp_dir, item))
                break;

            /*
             * Only pattern match directories if we're checking
             * for directories.
             */
            if (gpat && !Gmatch(item, pat) &&
                (dir_check || !isadirectory(exp_dir, item)))
                    break;

            /*
             * Remove duplicates in command listing and completion
             * AFEB added code for TW_LOGNAME and TW_USER cases
             */
            if (looking == TW_COMMAND || looking == TW_LOGNAME
                || looking == TW_USER || command == LIST) {
                copyn(buf, item, MAXPATHLEN);
                len = (int) Strlen(buf);
                switch (looking) {
                case TW_COMMAND:
                    if (!(dir_ok && exec_check))
                        break;
                    if (filetype(exp_dir, item) == '/') {
                        buf[len++] = '/';
                        buf[len] = '\0';
                    }
                    break;

                case TW_FILE:
                case TW_DIRECTORY:
                    buf[len++] = filetype(exp_dir, item);
                    buf[len] = '\0';
                    break;

                default:
                    break;
                }
                if ((looking == TW_COMMAND || looking == TW_USER
                     || looking == TW_LOGNAME) && tw_item_find(buf))
                    break;
                else {
                    /* maximum length 1 (NULL) + 1 (~ or $) + 1 (filetype) */
                    ptr = tw_item_add(len + 3);
                    copyn(ptr, buf, MAXPATHLEN);
                    if (command == LIST)
                        numitems++;
                }
            }
                    
            if (command == RECOGNIZE || command == RECOGNIZE_ALL ||
                command == RECOGNIZE_SCROLL) {
                if (ignoring && ignored(item)) {
                    nignored++;
                    break;
                } 
                else if (command == RECOGNIZE_SCROLL) {
                    add_scroll_tab(item);
                    cnt++;
                }
                
                if (match_unique_match || is_set(STRrecexact)) {
                    if (StrQcmp(target, item) == 0) {   /* EXACT match */
                        copyn(exp_name, item, MAXNAMLEN);
                        numitems = 1;   /* fake into expanding */
                        non_unique_match = TRUE;
                        done = TRUE;
                        break;
                    }
                }
                if (recognize(exp_name, item, name_length, ++numitems, enhanced)) 
                    if (command != RECOGNIZE_SCROLL)
                        done = TRUE;
                if (enhanced && (int)Strlen(exp_name) < name_length)
                    copyn(exp_name, target, MAXNAMLEN);
            }
            break;

        default:
            break;
        }
#ifdef TDEBUG
        xprintf("done item = %S\n", item);
#endif
    }


    if (command == RECOGNIZE_SCROLL) {
        if ((cnt <= curchoice) || (curchoice == -1)) {
            curchoice = -1;
            nignored = 0;
            numitems = 0;
        } else if (numitems > 1) {
            if (curchoice < -1)
                curchoice = cnt - 1;
            choose_scroll_tab(&exp_name, cnt);
            numitems = 1;
        }
    }
    free_scroll_tab();

    if (command == SPELL)
        return d;
    else {
        if (ignoring && numitems == 0 && nignored > 0) 
            return -nignored;
        else
            return numitems;
    }
}


/* tw_suffix():
 *      Find and return the appropriate suffix character
 */
/*ARGSUSED*/
static Char 
tw_suffix(looking, exp_dir, exp_name, target, name)
    int looking;
    Char *exp_dir, *exp_name, *target, *name;
{    
    Char *ptr;
    struct varent *vp;

    USE(name);
    (void) strip(exp_name);

    switch (looking) {

    case TW_LOGNAME:
        return '/';

    case TW_VARIABLE:
        /*
         * Don't consider array variables or empty variables
         */
        if ((vp = adrof(exp_name)) != NULL) {
            if ((ptr = vp->vec[0]) == NULL || *ptr == '\0' ||
                vp->vec[1] != NULL) 
                return ' ';
        }
        else if ((ptr = tgetenv(exp_name)) == NULL || *ptr == '\0')
            return ' ';

        *--target = '\0';

        return isadirectory(exp_dir, ptr) ? '/' : ' ';


    case TW_DIRECTORY:
        return '/';

    case TW_COMMAND:
    case TW_FILE:
        return isadirectory(exp_dir, exp_name) ? '/' : ' ';

    case TW_ALIAS:
    case TW_VARLIST:
    case TW_WORDLIST:
    case TW_SHELLVAR:
    case TW_ENVVAR:
    case TW_USER:
    case TW_BINDING:
    case TW_LIMIT:
    case TW_SIGNAL:
    case TW_JOB:
    case TW_COMPLETION:
    case TW_TEXT:
    case TW_GRPNAME:
        return ' ';

    default:
        return '\0';
    }
} /* end tw_suffix */


/* tw_fixword():
 *      Repair a word after a spalling or a recognizwe
 */
static void
tw_fixword(looking, word, dir, exp_name, max_word_length)
    int looking;
    Char *word, *dir, *exp_name;
    int max_word_length;
{
    Char *ptr;

    switch (looking) {
    case TW_LOGNAME:
        copyn(word, STRtilde, 1);
        break;
    
    case TW_VARIABLE:
        if ((ptr = Strrchr(word, '$')) != NULL)
            *++ptr = '\0';      /* Delete after the dollar */
        else
            word[0] = '\0';
        break;

    case TW_DIRECTORY:
    case TW_FILE:
    case TW_TEXT:
        copyn(word, dir, max_word_length);      /* put back dir part */
        break;

    default:
        word[0] = '\0';
        break;
    }

    (void) quote(exp_name);
    catn(word, exp_name, max_word_length);      /* add extended name */
} /* end tw_fixword */


/* tw_collect():
 *      Collect items. Return -1 in case we were interrupted or
 *      the return value of tw_collect
 *      This is really a wrapper for tw_collect_items, serving two
 *      purposes:
 *              1. Handles interrupt cleanups.
 *              2. Retries if we had no matches, but there were ignored matches
 */
static int
tw_collect(command, looking, exp_dir, exp_name, target, pat, flags, dir_fd)
    COMMAND command;
    int looking;
    Char *exp_dir, *exp_name, **target, *pat;
    int flags;
    DIR *dir_fd;
{
    static int ni;      /* static so we don't get clobbered */
    jmp_buf_t osetexit;

#ifdef TDEBUG
    xprintf("target = %S\n", *target);
#endif
    ni = 0;
    getexit(osetexit);
    for (;;) {
        (*tw_start_entry[looking])(dir_fd, pat);
        InsideCompletion = 1;
        if (setexit()) {
            /* interrupted, clean up */
            resexit(osetexit);
            InsideCompletion = 0;
            haderr = 0;

#if defined(SOLARIS2) && defined(i386) && !defined(__GNUC__)
            /* Compiler bug? (from PWP) */
            if ((looking == TW_LOGNAME) || (looking == TW_USER))
                tw_logname_end();
            else
                if (looking == TW_GRPNAME)
                   tw_grpname_end();
                else
                    tw_dir_end();
#else /* !(SOLARIS2 && i386 && !__GNUC__) */
            (*tw_end_entry[looking])();
#endif /* !(SOLARIS2 && i386 && !__GNUC__) */

            /* flag error */
            return(-1);
        }
        if ((ni = tw_collect_items(command, looking, exp_dir, exp_name,
                                   *target, pat, 
                                   ni >= 0 ? flags : 
                                        flags & ~TW_IGN_OK)) >= 0) {
            resexit(osetexit);
            InsideCompletion = 0;

#if defined(SOLARIS2) && defined(i386) && !defined(__GNUC__)
            /* Compiler bug? (from PWP) */
            if ((looking == TW_LOGNAME) || (looking == TW_USER))
                tw_logname_end();
            else
                if (looking == TW_GRPNAME)
                   tw_grpname_end();
                else
                    tw_dir_end();
#else /* !(SOLARIS2 && i386 && !__GNUC__) */
            (*tw_end_entry[looking])();
#endif /* !(SOLARIS2 && i386 && !__GNUC__) */

            return(ni);
        }
    }
} /* end tw_collect */


/* tw_list_items():
 *      List the items that were found
 *
 *      NOTE instead of looking at numerical vars listmax and listmaxrows
 *      we can look at numerical var listmax, and have a string value
 *      listmaxtype (or similar) than can have values 'items' and 'rows'
 *      (by default interpreted as 'items', for backwards compatibility)
 */
static void
tw_list_items(looking, numitems, list_max)
    int looking, numitems, list_max;
{
    Char *ptr;
    int max_items = 0;
    int max_rows = 0;

    if ((ptr = varval(STRlistmax)) != STRNULL) {
        while (*ptr) {
            if (!Isdigit(*ptr)) {
                max_items = 0;
                break;
            }
            max_items = max_items * 10 + *ptr++ - '0';
        }
        if ((max_items > 0) && (numitems > max_items) && list_max)
            max_items = numitems;
        else
            max_items = 0;
    }

    if (max_items == 0 && (ptr = varval(STRlistmaxrows)) != STRNULL) {
        int rows;

        while (*ptr) {
            if (!Isdigit(*ptr)) {
                max_rows = 0;
                break;
            }
            max_rows = max_rows * 10 + *ptr++ - '0';
        }
        if (max_rows != 0 && looking != TW_JOB)
            rows = find_rows(tw_item_get(), numitems, TRUE);
        else
            rows = numitems; /* underestimate for lines wider than the termH */
        if ((max_rows > 0) && (rows > max_rows) && list_max)
            max_rows = rows;
        else
            max_rows = 0;
    }


    if (max_items || max_rows) {
        char             tc;
        const char      *name;
        int maxs;

        if (max_items) {
            name = CGETS(30, 5, "items");
            maxs = max_items;
        }
        else {
            name = CGETS(30, 6, "rows");
            maxs = max_rows;
        }

        xprintf(CGETS(30, 7, "There are %d %s, list them anyway? [n/y] "),
                maxs, name);
        flush();
        /* We should be in Rawmode here, so no \n to catch */
        (void) read(SHIN, &tc, 1);
        xprintf("%c\r\n", tc);  /* echo the char, do a newline */
        /* 
         * Perhaps we should use the yesexpr from the
         * actual locale
         */
        if (strchr(CGETS(30, 13, "Yy"), tc) == NULL)
            return;
    }

    if (looking != TW_SIGNAL)
        qsort((ptr_t) tw_item_get(), (size_t) numitems, sizeof(Char *), 
              (int (*) __P((const void *, const void *))) fcompare);
    if (looking != TW_JOB)
        print_by_column(STRNULL, tw_item_get(), numitems, TRUE);
    else {
        /*
         * print one item on every line because jobs can have spaces
         * and it is confusing.
         */
        int i;
        Char **w = tw_item_get();

        for (i = 0; i < numitems; i++) {
            xprintf("%S", w[i]);
            if (Tty_raw_mode)
                xputchar('\r');
            xputchar('\n');
        }
    }
} /* end tw_list_items */


/* t_search():
 *      Perform a RECOGNIZE, LIST or SPELL command on string "word".
 *
 *      Return value:
 *              >= 0:   SPELL command: "distance" (see spdist())
 *                              other: No. of items found
 *               < 0:   Error (message or beep is output)
 */
/*ARGSUSED*/
int
t_search(word, wp, command, max_word_length, looking, list_max, pat, suf)
    Char   *word, *wp;          /* original end-of-word */
    COMMAND command;
    int     max_word_length, looking, list_max;
    Char   *pat;
    int     suf;
{
    int     numitems,                   /* Number of items matched */
            flags = 0,                  /* search flags */
            gpat = pat[0] != '\0',      /* Glob pattern search */
            nd;                         /* Normalized directory return */
    Char    exp_dir[FILSIZ + 1],        /* dir after ~ expansion */
            dir[FILSIZ + 1],            /* /x/y/z/ part in /x/y/z/f */
            exp_name[MAXNAMLEN + 1],    /* the recognized (extended) */
            name[MAXNAMLEN + 1],        /* f part in /d/d/d/f name */
           *target;                     /* Target to expand/correct/list */
    DIR    *dir_fd = NULL;      

    USE(wp);

    /*
     * bugfix by Marty Grossman (grossman@CC5.BBN.COM): directory listing can
     * dump core when interrupted
     */
    tw_item_free();

    non_unique_match = FALSE;   /* See the recexact code below */

    extract_dir_and_name(word, dir, name);

    /*
     *  SPECIAL HARDCODED COMPLETIONS:
     *    foo$variable                -> TW_VARIABLE
     *    ~user                       -> TW_LOGNAME
     *
     */
    if ((*word == '~') && (Strchr(word, '/') == NULL)) {
        looking = TW_LOGNAME;
        target = name;
        gpat = 0;       /* Override pattern mechanism */
    }
    else if ((target = Strrchr(name, '$')) != 0 && 
             (Strchr(name, '/') == NULL)) {
        target++;
        looking = TW_VARIABLE;
        gpat = 0;       /* Override pattern mechanism */
    }
    else
        target = name;

    /*
     * Try to figure out what we should be looking for
     */
    if (looking & TW_PATH) {
        gpat = 0;       /* pattern holds the pathname to be used */
        copyn(exp_dir, pat, MAXNAMLEN);
        if (exp_dir[Strlen(exp_dir) - 1] != '/')
            catn(exp_dir, STRslash, MAXNAMLEN);
        catn(exp_dir, dir, MAXNAMLEN);
    }
    else
        exp_dir[0] = '\0';

    switch (looking & ~TW_PATH) {
    case TW_NONE:
        return -1;

    case TW_ZERO:
        looking = TW_FILE;
        break;

    case TW_COMMAND:
        if (Strchr(word, '/') || (looking & TW_PATH)) {
            looking = TW_FILE;
            flags |= TW_EXEC_CHK;
            flags |= TW_DIR_OK;
        }
#ifdef notdef
        /* PWP: don't even bother when doing ALL of the commands */
        if (looking == TW_COMMAND && (*word == '\0')) 
            return (-1);
#endif
        break;


    case TW_VARLIST:
    case TW_WORDLIST:
        gpat = 0;       /* pattern holds the name of the variable */
        break;

    case TW_EXPLAIN:
        if (command == LIST && pat != NULL) {
            xprintf("%S", pat);
            if (Tty_raw_mode)
                xputchar('\r');
            xputchar('\n');
        }
        return 2;

    default:
        break;
    }

    /*
     * let fignore work only when we are not using a pattern
     */
    flags |= (gpat == 0) ? TW_IGN_OK : TW_PAT_OK;

#ifdef TDEBUG
    xprintf(CGETS(30, 8, "looking = %d\n"), looking);
#endif

    switch (looking) {
    case TW_ALIAS:
    case TW_SHELLVAR:
    case TW_ENVVAR:
    case TW_BINDING:
    case TW_LIMIT:
    case TW_SIGNAL:
    case TW_JOB:
    case TW_COMPLETION:
    case TW_GRPNAME:
        break;


    case TW_VARIABLE:
        if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
            return nd;
        break;

    case TW_DIRECTORY:
        flags |= TW_DIR_CHK;

#ifdef notyet
        /*
         * This is supposed to expand the directory stack.
         * Problems:
         * 1. Slow
         * 2. directories with the same name
         */
        flags |= TW_DIR_OK;
#endif
#ifdef notyet
        /*
         * Supposed to do delayed expansion, but it is inconsistent
         * from a user-interface point of view, since it does not
         * immediately obey addsuffix
         */
        if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
            return nd;
        if (isadirectory(exp_dir, name)) {
            if (exp_dir[0] != '\0' || name[0] != '\0') {
                catn(dir, name, MAXNAMLEN);
                if (dir[Strlen(dir) - 1] != '/')
                    catn(dir, STRslash, MAXNAMLEN);
                if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
                    return nd;
                if (word[Strlen(word) - 1] != '/')
                    catn(word, STRslash, MAXNAMLEN);
                name[0] = '\0';
            }
        }
#endif
        if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
            return nd;
        break;

    case TW_TEXT:
        flags |= TW_TEXT_CHK;
        /*FALLTHROUGH*/
    case TW_FILE:
        if ((nd = expand_dir(dir, exp_dir, &dir_fd, command)) != 0)
            return nd;
        break;

    case TW_PATH | TW_TEXT:
    case TW_PATH | TW_FILE:
    case TW_PATH | TW_DIRECTORY:
    case TW_PATH | TW_COMMAND:
        if ((dir_fd = opendir(short2str(exp_dir))) == NULL) {
            xprintf("%S: %s\n", exp_dir, strerror(errno));
            return -1;
        }
        if (exp_dir[Strlen(exp_dir) - 1] != '/')
            catn(exp_dir, STRslash, MAXNAMLEN);

        looking &= ~TW_PATH;

        switch (looking) {
        case TW_TEXT:
            flags |= TW_TEXT_CHK;
            break;

        case TW_FILE:
            break;

        case TW_DIRECTORY:
            flags |= TW_DIR_CHK;
            break;

        case TW_COMMAND:
            copyn(target, word, MAXNAMLEN);     /* so it can match things */
            break;

        default:
            abort();    /* Cannot happen */
            break;
        }
        break;

    case TW_LOGNAME:
        word++;
        /*FALLTHROUGH*/
    case TW_USER:
        /*
         * Check if the spelling was already correct
         * From: Rob McMahon <cudcv@cu.warwick.ac.uk>
         */
        if (command == SPELL && getpwnam(short2str(word)) != NULL) {
#ifdef YPBUGS
            fix_yp_bugs();
#endif /* YPBUGS */
            return (0);
        }
        copyn(name, word, MAXNAMLEN);   /* name sans ~ */
        if (looking == TW_LOGNAME)
            word--;
        break;

    case TW_COMMAND:
    case TW_VARLIST:
    case TW_WORDLIST:
        copyn(target, word, MAXNAMLEN); /* so it can match things */
        break;

    default:
        xprintf(CGETS(30, 9,
                "\n%s internal error: I don't know what I'm looking for!\n"),
                progname);
        NeedsRedraw = 1;
        return (-1);
    }

    numitems = tw_collect(command, looking, exp_dir, exp_name, 
                          &target, pat, flags, dir_fd);
    if (numitems == -1)
        return -1;

    switch (command) {
    case RECOGNIZE:
    case RECOGNIZE_ALL:
    case RECOGNIZE_SCROLL:
        if (numitems <= 0) 
            return (numitems);

        tw_fixword(looking, word, dir, exp_name, max_word_length);

        if (!match_unique_match && is_set(STRaddsuffix) && numitems == 1) {
            Char suffix[2];

            suffix[1] = '\0';
            switch (suf) {
            case 0:     /* Automatic suffix */
                suffix[0] = tw_suffix(looking, exp_dir, exp_name, target, name);
                break;

            case -1:    /* No suffix */
                return numitems;

            default:    /* completion specified suffix */
                suffix[0] = (Char) suf;
                break;
            }
            catn(word, suffix, max_word_length);
        }
        return numitems;

    case LIST:
        tw_list_items(looking, numitems, list_max);
        tw_item_free();
        return (numitems);

    case SPELL:
        tw_fixword(looking, word, dir, exp_name, max_word_length);
        return (numitems);

    default:
        xprintf("Bad tw_command\n");
        return (0);
    }
} /* end t_search */


/* extract_dir_and_name():
 *      parse full path in file into 2 parts: directory and file names
 *      Should leave final slash (/) at end of dir.
 */
static void
extract_dir_and_name(path, dir, name)
    Char   *path, *dir, *name;
{
    register Char *p;

    p = Strrchr(path, '/');
#ifdef WINNT
    if (p == NULL)
        p = Strrchr(path, ':');
#endif /* WINNT */
    if (p == NULL) {
        copyn(name, path, MAXNAMLEN);
        dir[0] = '\0';
    }
    else {
        p++;
        copyn(name, p, MAXNAMLEN);
        copyn(dir, path, p - path);
    }
} /* end extract_dir_and_name */


/* dollar():
 *      expand "/$old1/$old2/old3/"
 *      to "/value_of_old1/value_of_old2/old3/"
 */
Char *
dollar(new, old)
    Char   *new;
    const Char *old;
{
    Char    *p;
    size_t   space;

    for (space = FILSIZ, p = new; *old && space > 0;)
        if (*old != '$') {
            *p++ = *old++;
            space--;
        }
        else {
            if (expdollar(&p, &old, &space, QUOTE) == NULL)
                return NULL;
        }
    *p = '\0';
    return (new);
} /* end dollar */


/* tilde():
 *      expand ~person/foo to home_directory_of_person/foo
 *      or =<stack-entry> to <dir in stack entry>
 */
static Char *
tilde(new, old)
    Char   *new, *old;
{
    register Char *o, *p;

    switch (old[0]) {
    case '~':
        for (p = new, o = &old[1]; *o && *o != '/'; *p++ = *o++) 
            continue;
        *p = '\0';
        if (gethdir(new)) {
            new[0] = '\0';
            return NULL;
        }
        (void) Strcat(new, o);
        return new;

    case '=':
        if ((p = globequal(new, old)) == NULL) {
            *new = '\0';
            return NULL;
        }
        if (p == new)
            return new;
        /*FALLTHROUGH*/

    default:
        (void) Strcpy(new, old);
        return new;
    }
} /* end tilde */


/* expand_dir():
 *      Open the directory given, expanding ~user and $var
 *      Optionally normalize the path given
 */
static int
expand_dir(dir, edir, dfd, cmd)
    Char   *dir, *edir;
    DIR   **dfd;
    COMMAND cmd;
{
    Char   *nd = NULL;
    Char    tdir[MAXPATHLEN + 1];

    if ((dollar(tdir, dir) == 0) ||
        (tilde(edir, tdir) == 0) ||
        !(nd = dnormalize(*edir ? edir : STRdot, symlinks == SYM_IGNORE ||
                                                 symlinks == SYM_EXPAND)) ||
        ((*dfd = opendir(short2str(nd))) == NULL)) {
        xfree((ptr_t) nd);
        if (cmd == SPELL || SearchNoDirErr)
            return (-2);
        /*
         * From: Amos Shapira <amoss@cs.huji.ac.il>
         * Print a better message when completion fails
         */
        xprintf("\n%S %s\n",
                *edir ? edir :
                (*tdir ? tdir : dir),
                (errno == ENOTDIR ? CGETS(30, 10, "not a directory") :
                (errno == ENOENT ? CGETS(30, 11, "not found") :
                 CGETS(30, 12, "unreadable"))));
        NeedsRedraw = 1;
        return (-1);
    }
    if (nd) {
        if (*dir != '\0') {
            Char   *s, *d, *p;

            /*
             * Copy and append a / if there was one
             */
            for (p = edir; *p; p++)
                continue;
            if (*--p == '/') {
                for (p = nd; *p; p++)
                    continue;
                if (*--p != '/')
                    p = NULL;
            }
            for (d = edir, s = nd; (*d++ = *s++) != '\0';)
                continue;
            if (!p) {
                *d-- = '\0';
                *d = '/';
            }
        }
        xfree((ptr_t) nd);
    }
    return 0;
} /* end expand_dir */


/* nostat():
 *      Returns true if the directory should not be stat'd,
 *      false otherwise.
 *      This way, things won't grind to a halt when you complete in /afs
 *      or very large directories.
 */
static bool
nostat(dir)
     Char *dir;
{
    struct varent *vp;
    register Char **cp;

    if ((vp = adrof(STRnostat)) == NULL || (cp = vp->vec) == NULL)
        return FALSE;
    for (; *cp != NULL; cp++) {
        if (Strcmp(*cp, STRstar) == 0)
            return TRUE;
        if (Gmatch(dir, *cp))
            return TRUE;
    }
    return FALSE;
} /* end nostat */


/* filetype():
 *      Return a character that signifies a filetype
 *      symbology from 4.3 ls command.
 */
static  Char
filetype(dir, file)
    Char   *dir, *file;
{
    if (dir) {
        Char    path[512];
        char   *ptr;
        struct stat statb;
#ifdef S_ISCDF
        /* 
         * From: veals@crchh84d.bnr.ca (Percy Veals)
         * An extra stat is required for HPUX CDF files.
         */
        struct stat hpstatb;
#endif /* S_ISCDF */

        if (nostat(dir)) return(' ');

        (void) Strcpy(path, dir);
        catn(path, file, (int) (sizeof(path) / sizeof(Char)));

        if (lstat(ptr = short2str(path), &statb) != -1)
            /* see above #define of lstat */
        {
#ifdef S_ISLNK
            if (S_ISLNK(statb.st_mode)) {       /* Symbolic link */
                if (adrof(STRlistlinks)) {
                    if (stat(ptr, &statb) == -1)
                        return ('&');
                    else if (S_ISDIR(statb.st_mode))
                        return ('>');
                    else
                        return ('@');
                }
                else
                    return ('@');
            }
#endif
#ifdef S_ISSOCK
            if (S_ISSOCK(statb.st_mode))        /* Socket */
                return ('=');
#endif
#ifdef S_ISFIFO
            if (S_ISFIFO(statb.st_mode)) /* Named Pipe */
                return ('|');
#endif
#ifdef S_ISHIDDEN
            if (S_ISHIDDEN(statb.st_mode)) /* Hidden Directory [aix] */
                return ('+');
#endif
#ifdef S_ISCDF  
            (void) strcat(ptr, "+");    /* Must append a '+' and re-stat(). */
            if ((stat(ptr, &hpstatb) != -1) && S_ISCDF(hpstatb.st_mode))
                return ('+');           /* Context Dependent Files [hpux] */
#endif 
#ifdef S_ISNWK
            if (S_ISNWK(statb.st_mode)) /* Network Special [hpux] */
                return (':');
#endif
#ifdef S_ISCHR
            if (S_ISCHR(statb.st_mode)) /* char device */
                return ('%');
#endif
#ifdef S_ISBLK
            if (S_ISBLK(statb.st_mode)) /* block device */
                return ('#');
#endif
#ifdef S_ISDIR
            if (S_ISDIR(statb.st_mode)) /* normal Directory */
                return ('/');
#endif
            if (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
                return ('*');
        }
    }
    return (' ');
} /* end filetype */


/* isadirectory():
 *      Return trus if the file is a directory
 */
static int
isadirectory(dir, file)         /* return 1 if dir/file is a directory */
    Char   *dir, *file;         /* uses stat rather than lstat to get dest. */
{
    if (dir) {
        Char    path[MAXPATHLEN];
        struct stat statb;

        (void) Strcpy(path, dir);
        catn(path, file, (int) (sizeof(path) / sizeof(Char)));
        if (stat(short2str(path), &statb) >= 0) {       /* resolve through
                                                         * symlink */
#ifdef S_ISSOCK
            if (S_ISSOCK(statb.st_mode))        /* Socket */
                return 0;
#endif
#ifdef S_ISFIFO
            if (S_ISFIFO(statb.st_mode))        /* Named Pipe */
                return 0;
#endif
            if (S_ISDIR(statb.st_mode)) /* normal Directory */
                return 1;
        }
    }
    return 0;
} /* end isadirectory */



/* find_rows():
 *      Return how many rows needed to print sorted down columns
 */
static int
find_rows(items, count, no_file_suffix)
    Char *items[];
    int     count, no_file_suffix;
{
    register int i, columns, rows;
    unsigned int maxwidth = 0;

    for (i = 0; i < count; i++) /* find widest string */
        maxwidth = max(maxwidth, (unsigned int) Strlen(items[i]));

    maxwidth += no_file_suffix ? 1 : 2; /* for the file tag and space */
    columns = (TermH + 1) / maxwidth;   /* PWP: terminal size change */
    if (!columns)
        columns = 1;
    rows = (count + (columns - 1)) / columns;

    return rows;
} /* end rows_needed_by_print_by_column */


/* print_by_column():
 *      Print sorted down columns or across columns when the first
 *      word of $listflags shell variable contains 'x'.
 *
 */
void
print_by_column(dir, items, count, no_file_suffix)
    register Char *dir, *items[];
    int     count, no_file_suffix;
{
    register int i, r, c, columns, rows;
    unsigned int w, maxwidth = 0;
    Char *val;
    bool across;

    lbuffed = 0;                /* turn off line buffering */

    
    across = ((val = varval(STRlistflags)) != STRNULL) && 
             (Strchr(val, 'x') != NULL);

    for (i = 0; i < count; i++) /* find widest string */
        maxwidth = max(maxwidth, (unsigned int) Strlen(items[i]));

    maxwidth += no_file_suffix ? 1 : 2; /* for the file tag and space */
    columns = TermH / maxwidth;         /* PWP: terminal size change */
    if (!columns || !isatty(didfds ? 1 : SHOUT))
        columns = 1;
    rows = (count + (columns - 1)) / columns;

    i = -1;
    for (r = 0; r < rows; r++) {
        for (c = 0; c < columns; c++) {
            i = across ? (i + 1) : (c * rows + r);

            if (i < count) {
                w = (unsigned int) Strlen(items[i]);

#ifdef COLOR_LS_F
                if (no_file_suffix) {
                    /* Print the command name */
                    Char f = items[i][w - 1];
                    items[i][w - 1] = 0;
                    print_with_color(items[i], w - 1, f);
                }
                else {
                    /* Print filename followed by '/' or '*' or ' ' */
                    print_with_color(items[i], w, filetype(dir, items[i]));
                    w++;
                }
#else /* ifndef COLOR_LS_F */
                if (no_file_suffix) {
                    /* Print the command name */
                    xprintf("%S", items[i]);
                }
                else {
                    /* Print filename followed by '/' or '*' or ' ' */
                    xprintf("%S%c", items[i],
                            filetype(dir, items[i]));
                    w++;
                }
#endif /* COLOR_LS_F */

                if (c < (columns - 1))  /* Not last column? */
                    for (; w < maxwidth; w++)
                        xputchar(' ');
            }
            else if (across)
                break;
        }
        if (Tty_raw_mode)
            xputchar('\r');
        xputchar('\n');
    }

    lbuffed = 1;                /* turn back on line buffering */
    flush();
} /* end print_by_column */


/* StrQcmp():
 *      Compare strings ignoring the quoting chars
 */
int
StrQcmp(str1, str2)
    register Char *str1, *str2;
{
    for (; *str1 && samecase(*str1 & TRIM) == samecase(*str2 & TRIM); 
         str1++, str2++)
        continue;
    /*
     * The following case analysis is necessary so that characters which look
     * negative collate low against normal characters but high against the
     * end-of-string NUL.
     */
    if (*str1 == '\0' && *str2 == '\0')
        return (0);
    else if (*str1 == '\0')
        return (-1);
    else if (*str2 == '\0')
        return (1);
    else
        return ((*str1 & TRIM) - (*str2 & TRIM));
} /* end StrQcmp */


/* fcompare():
 *      Comparison routine for qsort
 */
int
fcompare(file1, file2)
    Char  **file1, **file2;
{
    return (int) collate(*file1, *file2);
} /* end fcompare */


/* catn():
 *      Concatenate src onto tail of des.
 *      Des is a string whose maximum length is count.
 *      Always null terminate.
 */
void
catn(des, src, count)
    register Char *des, *src;
    int count;
{
    while (--count >= 0 && *des)
        des++;
    while (--count >= 0)
        if ((*des++ = *src++) == 0)
            return;
    *des = '\0';
} /* end catn */


/* copyn():
 *       like strncpy but always leave room for trailing \0
 *       and always null terminate.
 */
void
copyn(des, src, count)
    register Char *des, *src;
    int count;
{
    while (--count >= 0)
        if ((*des++ = *src++) == 0)
            return;
    *des = '\0';
} /* end copyn */


/* tgetenv():
 *      like it's normal string counter-part
 *      [apollo uses that in tc.os.c, so it cannot be static]
 */
Char *
tgetenv(str)
    Char   *str;
{
    Char  **var;
    int     len, res;

    len = (int) Strlen(str);
    /* Search the STR_environ for the entry matching str. */
    for (var = STR_environ; var != NULL && *var != NULL; var++)
        if (Strlen(*var) >= len && (*var)[len] == '=') {
          /* Temporarily terminate the string so we can copy the variable
             name. */
            (*var)[len] = '\0';
            res = StrQcmp(*var, str);
            /* Restore the '=' and return a pointer to the value of the
               environment variable. */
            (*var)[len] = '=';
            if (res == 0)
                return (&((*var)[len + 1]));
        }
    return (NULL);
} /* end tgetenv */


struct scroll_tab_list *scroll_tab = 0;

static void
add_scroll_tab(item)
    Char *item;
{
    struct scroll_tab_list *new_scroll;

    new_scroll = (struct scroll_tab_list *) xmalloc((size_t)
            sizeof(struct scroll_tab_list));
    new_scroll->element = Strsave(item);
    new_scroll->next = scroll_tab;
    scroll_tab = new_scroll;
}

static void
choose_scroll_tab(exp_name, cnt)
    Char **exp_name;
    int cnt;
{
    struct scroll_tab_list *loop;
    int tmp = cnt;
    Char **ptr;

    ptr = (Char **) xmalloc((size_t) sizeof(Char *) * cnt);

    for(loop = scroll_tab; loop && (tmp >= 0); loop = loop->next)
        ptr[--tmp] = loop->element;

    qsort((ptr_t) ptr, (size_t) cnt, sizeof(Char *), 
          (int (*) __P((const void *, const void *))) fcompare);
            
    copyn(*exp_name, ptr[curchoice], (int) Strlen(ptr[curchoice]));     
    xfree((ptr_t) ptr);
}

static void
free_scroll_tab()
{
    struct scroll_tab_list *loop;

    while(scroll_tab) {
        loop = scroll_tab;
        scroll_tab = scroll_tab->next;
        xfree((ptr_t) loop->element);
        xfree((ptr_t) loop);
    }
}