v19i071: zsh2.00 - The Z shell, Patch02e/6
Paul Falstad
pfalstad at phoenix.princeton.edu
Thu May 16 08:03:25 AEST 1991
Submitted-by: Paul Falstad <pfalstad at phoenix.princeton.edu>
Posting-number: Volume 19, Issue 71
Archive-name: zsh2.00/patch02e
Patch-To: zsh2.00: Volume 18, Issue 84-98
#!/bin/sh
# this is zpatch.05 (part 5 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file zsh2.00/src/lex.c continued
#
if test ! -r _shar_seq_.tmp; then
echo 'Please unpack part 1 first!'
exit 1
fi
(read Scheck
if test "$Scheck" != 5; then
echo Please unpack part "$Scheck" next!
exit 1
else
exit 0
fi
) < _shar_seq_.tmp || exit 1
echo 'x - continuing file zsh2.00/src/lex.c'
sed 's/^X//' << 'SHAR_EOF' >> 'zsh2.00/src/lex.c' &&
X case DOUTANGAMP:case DOUTANGAMPBANG: inredir = 1; break;
X case FUNC:infunc = 1;break;
X case DINBRACK: incond = 1; break;
X case DOUTBRACK: incond = 0; break;
X case DSEMI: ignl = incase = 1; incmd = 0; break;
X case CASE: incmd = incase = 1; break;
X }
X return x;
}
X
#define LX1_BKSLASH 0
#define LX1_COMMENT 1
#define LX1_NEWLIN 2
#define LX1_SEMI 3
#define LX1_BANG 4
#define LX1_AMPER 5
#define LX1_BAR 6
#define LX1_INPAR 7
#define LX1_OUTPAR 8
#define LX1_INBRACE 9
#define LX1_OUTBRACE 10
#define LX1_INBRACK 11
#define LX1_OUTBRACK 12
#define LX1_INANG 13
#define LX1_OUTANG 14
#define LX1_OTHER 15
X
#define LX2_BREAK 0
#define LX2_OUTPAR 1
#define LX2_BAR 2
#define LX2_STRING 3
#define LX2_INBRACK 4
#define LX2_OUTBRACK 5
#define LX2_TILDE 6
#define LX2_INPAR 7
#define LX2_INBRACE 8
#define LX2_OUTBRACE 9
#define LX2_OUTANG 10
#define LX2_INANG 11
#define LX2_EQUALS 12
#define LX2_BKSLASH 13
#define LX2_QUOTE 14
#define LX2_DQUOTE 15
#define LX2_BQUOTE 16
#define LX2_OTHER 17
X
unsigned char lexact1[256],lexact2[256],lextok2[256];
X
void initlextabs() /**/
{
int t0;
static char *lx1 = "\\q\n;!&|(){}[]<>xx";
static char *lx2 = "x)|$[]~({}><=\\\'\"`x";
X
X for (t0 = 0; t0 != 256; t0++)
X {
X lexact1[t0] = LX1_OTHER;
X lexact2[t0] = LX2_OTHER;
X lextok2[t0] = t0;
X }
X for (t0 = 0; lx1[t0]; t0++)
X if (lx1[t0] != 'x')
X lexact1[lx1[t0]] = t0;
X for (t0 = 0; lx2[t0]; t0++)
X if (lx2[t0] != 'x')
X lexact2[lx2[t0]] = t0;
X lexact2[';'] = LX2_BREAK;
X lexact2['&'] = LX2_BREAK;
X lextok2[','] = Comma;
X lextok2['*'] = Star;
X lextok2['?'] = Quest;
X lextok2['{'] = Inbrace;
X lextok2['['] = Inbrack;
X lextok2['$'] = String;
}
X
/* initialize lexical state */
X
void lexinit() /**/
{
X ignl = lsep = incmd = incond = infunc = inredir = incase =
X nocorrect = dbparens = alstat = lexstop = 0;
X if (isset(EXTENDEDGLOB))
X {
X lextok2['#'] = Pound;
X lextok2['^'] = Hat;
X }
X else
X {
X lextok2['#'] = '#';
X lextok2['^'] = '^';
X }
}
X
int len = 0,bsiz = 256;
char *bptr;
X
/* add a char to the string buffer */
X
void add(c) /**/
int c;
{
X *bptr++ = c;
X if (bsiz == ++len)
X {
X int newbsiz;
X
X newbsiz = bsiz * 8;
X while (newbsiz < inbufct)
X newbsiz *= 2;
X bptr = len+(tokstr = hrealloc(tokstr,bsiz,newbsiz));
X bsiz = newbsiz;
X }
}
X
int gettok() /**/
{
int bct = 0,pct = 0,brct = 0;
int c,d,intpos = 1;
int peekfd = -1,peek,incm;
X
beginning:
X hlastw = NULL;
X tokstr = NULL;
X incm = incmd || incond || inredir || incase;
X while (iblank(c = hgetc()) && !lexstop);
X isfirstln = 0;
X wordbeg = inbufct;
X hwbegin();
X hwaddc(c);
X if (dbparens) /* handle ((...)) */
X {
X pct = 2;
X peek = STRING;
X len = dbparens = 0;
X bptr = tokstr = ncalloc(bsiz = 256);
X for (;;)
X {
X if (c == '(')
X pct++;
X else if (c == ')')
X pct--;
X else if (c == '\n')
X {
X zerr("parse error: )) expected",NULL,0);
X peek = LEXERR;
X return peek;
X }
X else if (c == '$')
X c = Qstring;
X if (pct >= 2)
X add(c);
X if (pct)
X c = hgetc();
X else
X break;
X }
X *bptr = '\0';
X yylval.str = tokstr;
X return peek;
X }
X if (idigit(c)) /* handle 1< foo */
X {
X d = hgetc();
X hungetc(d);
X if (d == '>' || d == '<')
X {
X peekfd = c-'0';
X c = hgetc();
X }
X }
X
X /* chars in initial position in word */
X
X if (c == hashchar && (!interact || unset(SHINSTDIN) || strin ||
X isset(INTERACTIVECOMMENTS)))
X {
X while ((c = hgetch()) != '\n' && !lexstop);
X if (c == '\n')
X peek = NEWLIN;
X else
X {
X peek = (errflag) ? LEXERR : ENDINPUT;
X errflag = 1;
X }
X return peek;
X }
X if (lexstop)
X return (errflag) ? LEXERR : ENDINPUT;
X switch (lexact1[(unsigned char) c])
X {
X case LX1_BKSLASH:
X d = hgetc();
X if (d == '\n')
X goto beginning;
X hungetc(d);
X break;
X case LX1_NEWLIN: return NEWLIN;
X case LX1_SEMI:
X d = hgetc();
X if (d != ';')
X {
X hungetc(d);
X return SEMI;
X }
X return DSEMI;
X case LX1_BANG:
X d = hgetc();
X hungetc(d);
X if (!inblank(d))
X break;
X if (!incm || incond)
X return BANG;
X break;
X case LX1_AMPER:
X d = hgetc();
X if (d != '&')
X {
X hungetc(d);
X return AMPER;
X }
X return DAMPER;
X case LX1_BAR:
X d = hgetc();
X if (d == '|')
X return DBAR;
X else if (d == '&')
X return BARAMP;
X hungetc(d);
X return BAR;
X case LX1_INPAR:
X d = hgetc();
X if (d == '(' && !incm)
X {
X yylval.str = tokstr = strdup("let");
X dbparens = 1;
X return STRING;
X }
X else if (d == ')')
X return INOUTPAR;
X hungetc(d);
X if (incm && !incond)
X break;
X return INPAR;
X case LX1_OUTPAR: return OUTPAR;
X case LX1_INBRACE: if (incm) break; return INBRACE;
X case LX1_OUTBRACE: return OUTBRACE;
X case LX1_INBRACK:
X if (incm)
X break;
X d = hgetc();
X if (d == '[')
X return DINBRACK;
X hungetc(d);
X break;
X case LX1_OUTBRACK:
X if (!incond)
X break;
X incond = 0;
X d = hgetc();
X if (d == ']')
X return DOUTBRACK;
X hungetc(d);
X break;
X case LX1_INANG:
X d = hgetc();
X if ((incmd && d == '(') || incase)
X {
X hungetc(d);
X break;
X }
X else if (d == '<')
X {
X int e = hgetc();
X
X if (e == '(')
X {
X hungetc(e);
X hungetc(d);
X peek = INANG;
X }
X else if (e == '<')
X peek = TRINANG;
X else if (e == '-')
X peek = DINANGDASH;
X else
X {
X hungetc(e);
X peek = DINANG;
X }
X }
X else if (d == '&')
X peek = INANGAMP;
X else
X {
X peek = INANG;
X hungetc(d);
X }
X yylval.fds.fd1 = peekfd;
X return peek;
X case LX1_OUTANG:
X d = hgetc();
X if (d == '(')
X {
X hungetc(d);
X break;
X }
X else if (d == '&')
X {
X d = hgetc();
X if (d == '!')
X peek = OUTANGAMPBANG;
X else
X {
X hungetc(d);
X peek = OUTANGAMP;
X }
X }
X else if (d == '!')
X peek = OUTANGBANG;
X else if (d == '>')
X {
X d = hgetc();
X if (d == '&')
X {
X d = hgetc();
X if (d == '!')
X peek = DOUTANGAMPBANG;
X else
X {
X hungetc(d);
X peek = DOUTANGAMP;
X }
X }
X else if (d == '!')
X peek = DOUTANGBANG;
X else if (d == '(')
X {
X hungetc(d);
X hungetc('>');
X peek = OUTANG;
X }
X else
X {
X hungetc(d);
X peek = DOUTANG;
X }
X }
X else
X {
X hungetc(d);
X peek = OUTANG;
X }
X yylval.fds.fd1 = peekfd;
X return peek;
X }
X
X /* we've started a string, now get the rest of it, performing
X tokenization */
X
X peek = STRING;
X len = 0;
X bptr = tokstr = ncalloc(bsiz = 256);
X for(;;)
X {
X int act;
X int d;
X
X if (inblank(c))
X act = LX2_BREAK;
X else
X {
X act = lexact2[(unsigned char) c];
X c = lextok2[(unsigned char) c];
X }
X switch (act)
X {
X case LX2_BREAK: goto brk;
X case LX2_OUTPAR:
X if (!pct)
X goto brk;
X c = Outpar;
X pct--;
X break;
X case LX2_BAR:
X if (!pct && !incase)
X goto brk;
X c = Bar;
X break;
X case LX2_STRING:
X d = hgetc();
X if (d == '[')
X {
X add(String);
X add(Inbrack);
X while ((c = hgetc()) != ']' && !lexstop)
X add(c);
X c = Outbrack;
X }
X else if (d == '(')
X {
X add(String);
X skipcomm();
X c = Outpar;
X }
X else
X hungetc(d);
X break;
X case LX2_INBRACK: brct++; break;
X case LX2_OUTBRACK:
X if (incond && !brct)
X goto brk;
X brct--;
X c = Outbrack;
X break;
X case LX2_TILDE: if (intpos) c = Tilde; break;
X case LX2_INPAR:
X d = hgetc();
X hungetc(d);
X if (d == ')' || !incm)
X goto brk;
X pct++;
X c = Inpar;
X break;
X case LX2_INBRACE: bct++; break;
X case LX2_OUTBRACE:
X if (!bct)
X goto brk;
X bct--;
X c = Outbrace;
X break;
X case LX2_OUTANG:
X d = hgetc();
X if (d != '(')
X {
X hungetc(d);
X goto brk;
X }
X add(Outang);
X skipcomm();
X c = Outpar;
X break;
X case LX2_INANG:
X d = hgetc();
X if (!(idigit(d) || d == '-' || d == '>' || d == '(' || d == ')'))
X {
X hungetc(d);
X goto brk;
X }
X c = Inang;
X if (d == '(')
X {
X add(c);
X skipcomm();
X c = Outpar;
X }
X else if (d == ')')
X hungetc(d);
X else
X {
X add(c);
X c = d;
X while (c != '>' && !lexstop)
X add(c),c = hgetc();
X c = Outang;
X }
X break;
X case LX2_EQUALS:
X if (intpos)
X {
X d = hgetc();
X if (d != '(')
X {
X hungetc(d);
X c = Equals;
X }
X else
X {
X add(Equals);
X skipcomm();
X c = Outpar;
X }
X }
X else if (peek != ENVSTRING && !incm)
X {
X d = hgetc();
X if (d == '(' && !incm)
X {
X *bptr = '\0';
X yylval.str = tokstr;
X return ENVARRAY;
X }
X hungetc(d);
X peek = ENVSTRING;
X intpos = 2;
X }
X break;
X case LX2_BKSLASH:
X c = hgetc();
X if (c == '\n')
X {
X c = hgetc();
X continue;
X }
X add(c);
X c = hgetc();
X continue;
X case LX2_QUOTE:
X add(Nularg);
X
X /* we add the Nularg to prevent this:
X
X echo $PA'TH'
X
X from printing the path. */
X
X while ((c = hgetc()) != '\'' && !lexstop)
X add(c);
X c = Nularg;
X break;
X case LX2_DQUOTE:
X add(Nularg);
X while ((c = hgetc()) != '\"' && !lexstop)
X if (c == '\\')
X {
X c = hgetc();
X if (c != '\n')
X {
X if (c != '$' && c != '\\' && c != '\"' && c != '`')
X add('\\');
X add(c);
X }
X }
X else
X {
X if (c == '$')
X {
X d = hgetc();
X if (d == '(')
X {
X add(Qstring);
X skipcomm();
X c = Outpar;
X }
X else if (d == '[')
X {
X add(String);
X add(Inbrack);
X while ((c = hgetc()) != ']' && !lexstop)
X add(c);
X c = Outbrack;
X }
X else
X {
X c = Qstring;
X hungetc(d);
X }
X }
X else if (c == '`')
X c = Qtick;
X add(c);
X }
X c = Nularg;
X break;
X case LX2_BQUOTE:
X add(Tick);
X while ((c = hgetc()) != '`' && !lexstop)
X if (c == '\\')
X {
X c = hgetc();
X if (c != '\n')
X {
X if (c != '`' && c != '\\' && c != '$')
X add('\\');
X add(c);
X }
X }
X else
X {
X if (c == '$')
X c = String;
X add(c);
X }
X c = Tick;
X break;
X }
X add(c);
X c = hgetc();
X if (intpos)
X intpos--;
X if (lexstop)
X break;
X }
brk:
X hungetc(c);
X *bptr = '\0';
X yylval.str = tokstr;
X return peek;
}
X
/* expand aliases, perhaps */
X
int exalias(pk) /**/
int *pk;
{
struct alias *an;
char *s,*t;
int ic;
X
X s = yytext = hwadd();
X for (t = s; *t && *t != HISTSPACE; t++);
X if (!*t)
X t = NULL;
X else
X *t = '\0';
X ic = incmd || incond || inredir || incase;
X if (interact && isset(SHINSTDIN) && !strin && !incase && *pk == STRING &&
X (isset(CORRECTALL) || (isset(CORRECT) && !ic)) && !nocorrect)
X spckword(&yylval.str,&s,ic,1);
X if (zleparse && !alstackind)
X gotword(s);
X an = gethnode(s,aliastab);
X if (t)
X *t = HISTSPACE;
X if (alstackind != MAXAL && an && !an->inuse)
X if (!(an->cmd && ic && alstat != ALSTAT_MORE))
X {
X if (an->cmd < 0)
X {
X *pk = DO-an->cmd-1;
X return 0;
X }
X else
X {
X an->inuse = 1;
X hungets(ALPOPS);
X hungets((alstack[alstackind++] = an)->text);
X alstat = 0;
X return 1;
X }
X }
X else if (incase && DO-an->cmd-1 == ESAC)
X *pk = ESAC;
X return 0;
}
X
/* skip (...) */
X
void skipcomm() /**/
{
int pct = 1,c;
X
X c = Inpar;
X do
X {
X add(c);
X c = hgetc();
X if (itok(c) || c == EOF)
X break;
X else if (c == '(') pct++;
X else if (c == ')') pct--;
X else if (c == '\\')
X {
X add(c);
X c = hgetc();
X }
X else if (c == '\'')
X {
X add(c);
X while ((c = hgetc()) != '\'' && !lexstop)
X add(c);
X }
X else if (c == '\"')
X {
X add(c);
X while ((c = hgetc()) != '\"' && !lexstop)
X if (c == '\\')
X {
X add(c);
X add(hgetc());
X }
X else add(c);
X }
X else if (c == '`')
X {
X add(c);
X while ((c = hgetc()) != '`' && !lexstop)
X if (c == '\\') add(c), add(hgetc());
X else add(c);
X }
X }
X while(pct);
}
X
SHAR_EOF
echo 'File zsh2.00/src/lex.c is complete' &&
chmod 0644 zsh2.00/src/lex.c ||
echo 'restore of zsh2.00/src/lex.c failed'
Wc_c="`wc -c < 'zsh2.00/src/lex.c'`"
test 15255 -eq "$Wc_c" ||
echo 'zsh2.00/src/lex.c: original size 15255, current size' "$Wc_c"
# ============= zsh2.00/src/lex.pro ==============
echo 'x - extracting zsh2.00/src/lex.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/lex.pro' &&
void lexsave DCLPROTO((void));
void lexrestore DCLPROTO((void));
int yylex DCLPROTO((void));
void initlextabs DCLPROTO((void));
void lexinit DCLPROTO((void));
void add DCLPROTO((int c));
int gettok DCLPROTO((void));
int exalias DCLPROTO((int *pk));
void skipcomm DCLPROTO((void));
SHAR_EOF
chmod 0644 zsh2.00/src/lex.pro ||
echo 'restore of zsh2.00/src/lex.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/lex.pro'`"
test 281 -eq "$Wc_c" ||
echo 'zsh2.00/src/lex.pro: original size 281, current size' "$Wc_c"
# ============= zsh2.00/src/mem.c ==============
echo 'x - extracting zsh2.00/src/mem.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/mem.c' &&
/*
X
X mem.c - memory management
X
X This file is part of zsh, the Z shell.
X
X zsh is free software; no one can prevent you from reading the source
X code, or giving it to someone else.
X
X This file is copyrighted under the GNU General Public License, which
X can be found in the file called COPYING.
X
X Copyright (C) 1990, 1991 Paul Falstad
X
X zsh is distributed in the hope that it will be useful, but
X WITHOUT ANY WARRANTY. No author or distributor accepts
X responsibility to anyone for the consequences of using it or for
X whether it serves any particular purpose or works at all, unless he
X says so in writing. Refer to the GNU General Public License
X for full details.
X
X Everyone is granted permission to copy, modify and redistribute
X zsh, but only under the conditions described in the GNU General Public
X License. A copy of this license is supposed to have been given to you
X along with zsh so you can know your rights and responsibilities.
X It should be in a file named COPYING.
X
X Among other things, the copyright notice and this notice must be
X preserved on all copies.
X
*/
X
#include "zsh.h"
#define HEAPSIZE 8192
X
/*
X
X There are two ways to allocate memory in zsh. The first way is
X to call zalloc/zcalloc, which call malloc/calloc directly. It
X is legal to call realloc() or free() on memory allocated this way.
X The second way is to call halloc/hcalloc, which allocates memory
X from one of the memory pools on the heap stack. A pool can be
X created by calling pushheap(), and destroyed by calling popheap().
X To free the memory in the pool without destroying it, call
X freeheap(); this is equivalent to { popheap(); pushheap(); }
X Memory allocated in this way does not have to be freed explicitly;
X it will all be freed when the pool is destroyed. In fact,
X attempting to free this memory may result in a core dump.
X The pair of pointers ncalloc and alloc may point to either
X zalloc & zcalloc or halloc & hcalloc; permalloc() sets them to the
X former, and heapalloc() sets them to the latter. This can be useful.
X For example, the dupstruct() routine duplicates a syntax tree,
X allocating the new memory for the tree using alloc(). If you want
X to duplicate a structure for a one-time use (i.e. to execute the list
X in a for loop), call heapalloc(), then dupstruct(). If you want
X to duplicate a structure in order to preserve it (i.e. a function
X definition), call permalloc(), then dupstruct().
X
*/
X
/* initialize heap stack */
X
void meminit() /**/
{
X permalloc();
X heaplist = newlist();
X pushheap();
}
X
/* set default allocation to heap stack */
X
void heapalloc() /**/
{
X alloc = hcalloc;
X ncalloc = halloc;
X useheap = 1;
}
X
static vptr (*lastcalloc) DCLPROTO((int));
static vptr (*lastncalloc) DCLPROTO((int));
X
/* set default allocation to malloc() */
X
void permalloc() /**/
{
X lastcalloc = alloc;
X lastncalloc = ncalloc;
X alloc = zcalloc;
X ncalloc = zalloc;
X useheap = 0;
}
X
/* reset previous default allocation */
X
void lastalloc() /**/
{
X alloc = lastcalloc;
X ncalloc = lastncalloc;
}
X
struct heap {
X char *pool,*ptr;
X int free;
X struct heap *next;
X };
X
/* create a memory pool */
X
void pushheap() /**/
{
Heap h;
X
X h = (Heap) zalloc(sizeof *h);
X h->pool = h->ptr = zalloc(HEAPSIZE);
X h->free = HEAPSIZE;
X h->next = NULL;
X permalloc();
X pushnode(heaplist,h);
X lastalloc();
}
X
/* reset a memory pool */
X
void freeheap() /**/
{
Heap h = (Heap) peekfirst(heaplist);
X
X freeh(h->next);
X h->free += (h->ptr-h->pool);
X h->ptr = h->pool;
}
X
/* destroy a memory pool */
X
void popheap() /**/
{
Heap h = (Heap) getnode(heaplist);
X
X freeh(h);
}
X
void freeh(h) /**/
Heap h;
{
X if (h)
X {
X freeh(h->next);
X free(h->pool);
X free(h);
X }
}
X
/* allocate memory from the current memory pool */
X
vptr halloc(size) /**/
int size;
{
Heap h = (Heap) peekfirst(heaplist),h2;
char *ret;
X
X size = (size|7)+1;
X while (h && h->free-size < 0)
X h = h->next;
X if (!h)
X {
X h2 = (Heap) zalloc(sizeof *h2);
X h2->pool = h2->ptr = zalloc(h2->free =
X (size < HEAPSIZE) ? HEAPSIZE : (size|(HEAPSIZE-1))+1);
X h2->next = h;
X setdata(firstnode(heaplist),(Heap) h2);
X h = h2;
X }
X h->free -= size;
X ret = h->ptr;
X h->ptr += size;
X return ret;
}
X
/* allocate memory from the current memory pool and clear it */
X
vptr hcalloc(size) /**/
int size;
{
vptr ptr;
X
X ptr = halloc(size);
X bzero(ptr,size);
X return ptr;
}
X
vptr hrealloc(p,old,new) /**/
char *p;int old;int new;
{
char *ptr;
X
X ptr = halloc(new);
X memcpy(ptr,p,old);
X return ptr;
}
X
/* allocate permanent memory */
X
vptr zalloc(l) /**/
int l;
{
vptr z;
X
X if (!l)
X l = 1;
X if (!(z = malloc(l)))
X {
X zerr("fatal error: out of memory",NULL,0);
X exit(1);
X }
X return z;
}
X
vptr zcalloc(size) /**/
int size;
{
vptr ptr;
X
X ptr = zalloc(size);
X bzero(ptr,size);
X return ptr;
}
X
char *strdup(s) /**/
char *s;
{
char *t;
X
X if (!s)
X return NULL;
X t = ncalloc(strlen(s)+1);
X strcpy(t,s);
X return t;
}
X
char *ztrdup(s) /**/
char *s;
{
char *t;
X
X if (!s)
X return NULL;
X t = zalloc(strlen(s)+1);
X strcpy(t,s);
X return t;
}
X
SHAR_EOF
chmod 0644 zsh2.00/src/mem.c ||
echo 'restore of zsh2.00/src/mem.c failed'
Wc_c="`wc -c < 'zsh2.00/src/mem.c'`"
test 5001 -eq "$Wc_c" ||
echo 'zsh2.00/src/mem.c: original size 5001, current size' "$Wc_c"
# ============= zsh2.00/src/mem.pro ==============
echo 'x - extracting zsh2.00/src/mem.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/mem.pro' &&
void meminit DCLPROTO((void));
void heapalloc DCLPROTO((void));
void permalloc DCLPROTO((void));
void lastalloc DCLPROTO((void));
void pushheap DCLPROTO((void));
void freeheap DCLPROTO((void));
void popheap DCLPROTO((void));
void freeh DCLPROTO((Heap h));
vptr halloc DCLPROTO((int size));
vptr hcalloc DCLPROTO((int size));
vptr hrealloc DCLPROTO((char *p,int old,int new));
vptr zalloc DCLPROTO((int l));
vptr zcalloc DCLPROTO((int size));
char *strdup DCLPROTO((char *s));
char *ztrdup DCLPROTO((char *s));
SHAR_EOF
chmod 0644 zsh2.00/src/mem.pro ||
echo 'restore of zsh2.00/src/mem.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/mem.pro'`"
test 510 -eq "$Wc_c" ||
echo 'zsh2.00/src/mem.pro: original size 510, current size' "$Wc_c"
# ============= zsh2.00/src/subst.pro ==============
echo 'x - extracting zsh2.00/src/subst.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/subst.pro' &&
void prefork DCLPROTO((Lklist list));
void postfork DCLPROTO((Lklist list,int doglob));
void singsub DCLPROTO((char **s));
vptr nstrdup DCLPROTO((vptr s));
char *dynread DCLPROTO((int stop));
int filesub DCLPROTO((char **namptr));
char *gethome DCLPROTO((char *user,int len));
void commsubst DCLPROTO((Lklist l,Lknode n,char *str3,char *str,int qt));
void paramsubst DCLPROTO((Lklist l,Lknode n,char *aptr,char *bptr,int qt));
void arithsubst DCLPROTO((vptr *aptr,char **bptr));
void modify DCLPROTO((char **str,char **ptr));
char *dstackent DCLPROTO((int val));
struct alias *mkanode DCLPROTO((char *txt,int cmflag));
SHAR_EOF
chmod 0644 zsh2.00/src/subst.pro ||
echo 'restore of zsh2.00/src/subst.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/subst.pro'`"
test 619 -eq "$Wc_c" ||
echo 'zsh2.00/src/subst.pro: original size 619, current size' "$Wc_c"
# ============= zsh2.00/src/table.pro ==============
echo 'x - extracting zsh2.00/src/table.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/table.pro' &&
Lklist newlist DCLPROTO((void));
Hashtab newhtable DCLPROTO((int size));
int hasher DCLPROTO((char *s));
void Addhnode DCLPROTO((char *nam,vptr dat,Hashtab ht,FFunc freefunc,int canfree));
void expandhtab DCLPROTO((Hashtab ht));
vptr gethnode DCLPROTO((char *nam,Hashtab ht));
void freehtab DCLPROTO((Hashtab ht,FFunc freefunc));
vptr remhnode DCLPROTO((char *nam,Hashtab ht));
void insnode DCLPROTO((Lklist list,Lknode llast,vptr dat));
void addnodeinorder DCLPROTO((Lklist x, char *dat));
vptr remnode DCLPROTO((Lklist list,Lknode nd));
vptr uremnode DCLPROTO((Lklist list,Lknode nd));
void chuck DCLPROTO((char *str));
vptr getnode DCLPROTO((Lklist list));
vptr ugetnode DCLPROTO((Lklist list));
void freetable DCLPROTO((Lklist tab,FFunc freefunc));
char *ztrstr DCLPROTO((char *s,char *t));
void inslist DCLPROTO((Lklist l,Lknode where,Lklist x));
int countnodes DCLPROTO((Lklist x));
SHAR_EOF
chmod 0644 zsh2.00/src/table.pro ||
echo 'restore of zsh2.00/src/table.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/table.pro'`"
test 889 -eq "$Wc_c" ||
echo 'zsh2.00/src/table.pro: original size 889, current size' "$Wc_c"
# ============= zsh2.00/src/utils.pro ==============
echo 'x - extracting zsh2.00/src/utils.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/utils.pro' &&
int source DCLPROTO((char *s));
void sourcehome DCLPROTO((char *s));
void zerrnam DCLPROTO((char *cmd, char *fmt, char *str,int num));
void zerr DCLPROTO((char *fmt, char *str,int num));
void niceputc DCLPROTO((int c,FILE *f));
void intr DCLPROTO((void));
void noholdintr DCLPROTO((void));
void holdintr DCLPROTO((void));
char *fgetline DCLPROTO((char *buf,int len,FILE *in));
char *findcwd DCLPROTO((char *s));
char *fixcwd DCLPROTO((char *s));
int ispwd DCLPROTO((char *s));
char *xsymlink DCLPROTO((char *s));
char **slashsplit DCLPROTO((char *s));
int islink DCLPROTO((char *s));
int xsymlinks DCLPROTO((char *s));
void printdir DCLPROTO((char *s));
int finddir DCLPROTO((char *s));
void adduserdir DCLPROTO((char *s,char *t));
int dircmp DCLPROTO((char *s,char *t));
int ddifftime DCLPROTO((time_t t1,time_t t2));
void scanjobs DCLPROTO((void));
void preprompt DCLPROTO((void));
int arrlen DCLPROTO((char **s));
void checkmailpath DCLPROTO((char **s));
void saveoldfuncs DCLPROTO((char *x,Cmdnam y));
void newcmdnamtab DCLPROTO((void));
void freecmdnam DCLPROTO((vptr a));
void freestr DCLPROTO((vptr a));
void freeanode DCLPROTO((vptr a));
void freepm DCLPROTO((vptr a));
void restoretty DCLPROTO((void));
void gettyinfo DCLPROTO((struct ttyinfo *ti));
void settyinfo DCLPROTO((struct ttyinfo *ti));
void sanetty DCLPROTO((struct ttyinfo *ti));
void adjustwinsize DCLPROTO((void));
int zyztem DCLPROTO((char *s,char *t));
int waitfork DCLPROTO((void));
int movefd DCLPROTO((int fd));
void redup DCLPROTO((int x,int y));
void settrap DCLPROTO((int t0,List l));
void unsettrap DCLPROTO((int t0));
void dotrap DCLPROTO((int sig));
void strucpy DCLPROTO((char **s,char *t));
void struncpy DCLPROTO((char **s,char *t,int n));
void checkrmall DCLPROTO((void));
int getquery DCLPROTO((void));
void spscan DCLPROTO((char *s,char *junk));
void spckword DCLPROTO((char **s,char **s2,int cmd,int ask));
int ztrftime DCLPROTO((char *buf,int bufsize,char *fmt,struct tm *tm));
char *join DCLPROTO((char **arr,int delim));
char *spacejoin DCLPROTO((char **s));
char *colonjoin DCLPROTO((char **s));
char **colonsplit DCLPROTO((char *s));
char **spacesplit DCLPROTO((char *s));
List getshfunc DCLPROTO((char *nam));
vptr allocnode DCLPROTO((int type));
vptr dupstruct DCLPROTO((vptr a));
void freestruct DCLPROTO((vptr a));
Lklist duplist DCLPROTO((Lklist l,VFunc func));
char **mkarray DCLPROTO((char *s));
void feep DCLPROTO((void));
void freearray DCLPROTO((char **s));
int equalsplit DCLPROTO((char *s,char **t));
void simplifyright DCLPROTO((List l));
void inittyptab DCLPROTO((void));
char **arrdup DCLPROTO((char **s));
char *spname DCLPROTO((char *oldname));
int mindist DCLPROTO((char *dir,char *guess,char *best));
int spdist DCLPROTO((char *s,char *t,int thresh));
char *zgetenv DCLPROTO((char *s));
int tulower DCLPROTO((int c));
int tuupper DCLPROTO((int c));
SHAR_EOF
chmod 0644 zsh2.00/src/utils.pro ||
echo 'restore of zsh2.00/src/utils.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/utils.pro'`"
test 2865 -eq "$Wc_c" ||
echo 'zsh2.00/src/utils.pro: original size 2865, current size' "$Wc_c"
# ============= zsh2.00/src/y.tab.h ==============
echo 'x - extracting zsh2.00/src/y.tab.h (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/y.tab.h' &&
X
typedef union {
X Pline Pline;
X List List;
X Sublist Sublist;
X struct cmd *Comm;
X struct redir *Fnode;
X struct cond *Cond;
X struct forcmd *Fornode;
X struct casecmd *Casenode;
X struct ifcmd *Ifnode;
X struct whilecmd *Whilenode;
X struct repeatcmd *Repeatnode;
X struct varasg *Varnode;
X Lklist Table;
X struct fdpair fds;
X char *str;
X int value;
} YYSTYPE;
extern YYSTYPE yylval;
# define DOITNOW 257
# define EMPTY 258
# define LEXERR 259
# define SEPER 260
# define NEWLIN 261
# define SEMI 262
# define DSEMI 263
# define AMPER 264
# define INPAR 265
# define INBRACE 266
# define OUTPAR 267
# define DBAR 268
# define DAMPER 269
# define BANG 270
# define OUTBRACE 271
# define OUTANG 272
# define OUTANGBANG 273
# define DOUTANG 274
# define DOUTANGBANG 275
# define INANG 276
# define DINANG 277
# define INANGAMP 278
# define OUTANGAMP 279
# define OUTANGAMPBANG 280
# define DOUTANGAMP 281
# define DOUTANGAMPBANG 282
# define TRINANG 283
# define DINANGDASH 284
# define BAR 285
# define BARAMP 286
# define DINBRACK 287
# define DOUTBRACK 288
# define STRING 289
# define ENVSTRING 290
# define ENVARRAY 291
# define ENDINPUT 292
# define INOUTPAR 293
# define DO 294
# define DONE 295
# define ESAC 296
# define THEN 297
# define ELIF 298
# define ELSE 299
# define FI 300
# define FOR 301
# define CASE 302
# define IF 303
# define WHILE 304
# define FUNC 305
# define REPEAT 306
# define TIME 307
# define UNTIL 308
# define EXEC 309
# define COMMAND 310
# define SELECT 311
# define COPROC 312
# define NOGLOB 313
# define DASH 314
# define DOITLATER 315
SHAR_EOF
chmod 0644 zsh2.00/src/y.tab.h ||
echo 'restore of zsh2.00/src/y.tab.h failed'
Wc_c="`wc -c < 'zsh2.00/src/y.tab.h'`"
test 1565 -eq "$Wc_c" ||
echo 'zsh2.00/src/y.tab.h: original size 1565, current size' "$Wc_c"
# ============= zsh2.00/src/zle_main.pro ==============
echo 'x - extracting zsh2.00/src/zle_main.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/zle_main.pro' &&
void setterm DCLPROTO((void));
void unsetterm DCLPROTO((void));
void ungetkey DCLPROTO((int ch));
void ungetkeys DCLPROTO((char *s,int len));
unsigned int getkey DCLPROTO((int tmok));
char *zleread DCLPROTO((char *ppt,char *ppt2,int plen));
int getkeycmd DCLPROTO((void));
void sendstring DCLPROTO((void));
Key makefunckey DCLPROTO((int fun));
void initxbindtab DCLPROTO((void));
char *getkeystring DCLPROTO((char *s,int *len));
void printbind DCLPROTO((char *s,int len));
void printbinding DCLPROTO((char *str,Key k));
int bin_bindkey DCLPROTO((char *name,char **argv,char *ops,int junc));
void freekey DCLPROTO((vptr x));
SHAR_EOF
chmod 0644 zsh2.00/src/zle_main.pro ||
echo 'restore of zsh2.00/src/zle_main.pro failed'
Wc_c="`wc -c < 'zsh2.00/src/zle_main.pro'`"
test 624 -eq "$Wc_c" ||
echo 'zsh2.00/src/zle_main.pro: original size 624, current size' "$Wc_c"
# ============= zsh2.00/src/zle_tricky.c ==============
echo 'x - extracting zsh2.00/src/zle_tricky.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/zle_tricky.c' &&
/*
X
X zle_tricky.c - expansion and completion
X
X This file is part of zsh, the Z shell.
X
X zsh is free software; no one can prevent you from reading the source
X code, or giving it to someone else.
X
X This file is copyrighted under the GNU General Public License, which
X can be found in the file called COPYING.
X
X Copyright (C) 1990, 1991 Paul Falstad
X
X zsh is distributed in the hope that it will be useful, but
X WITHOUT ANY WARRANTY. No author or distributor accepts
X responsibility to anyone for the consequences of using it or for
X whether it serves any particular purpose or works at all, unless he
X says so in writing. Refer to the GNU General Public License
X for full details.
X
X Everyone is granted permission to copy, modify and redistribute
X zsh, but only under the conditions described in the GNU General Public
X License. A copy of this license is supposed to have been given to you
X along with zsh so you can know your rights and responsibilities.
X It should be in a file named COPYING.
X
X Among other things, the copyright notice and this notice must be
X preserved on all copies.
X
*/
X
#define ZLE
#include "zsh.h"
#include "y.tab.h"
#include <sys/dir.h>
#include <pwd.h>
X
static int we,wb,usemenu,useglob;
X
static int menub,menue,menuw;
static Lklist menulist;
static Lknode menunode;
X
#define INCMD (incmd||incond||inredir||incase)
X
#define inststr(X) inststrlen((X),-1)
X
/* strncpy() does not null always terminate the string, pem */
#define STRNCPY(s1, s2, len) (strncpy(s1, s2, len), s1[len] = '\0')
X
int usetab() /**/
{
char *s = line+cs-1;
X
X for (; s >= line && *s != '\n'; s--)
X if (*s != '\t' && *s != ' ')
X return 0;
X return 1;
}
X
#define COMP_COMPLETE 0
#define COMP_LIST_COMPLETE 1
#define COMP_SPELL 2
#define COMP_EXPAND 3
#define COMP_EXPAND_COMPLETE 4
#define COMP_LIST_EXPAND 5
#define COMP_ISEXPAND(X) ((X) >= COMP_EXPAND)
X
void completeword() /**/
{
X usemenu = isset(MENUCOMPLETE) || (useglob = isset(GLOBCOMPLETE));
X if (c == '\t' && usetab())
X selfinsert();
X else
X docomplete(COMP_COMPLETE);
}
X
void menucompleteword() /**/
{
X usemenu = 1; useglob = isset(GLOBCOMPLETE);
X if (c == '\t' && usetab())
X selfinsert();
X else
X docomplete(COMP_COMPLETE);
}
X
void listchoices() /**/
{
X usemenu = isset(MENUCOMPLETE) || (useglob = isset(GLOBCOMPLETE));
X docomplete(COMP_LIST_COMPLETE);
}
X
void spellword() /**/
{
X usemenu = useglob = 0;
X docomplete(COMP_SPELL);
}
X
void deletecharorlist() /**/
{
X usemenu = isset(MENUCOMPLETE) || (useglob = isset(GLOBCOMPLETE));
X if (cs != ll)
X deletechar();
X else
X docomplete(COMP_LIST_COMPLETE);
}
X
void expandword() /**/
{
X usemenu = useglob = 0;
X if (c == '\t' && usetab())
X selfinsert();
X else
X docomplete(COMP_EXPAND);
}
X
void expandorcomplete() /**/
{
X usemenu = isset(MENUCOMPLETE) || (useglob = isset(GLOBCOMPLETE));
X if (c == '\t' && usetab())
X selfinsert();
X else
X docomplete(COMP_EXPAND_COMPLETE);
}
X
void menuexpandorcomplete() /**/
{
X usemenu = 1; useglob = isset(GLOBCOMPLETE);
X if (c == '\t' && usetab())
X selfinsert();
X else
X docomplete(COMP_EXPAND_COMPLETE);
}
X
void listexpand() /**/
{
X usemenu = isset(MENUCOMPLETE); useglob = isset(GLOBCOMPLETE);
X docomplete(COMP_LIST_EXPAND);
}
X
void reversemenucomplete() /**/
{
char *s;
X
X if (!menucmp)
X menucompleteword(); /* better than just feep'ing, pem */
X if (!menucmp) return;
X cs = menub;
X foredel(menue-menub);
X if (menunode == firstnode(menulist))
X menunode = lastnode(menulist);
X else
X menunode = prevnode(menunode);
X inststr(s = menunode->dat);
X menue = cs;
}
X
/*
X * Accepts the current completion and starts a new arg,
X * with the next completions. This gives you a way to accept
X * several selections from the list of matches.
X */
void acceptandmenucomplete() /**/
{
int t0,t1;
X
X if (!menucmp)
X {
X feep();
X return;
X }
X spaceinline(1);
X line[cs++] = ' ';
X spaceinline(menub-menuw);
X t1 = cs;
X for (t0 = menuw; t0 != menub; t0++)
X line[cs++] = line[t0];
X menue = menub = cs;
X menuw = t1;
X menucompleteword();
}
X
void docomplete(lst) /**/
int lst;
{
int t0,lincmd = INCMD;
char *s;
X
X if (menucmp)
X {
X if (lst == COMP_LIST_COMPLETE)
X {
X listmatches(menulist, NULL);
X return;
X }
X cs = menub;
X foredel(menue-menub);
X incnode(menunode);
X if (!menunode)
X menunode = firstnode(menulist);
X s = menunode->dat;
X if (*s == '~' || *s == '=')
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X inststr(s = menunode->dat);
X menue = cs;
X return;
X }
X if (doexpandhist())
X return;
X zleparse = 1;
X eofseen = 0;
X lexsave();
X hungets(" "); /* KLUDGE! */
X hungets(line);
X strinbeg();
X pushheap();
X while (!eofseen && zleparse)
X {
X lincmd = INCMD;
X if ((t0 = yylex()) == ENDINPUT)
X break;
X }
X if (t0 == ENDINPUT)
X {
X s = ztrdup("");
X we = wb = cs;
X t0 = STRING;
X }
X else if (t0 == STRING)
X s = ztrdup(yylval.str);
X hflush();
X strinend();
X errflag = zleparse = 0;
X if (we > ll)
X we = ll;
X if (lst == COMP_EXPAND_COMPLETE)
X {
X char *q = s;
X
X if (*q == Tilde)
X lst = COMP_COMPLETE;
X else if (*q == Equals)
X {
X for (q++; *q; q++)
X if (*q == '/')
X break;
X if (!*q)
X lst = COMP_EXPAND;
X q = s+1;
X }
X if (lst == COMP_EXPAND_COMPLETE)
X {
X for (; *q; q++)
X if (itok(*q))
X break;
X if (!*q)
X lst = COMP_COMPLETE;
X }
X }
X if (t0 != STRING)
X feep();
X else
X {
X if (lst == COMP_SPELL)
X {
X char **x = &s;
X untokenize(s);
X cs = wb;
X foredel(we-wb);
X /* call the real spell checker, ash at aaii.oz.zu */
X spckword(x, NULL, lincmd, 0);
X inststr(*x);
X }
X else if (COMP_ISEXPAND(lst))
X doexpansion(s,lst,lincmd);
X else
X {
X if (!useglob)
X untokenize(s);
X docompletion(s,lst,lincmd);
X }
X free(s);
X }
X popheap();
X lexrestore();
}
X
void doexpansion(s,lst,lincmd) /**/
char *s;int lst;int lincmd;
{
Lklist vl = newlist();
char *ss;
X
X pushheap();
X addnode(vl,s);
X prefork(vl);
X if (errflag)
X goto end;
X postfork(vl,1);
X if (errflag)
X goto end;
X if (lst == COMP_LIST_EXPAND)
X {
X listmatches(vl,NULL);
X goto end;
X }
X else if (peekfirst(vl) == s)
X {
X if (lst == COMP_EXPAND_COMPLETE)
X {
X untokenize(s);
X docompletion(s,COMP_COMPLETE,lincmd);
X }
X else
X feep();
X goto end;
X }
X if (!full(vl) || !*(char *) peekfirst(vl))
X {
X feep();
X goto end;
X }
X cs = wb;
X foredel(we-wb);
X while (ss = ugetnode(vl))
X {
X inststr(ss);
X if (full(vl))
X {
X spaceinline(1);
X line[cs++] = ' ';
X }
X }
end:
X popheap();
X setterm();
}
X
void gotword(s) /**/
char *s;
{
X we = ll+1-inbufct;
X if (cs <= we)
X {
X wb = ll-wordbeg;
X zleparse = 0;
X /* major hack ahead */
X if (wb && line[wb] == '!' && line[wb-1] == '\\')
X wb--;
X }
}
X
void inststrlen(s,l) /**/
char *s;int l;
{
char *t,*u,*v;
X
X t = halloc(strlen(s)*2+2);
X u = s;
X v = t;
X for (; *u; u++)
X {
X if (l != -1 && !l--)
X break;
X if (ispecial(*u))
X if (*u == '\n')
X {
X *v++ = '\'';
X *v++ = '\n';
X *v++ = '\'';
X continue;
X }
X else
X *v++ = '\\';
X *v++ = *u;
X }
X *v = '\0';
X spaceinline(strlen(t));
X strncpy(line+cs,t,strlen(t));
X cs += strlen(t);
}
X
static int ambig,haspath,exact;
static Lklist matches;
static char *pat;
X
void addmatch(s) /**/
char *s;
{
X if (full(matches))
X {
X int y = pfxlen(peekfirst(matches),s);
X
X if (y < ambig)
X ambig = y;
X }
X else
X ambig = strlen(s);
X if (!strcmp(pat,s))
X exact = 1;
X addnodeinorder(matches,strdup(s));
}
X
X
void addcmdmatch(s,t) /**/
char *s;char *t;
{
X if (strpfx(pat,s))
X addmatch(s);
}
X
void maketildelist(s) /**/
char *s;
{
X struct passwd *pwd;
X int len;
X
X s++;
X len = strlen(s);
X if (len < 1) {
X addmatch(s);
X *s = 0;
X return;
X }
X while ((pwd = getpwent()) != NULL && !errflag)
X if (strncmp(pwd->pw_name, s, len) == 0)
X addmatch(pwd->pw_name);
X endpwent();
X *s = 0;
}
X
/*
X * opendir that handles '~' and '='.
X * orig. by ash at aaii.oz.au, mod. by pf
X */
DIR *OPENDIR(s)
char *s;
{
X if (*s != '~' && *s != '=')
X return(opendir(s));
X s = strdup(s);
X *s = (*s == '=') ? Equals : Tilde;
X filesub(&s);
X return(opendir(s));
}
X
int Isdir(s) /**/
char *s;
{
struct stat sbuf;
X
X if (stat(s,&sbuf) == -1)
X return 0;
X return S_ISDIR(sbuf.st_mode);
}
X
int isdir(t,s) /**/
char *t;char *s;
{
char buf[MAXPATHLEN];
X
X sprintf(buf,"%s/%s",(s) ? s : ".",t);
X s = buf;
X if (*s != '~' && *s != '=')
X return(Isdir(s));
X s = strdup(s);
X *s = (*s == '=') ? Equals : Tilde;
X filesub(&s);
X return(Isdir(s));
}
X
void docompletion(s,lst,incmd) /**/
char *s;int lst;int incmd;
{
DIR *d;
struct direct *de;
char *u,*ppfx = NULL;
int commcomp = 0;
int tildeexpand = 0;
char *ss;
int addedstar = 0;
X
X heapalloc();
X pushheap();
X ss = strdup(s);
X matches = newlist();
X if (useglob)
X {
X char *pt;
X char ch;
X int hasp = 0;
X
X /*
X * Find the longest prefix string without any
X * chars special to glob - ash.
X */
X for (pt = s; *pt; pt++)
X {
X if (pt == s && (*pt == Tilde || *pt == Equals))
X continue;
X if (ispecial(*pt) || itok(*pt))
X break;
X }
X for (; pt > s && *pt != '/'; pt--)
X ;
X if (*pt == '/')
X {
X *pt = 0;
X u = pt + 1;
X wb += strlen(s) + 1;
X hasp = 1;
X }
X else
X u = s;
X if (!hasp && (*s == Tilde || *s == Equals))
X {
X /* string contains only ~xx, so do tilde expansion */
X maketildelist(s);
X wb++;
X ppfx = s;
X tildeexpand = 1;
X }
X else
X {
X int commonprefix = 0;
X char *prefix;
X Lknode n;
X int nonomatch = isset(NONOMATCH);
X
X opts[NONOMATCH] = 1;
X if (hasp)
X {
X /* Find the longest common prefix string
X * after globbing the input. All expansions
X * ~foo/bar/* will turn into something like
X * /tmp_mnt/hosts/somehost/home/foo/...
X * We will remove this common prefix from the matches.
X * ash, 7 May '91
X */
X addnode(matches,s);
X prefork(matches);
X if (!errflag)
X postfork(matches,1);
X if (!errflag)
X {
X prefix = peekfirst(matches);
X if (prefix)
X commonprefix = strlen(prefix) + 1;
X *pt = '/';
X }
X }
X if (s[strlen(s) - 1] == '/') {
X /* if strings ends in a '/' always add a '*' */
X s = dyncat(s,"x");
X s[strlen(s)-1] = Star;
X addedstar = 1;
X };
X matches = newlist();
X addnode(matches,s);
X prefork(matches);
X if (!errflag)
X postfork(matches,1);
X opts[NONOMATCH] = nonomatch;
X if (errflag || !full(matches) || !nextnode(firstnode(matches)))
X {
X /* if there were no matches (or only one)
X add a trailing * and try again */
X s = dyncat(s,"x");
X s[strlen(s)-1] = Star;
X addedstar = 1;
X matches = newlist();
X addnode(matches,s);
X prefork(matches);
X if (errflag)
X goto end;
X postfork(matches,1);
X if (errflag)
X goto end;
X }
X if (commonprefix)
X /* remove the common prefix from all the matches */
X for (n = firstnode(matches); n; incnode(n))
X (char *)(n->dat) += commonprefix;
X s = pt;
X *s = 0;
X }
X }
X else
X {
X haspath = exact = 0;
X for (u = s+strlen(s); u >= s && *u != '/'; u--);
X if (u >= s)
X {
X *u++ = '\0';
X haspath = 1;
X }
X else
X u = s;
X pat = u;
X if (commcomp = !incmd && !haspath)
X {
X listhtable(aliastab ,addcmdmatch);
X listhtable(cmdnamtab,addcmdmatch);
X }
X else if ((*s == '~' || *s == '=') && !haspath)
X {
X maketildelist(s);
X ppfx = s;
X tildeexpand = 1;
X }
X else if (d = OPENDIR(ppfx =
X ((haspath || *s == '~') ? ((*s) ? s : "/") : ".")))
X {
X char *q;
X
X readdir(d); readdir(d);
X while ((de = readdir(d)) && !errflag)
X if (strpfx(pat,q = de->d_name) &&
X (*q != '.' || *u == '.' || isset(GLOBDOTS)))
X addmatch(q);
X closedir(d);
X }
X }
X if (full(matches) && nextnode(firstnode(matches)))
X {
X Lknode z,zn;
X
X for (z = firstnode(matches); z; z = zn)
X {
X char *q = getdata(z);
X int namlen = strlen(q);
X int slen = strlen(ss);
X char **pt = fignore;
X
X zn = nextnode(z);
X for (; *pt; pt++)
X {
X /* We try to be smart here and override the
X fignore variable if the user has explicity
X used the ignored prefix, pem, 7 May 1991 */
X if (!addedstar && strcmp(ss+slen-strlen(*pt), *pt) == 0)
X continue;
X if (strlen(*pt) < namlen && !strcmp(q+namlen-strlen(*pt),*pt))
X {
X uremnode(matches,z);
X break;
X }
X }
X }
X }
X if (!full(matches) || errflag)
X feep();
X else if (lst == COMP_LIST_COMPLETE)
X listmatches(matches,
X unset(LISTTYPES) ? NULL : (haspath) ? ppfx : "./");
X else if (nextnode(firstnode(matches)))
X {
X if (usemenu)
X {
X menucmp = 1;
X if (isset(MENUCOMPLETEBEEP))
X feep();
X cs = wb;
X menuw = cs;
X foredel(we-wb);
X if (*s == '~' || *s == '=')
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X if (haspath)
X {
X inststr(s);
X spaceinline(1);
X line[cs++] = '/';
X }
X menub = cs;
X s = peekfirst(matches);
X if ((*s == '~' || *s == '=') && !haspath)
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X inststr(s);
X menue = cs;
X permalloc();
X menulist = duplist(matches,ztrdup);
X heapalloc();
X menunode = firstnode(menulist);
X popheap();
X permalloc();
X return;
X }
X else if (useglob)
X {
X feep();
X if (isset(AUTOLIST))
X listmatches(matches,
X unset(LISTTYPES) ? NULL : (haspath) ? ppfx : "./");
X goto end;
X }
X cs = wb;
X foredel(we-wb);
X if (*s == '~' || *s == '=')
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X if (haspath)
X {
X inststr(s);
X spaceinline(1);
X line[cs++] = '/';
X }
X if (isset(RECEXACT) && exact)
X {
X if ((*u == '~' || *u == '=') && !haspath)
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X inststr(u);
X spaceinline(1);
X line[cs++] = (!commcomp && (tildeexpand ||
X isdir(u,ppfx)) ? '/' : ' ');
X }
X else
X {
X s = peekfirst(matches);
X if ((*s == '~' || *s == '=') && !haspath)
X {
X spaceinline(1);
X line[cs++] = *s++;
X ambig--;
X }
X inststrlen(s,ambig);
X refresh();
X feep();
X if (isset(AUTOLIST))
X listmatches(matches,
X unset(LISTTYPES) ? NULL : (haspath) ? ppfx : "./");
X }
X }
X else
X {
X cs = wb;
X foredel(we-wb);
X if (*s == '~' || *s == '=')
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X if (haspath)
X {
X inststr(s);
X spaceinline(1);
X line[cs++] = '/';
X }
X s = peekfirst(matches);
X if ((*s == '~' || *s == '=') && !haspath)
X {
X spaceinline(1);
X line[cs++] = *s++;
X }
X inststr(s);
X spaceinline(1);
X line[cs++] = (!commcomp && (tildeexpand ||
X isdir(peekfirst(matches),ppfx)) ? '/' : ' ');
X }
X ll = strlen(line);
end:
X setterm();
X popheap();
X permalloc();
}
X
int strpfx(s,t) /**/
char *s;char *t;
{
X while (*s && *s == *t) s++,t++;
X return !*s;
}
X
int pfxlen(s,t) /**/
char *s;char *t;
{
int i = 0;
X
X while (*s && *s == *t) s++,t++,i++;
X return i;
}
X
void listmatches(l,apps) /**/
Lklist l;char *apps;
{
int longest = 1,fct,fw = 0,colsz,t0,t1,ct;
Lknode n;
char **arr,**ap;
X
X trashzle();
X ct = countnodes(l);
X if (listmax && ct > listmax)
X {
X fprintf(stdout,"zsh: do you wish to see all %d possibilities? ",ct);
X fflush(stdout);
X if (getquery() != 'y')
X return;
X }
X ap = arr = alloc((countnodes(l)+1)*sizeof(char **));
X for (n = firstnode(l); n; incnode(n))
X *ap++ = getdata(n);
X *ap = NULL;
X for (ap = arr; *ap; ap++)
X if (strlen(*ap) > longest)
X longest = strlen(*ap);
X if (apps)
X {
X apps = strdup(apps);
X if (*apps == '~')
X *apps = Tilde;
X else if (*apps == '=')
X *apps = Equals;
X filesub(&apps);
X longest++;
X }
X qsort(arr,ct,sizeof(char *),forstrcmp);
X fct = (columns-1)/(longest+2);
X if (fct == 0)
X fct = 1;
X else
X fw = (columns-1)/fct;
X colsz = (ct+fct-1)/fct;
X for (t1 = 0; t1 != colsz; t1++)
X {
X ap = arr+t1;
X if (apps)
X do
X {
X int t2 = strlen(*ap)+1;
X char pbuf[MAXPATHLEN];
X struct stat buf;
X
X printf("%s",*ap);
X sprintf(pbuf,"%s/%s",apps,*ap);
X if (lstat(pbuf,&buf))
X putchar(' ');
X else switch (buf.st_mode & S_IFMT) /* screw POSIX */
X {
X case S_IFDIR: putchar('/'); break;
#ifdef S_IFIFO
X case S_IFIFO: putchar('|'); break;
#endif
X case S_IFCHR: putchar('%'); break;
X case S_IFBLK: putchar('#'); break;
X case S_IFLNK: putchar('@'); break;
X case S_IFSOCK: putchar('='); break;
X default:
X if (buf.st_mode & 0111)
X putchar('*');
X else
X putchar(' ');
X break;
X }
X for (; t2 < fw; t2++) putchar(' ');
X for (t0 = colsz; t0 && *ap; t0--,ap++);
X }
X while (*ap);
X else
X do
X {
X int t2 = strlen(*ap);
X
X printf("%s",*ap);
X for (; t2 < fw; t2++) putchar(' ');
X for (t0 = colsz; t0 && *ap; t0--,ap++);
X }
X while (*ap);
X putchar('\n');
X }
X resetneeded = 1;
X fflush(stdout);
}
X
void selectlist(l) /**/
Lklist l;
{
int longest = 1,fct,fw = 0,colsz,t0,t1,ct;
Lknode n;
char **arr,**ap;
X
X trashzle();
X ct = countnodes(l);
X ap = arr = alloc((countnodes(l)+1)*sizeof(char **));
X for (n = firstnode(l); n; incnode(n))
X *ap++ = getdata(n);
X *ap = NULL;
X for (ap = arr; *ap; ap++)
X if (strlen(*ap) > longest)
X longest = strlen(*ap);
X t0 = ct;
X longest++;
X while (t0)
X t0 /= 10, longest++;
X fct = (columns-1)/(longest+2);
X if (fct == 0)
X fct = 1;
X else
X fw = (columns-1)/fct;
X colsz = (ct+fct-1)/fct;
X for (t1 = 0; t1 != colsz; t1++)
X {
X ap = arr+t1;
X do
X {
X int t2 = strlen(*ap)+1,t3;
X
X fprintf(stderr,"%d %s",t3 = ap-arr+1,*ap);
X while (t3)
X t2++,t3 /= 10;
X for (; t2 < fw; t2++) fputc(' ',stderr);
X for (t0 = colsz; t0 && *ap; t0--,ap++);
X }
X while (*ap);
X fputc('\n',stderr);
X }
X resetneeded = 1;
X fflush(stderr);
}
X
int doexpandhist() /**/
{
char *cc,*ce;
int t0;
X
X for (cc = line, ce = line+ll; cc < ce; cc++)
X if (*cc == bangchar || *cc == hatchar)
X break;
X if (cc == ce)
X return 0;
X zleparse = 1;
X eofseen = 0;
X lexsave();
X hungets(line);
X strinbeg();
X pushheap();
X ll = cs = 0;
X for(;;)
X {
X t0 = hgetc();
X if (lexstop)
X break;
X spaceinline(1);
X line[cs++] = t0;
X }
X hflush();
X popheap();
X strinend();
X errflag = zleparse = 0;
X t0 = histdone;
X lexrestore();
X line[ll = cs] = '\0';
X return t0;
}
X
void magicspace() /**/
{
X doexpandhist();
X c = ' ';
X selfinsert();
}
X
void expandhistory() /**/
{
X if (!doexpandhist())
X feep();
}
X
char *getcurcmd() /**/
{
int t0,lincmd = INCMD;
char *s = NULL;
X
X zleparse = 1;
X eofseen = 0;
X lexsave();
X hungets(" "); /* KLUDGE! */
X hungets(line);
X strinbeg();
X pushheap();
X while (!eofseen && zleparse)
X {
X if ((t0 = yylex()) == ENDINPUT)
X break;
X else if (t0 == STRING && !lincmd)
X {
X if (s)
X free(s);
X s = ztrdup(yylval.str);
X }
X lincmd = INCMD;
X }
X hflush();
X popheap();
X strinend();
X errflag = zleparse = 0;
X lexrestore();
X return s;
}
X
void processcmd() /**/
{
char *s;
X
X s = getcurcmd();
X if (s)
X {
X char *t;
X
X t = zlecmds[bindk].name;
X mult = 1;
X pushline();
X sizeline(strlen(s)+strlen(t)+1);
X strcpy(line,t);
X strcat(line," ");
X cs = ll = strlen(line);
X inststr(s);
X free(s);
X done = 1;
X }
X else
X feep();
}
X
void freemenu() /**/
{
X if (menucmp)
X {
X menucmp = 0;
X freetable(menulist,freestr);
X }
}
X
SHAR_EOF
chmod 0644 zsh2.00/src/zle_tricky.c ||
echo 'restore of zsh2.00/src/zle_tricky.c failed'
Wc_c="`wc -c < 'zsh2.00/src/zle_tricky.c'`"
test 18859 -eq "$Wc_c" ||
echo 'zsh2.00/src/zle_tricky.c: original size 18859, current size' "$Wc_c"
# ============= zsh2.00/src/zle_tricky.pro ==============
echo 'x - extracting zsh2.00/src/zle_tricky.pro (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'zsh2.00/src/zle_tricky.pro' &&
int usetab DCLPROTO((void));
void completeword DCLPROTO((void));
void globcomplete DCLPROTO((void));
void menucompleteword DCLPROTO((void));
void listchoices DCLPROTO((void));
void spellword DCLPROTO((void));
void deletecharorlist DCLPROTO((void));
void expandword DCLPROTO((void));
void expandorcomplete DCLPROTO((void));
void menuexpandorcomplete DCLPROTO((void));
void listexpand DCLPROTO((void));
void reversemenucomplete DCLPROTO((void));
void acceptandmenucomplete DCLPROTO((void));
void docomplete DCLPROTO((int lst));
void doexpansion DCLPROTO((char *s,int lst,int lincmd));
void gotword DCLPROTO((char *s));
void inststrlen DCLPROTO((char *s,int l));
void addmatch DCLPROTO((char *s));
void addcmdmatch DCLPROTO((char *s,char *t));
void maketildelist DCLPROTO((char *s));
int Isdir DCLPROTO((char *s));
int isdir DCLPROTO((char *t,char *s));
void docompletion DCLPROTO((char *s,int lst,int incmd));
int strpfx DCLPROTO((char *s,char *t));
int pfxlen DCLPROTO((char *s,char *t));
void listmatches DCLPROTO((Lklist l,char *apps));
void selectlist DCLPROTO((Lklist l));
int doexpandhist DCLPROTO((void));
void magicspace DCLPROTO((void));
void expandhistory DCLPROTO((void));
char *getcurcmd DCLPROTO((void));
void processcmd DCLPROTO((void));
SHAR_EOF
true || echo 'restore of zsh2.00/src/zle_tricky.pro failed'
echo 'End of part 5'
echo 'File zsh2.00/src/zle_tricky.pro is continued in part 6'
echo 6 > _shar_seq_.tmp
exit 0
Paul Falstad pfalstad at phoenix.princeton.edu
And on the roads, too, vicious gangs of KEEP LEFT signs!
If Princeton knew my opinions, they'd have expelled me long ago.
exit 0 # Just in case...
--
Kent Landfield INTERNET: kent at sparky.IMD.Sterling.COM
Sterling Software, IMD UUCP: uunet!sparky!kent
Phone: (402) 291-8300 FAX: (402) 291-4362
Please send comp.sources.misc-related mail to kent at uunet.uu.net.
More information about the Comp.sources.misc
mailing list