void
run_init_scripts(void)
{
#ifdef __EMX__
char tempbuf[128];
#endif
noerrexit = -1;
if (emulation == EMULATE_KSH || emulation == EMULATE_SH) {
if (islogin)
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(tempbuf,"/etc/profile"));
#else
source("/etc/profile");
#endif
if (unset(PRIVILEGED)) {
char *s = getsparam("ENV");
if (islogin)
#ifdef __EMX__
sourcehome("profile");
#else
sourcehome(".profile");
#endif
noerrs = 1;
if (s && !parsestr(s)) {
singsub(&s);
noerrs = 0;
source(s);
}
noerrs = 0;
} else
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(tempbuf,"/etc/suid_profile"));
#else
source("/etc/suid_profile");
#endif
} else {
#ifdef GLOBAL_ZSHENV
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(GLOBAL_DIR,GLOBAL_ZSHENV));
#else
source(GLOBAL_ZSHENV);
#endif
#endif
if (isset(RCS)) {
if (unset(PRIVILEGED))
#ifdef __EMX__
sourcehome("zshenv.zsh");
#endif
sourcehome(".zshenv");
if (islogin) {
#ifdef GLOBAL_ZPROFILE
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(tempbuf,GLOBAL_ZPROFILE));
#else
source(GLOBAL_ZPROFILE);
#endif
#endif
if (unset(PRIVILEGED))
#ifdef __EMX__
sourcehome("zprofile.zsh");
#endif
sourcehome(".zprofile");
}
if (interact) {
#ifdef GLOBAL_ZSHRC
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(tempbuf,GLOBAL_ZSHRC));
#else
source(GLOBAL_ZSHRC);
#endif
#endif
if (unset(PRIVILEGED))
#ifdef __EMX__
sourcehome("zshrc.zsh");
#endif
sourcehome(".zshrc");
}
if (islogin) {
#ifdef GLOBAL_ZLOGIN
#ifdef __EMX__
strcpy(tempbuf,GLOBAL_DIR);
source(strcat(tempbuf,GLOBAL_ZLOGIN));
#else
source(GLOBAL_ZLOGIN);
#endif
#endif
if (unset(PRIVILEGED))
#ifdef __EMX__
sourcehome("zlogin.zsh");
#endif
sourcehome(".zlogin");
}
}
}
noerrexit = 0;
nohistsave = 0;
}
NODE *
spec(FILE *fp)
{
NODE *centry, *last, *pathparent, *cur;
char *p, *e, *next;
NODE ginfo, *root;
char *buf, *tname, *ntname;
size_t tnamelen, plen;
root = NULL;
centry = last = NULL;
tname = NULL;
tnamelen = 0;
memset(&ginfo, 0, sizeof(ginfo));
for (mtree_lineno = 0;
(buf = fparseln(fp, NULL, &mtree_lineno, NULL,
FPARSELN_UNESCCOMM));
free(buf)) {
/* Skip leading whitespace. */
for (p = buf; *p && isspace((unsigned char)*p); ++p)
continue;
/* If nothing but whitespace, continue. */
if (!*p)
continue;
#ifdef DEBUG
fprintf(stderr, "line %lu: {%s}\n",
(u_long)mtree_lineno, p);
#endif
/* Grab file name, "$", "set", or "unset". */
next = buf;
while ((p = strsep(&next, " \t")) != NULL && *p == '\0')
continue;
if (p == NULL)
mtree_err("missing field");
if (p[0] == '/') {
if (strcmp(p + 1, "set") == 0)
set(next, &ginfo);
else if (strcmp(p + 1, "unset") == 0)
unset(next, &ginfo);
else
mtree_err("invalid specification `%s'", p);
continue;
}
if (strcmp(p, "..") == 0) {
/* Don't go up, if haven't gone down. */
if (root == NULL)
goto noparent;
if (last->type != F_DIR || last->flags & F_DONE) {
if (last == root)
goto noparent;
last = last->parent;
}
last->flags |= F_DONE;
continue;
noparent: mtree_err("no parent node");
}
plen = strlen(p) + 1;
if (plen > tnamelen) {
if ((ntname = realloc(tname, plen)) == NULL)
mtree_err("realloc: %s", strerror(errno));
tname = ntname;
tnamelen = plen;
}
if (strunvis(tname, p) == -1)
mtree_err("strunvis failed on `%s'", p);
p = tname;
pathparent = NULL;
if (strchr(p, '/') != NULL) {
cur = root;
for (; (e = strchr(p, '/')) != NULL; p = e+1) {
if (p == e)
continue; /* handle // */
*e = '\0';
if (strcmp(p, ".") != 0) {
while (cur &&
strcmp(cur->name, p) != 0) {
cur = cur->next;
}
}
if (cur == NULL || cur->type != F_DIR) {
mtree_err("%s: %s", tname,
"missing directory in specification");
}
*e = '/';
pathparent = cur;
cur = cur->child;
}
if (*p == '\0')
mtree_err("%s: empty leaf element", tname);
}
if ((centry = calloc(1, sizeof(NODE) + strlen(p))) == NULL)
mtree_err("%s", strerror(errno));
*centry = ginfo;
centry->lineno = mtree_lineno;
strcpy(centry->name, p);
#define MAGIC "?*["
if (strpbrk(p, MAGIC))
centry->flags |= F_MAGIC;
set(next, centry);
if (root == NULL) {
/*
* empty tree
*/
/*
* Allow a bare "." root node by forcing it to
* type=dir for compatibility with FreeBSD.
*/
if (strcmp(centry->name, ".") == 0 && centry->type == 0)
centry->type = F_DIR;
if (strcmp(centry->name, ".") != 0 ||
centry->type != F_DIR)
mtree_err(
"root node must be the directory `.'");
last = root = centry;
root->parent = root;
} else if (pathparent != NULL) {
/*
* full path entry; add or replace
*/
centry->parent = pathparent;
addchild(pathparent, centry);
last = centry;
} else if (strcmp(centry->name, ".") == 0) {
/*
* duplicate "." entry; always replace
*/
replacenode(root, centry);
} else if (last->type == F_DIR && !(last->flags & F_DONE)) {
/*
* new relative child in current dir;
* add or replace
*/
centry->parent = last;
addchild(last, centry);
last = centry;
} else {
/*
* new relative child in parent dir
* (after encountering ".." entry);
* add or replace
*/
centry->parent = last->parent;
addchild(last->parent, centry);
last = centry;
}
}
return (root);
}
void
parseargs(char **argv)
{
char **x;
int action, optno;
LinkList paramlist;
int bourne = (emulation == EMULATE_KSH || emulation == EMULATE_SH);
hackzero = argzero = *argv++;
SHIN = 0;
/* There's a bit of trickery with opts[INTERACTIVE] here. It starts *
* at a value of 2 (instead of 1) or 0. If it is explicitly set on *
* the command line, it goes to 1 or 0. If input is coming from *
* somewhere that normally makes the shell non-interactive, we do *
* "opts[INTERACTIVE] &= 1", so that only a *default* on state will *
* be changed. At the end of the function, a value of 2 gets *
* changed to 1. */
opts[INTERACTIVE] = isatty(0) ? 2 : 0;
opts[SHINSTDIN] = 0;
opts[SINGLECOMMAND] = 0;
/* loop through command line options (begins with "-" or "+") */
while (*argv && (**argv == '-' || **argv == '+')) {
action = (**argv == '-');
if(!argv[0][1])
*argv = "--";
while (*++*argv) {
/* The pseudo-option `--' signifies the end of options. *
* `-b' does too, csh-style, unless we're emulating a *
* Bourne style shell. */
if (**argv == '-' || (!bourne && **argv == 'b')) {
argv++;
goto doneoptions;
}
if (**argv == 'c') { /* -c command */
if (!*++argv) {
zerr("string expected after -c", NULL, 0);
exit(1);
}
cmd = *argv++;
opts[INTERACTIVE] &= 1;
opts[SHINSTDIN] = 0;
goto doneoptions;
} else if (**argv == 'o') {
if (!*++*argv)
argv++;
if (!*argv) {
zerr("string expected after -o", NULL, 0);
exit(1);
}
if(!(optno = optlookup(*argv)))
zerr("no such option: %s", *argv, 0);
else
dosetopt(optno, action, 1);
break;
} else {
if (!(optno = optlookupc(**argv))) {
zerr("bad option: -%c", NULL, **argv);
exit(1);
} else
dosetopt(optno, action, 1);
}
}
argv++;
}
doneoptions:
paramlist = newlinklist();
if (*argv) {
if (unset(SHINSTDIN)) {
argzero = *argv;
if (!cmd)
SHIN = movefd(open(unmeta(argzero), O_RDONLY));
if (SHIN == -1) {
zerr("can't open input file: %s", argzero, 0);
exit(1);
}
opts[INTERACTIVE] &= 1;
argv++;
}
while (*argv)
addlinknode(paramlist, ztrdup(*argv++));
} else
opts[SHINSTDIN] = 1;
if(isset(SINGLECOMMAND))
opts[INTERACTIVE] &= 1;
opts[INTERACTIVE] = !!opts[INTERACTIVE];
pparams = x = (char **) zcalloc((countlinknodes(paramlist) + 1) * sizeof(char *));
while ((*x++ = (char *)getlinknode(paramlist)));
free(paramlist);
argzero = ztrdup(argzero);
}
int
init_term(void)
{
#ifndef TGETENT_ACCEPTS_NULL
static char termbuf[2048]; /* the termcap buffer */
#endif
if (!*term)
return termok = TERM_BAD;
/* unset zle if using zsh under emacs */
if (!strcmp(term, "emacs"))
opts[USEZLE] = 0;
#ifdef TGETENT_ACCEPTS_NULL
/* If possible, we let tgetent allocate its own termcap buffer */
if (tgetent(NULL, term) != 1) {
#else
if (tgetent(termbuf, term) != 1) {
#endif
if (isset(INTERACTIVE))
zerr("can't find termcap info for %s", term, 0);
errflag = 0;
return termok = TERM_BAD;
} else {
char tbuf[1024], *pp;
int t0;
termok = TERM_OK;
for (t0 = 0; t0 != TC_COUNT; t0++) {
pp = tbuf;
zsfree(tcstr[t0]);
/* AIX tgetstr() ignores second argument */
if (!(pp = tgetstr(tccapnams[t0], &pp)))
tcstr[t0] = NULL, tclen[t0] = 0;
else {
tclen[t0] = strlen(pp);
tcstr[t0] = (char *) zalloc(tclen[t0] + 1);
memcpy(tcstr[t0], pp, tclen[t0] + 1);
}
}
/* check whether terminal has automargin (wraparound) capability */
hasam = tgetflag("am");
/* if there's no termcap entry for cursor up, use single line mode: *
* this is flagged by termok which is examined in zle_refresh.c *
*/
if (!tccan(TCUP)) {
tcstr[TCUP] = NULL;
termok = TERM_NOUP;
}
/* if there's no termcap entry for cursor left, use \b. */
if (!tccan(TCLEFT)) {
tcstr[TCLEFT] = ztrdup("\b");
tclen[TCLEFT] = 1;
}
/* if the termcap entry for down is \n, don't use it. */
if (tccan(TCDOWN) && tcstr[TCDOWN][0] == '\n') {
tclen[TCDOWN] = 0;
zsfree(tcstr[TCDOWN]);
tcstr[TCDOWN] = NULL;
}
/* if there's no termcap entry for clear, use ^L. */
if (!tccan(TCCLEARSCREEN)) {
tcstr[TCCLEARSCREEN] = ztrdup("\14");
tclen[TCCLEARSCREEN] = 1;
}
}
return termok;
}
/* Initialize lots of global variables and hash tables */
/**/
void
setupvals(void)
{
struct passwd *pswd;
struct timezone dummy_tz;
char *ptr;
#ifdef HAVE_GETRLIMIT
int i;
#endif
noeval = 0;
curhist = 0;
histsiz = DEFAULT_HISTSIZE;
inithist();
clwords = (char **) zcalloc((clwsize = 16) * sizeof(char *));
cmdstack = (unsigned char *) zalloc(256);
cmdsp = 0;
bangchar = '!';
hashchar = '#';
hatchar = '^';
termok = TERM_BAD;
curjob = prevjob = coprocin = coprocout = -1;
gettimeofday(&shtimer, &dummy_tz); /* init $SECONDS */
srand((unsigned int)(shtimer.tv_sec + shtimer.tv_usec)); /* seed $RANDOM */
hostnam = (char *) zalloc(256);
gethostname(hostnam, 256);
/* Set default path */
path = (char **) zalloc(sizeof(*path) * 5);
path[0] = ztrdup("/bin");
path[1] = ztrdup("/usr/bin");
path[2] = ztrdup("/usr/ucb");
path[3] = ztrdup("/usr/local/bin");
path[4] = NULL;
cdpath = mkarray(NULL);
manpath = mkarray(NULL);
fignore = mkarray(NULL);
fpath = mkarray(NULL);
mailpath = mkarray(NULL);
watch = mkarray(NULL);
psvar = mkarray(NULL);
#ifdef DYNAMIC
module_path = mkarray(ztrdup(MODULE_DIR));
modules = newlinklist();
#endif
/* Set default prompts */
if (opts[INTERACTIVE]) {
prompt = ztrdup("%m%# ");
prompt2 = ztrdup("%_> ");
} else {
prompt = ztrdup("");
prompt2 = ztrdup("");
}
prompt3 = ztrdup("?# ");
prompt4 = ztrdup("+ ");
sprompt = ztrdup("zsh: correct '%R' to '%r' [nyae]? ");
ifs = ztrdup(DEFAULT_IFS);
wordchars = ztrdup(DEFAULT_WORDCHARS);
postedit = ztrdup("");
underscore = ztrdup("");
zoptarg = ztrdup("");
zoptind = 1;
schedcmds = NULL;
ppid = (long) getppid();
mypid = (long) getpid();
term = ztrdup("");
#ifdef TIOCGWINSZ
if (!(columns = shttyinfo.winsize.ws_col))
columns = 80;
if (columns < 2)
opts[USEZLE] = 0;
if (!(lines = shttyinfo.winsize.ws_row))
lines = 24;
if (lines < 2)
opts[SINGLELINEZLE] = 1;
#else
columns = 80;
lines = 24;
#endif
/* The following variable assignments cause zsh to behave more *
* like Bourne and Korn shells when invoked as "sh" or "ksh". *
* NULLCMD=":" and READNULLCMD=":" */
if (emulation == EMULATE_KSH || emulation == EMULATE_SH) {
nullcmd = ztrdup(":");
readnullcmd = ztrdup(":");
} else {
nullcmd = ztrdup("cat");
readnullcmd = ztrdup("more");
}
/* We cache the uid so we know when to *
* recheck the info for `USERNAME' */
cached_uid = getuid();
/* Get password entry and set info for `HOME' and `USERNAME' */
if ((pswd = getpwuid(cached_uid))) {
home = metafy(pswd->pw_dir, -1, META_DUP);
cached_username = ztrdup(pswd->pw_name);
} else {
home = ztrdup("/");
cached_username = ztrdup("");
}
/* Try a cheap test to see if we can *
* initialize `PWD' from `HOME' */
if (ispwd(home))
pwd = ztrdup(home);
else if ((ptr = zgetenv("PWD")) && ispwd(ptr))
pwd = ztrdup(ptr);
else
pwd = metafy(zgetcwd(), -1, META_REALLOC);
oldpwd = ztrdup(pwd); /* initialize `OLDPWD' = `PWD' */
#ifdef __EMX__
*cdrive = _getdrive();
strcat(cdrive+1,":");
#endif
inittyptab(); /* initialize the ztypes table */
initlextabs(); /* initialize lexing tables */
createreswdtable(); /* create hash table for reserved words */
createaliastable(); /* create hash table for aliases */
createcmdnamtable(); /* create hash table for external commands */
createshfunctable(); /* create hash table for shell functions */
createbuiltintable(); /* create hash table for builtin commands */
createnameddirtable(); /* create hash table for named directories */
createparamtable(); /* create paramater hash table */
#ifdef ZLE_MODULE
add_dep("compctl", "zle");
addbuiltin("bindkey", 0, NULL, 0, -1, "zle");
addbuiltin("vared", 0, NULL, 1, 7, "zle");
addbuiltin("compctl", 0, NULL, 0, -1, "compctl");
#endif
#ifdef HAVE_GETRLIMIT
for (i = 0; i != RLIM_NLIMITS; i++) {
getrlimit(i, current_limits + i);
limits[i] = current_limits[i];
}
#endif
breaks = loops = 0;
lastmailcheck = time(NULL);
locallist = NULL;
locallevel = sourcelevel = 0;
trapreturn = 0;
noerrexit = 0;
nohistsave = 1;
dirstack = newlinklist();
bufstack = newlinklist();
hsubl = hsubr = NULL;
lastpid = 0;
bshin = SHIN ? fdopen(SHIN, "r") : stdin;
if (isset(SHINSTDIN) && !SHIN && unset(INTERACTIVE)) {
#ifdef _IONBF
setvbuf(stdin, NULL, _IONBF, 0);
#else
setlinebuf(stdin);
#endif
}
times(&shtms);
}
/* Initialize signal handling */
/**/
void
init_signals(void)
{
intr();
#ifndef QDEBUG
signal_ignore(SIGQUIT);
#endif
install_handler(SIGHUP);
install_handler(SIGCHLD);
if (interact) {
install_handler(SIGALRM);
#ifdef SIGWINCH
install_handler(SIGWINCH);
#endif
signal_ignore(SIGTERM);
}
if (jobbing) {
long ttypgrp;
#ifndef __EMX__
while ((ttypgrp = gettygrp()) != -1 && ttypgrp != mypgrp)
kill(0, SIGTTIN);
#endif
if (ttypgrp == -1) {
opts[MONITOR] = 0;
} else {
#ifndef __EMX__
signal_ignore(SIGTTOU);
signal_ignore(SIGTSTP);
signal_ignore(SIGTTIN);
#endif
signal_ignore(SIGPIPE);
attachtty(mypgrp);
}
}
if (islogin) {
signal_setmask(signal_mask(0));
} else if (interact) {
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGQUIT);
signal_unblock(set);
}
}
backgroundMesh2D::~backgroundMesh2D()
{
unset();
}
void Map::unset(std::vector<Tile>& tiles) {
for (auto tile : tiles) {
unset(tile);
}
}
mod_export void
zsetterm(void)
{
struct ttyinfo ti;
#if defined(FIONREAD)
int val;
#endif
if (fetchttyinfo) {
/*
* User requested terminal to be returned to normal use,
* so remember the terminal settings if not frozen.
*/
if (!ttyfrozen)
gettyinfo(&shttyinfo);
fetchttyinfo = 0;
}
#if defined(FIONREAD)
ioctl(SHTTY, FIONREAD, (char *)&val);
if (val) {
/*
* Problems can occur on some systems when switching from
* canonical to non-canonical input. The former is usually
* set while running programmes, but the latter is necessary
* for zle. If there is input in canonical mode, then we
* need to read it without setting up the terminal. Furthermore,
* while that input gets processed there may be more input
* being typed (i.e. further typeahead). This means that
* we can't set up the terminal for zle *at all* until
* we are sure there is no more typeahead to come. So
* if there is typeahead, we set the flag delayzsetterm.
* Then getbyte() performs another FIONREAD call; if that is
* 0, we have finally used up all the typeahead, and it is
* safe to alter the terminal, which we do at that point.
*/
delayzsetterm = 1;
return;
} else
delayzsetterm = 0;
#endif
/* sanitize the tty */
#ifdef HAS_TIO
shttyinfo.tio.c_lflag |= ICANON | ECHO;
# ifdef FLUSHO
shttyinfo.tio.c_lflag &= ~FLUSHO;
# endif
#else /* not HAS_TIO */
shttyinfo.sgttyb.sg_flags = (shttyinfo.sgttyb.sg_flags & ~CBREAK) | ECHO;
shttyinfo.lmodes &= ~LFLUSHO;
#endif
attachtty(mypgrp);
ti = shttyinfo;
#ifdef HAS_TIO
if (unset(FLOWCONTROL))
ti.tio.c_iflag &= ~IXON;
ti.tio.c_lflag &= ~(ICANON | ECHO
# ifdef FLUSHO
| FLUSHO
# endif
);
# ifdef TAB3
ti.tio.c_oflag &= ~TAB3;
# else
# ifdef OXTABS
ti.tio.c_oflag &= ~OXTABS;
# else
# ifdef XTABS
ti.tio.c_oflag &= ~XTABS;
# endif
# endif
# endif
#ifdef ONLCR
ti.tio.c_oflag |= ONLCR;
#endif
ti.tio.c_cc[VQUIT] =
# ifdef VDISCARD
ti.tio.c_cc[VDISCARD] =
# endif
# ifdef VSUSP
ti.tio.c_cc[VSUSP] =
# endif
# ifdef VDSUSP
ti.tio.c_cc[VDSUSP] =
# endif
# ifdef VSWTCH
ti.tio.c_cc[VSWTCH] =
# endif
# ifdef VLNEXT
ti.tio.c_cc[VLNEXT] =
# endif
VDISABLEVAL;
# if defined(VSTART) && defined(VSTOP)
if (unset(FLOWCONTROL))
ti.tio.c_cc[VSTART] = ti.tio.c_cc[VSTOP] = VDISABLEVAL;
# endif
eofchar = ti.tio.c_cc[VEOF];
ti.tio.c_cc[VMIN] = 1;
ti.tio.c_cc[VTIME] = 0;
ti.tio.c_iflag |= (INLCR | ICRNL);
/* this line exchanges \n and \r; it's changed back in getbyte
so that the net effect is no change at all inside the shell.
This double swap is to allow typeahead in common cases, eg.
% bindkey -s '^J' 'echo foo^M'
% sleep 10
echo foo<return> <--- typed before sleep returns
The shell sees \n instead of \r, since it was changed by the kernel
while zsh wasn't looking. Then in getbyte() \n is changed back to \r,
and it sees "echo foo<accept line>", as expected. Without the double
swap the shell would see "echo foo\n", which is translated to
"echo fooecho foo<accept line>" because of the binding.
Note that if you type <line-feed> during the sleep the shell just sees
\n, which is translated to \r in getbyte(), and you just get another
prompt. For type-ahead to work in ALL cases you have to use
stty inlcr.
Unfortunately it's IMPOSSIBLE to have a general solution if both
<return> and <line-feed> are mapped to the same character. The shell
could check if there is input and read it before setting it's own
terminal modes but if we get a \n we don't know whether to keep it or
change to \r :-(
*/
#else /* not HAS_TIO */
ti.sgttyb.sg_flags = (ti.sgttyb.sg_flags | CBREAK) & ~ECHO & ~XTABS;
ti.lmodes &= ~LFLUSHO;
eofchar = ti.tchars.t_eofc;
ti.tchars.t_quitc =
ti.ltchars.t_suspc =
ti.ltchars.t_flushc =
ti.ltchars.t_dsuspc = ti.ltchars.t_lnextc = -1;
#endif
#if defined(TTY_NEEDS_DRAINING) && defined(TIOCOUTQ) && defined(HAVE_SELECT)
if (baud) { /**/
int n = 0;
while ((ioctl(SHTTY, TIOCOUTQ, (char *)&n) >= 0) && n) {
struct timeval tv;
tv.tv_sec = n / baud;
tv.tv_usec = ((n % baud) * 1000000) / baud;
select(0, NULL, NULL, NULL, &tv);
}
}
#endif
settyinfo(&ti);
}
int LComponent::unreg(lua_State*) {
String cb = LUA::getString(2);
unset(cb);
return 0;
}
char *
zleread(char **lp, char **rp, int flags, int context, char *init, char *finish)
{
char *s;
int old_errno = errno;
int tmout = getiparam("TMOUT");
#if defined(HAVE_POLL) || defined(HAVE_SELECT)
/* may not be set, but that's OK since getiparam() returns 0 == off */
baud = getiparam("BAUD");
costmult = (baud) ? 3840000L / baud : 0;
#endif
/* ZLE doesn't currently work recursively. This is needed in case a *
* select loop is used in a function called from ZLE. vared handles *
* this differently itself. */
if(zleactive) {
char *pptbuf;
int pptlen;
pptbuf = unmetafy(promptexpand(lp ? *lp : NULL, 0, NULL, NULL,
&pmpt_attr),
&pptlen);
write_loop(2, pptbuf, pptlen);
free(pptbuf);
return shingetline();
}
/*
* The current status is what we need if we are going
* to display a prompt. We'll remember it here for
* use further in.
*/
pre_zle_status = lastval;
keytimeout = (time_t)getiparam("KEYTIMEOUT");
if (!shout) {
if (SHTTY != -1)
init_shout();
if (!shout)
return NULL;
/* We could be smarter and default to a system read. */
/* If we just got a new shout, make sure the terminal is set up. */
if (termflags & TERM_UNKNOWN)
init_term();
}
fflush(shout);
fflush(stderr);
intr();
insmode = unset(OVERSTRIKE);
eofsent = 0;
resetneeded = 0;
fetchttyinfo = 0;
trashedzle = 0;
raw_lp = lp;
lpromptbuf = promptexpand(lp ? *lp : NULL, 1, NULL, NULL, &pmpt_attr);
raw_rp = rp;
rpmpt_attr = pmpt_attr;
rpromptbuf = promptexpand(rp ? *rp : NULL, 1, NULL, NULL, &rpmpt_attr);
free_prepostdisplay();
zlereadflags = flags;
zlecontext = context;
histline = curhist;
vistartchange = -1;
zleline = (ZLE_STRING_T)zalloc(((linesz = 256) + 2) * ZLE_CHAR_SIZE);
*zleline = ZWC('\0');
virangeflag = lastcmd = done = zlecs = zlell = mark = 0;
vichgflag = 0;
viinsbegin = 0;
statusline = NULL;
selectkeymap("main", 1);
initundo();
fixsuffix();
if ((s = getlinknode(bufstack))) {
setline(s, ZSL_TOEND);
zsfree(s);
if (stackcs != -1) {
zlecs = stackcs;
stackcs = -1;
if (zlecs > zlell)
zlecs = zlell;
CCLEFT();
}
if (stackhist != -1) {
histline = stackhist;
stackhist = -1;
}
}
/*
* If main is linked to the viins keymap, we need to register
* explicitly that we're now in vi insert mode as there's
* no user operation to indicate this.
*/
if (openkeymap("main") == openkeymap("viins"))
viinsert_init();
selectlocalmap(NULL);
if (isset(PROMPTCR))
putc('\r', shout);
if (tmout)
alarm(tmout);
/*
* On some windowing systems we may enter this function before the
* terminal is fully opened and sized, resulting in an infinite
* series of SIGWINCH when the handler prints the prompt before we
* have done so here. Therefore, hold any such signal until the
* first full refresh has completed. The important bit is that the
* handler must not see zleactive = 1 until ZLE really is active.
* See the end of adjustwinsize() in Src/utils.c
*/
queue_signals();
zleactive = 1;
resetneeded = 1;
errflag = retflag = 0;
lastcol = -1;
initmodifier(&zmod);
prefixflag = 0;
zrefresh();
unqueue_signals(); /* Should now be safe to acknowledge SIGWINCH */
zlecallhook(init, NULL);
zrefresh();
zlecore();
if (errflag)
setsparam("ZLE_LINE_ABORTED", zlegetline(NULL, NULL));
if (done && !exit_pending && !errflag)
zlecallhook(finish, NULL);
statusline = NULL;
invalidatelist();
trashzle();
free(lpromptbuf);
free(rpromptbuf);
zleactive = zlereadflags = lastlistlen = zlecontext = 0;
alarm(0);
freeundo();
if (eofsent || errflag) {
s = NULL;
} else {
zleline[zlell++] = ZWC('\n');
s = zlegetline(NULL, NULL);
}
free(zleline);
zleline = NULL;
forget_edits();
errno = old_errno;
/* highlight no longer valid */
set_region_highlight(NULL, NULL);
return s;
}
static int
bin_vared(char *name, char **args, Options ops, UNUSED(int func))
{
char *s, *t, *ova = varedarg;
struct value vbuf;
Value v;
Param pm = 0;
int ifl;
int type = PM_SCALAR, obreaks = breaks, haso = 0, oSHTTY = 0;
char *p1, *p2, *main_keymapname, *vicmd_keymapname, *init, *finish;
Keymap main_keymapsave = NULL, vicmd_keymapsave = NULL;
FILE *oshout = NULL;
if ((interact && unset(USEZLE)) || !strcmp(term, "emacs")) {
zwarnnam(name, "ZLE not enabled");
return 1;
}
if (zleactive) {
zwarnnam(name, "ZLE cannot be used recursively (yet)");
return 1;
}
if (OPT_ISSET(ops,'A'))
{
if (OPT_ISSET(ops, 'a'))
{
zwarnnam(name, "specify only one of -a and -A");
return 1;
}
type = PM_HASHED;
}
else if (OPT_ISSET(ops,'a'))
type = PM_ARRAY;
p1 = OPT_ARG_SAFE(ops,'p');
p2 = OPT_ARG_SAFE(ops,'r');
main_keymapname = OPT_ARG_SAFE(ops,'M');
vicmd_keymapname = OPT_ARG_SAFE(ops,'m');
init = OPT_ARG_SAFE(ops,'i');
finish = OPT_ARG_SAFE(ops,'f');
if (type != PM_SCALAR && !OPT_ISSET(ops,'c')) {
zwarnnam(name, "-%s ignored", type == PM_ARRAY ? "a" : "A");
}
/* handle non-existent parameter */
s = args[0];
queue_signals();
v = fetchvalue(&vbuf, &s, (!OPT_ISSET(ops,'c') || type == PM_SCALAR),
SCANPM_WANTKEYS|SCANPM_WANTVALS|SCANPM_MATCHMANY);
if (!v && !OPT_ISSET(ops,'c')) {
unqueue_signals();
zwarnnam(name, "no such variable: %s", args[0]);
return 1;
} else if (v) {
if (*s) {
zwarnnam(name, "not an identifier: `%s'", args[0]);
return 1;
}
if (v->isarr) {
/* Array: check for separators and quote them. */
char **arr = getarrvalue(v), **aptr, **tmparr, **tptr;
tptr = tmparr = (char **)zhalloc(sizeof(char *)*(arrlen(arr)+1));
for (aptr = arr; *aptr; aptr++) {
int sepcount = 0, clen;
convchar_t c;
/*
* See if this word contains a separator character
* or backslash
*/
MB_METACHARINIT();
for (t = *aptr; *t; ) {
if (*t == '\\') {
t++;
sepcount++;
} else {
t += MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
sepcount++;
}
}
if (sepcount) {
/* Yes, so allocate enough space to quote it. */
char *newstr, *nptr;
newstr = zhalloc(strlen(*aptr)+sepcount+1);
/* Go through string quoting separators */
MB_METACHARINIT();
for (t = *aptr, nptr = newstr; *t; ) {
if (*t == '\\') {
*nptr++ = '\\';
*nptr++ = *t++;
} else {
clen = MB_METACHARLENCONV(t, &c);
if (WC_ZISTYPE(c, ISEP))
*nptr++ = '\\';
while (clen--)
*nptr++ = *t++;
}
}
*nptr = '\0';
/* Stick this into the array of words to join up */
*tptr++ = newstr;
} else
*tptr++ = *aptr; /* No, keep original array element */
}
*tptr = NULL;
s = sepjoin(tmparr, NULL, 0);
} else {
s = ztrdup(getstrvalue(v));
}
unqueue_signals();
} else if (*s) {
unqueue_signals();
zwarnnam(name, "invalid parameter name: %s", args[0]);
return 1;
} else {
unqueue_signals();
s = ztrdup(s);
}
if (SHTTY == -1 || OPT_ISSET(ops,'t')) {
/* need to open /dev/tty specially */
oSHTTY = SHTTY;
if ((SHTTY = open(OPT_ISSET(ops,'t') ? OPT_ARG(ops,'t') : "/dev/tty",
O_RDWR|O_NOCTTY)) == -1) {
zwarnnam(name, "can't access terminal");
zsfree(s);
return 1;
}
if (!isatty(SHTTY)) {
zwarnnam(name, "%s: not a terminal", OPT_ARG(ops,'t'));
close(SHTTY);
SHTTY = oSHTTY;
zsfree(s);
return 1;
}
oshout = shout;
init_shout();
haso = 1;
}
/* edit the parameter value */
zpushnode(bufstack, s);
if (main_keymapname &&
savekeymap(name, "main", main_keymapname, &main_keymapsave))
main_keymapname = NULL;
if (vicmd_keymapname &&
savekeymap(name, "vicmd", vicmd_keymapname, &vicmd_keymapsave))
vicmd_keymapname = NULL;
varedarg = *args;
ifl = isfirstln;
if (OPT_ISSET(ops,'h'))
hbegin(2);
isfirstln = OPT_ISSET(ops,'e');
t = zleread(&p1, &p2, OPT_ISSET(ops,'h') ? ZLRF_HISTORY : 0, ZLCON_VARED,
init ? init : "zle-line-init",
finish ? finish : "zle-line-finish");
if (OPT_ISSET(ops,'h'))
hend(NULL);
isfirstln = ifl;
varedarg = ova;
restorekeymap(name, "main", main_keymapname, main_keymapsave);
restorekeymap(name, "vicmd", vicmd_keymapname, vicmd_keymapsave);
if (haso) {
fclose(shout); /* close(SHTTY) */
shout = oshout;
SHTTY = oSHTTY;
}
if (!t || errflag) {
/* error in editing */
errflag = 0;
breaks = obreaks;
if (t)
zsfree(t);
return 1;
}
/* strip off trailing newline, if any */
if (t[strlen(t) - 1] == '\n')
t[strlen(t) - 1] = '\0';
/* final assignment of parameter value */
if (OPT_ISSET(ops,'c')) {
unsetparam(args[0]);
createparam(args[0], type);
}
queue_signals();
pm = (Param) paramtab->getnode(paramtab, args[0]);
if (pm && (PM_TYPE(pm->node.flags) & (PM_ARRAY|PM_HASHED))) {
char **a;
/*
* Use spacesplit with fourth argument 1: identify quoted separators,
* and unquote. This duplicates the string, so we still need to free.
*/
a = spacesplit(t, 1, 0, 1);
zsfree(t);
if (PM_TYPE(pm->node.flags) == PM_ARRAY)
setaparam(args[0], a);
else
sethparam(args[0], a);
} else
setsparam(args[0], t);
unqueue_signals();
return 0;
}
int
doglobal( /* execute a global command */
PRIMITIVE *g
)
{
FILE *fp = NULL;
switch (g->com) {
case PEOF:
return(0);
case PPAUS:
break;
case PINCL:
if (g->args == NULL)
error(USER, "missing include file name in include");
if (g->arg0 == 2 || (fp = fopen(g->args, "r")) == NULL) {
if (g->arg0 != 0)
fp = mfopen(g->args, "r");
else {
sprintf(errmsg, "cannot open user include file \"%s\"",
g->args);
error(USER, errmsg);
}
}
plot(fp);
fclose(fp);
break;
case PDRAW:
fflush(stdout);
break;
case PEOP:
endpage();
newpage = TRUE;
break;
case PSET:
set(g->arg0, g->args);
break;
case PUNSET:
unset(g->arg0);
break;
case PRESET:
reset(g->arg0);
break;
case POPEN:
segopen(g->args);
break;
case PCLOSE:
segclose();
break;
default:
sprintf(errmsg, "unknown command '%c' in doglobal", g->com);
error(WARNING, errmsg);
break;
}
return(1);
}
ArrayData *GlobalArrayWrapper::remove(const StringData* k, bool copy) {
unset(m_globals->get(StrNR(k)));
return NULL;
}
void MemoryHeader::unset_lock(STATE) {
unset(locked_count_field);
}
int
main(int argc, char *argv[])
{
const struct bitstr *bs;
long lval;
u_int32_t ga_mask = 0, ga_flags = 0;
int pin, ch, ga_offset = -1, n, fl = 0, value = 0;
const char *errstr;
char *ep, *flags, *nam = NULL;
char devn[32];
while ((ch = getopt(argc, argv, "q")) != -1)
switch (ch) {
case 'q':
quiet = 1;
break;
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if (argc < 1)
usage();
dev = argv[0];
if (strncmp(_PATH_DEV, dev, sizeof(_PATH_DEV) - 1)) {
(void)snprintf(devn, sizeof(devn), "%s%s", _PATH_DEV, dev);
dev = devn;
}
if ((devfd = open(dev, O_RDWR)) == -1)
err(1, "%s", dev);
if (argc == 1) {
getinfo();
return 0;
}
if (!strcmp(argv[1], "attach")) {
char *driver, *offset, *mask;
if (argc != 5 && argc != 6)
usage();
driver = argv[2];
offset = argv[3];
mask = argv[4];
flags = argc == 6 ? argv[5] : NULL;
ga_offset = strtonum(offset, 0, INT_MAX, &errstr);
if (errstr)
errx(1, "offset is %s: %s", errstr, offset);
lval = strtol(mask, &ep, 0);
if (*mask == '\0' || *ep != '\0')
errx(1, "invalid mask (not a number)");
if ((errno == ERANGE && (lval == LONG_MAX
|| lval == LONG_MIN)) || lval > UINT_MAX)
errx(1, "mask out of range");
ga_mask = lval;
if (flags != NULL) {
lval = strtonum(flags, 0, UINT_MAX, &errstr);
if (errstr)
errx(1, "flags is %s: %s", errstr, flags);
ga_flags = lval;
}
devattach(driver, ga_offset, ga_mask, ga_flags);
return 0;
} else if (!strcmp(argv[1], "detach")) {
if (argc != 3)
usage();
devdetach(argv[2]);
} else {
char *nm = NULL;
/* expecting a pin number or name */
pin = strtonum(argv[1], 0, INT_MAX, &errstr);
if (errstr)
nm = argv[1]; /* try named pin */
if (argc > 2) {
if (!strcmp(argv[2], "set")) {
for (n = 3; n < argc; n++) {
for (bs = pinflags; bs->string != NULL;
bs++) {
if (!strcmp(argv[n],
bs->string)) {
fl |= bs->mask;
break;
}
}
if (bs->string == NULL)
nam = argv[n];
}
pinset(pin, nm, fl, nam);
} else if (!strcmp(argv[2], "unset")) {
unset(pin, nm);
} else {
value = strtonum(argv[2], INT_MIN, INT_MAX,
&errstr);
if (errstr) {
if (!strcmp(argv[2], "on"))
value = 1;
else if (!strcmp(argv[2], "off"))
value = 0;
else if (!strcmp(argv[2], "toggle"))
value = 2;
else
errx(1, "%s: invalid value",
argv[2]);
}
pinwrite(pin, nm, value);
}
} else
pinread(pin, nm);
}
return (0);
}
void SettingsManager::load(string const& aFileName)
{
try {
SimpleXML xml;
xml.fromXML(File(aFileName, File::READ, File::OPEN).read());
xml.resetCurrentChild();
xml.stepIn();
if(xml.findChild("Settings"))
{
xml.stepIn();
int i;
for(i=STR_FIRST; i<STR_LAST; i++)
{
const string& attr = settingTags[i];
dcassert(attr.find("SENTRY") == string::npos);
if(xml.findChild(attr))
set(StrSetting(i), xml.getChildData());
xml.resetCurrentChild();
}
for(i=INT_FIRST; i<INT_LAST; i++)
{
const string& attr = settingTags[i];
dcassert(attr.find("SENTRY") == string::npos);
if(xml.findChild(attr))
set(IntSetting(i), Util::toInt(xml.getChildData()));
xml.resetCurrentChild();
}
for(i=FLOAT_FIRST; i<FLOAT_LAST; i++)
{
const string& attr = settingTags[i];
dcassert(attr.find("SENTRY") == string::npos);
if(xml.findChild(attr))
set(FloatSetting(i), Util::toInt(xml.getChildData()) / 1000.);
xml.resetCurrentChild();
}
for(i=INT64_FIRST; i<INT64_LAST; i++)
{
const string& attr = settingTags[i];
dcassert(attr.find("SENTRY") == string::npos);
if(xml.findChild(attr))
set(Int64Setting(i), Util::toInt64(xml.getChildData()));
xml.resetCurrentChild();
}
xml.stepOut();
}
xml.resetCurrentChild();
if(xml.findChild("SearchTypes")) {
try {
searchTypes.clear();
xml.stepIn();
while(xml.findChild("SearchType")) {
const string& extensions = xml.getChildData();
if(extensions.empty()) {
continue;
}
const string& name = xml.getChildAttrib("Id");
if(name.empty()) {
continue;
}
searchTypes[name] = StringTokenizer<string>(extensions, ';').getTokens();
}
xml.stepOut();
} catch(const SimpleXMLException&) {
setSearchTypeDefaults();
}
}
if(SETTING(PRIVATE_ID).length() != 39 || CID(SETTING(PRIVATE_ID)).isZero()) {
set(PRIVATE_ID, CID::generate().toBase32());
}
double v = Util::toDouble(SETTING(CONFIG_VERSION));
// if(v < 0.x) { // Fix old settings here }
if(v <= 0.674) {
// Formats changed, might as well remove these...
unset(LOG_FORMAT_POST_DOWNLOAD);
unset(LOG_FORMAT_POST_UPLOAD);
unset(LOG_FORMAT_MAIN_CHAT);
unset(LOG_FORMAT_PRIVATE_CHAT);
unset(LOG_FORMAT_STATUS);
unset(LOG_FORMAT_SYSTEM);
unset(LOG_FILE_MAIN_CHAT);
unset(LOG_FILE_STATUS);
unset(LOG_FILE_PRIVATE_CHAT);
unset(LOG_FILE_UPLOAD);
unset(LOG_FILE_DOWNLOAD);
unset(LOG_FILE_SYSTEM);
}
if(SETTING(SET_MINISLOT_SIZE) < 64)
set(SET_MINISLOT_SIZE, 64);
if(SETTING(AUTODROP_INTERVAL) < 1)
set(AUTODROP_INTERVAL, 1);
if(SETTING(AUTODROP_ELAPSED) < 1)
set(AUTODROP_ELAPSED, 1);
if(SETTING(AUTO_SEARCH_LIMIT) > 5)
set(AUTO_SEARCH_LIMIT, 5);
else if(SETTING(AUTO_SEARCH_LIMIT) < 1)
set(AUTO_SEARCH_LIMIT, 1);
#ifdef _DEBUG
set(PRIVATE_ID, CID::generate().toBase32());
#endif
setDefault(UDP_PORT, SETTING(TCP_PORT));
File::ensureDirectory(SETTING(TLS_TRUSTED_CERTIFICATES_PATH));
fire(SettingsManagerListener::Load(), xml);
xml.stepOut();
} catch(const Exception&) {
if(CID(SETTING(PRIVATE_ID)).isZero())
set(PRIVATE_ID, CID::generate().toBase32());
}
if (SETTING(DHT_KEY).length() != 39 || CID(SETTING(DHT_KEY)).isZero())
set(DHT_KEY, CID::generate().toBase32());
}
File::~File()
{
unset();
}
NODE *
spec(void)
{
NODE *centry, *last;
char *p;
NODE ginfo, *root;
int c_cur, c_next;
char *buf, *tbuf = NULL;
size_t len;
last = root = NULL;
bzero(&ginfo, sizeof(ginfo));
centry = &ginfo;
c_cur = c_next = 0;
for (lineno = 1; (buf = fgetln(stdin, &len));
++lineno, c_cur = c_next, c_next = 0) {
/* Null-terminate the line. */
if (buf[len - 1] == '\n') {
buf[--len] = '\0';
} else {
/* EOF with no newline. */
tbuf = malloc(len + 1);
memcpy(tbuf, buf, len);
tbuf[len] = '\0';
buf = tbuf;
}
/* Skip leading whitespace. */
for (p = buf; isspace((unsigned char)*p); p++)
;
/* If nothing but whitespace or comment char, continue. */
if (*p == '\0' || *p == '#')
continue;
/* See if next line is continuation line. */
if (buf[len - 1] == '\\') {
c_next = 1;
if (--len == 0)
continue;
buf[len] = '\0';
}
#ifdef DEBUG
(void)fprintf(stderr, "line %d: {%s}\n", lineno, p);
#endif
if (c_cur) {
set(p, centry);
continue;
}
/* Grab file name, "$", "set", or "unset". */
if ((p = strtok(p, "\n\t ")) == NULL)
error("missing field");
if (p[0] == '/')
switch(p[1]) {
case 's':
if (strcmp(p + 1, "set"))
break;
set(NULL, &ginfo);
continue;
case 'u':
if (strcmp(p + 1, "unset"))
break;
unset(NULL, &ginfo);
continue;
}
if (strchr(p, '/'))
error("slash character in file name");
if (!strcmp(p, "..")) {
/* Don't go up, if haven't gone down. */
if (!root)
goto noparent;
if (last->type != F_DIR || last->flags & F_DONE) {
if (last == root)
goto noparent;
last = last->parent;
}
last->flags |= F_DONE;
continue;
noparent: error("no parent node");
}
len = strlen(p) + 1; /* NUL in struct _node */
if ((centry = calloc(1, sizeof(NODE) + len - 1)) == NULL)
error("%s", strerror(errno));
*centry = ginfo;
#define MAGIC "?*["
if (strpbrk(p, MAGIC))
centry->flags |= F_MAGIC;
if (strunvis(centry->name, p) == -1) {
fprintf(stderr,
"mtree: filename (%s) encoded incorrectly\n", p);
strlcpy(centry->name, p, len);
}
set(NULL, centry);
if (!root) {
last = root = centry;
root->parent = root;
} else if (last->type == F_DIR && !(last->flags & F_DONE)) {
centry->parent = last;
last = last->child = centry;
} else {
centry->parent = last->parent;
centry->prev = last;
last = last->next = centry;
}
}
free(tbuf);
return (root);
}
