void
createaliastable(void)
{
aliastab = newhashtable(23);
aliastab->hash = hasher;
aliastab->emptytable = NULL;
aliastab->filltable = NULL;
aliastab->addnode = addhashnode;
aliastab->getnode = gethashnode;
aliastab->getnode2 = gethashnode2;
aliastab->removenode = removehashnode;
aliastab->disablenode = disablehashnode;
aliastab->enablenode = enablehashnode;
aliastab->freenode = freealiasnode;
aliastab->printnode = printaliasnode;
#ifdef ZSH_HASH_DEBUG
aliastab->printinfo = printhashtabinfo;
aliastab->tablename = ztrdup("aliastab");
#endif
/* add the default aliases */
aliastab->addnode(aliastab, ztrdup("run-help"), createaliasnode(ztrdup("man"), 0));
aliastab->addnode(aliastab, ztrdup("which-command"), createaliasnode(ztrdup("whence"), 0));
}
void
hashdir(char **dirp)
{
Cmdnam cn;
DIR *dir;
char *fn;
if (isrelative(*dirp) || !(dir = opendir(unmeta(*dirp))))
return;
while ((fn = zreaddir(dir))) {
/* Ignore `.' and `..'. */
if (fn[0] == '.' &&
(fn[1] == '\0' ||
(fn[1] == '.' && fn[2] == '\0')))
continue;
#ifndef WINNT
if (!cmdnamtab->getnode(cmdnamtab, fn)) {
cn = (Cmdnam) zcalloc(sizeof *cn);
cn->flags = 0;
cn->u.name = dirp;
cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
}
#else
if (!cmdnamtab->getnode(cmdnamtab, fn)) {
char *fext;
fext = fn;
while(*fext++)
;
while((fext >fn )&& (*fext != '.'))
fext--;
if ( (fext == fn) /*no extension */
|| is_pathext(fext+1) ) {
cn = (Cmdnam) zcalloc(sizeof *cn);
cn->flags = 0;
cn->u.name = dirp;
cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
/*if (fext != fn && !strnicmp(fext+1,"exe",3)) */
*fext = 0;
cn = (Cmdnam) zcalloc(sizeof *cn);
cn->flags = 0;
cn->u.name = dirp;
cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
}
#ifdef ZSH_HASH_DEBUG
printhashtabinfo(cmdnamtab);
#endif /* ZSH_HASH_DEBUG */
}
#endif /* WINNT */
}
closedir(dir);
}
mod_export char *
zlegetline(int *ll, int *cs)
{
if (zlemetaline != NULL) {
*ll = zlemetall;
*cs = zlemetacs;
return ztrdup(zlemetaline);
}
if (zleline)
return zlelineasstring(zleline, zlell, zlecs, ll, cs, 0);
*ll = *cs = 0;
return ztrdup("");
}
void
setline(char *s, int flags)
{
char *scp;
UNMETACHECK();
if (flags & ZSL_COPY)
scp = ztrdup(s);
else
scp = s;
/*
* TBD: we could make this more efficient by passing the existing
* allocated line to stringaszleline.
*/
free(zleline);
zleline = stringaszleline(scp, 0, &zlell, &linesz, NULL);
if ((flags & ZSL_TOEND) && (zlecs = zlell) && invicmdmode())
DECCS();
else if (zlecs > zlell)
zlecs = zlell;
CCRIGHT();
if (flags & ZSL_COPY)
free(scp);
}
static void
setpmmapfiles(Param pm, HashTable ht)
{
int i;
HashNode hn;
/* just to see if I've understood what's happening */
DPUTS(pm != mapfile_pm, "BUG: setpmmapfiles called for wrong param");
if (!ht)
return;
if (!(pm->flags & PM_READONLY))
for (i = 0; i < ht->hsize; i++)
for (hn = ht->nodes[i]; hn; hn = hn->next) {
struct value v;
v.isarr = v.inv = v.start = 0;
v.end = -1;
v.arr = NULL;
v.pm = (Param) hn;
setpmmapfile(v.pm, ztrdup(getstrvalue(&v)));
}
deleteparamtable(ht);
}
static void
set_compstate(UNUSED(Param pm), HashTable ht)
{
struct compparam *cp;
Param *pp;
HashNode hn;
int i;
struct value v;
char *str;
if (!ht)
return;
for (i = 0; i < ht->hsize; i++)
for (hn = ht->nodes[i]; hn; hn = hn->next)
for (cp = compkparams,
pp = compkpms; cp->name; cp++, pp++)
if (!strcmp(hn->nam, cp->name)) {
v.isarr = v.flags = v.start = 0;
v.end = -1;
v.arr = NULL;
v.pm = (Param) hn;
if (cp->type == PM_INTEGER)
*((zlong *) cp->var) = getintvalue(&v);
else if ((str = getstrvalue(&v))) {
zsfree(*((char **) cp->var));
*((char **) cp->var) = ztrdup(str);
}
(*pp)->node.flags &= ~PM_UNSET;
break;
}
deleteparamtable(ht);
}
mod_export Cpattern
cp_cpattern_element(Cpattern o)
{
Cpattern n = zalloc(sizeof(struct cpattern));
n->next = NULL;
n->tp = o->tp;
switch (o->tp)
{
case CPAT_CCLASS:
case CPAT_NCLASS:
case CPAT_EQUIV:
n->u.str = ztrdup(o->u.str);
break;
case CPAT_CHAR:
n->u.chr = o->u.chr;
break;
default:
/* just to keep compiler quiet */
break;
}
return n;
}
void
createreswdtable(void)
{
Reswd rw;
reswdtab = newhashtable(23);
reswdtab->hash = hasher;
reswdtab->emptytable = NULL;
reswdtab->filltable = NULL;
reswdtab->addnode = addhashnode;
reswdtab->getnode = gethashnode;
reswdtab->getnode2 = gethashnode2;
reswdtab->removenode = NULL;
reswdtab->disablenode = disablehashnode;
reswdtab->enablenode = enablehashnode;
reswdtab->freenode = NULL;
reswdtab->printnode = printreswdnode;
#ifdef ZSH_HASH_DEBUG
reswdtab->printinfo = printhashtabinfo;
reswdtab->tablename = ztrdup("reswdtab");
#endif
for (rw = reswds; rw->nam; rw++)
reswdtab->addnode(reswdtab, rw->nam, rw);
}
void
createbuiltintable(void)
{
Builtin bn;
builtintab = newhashtable(85);
builtintab->hash = hasher;
builtintab->emptytable = NULL;
builtintab->filltable = NULL;
builtintab->addnode = addhashnode;
builtintab->getnode = gethashnode;
builtintab->getnode2 = gethashnode2;
builtintab->removenode = NULL;
builtintab->disablenode = disablehashnode;
builtintab->enablenode = enablehashnode;
builtintab->freenode = NULL;
builtintab->printnode = printbuiltinnode;
#ifdef ZSH_HASH_DEBUG
builtintab->printinfo = printhashtabinfo;
builtintab->tablename = ztrdup("builtintab");
#endif
for (bn = builtins; bn->nam; bn++)
builtintab->addnode(builtintab, bn->nam, bn);
}
static int
domove(char *nam, MoveFunc movefn, char *p, char *q, int flags)
{
struct stat st;
char *pbuf, *qbuf;
pbuf = ztrdup(unmeta(p));
qbuf = unmeta(q);
if(flags & MV_NODIRS) {
errno = EISDIR;
if(lstat(pbuf, &st) || S_ISDIR(st.st_mode)) {
zwarnnam(nam, "%s: %e", p, errno);
zsfree(pbuf);
return 1;
}
}
if(!lstat(qbuf, &st)) {
int doit = flags & MV_FORCE;
if(S_ISDIR(st.st_mode)) {
zwarnnam(nam, "%s: cannot overwrite directory", q);
zsfree(pbuf);
return 1;
} else if(flags & MV_INTERACTIVE) {
nicezputs(nam, stderr);
fputs(": replace `", stderr);
nicezputs(q, stderr);
fputs("'? ", stderr);
fflush(stderr);
if(!ask()) {
zsfree(pbuf);
return 0;
}
doit = 1;
} else if((flags & MV_ASKNW) &&
!S_ISLNK(st.st_mode) &&
access(qbuf, W_OK)) {
nicezputs(nam, stderr);
fputs(": replace `", stderr);
nicezputs(q, stderr);
fprintf(stderr, "', overriding mode %04o? ",
mode_to_octal(st.st_mode));
fflush(stderr);
if(!ask()) {
zsfree(pbuf);
return 0;
}
doit = 1;
}
if(doit && !(flags & MV_ATOMIC))
unlink(qbuf);
}
if(movefn(pbuf, qbuf)) {
zwarnnam(nam, "%s: %e", p, errno);
zsfree(pbuf);
return 1;
}
zsfree(pbuf);
return 0;
}
/**
* This function will be called whenever the prompt is drawn by the zle.
* Sets the zsh global variable 'prompt' which is equivalent to the env
* PROMPT / PS1.
*/
static void rift_prompt(void)
{
const char* rw_prompt = rwcli_get_prompt();
if (rw_prompt) {
zfree(prompt, 0);
prompt = ztrdup(rw_prompt);
}
}
mod_export void
makesuffixstr(char *f, char *s, int n)
{
if (f) {
zsfree(suffixfunc);
suffixfunc = ztrdup(f);
suffixfunclen = n;
} else if (s) {
int inv, i, z = 0;
ZLE_STRING_T ws, lasts, wptr;
if (*s == '^' || *s == '!') {
inv = 1;
s++;
} else
inv = 0;
s = getkeystring(s, &i, GETKEYS_SUFFIX, &z);
s = metafy(s, i, META_USEHEAP);
ws = stringaszleline(s, 0, &i, NULL, NULL);
if (z)
suffixnoinslen = inv ? 0 : n;
else if (inv) {
/*
* negative match, \- wasn't present, so it *should*
* have this suffix length
*/
suffixnoinslen = n;
}
lasts = wptr = ws;
while (i) {
if (i >= 3 && wptr[1] == ZWC('-')) {
ZLE_CHAR_T str[2];
if (wptr > lasts)
addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,
lasts, wptr - lasts, n);
str[0] = *wptr;
str[1] = wptr[2];
addsuffix(inv ? SUFTYP_NEGRNG : SUFTYP_POSRNG, 0,
str, 2, n);
wptr += 3;
i -= 3;
lasts = wptr;
} else {
wptr++;
i--;
}
}
if (wptr > lasts)
addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,
lasts, wptr - lasts, n);
free(ws);
} else
makesuffix(n);
}
Thingy
rthingy(char *nam)
{
Thingy t = (Thingy) thingytab->getnode2(thingytab, nam);
if(!t)
thingytab->addnode(thingytab, ztrdup(nam), t = makethingynode());
return refthingy(t);
}
void
insertlastword(void)
{
int n;
char *s, *t;
int len;
Histent he;
/* multiple calls will now search back through the history, pem */
static char *lastinsert;
static int lasthist, lastpos;
int evhist = curhist - 1, save;
if (lastinsert) {
int lastlen = ztrlen(lastinsert);
int pos = cs;
if (lastpos <= pos &&
lastlen == pos - lastpos &&
memcmp(lastinsert, (char *)&line[lastpos], lastlen) == 0) {
evhist = --lasthist;
cs = lastpos;
foredel(pos - cs);
}
zsfree(lastinsert);
lastinsert = NULL;
}
if (!(he = quietgethist(evhist)) || !he->nwords) {
feep();
return;
}
if (zmult > 0) {
n = he->nwords - (zmult - 1);
} else {
n = 1 - zmult;
}
if (n < 1 || n > he->nwords) {
feep();
return;
}
s = he->text + he->words[2*n-2];
t = he->text + he->words[2*n-1];
save = *t;
*t = '\0'; /* ignore trailing whitespace */
lasthist = evhist;
lastpos = cs;
lastinsert = ztrdup(s);
spaceinline(len = ztrlen(s));
while (len--) {
line[cs++] = *s == Meta ? *++s ^ 32 : *s;
s++;
}
*t = save;
}
void
createaliastables(void)
{
/* Table for regular and global aliases */
aliastab = newhashtable(23, "aliastab", NULL);
createaliastable(aliastab);
/* add the default aliases */
aliastab->addnode(aliastab, ztrdup("run-help"), createaliasnode(ztrdup("man"), 0));
aliastab->addnode(aliastab, ztrdup("which-command"), createaliasnode(ztrdup("whence"), 0));
/* Table for suffix aliases --- make this smaller */
sufaliastab = newhashtable(11, "sufaliastab", NULL);
createaliastable(sufaliastab);
}
static void
setpmmapfile(Param pm, char *value)
{
int fd = -1, len;
char *name = ztrdup(pm->nam);
#ifdef USE_MMAP
caddr_t mmptr;
#else
FILE *fout;
#endif
/*
* First unmetafy the value, and the name since we don't
* where it's been.
*/
unmetafy(name, &len);
unmetafy(value, &len);
/* Open the file for writing */
#ifdef USE_MMAP
if (!(pm->flags & PM_READONLY) &&
(fd = open(name, O_RDWR|O_CREAT|O_NOCTTY, 0666)) >= 0 &&
(mmptr = (caddr_t)mmap((caddr_t)0, len, PROT_READ | PROT_WRITE,
MMAP_ARGS, fd, (off_t)0)) != (caddr_t)-1) {
/*
* First we need to make sure the file is long enough for
* when we msync. On AIX, at least, we just get zeroes otherwise.
*/
ftruncate(fd, len);
memcpy(mmptr, value, len);
#ifndef MS_SYNC
#define MS_SYNC 0
#endif
msync(mmptr, len, MS_SYNC);
/*
* Then we need to truncate again, since mmap() always maps complete
* pages. Honestly, I tried it without, and you need both.
*/
ftruncate(fd, len);
munmap(mmptr, len);
}
#else /* don't USE_MMAP */
/* can't be bothered to do anything too clever here */
if ((fout = fopen(name, "w"))) {
while (len--)
putc(*value++, fout);
fclose(fout);
}
#endif /* USE_MMAP */
if (fd >= 0)
close(fd);
free(name);
free(value);
}
mod_export void
makesuffixstr(char *f, char *s, int n)
{
if (f) {
zsfree(suffixfunc);
suffixfunc = ztrdup(f);
suffixfunclen = n;
} else if (s) {
int inv, i, z = 0;
ZLE_STRING_T ws, lasts, wptr;
if (*s == '^' || *s == '!') {
inv = 1;
s++;
} else
inv = 0;
s = getkeystring(s, &i, GETKEYS_SUFFIX, &z);
s = metafy(s, i, META_USEHEAP);
ws = stringaszleline(s, 0, &i, NULL, NULL);
/* Remove suffix on uninsertable characters if \- was given *
* and the character class wasn't negated -- or vice versa. */
suffixnoinsrem = z ^ inv;
suffixlen = n;
lasts = wptr = ws;
while (i) {
if (i >= 3 && wptr[1] == ZWC('-')) {
ZLE_CHAR_T str[2];
if (wptr > lasts)
addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,
lasts, wptr - lasts, n);
str[0] = *wptr;
str[1] = wptr[2];
addsuffix(inv ? SUFTYP_NEGRNG : SUFTYP_POSRNG, 0,
str, 2, n);
wptr += 3;
i -= 3;
lasts = wptr;
} else {
wptr++;
i--;
}
}
if (wptr > lasts)
addsuffix(inv ? SUFTYP_NEGSTR : SUFTYP_POSSTR, 0,
lasts, wptr - lasts, n);
free(ws);
} else
makesuffix(n);
}
int
setup_(UNUSED(Module m))
{
hasperm = 0;
comprpms = compkpms = NULL;
compwords = compredirs = NULL;
compprefix = compsuffix = compiprefix = compisuffix =
compqiprefix = compqisuffix =
compcontext = compparameter = compredirect = compquote =
compquoting = comprestore = complist = compinsert =
compexact = compexactstr = comppatmatch = comppatinsert =
complastprompt = comptoend = compoldlist = compoldins =
compvared = compqstack = NULL;
complastprefix = ztrdup("");
complastsuffix = ztrdup("");
complistmax = 0;
hascompmod = 1;
return 0;
}
void
hashdir(char **dirp)
{
Cmdnam cn;
DIR *dir;
char *fn;
#if defined(_WIN32) || defined(__CYGWIN__)
char *exe;
#endif /* _WIN32 || _CYGWIN__ */
if (isrelative(*dirp) || !(dir = opendir(unmeta(*dirp))))
return;
while ((fn = zreaddir(dir, 1))) {
if (!cmdnamtab->getnode(cmdnamtab, fn)) {
cn = (Cmdnam) zshcalloc(sizeof *cn);
cn->flags = 0;
cn->u.name = dirp;
cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
}
#if defined(_WIN32) || defined(__CYGWIN__)
/* Hash foo.exe as foo, since when no real foo exists, foo.exe
will get executed by DOS automatically. This quiets
spurious corrections when CORRECT or CORRECT_ALL is set. */
if ((exe = strrchr(fn, '.')) &&
(exe[1] == 'E' || exe[1] == 'e') &&
(exe[2] == 'X' || exe[2] == 'x') &&
(exe[3] == 'E' || exe[3] == 'e') && exe[4] == 0) {
*exe = 0;
if (!cmdnamtab->getnode(cmdnamtab, fn)) {
cn = (Cmdnam) zshcalloc(sizeof *cn);
cn->flags = 0;
cn->u.name = dirp;
cmdnamtab->addnode(cmdnamtab, ztrdup(fn), cn);
}
}
#endif /* _WIN32 || __CYGWIN__ */
}
closedir(dir);
}
mod_export void
addsuffixstring(int tp, int flags, char *chars, int lensuf)
{
int slen, alloclen;
ZLE_STRING_T suffixstr;
/* string needs to be writable... I've been regretting this for years.. */
chars = ztrdup(chars);
suffixstr = stringaszleline(chars, 0, &slen, &alloclen, NULL);
addsuffix(tp, flags, suffixstr, slen, lensuf);
zfree(suffixstr, alloclen);
zsfree(chars);
}
static void
unsetpmmapfile(Param pm, UNUSED(int exp))
{
/* Unlink the file given by pm->nam */
char *fname = ztrdup(pm->nam);
int dummy;
unmetafy(fname, &dummy);
if (!(pm->flags & PM_READONLY))
unlink(fname);
free(fname);
}
void
acceptlineanddownhistory(void)
{
char *s;
if (!(s = zle_get_event(histline + 1))) {
feep();
return;
}
pushnode(bufstack, ztrdup(s));
done = 1;
stackhist = histline + 1;
}
int
setup_(UNUSED(Module m))
{
char **bpaste;
/* Set up editor entry points */
zle_entry_ptr = zle_main_entry;
zle_load_state = 1;
/* initialise the thingies */
init_thingies();
lbindk = NULL;
/* miscellaneous initialisations */
stackhist = stackcs = -1;
kungetbuf = (char *) zalloc(kungetsz = 32);
comprecursive = 0;
rdstrs = NULL;
/* initialise the keymap system */
init_keymaps();
varedarg = NULL;
incompfunc = incompctlfunc = hascompmod = 0;
hascompwidgets = 0;
clwords = (char **) zshcalloc((clwsize = 16) * sizeof(char *));
bpaste = zshcalloc(3*sizeof(char *));
bpaste[0] = ztrdup("\033[?2004h");
bpaste[1] = ztrdup("\033[?2004l");
/* Intended to be global, no WARNCREATEGLOBAL check. */
assignaparam("zle_bracketed_paste", bpaste, 0);
return 0;
}
void
pushline(void)
{
int n = zmult;
if (n < 0)
return;
pushnode(bufstack, metafy((char *) line, ll, META_DUP));
while (--n)
pushnode(bufstack, ztrdup(""));
stackcs = cs;
*line = '\0';
ll = cs = 0;
clearlist = 1;
}
static zlong
get_cursor(UNUSED(Param pm))
{
if (zlemetaline != NULL) {
/* A lot of work for one number, but still... */
ZLE_STRING_T tmpline;
int tmpcs, tmpll, tmpsz;
char *tmpmetaline = ztrdup(zlemetaline);
tmpline = stringaszleline(tmpmetaline, zlemetacs,
&tmpll, &tmpsz, &tmpcs);
free(tmpmetaline);
free(tmpline);
return tmpcs;
}
return zlecs;
}
void
set_default_colour_sequences(void)
{
fg_bg_sequences[COL_SEQ_FG].start = ztrdup(TC_COL_FG_START);
fg_bg_sequences[COL_SEQ_FG].end = ztrdup(TC_COL_FG_END);
fg_bg_sequences[COL_SEQ_FG].def = ztrdup(TC_COL_FG_DEFAULT);
fg_bg_sequences[COL_SEQ_BG].start = ztrdup(TC_COL_BG_START);
fg_bg_sequences[COL_SEQ_BG].end = ztrdup(TC_COL_BG_END);
fg_bg_sequences[COL_SEQ_BG].def = ztrdup(TC_COL_BG_DEFAULT);
}
static int
bin_strftime(char *nam, char **argv, Options ops, int func)
{
int result = 1;
char *tz = getsparam("TZ");
startparamscope();
if (tz && *tz) {
Param pm = createparam("TZ", PM_LOCAL|PM_SCALAR|PM_EXPORTED);
if (pm)
pm->level = locallevel; /* because createparam() doesn't */
setsparam("TZ", ztrdup(tz));
}
result = output_strftime(nam, argv, ops, func);
endparamscope();
return result;
}
void
acceptandinfernexthistory(void)
{
int t0;
char *s;
done = 1;
for (t0 = histline - 2;; t0--) {
if (!(s = qgetevent(t0)))
return;
if (!metadiffer(s, (char *) line, ll))
break;
}
if (!(s = qgetevent(t0 + 1)))
return;
pushnode(bufstack, ztrdup(s));
stackhist = t0 + 1;
}
static char *
get_contents(char *fname)
{
int fd;
#ifdef USE_MMAP
caddr_t mmptr;
struct stat sbuf;
#endif
char *val;
unmetafy(fname = ztrdup(fname), &fd);
#ifdef USE_MMAP
if ((fd = open(fname, O_RDONLY | O_NOCTTY)) < 0 ||
fstat(fd, &sbuf) ||
(mmptr = (caddr_t)mmap((caddr_t)0, sbuf.st_size, PROT_READ,
MMAP_ARGS, fd, (off_t)0)) == (caddr_t)-1) {
if (fd >= 0)
close(fd);
free(fname);
return NULL;
}
/*
* Sadly, we need to copy the thing even if metafying doesn't
* change it. We just don't know when we might get a chance to
* munmap it, otherwise.
*/
val = metafy((char *)mmptr, sbuf.st_size, META_HEAPDUP);
munmap(mmptr, sbuf.st_size);
close(fd);
#else /* don't USE_MMAP */
val = NULL;
if ((fd = open(fname, O_RDONLY | O_NOCTTY)) >= 0) {
LinkList ll;
if ((ll = readoutput(fd, 1)))
val = peekfirst(ll);
}
#endif /* USE_MMAP */
free(fname);
return val;
}
void
fillnameddirtable(HashTable ht)
{
#ifndef WINNT
if (!allusersadded) {
struct passwd *pw;
setpwent();
/* loop through the password file/database *
* and add all entries returned. */
while ((pw = getpwent()) && !errflag)
adduserdir(ztrdup(pw->pw_name), pw->pw_dir, ND_USERNAME, 1);
endpwent();
allusersadded = 1;
}
#endif /* WINNT */
return;
}
