void
spawn_command(const char *cmd) {
char *shell, *p;
if(doublefork() == 0) {
if((p = pathsearch(getenv("WMII_CONFPATH"), cmd, true)))
cmd = p;
if(setsid() == -1)
fatal("Can't setsid: %r");
/* Run through the user's shell as a login shell */
shell = passwd->pw_shell;
if(shell[0] != '/')
fatal("Shell is not an absolute path: %s", shell);
p = smprint("-%s", strrchr(shell, '/') + 1);
close(0);
open("/dev/null", O_RDONLY);
execl(shell, p, "-c", cmd, nil);
fatal("Can't exec '%s': %r", cmd);
/* NOTREACHED */
}
}
/* The next function finds the header template file and opens it, returning
** a pointer to the opened file. */
PRIVATE FILE *htplt_open(struct lmno *lmnop)
{
static char templatename[] = "parser_template.thpp";
char buf[1000];
FILE *in;
char *tpltname;
char *cp;
// truncate filename to parser_template.th if we want C output
if(lmnop->export_c)
templatename[strlen(templatename) - 2] = '\0';
cp = strrchr(lmnop->filename,'.');
if(cp)
{
sprintf(buf,"%.*s.lt",(int)(cp-lmnop->filename),lmnop->filename);
}
else
{
sprintf(buf,"%s.lt",lmnop->filename);
}
if(access(buf,004)==0)
{
tpltname = buf;
}
else if(access(templatename,004)==0){
tpltname = templatename;
}
else
{
tpltname = pathsearch(lmnop->argv0,templatename,0);
}
if(tpltname==0)
{
fprintf(stderr,"Can't find the parser header template file \"%s\".\n",
templatename);
lmnop->errorcnt++;
return 0;
}
in = fopen(tpltname,"r");
if(in==0)
{
fprintf(stderr,"Can't open the parser header template file \"%s\".\n",
templatename);
lmnop->errorcnt++;
return 0;
}
return in;
}
/*
* Return st_mode information in response to stat or lstat calls
*/
static int
glob_stat(const char *name, struct stat *stp)
{
struct direct *dp;
dp = pathsearch(name);
if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0))
return (-1);
if (inodetype(dp->d_ino) == NODE)
stp->st_mode = S_IFDIR;
else
stp->st_mode = S_IFREG;
return (0);
}
/*
* Insure that all the components of a pathname exist.
*/
void
pathcheck(char *name)
{
char *cp;
struct entry *ep;
char *start;
start = strchr(name, '/');
if (start == 0)
return;
for (cp = start; *cp != '\0'; cp++) {
if (*cp != '/')
continue;
*cp = '\0';
ep = lookupname(name);
if (ep == NULL) {
/* Safe; we know the pathname exists in the dump. */
ep = addentry(name, pathsearch(name)->d_ino, NODE);
newnode(ep);
}
ep->e_flags |= NEW|KEEP;
*cp = '/';
}
}
/*
* Do an "ls" style listing of a directory
*/
static void
printlist(const char *name, char *basename)
{
struct afile *fp, *list, *listp = NULL;
struct direct *dp;
struct afile single;
RST_DIR *dirp;
int entries, len, namelen;
char locname[MAXPATHLEN + 1];
dp = pathsearch(name);
if (dp == NULL || (!dflag && TSTINO(dp->d_ino, dumpmap) == 0) ||
(!vflag && dp->d_ino == UFS_WINO))
return;
if ((dirp = rst_opendir(name)) == NULL) {
entries = 1;
list = &single;
mkentry(name, dp, list);
len = strlen(basename) + 1;
if (strlen(name) - len > (unsigned short)single.len) {
freename(single.fname);
single.fname = savename(&name[len]);
single.len = strlen(single.fname);
}
} else {
entries = 0;
while ((dp = rst_readdir(dirp)))
entries++;
rst_closedir(dirp);
list = (struct afile *)malloc(entries * sizeof(struct afile));
if (list == NULL) {
fprintf(stderr, "ls: out of memory\n");
return;
}
if ((dirp = rst_opendir(name)) == NULL)
panic("directory reopen failed\n");
fprintf(stderr, "%s:\n", name);
entries = 0;
listp = list;
strncpy(locname, name, MAXPATHLEN);
strncat(locname, "/", MAXPATHLEN);
namelen = strlen(locname);
while ((dp = rst_readdir(dirp))) {
if (dp == NULL)
break;
if (!dflag && TSTINO(dp->d_ino, dumpmap) == 0)
continue;
if (!vflag && (dp->d_ino == UFS_WINO ||
strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0))
continue;
locname[namelen] = '\0';
if (namelen + dp->d_namlen >= MAXPATHLEN) {
fprintf(stderr, "%s%s: name exceeds %d char\n",
locname, dp->d_name, MAXPATHLEN);
} else {
strncat(locname, dp->d_name, (int)dp->d_namlen);
mkentry(locname, dp, listp++);
entries++;
}
}
rst_closedir(dirp);
if (entries == 0) {
fprintf(stderr, "\n");
free(list);
return;
}
qsort((char *)list, entries, sizeof(struct afile), fcmp);
}
formatf(list, entries);
if (dirp != NULL) {
for (fp = listp - 1; fp >= list; fp--)
freename(fp->fname);
fprintf(stderr, "\n");
free(list);
}
}
int pathsearch_executable (const char *name)
{
return pathsearch (name, 0111);
}
/* eval -- evaluate a list, producing a list */
extern List *eval(List *list0, Binding *binding0, int flags) {
Closure *volatile cp;
List *fn;
if (++evaldepth >= maxevaldepth)
fail("es:eval", "max-eval-depth exceeded");
Ref(List *, list, list0);
Ref(Binding *, binding, binding0);
Ref(char *, funcname, NULL);
restart:
if (list == NULL) {
RefPop3(funcname, binding, list);
--evaldepth;
return true;
}
assert(list->term != NULL);
if ((cp = getclosure(list->term)) != NULL) {
switch (cp->tree->kind) {
case nPrim:
assert(cp->binding == NULL);
list = prim(cp->tree->u[0].s, list->next, binding, flags);
break;
case nThunk:
list = walk(cp->tree->u[0].p, cp->binding, flags);
break;
case nLambda:
ExceptionHandler
Push p;
Ref(Tree *, tree, cp->tree);
Ref(Binding *, context,
bindargs(tree->u[0].p,
list->next,
cp->binding));
if (funcname != NULL)
varpush(&p, "0",
mklist(mkterm(funcname,
NULL),
NULL));
list = walk(tree->u[1].p, context, flags);
if (funcname != NULL)
varpop(&p);
RefEnd2(context, tree);
CatchException (e)
if (termeq(e->term, "return")) {
list = e->next;
goto done;
}
throw(e);
EndExceptionHandler
break;
case nList: {
list = glom(cp->tree, cp->binding, TRUE);
list = append(list, list->next);
goto restart;
}
default:
panic("eval: bad closure node kind %d",
cp->tree->kind);
}
goto done;
}
/* the logic here is duplicated in $&whatis */
Ref(char *, name, getstr(list->term));
fn = varlookup2("fn-", name, binding);
if (fn != NULL) {
funcname = name;
list = append(fn, list->next);
RefPop(name);
goto restart;
}
if (isabsolute(name)) {
char *error = checkexecutable(name);
if (error != NULL)
fail("$&whatis", "%s: %s", name, error);
list = forkexec(name, list, flags & eval_inchild);
RefPop(name);
goto done;
}
RefEnd(name);
fn = pathsearch(list->term);
if (fn != NULL && fn->next == NULL
&& (cp = getclosure(fn->term)) == NULL) {
char *name = getstr(fn->term);
list = forkexec(name, list, flags & eval_inchild);
goto done;
}
list = append(fn, list->next);
goto restart;
done:
--evaldepth;
if ((flags & eval_exitonfalse) && !istrue(list))
exit(exitstatus(list));
RefEnd2(funcname, binding);
RefReturn(list);
}
