static char *example_obj_list(struct manifest *m, struct ccan_file *f)
{
struct manifest **deps = talloc_array(f, struct manifest *, 0);
char **lines, *list;
unsigned int i;
/* This one for a start. */
add_dep(&deps, m->basename);
/* Other modules implied by includes. */
for (lines = get_ccan_file_lines(f); *lines; lines++) {
unsigned preflen = strspn(*lines, " \t");
if (strstarts(*lines + preflen, "#include <ccan/")) {
char *modname;
modname = talloc_strdup(f, *lines + preflen
+ strlen("#include <ccan/"));
modname[strcspn(modname, "/")] = '\0';
if (!have_mod(deps, modname))
add_dep(&deps, modname);
}
}
list = talloc_strdup(f, "");
for (i = 0; i < talloc_get_size(deps) / sizeof(*deps); i++) {
if (deps[i]->compiled[COMPILE_NORMAL])
list = talloc_asprintf_append(list, " %s",
deps[i]->compiled
[COMPILE_NORMAL]);
}
return list;
}
static void check_depends_exist(struct manifest *m,
bool keep,
unsigned int *timeleft, struct score *score)
{
unsigned int i;
char **deps;
char *updir = talloc_strdup(m, m->dir);
*strrchr(updir, '/') = '\0';
if (safe_mode)
deps = get_safe_ccan_deps(m, m->dir, true,
&m->info_file->compiled);
else
deps = get_deps(m, m->dir, true, &m->info_file->compiled);
for (i = 0; deps[i]; i++) {
if (!strstarts(deps[i], "ccan/"))
continue;
if (!add_dep(m, deps[i], score))
return;
}
/* We may need libtap for testing, unless we're "tap" */
if (!streq(m->basename, "tap")
&& (!list_empty(&m->run_tests) || !list_empty(&m->api_tests))) {
if (!add_dep(m, "ccan/tap", score))
return;
}
score->pass = true;
score->score = score->total;
}
static void add_dep(struct manifest ***deps, const char *modname)
{
unsigned int i;
struct manifest *m;
char *errstr;
if (have_mod(*deps, modname))
return;
m = get_manifest(*deps,
tal_fmt(*deps, "%s/ccan/%s", ccan_dir, modname));
errstr = build_submodule(m, cflags, COMPILE_NORMAL);
if (errstr)
errx(1, "%s", errstr);
add_mod(deps, m);
/* Get that modules depends as well... */
assert(!safe_mode);
if (m->info_file) {
char **infodeps;
infodeps = get_deps(m, m->dir, "depends", false,
get_or_compile_info);
for (i = 0; infodeps[i]; i++) {
if (strstarts(infodeps[i], "ccan/"))
add_dep(deps, infodeps[i] + strlen("ccan/"));
}
}
}
static void setup_test(void)
{
struct dependency_context *ctx = NULL;
struct output_writter *output = NULL;
output = get_console_writter();
TEST_ASSERT_NOT_NULL(output);
struct memory_allocator *allocator = NULL;
allocator = get_default_allocator();
TEST_ASSERT_NOT_NULL(allocator);
ctx = create_dependency_ctx(create_dependency(output, OUTPUT),
create_dependency(allocator, ALLOCATOR),
NULL);
TEST_ASSERT_NOT_NULL(ctx->array);
TEST_ASSERT(ctx->count == 2);
uint32_t i;
for(i = 0; i < ctx->count; i++)
{
TEST_ASSERT_NOT_NULL(ctx->array[i]);
}
TEST_ASSERT(ctx->array[0]->name == OUTPUT);
TEST_ASSERT(ctx->array[1]->name == ALLOCATOR);
inject_crypto_deps(ctx);
struct random_generator *random_gen = NULL;
random_gen = get_default_random_generator();
TEST_ASSERT_NOT_NULL(random_gen);
int32_t rtrn = 0;
rtrn = add_dep(ctx, create_dependency(random_gen, RANDOM_GEN));
TEST_ASSERT(rtrn == 0);
struct hasher *hasher = NULL;
hasher = get_hasher();
TEST_ASSERT_NOT_NULL(hasher);
rtrn = add_dep(ctx, create_dependency(hasher, HASHER));
TEST_ASSERT(rtrn == 0);
inject_utils_deps(ctx);
}
/* Adds memory dependencies based on ordering type:
0 - exact; 1 - strong; 2 - weak; 3 - none */
void add_memory_dep (cuc_func *f, int otype)
{
int b, i;
dep_list *all_mem = NULL;
for (b = 0; b < f->num_bb; b++) {
cuc_insn *insn = f->bb[b].insn;
for (i = 0; i < f->bb[b].ninsn; i++)
if (insn[i].type & IT_MEMORY) {
dep_list *tmp = all_mem;
while (tmp) {
//PRINTF ("%x %x\n", REF (b,i), tmp->ref);
if (check_memory_conflict (f, &insn[i], &f->INSN(tmp->ref), otype))
add_dep (&insn[i].dep, tmp->ref);
tmp = tmp->next;
}
add_dep (&all_mem, REF (b, i));
}
}
dispose_list (&all_mem);
}
void Version::from_bip(char*& cursor)
{
set_label(read_string(cursor));
if(!label().empty()) set_exists();
int num_deps = read_uint(cursor);
_deps.clear();
_deps.reserve(num_deps);
for(int i=0; i < num_deps; i++)
{
Package::Ptr pkg = dataset.package(read_uint(cursor));
Version::Ptr dep = pkg->version(time());
add_dep(dep);
}
}
/* Schedule memory accesses
0 - exact; 1 - strong; 2 - weak; 3 - none */
int schedule_memory (cuc_func *f, int otype)
{
int b, i, j;
int modified = 0;
f->nmsched = 0;
for (b = 0; b < f->num_bb; b++) {
cuc_insn *insn = f->bb[b].insn;
for (i = 0; i < f->bb[b].ninsn; i++)
if (insn[i].type & IT_MEMORY) {
f->msched[f->nmsched++] = REF (b, i);
if (otype == MO_NONE || otype == MO_WEAK) insn[i].type |= IT_FLAG1; /* mark unscheduled */
}
}
for (i = 0; i < f->nmsched; i++)
cucdebug (2, "[%x]%x%c ", f->msched[i], f->mtype[i] & MT_WIDTH, (f->mtype[i] & MT_BURST) ? (f->mtype[i] & MT_BURSTE) ? 'E' : 'B' : ' ');
cucdebug (2, "\n");
/* We can reorder just more loose types
We assume, that memory accesses are currently in valid (but not neccesserly)
optimal order */
if (otype == MO_WEAK || otype == MO_NONE) {
for (i = 0; i < f->nmsched; i++) {
int best = i;
int tmp;
for (j = i + 1; j < f->nmsched; j++) if (REF_BB(f->msched[j]) == REF_BB(f->msched[best])) {
if (mem_ordering_cmp (f, &f->INSN (f->msched[j]), &f->INSN(f->msched[best]))) {
/* Check dependencies */
dep_list *t = f->INSN(f->msched[j]).dep;
while (t) {
if (f->INSN(t->ref).type & IT_FLAG1) break;
t = t->next;
}
if (!t) best = j; /* no conflicts -> ok */
}
}
/* we have to shift instructions up, to maintain valid dependencies
and make space for best candidate */
/* make local copy */
tmp = f->msched[best];
for (j = best; j > i; j--) f->msched[j] = f->msched[j - 1];
f->msched[i] = tmp;
f->INSN(f->msched[i]).type &= ~IT_FLAG1; /* mark scheduled */
}
}
for (i = 0; i < f->nmsched; i++)
cucdebug (2, "[%x]%x%c ", f->msched[i], f->mtype[i] & MT_WIDTH, (f->mtype[i] & MT_BURST) ? (f->mtype[i] & MT_BURSTE) ? 'E' : 'B' : ' ');
cucdebug (2, "\n");
/* Assign memory types */
for (i = 0; i < f->nmsched; i++) {
cuc_insn *a = &f->INSN(f->msched[i]);
f->mtype[i] = !II_IS_LOAD(a->index) ? MT_STORE : MT_LOAD;
f->mtype[i] |= II_MEM_WIDTH (a->index);
if (a->type & IT_SIGNED) f->mtype[i] |= MT_SIGNED;
}
if (same_transfers (f, otype)) modified = 1;
if (join_transfers (f, otype)) modified = 1;
for (i = 0; i < f->nmsched; i++)
cucdebug (2, "[%x]%x%c ", f->msched[i], f->mtype[i] & MT_WIDTH, (f->mtype[i] & MT_BURST) ? (f->mtype[i] & MT_BURSTE) ? 'E' : 'B' : ' ');
cucdebug (2, "\n");
if (cuc_debug > 5) print_cuc_bb (f, "AFTER_MEM_REMOVAL");
if (config.cuc.enable_bursts) {
//PRINTF ("\n");
for (i = 1; i < f->nmsched; i++) {
cuc_insn *a = &f->INSN(f->msched[i - 1]);
cuc_insn *b = &f->INSN(f->msched[i]);
int aw = f->mtype[i - 1] & MT_WIDTH;
/* Burst can only be out of words */
if (aw != 4) continue;
if ((a->opt[1] & OPT_REF) && f->INSN(a->op[1]).index == II_ADD
&&(b->opt[1] & OPT_REF) && f->INSN(b->op[1]).index == II_ADD) {
a = &f->INSN(a->op[1]);
b = &f->INSN(b->op[1]);
/* Not in usual form? */
if (a->opt[1] != b->opt[1] || a->op[1] != b->op[1]
|| a->opt[2] != OPT_CONST || b->opt[2] != OPT_CONST) continue;
//PRINTF ("%i %i, ", a->op[2], b->op[2]);
/* Check if they touch together */
if (a->op[2] + aw == b->op[2]
&& REF_BB(f->msched[i - 1]) == REF_BB(f->msched[i])) {
/* yes => do burst */
f->mtype[i - 1] &= ~MT_BURSTE;
f->mtype[i - 1] |= MT_BURST;
f->mtype[i] |= MT_BURST | MT_BURSTE;
}
}
}
}
for (i = 0; i < f->nmsched; i++)
cucdebug (2, "[%x]%x%c ", f->msched[i], f->mtype[i] & MT_WIDTH, (f->mtype[i] & MT_BURST) ? (f->mtype[i] & MT_BURSTE) ? 'E' : 'B' : ' ');
cucdebug (2, "\n");
/* We don't need dependencies in non-memory instructions */
for (b = 0; b < f->num_bb; b++) {
cuc_insn *insn = f->bb[b].insn;
for (i = 0; i < f->bb[b].ninsn; i++) if (!(insn[i].type & IT_MEMORY))
dispose_list (&insn[i].dep);
}
if (cuc_debug > 5) print_cuc_bb (f, "AFTER_MEM_REMOVAL2");
/* Reduce number of dependecies, keeping just direct dependencies, based on memory schedule */
{
int lastl[3] = {-1, -1, -1};
int lasts[3] = {-1, -1, -1};
int lastc[3] = {-1, -1, -1};
int last_load = -1, last_store = -1, last_call = -1;
for (i = 0; i < f->nmsched; i++) {
int t = f->mtype[i] & MT_LOAD ? 0 : f->mtype[i] & MT_STORE ? 1 : 2;
int maxl = lastl[t];
int maxs = lasts[t];
int maxc = lastc[t];
dep_list *tmp = f->INSN(f->msched[i]).dep;
cucdebug (7, "!%i %x %p\n", i, f->msched[i], tmp);
while (tmp) {
if (f->INSN(tmp->ref).type & IT_MEMORY && REF_BB(tmp->ref) == REF_BB(f->msched[i])) {
cucdebug (7, "%i %x %lx\n", i, f->msched[i], tmp->ref);
/* Search for the reference */
for (j = 0; j < f->nmsched; j++) if (f->msched[j] == tmp->ref) break;
assert (j < f->nmsched);
if (f->mtype[j] & MT_STORE) {
if (maxs < j) maxs = j;
} else if (f->mtype[j] & MT_LOAD) {
if (maxl < j) maxl = j;
} else if (f->mtype[j] & MT_CALL) {
if (maxc < j) maxc = j;
}
}
tmp = tmp->next;
}
dispose_list (&f->INSN(f->msched[i]).dep);
if (f->mtype[i] & MT_STORE) {
maxs = last_store;
last_store = i;
} else if (f->mtype[i] & MT_LOAD) {
maxl = last_load;
last_load = i;
} else if (f->mtype[i] & MT_CALL) {
maxc = last_call;
last_call = i;
}
if (maxl > lastl[t]) {
add_dep (&f->INSN(f->msched[i]).dep, f->msched[maxl]);
lastl[t] = maxl;
}
if (maxs > lasts[t]) {
add_dep (&f->INSN(f->msched[i]).dep, f->msched[maxs]);
lasts[t] = maxs;
}
if (maxc > lastc[t]) {
add_dep (&f->INSN(f->msched[i]).dep, f->msched[maxc]);
lastc[t] = maxc;
}
//PRINTF ("%i(%i)> ml %i(%i) ms %i(%i) lastl %i %i lasts %i %i last_load %i last_store %i\n", i, f->msched[i], maxl, f->msched[maxl], maxs, f->msched[maxs], lastl[0], lastl[1], lasts[0], lasts[1], last_load, last_store);
/* What we have to wait to finish this BB? */
if (i + 1 >= f->nmsched || REF_BB(f->msched[i + 1]) != REF_BB(f->msched[i])) {
if (last_load > lastl[t]) {
add_dep (&f->bb[REF_BB(f->msched[i])].mdep, f->msched[last_load]);
lastl[t] = last_load;
}
if (last_store > lasts[t]) {
add_dep (&f->bb[REF_BB(f->msched[i])].mdep, f->msched[last_store]);
lasts[t] = last_store;
}
if (last_call > lastc[t]) {
add_dep (&f->bb[REF_BB(f->msched[i])].mdep, f->msched[last_call]);
lastc[t] = last_call;
}
}
}
}
return modified;
}
static void
add_deps(_jc_env *env, _jc_splay_tree *tree, _jc_classfile *cf, int flags)
{
_jc_classbytes *cb = NULL;
_jc_classfile *scf;
_jc_class_ref *deps;
_jc_class_ref ref;
int num_deps;
int i;
/* Already doing this class? */
ref.name = cf->name;
ref.len = strlen(cf->name);
if (_jc_splay_find(tree, &ref) != NULL)
return;
/* Add this class */
add_dep(tree, cf->name, strlen(cf->name));
/* Dump superclasses' dependencies */
if (cf->superclass == NULL)
goto no_superclass;
if ((cb = _jc_bootcl_find_classbytes(env, cf->superclass, NULL)) == NULL
|| (scf = _jc_parse_classfile(env, cb, 2)) == NULL) {
errx(1, "failed to load classfile: %s: %s",
_jc_vmex_names[env->ex.num], env->ex.msg);
}
_jc_free_classbytes(&cb);
add_deps(env, tree, scf, flags);
_jc_destroy_classfile(&scf);
no_superclass:
/* Dump superinterfaces' dependencies */
for (i = 0; i < cf->num_interfaces; i++) {
if ((cb = _jc_bootcl_find_classbytes(env,
cf->interfaces[i], NULL)) == NULL
|| (scf = _jc_parse_classfile(env, cb, 2)) == NULL) {
errx(1, "failed to load classfile: %s: %s",
_jc_vmex_names[env->ex.num], env->ex.msg);
}
_jc_free_classbytes(&cb);
add_deps(env, tree, scf, flags);
_jc_destroy_classfile(&scf);
}
/* If 'supers_only', we're done */
if ((flags & DUMP_SUPERS_ONLY) != 0)
return;
/* Update flags */
if ((flags & DUMP_TRANS_CLOSURE) == 0)
flags |= DUMP_SUPERS_ONLY;
/* Dump this class's direct dependencies and their supers */
if ((num_deps = _jc_gen_deplist(env, cf, &deps)) == -1)
errx(1, "failed to generate dependency list: %s: %s",
_jc_vmex_names[env->ex.num], env->ex.msg);
for (i = 0; i < num_deps; i++) {
_jc_class_ref *const dep = &deps[i];
char *name;
if ((name = malloc(dep->len + 1)) == NULL)
err(1, "malloc");
memcpy(name, dep->name, dep->len);
name[dep->len] = '\0';
if ((cb = _jc_bootcl_find_classbytes(env, name, NULL)) == NULL
|| (scf = _jc_parse_classfile(env, cb, 2)) == NULL) {
errx(1, "failed to load classfile: %s: %s",
_jc_vmex_names[env->ex.num], env->ex.msg);
}
_jc_free_classbytes(&cb);
add_deps(env, tree, scf, flags);
_jc_destroy_classfile(&scf);
free(name);
}
_jc_vm_free(&deps);
}
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);
}
}
