_nc_leaks_tinfo(void)
{
#if NO_LEAKS
char *s;
#endif
T((T_CALLED("_nc_free_tinfo()")));
#if NO_LEAKS
_nc_free_tparm();
_nc_tgetent_leaks();
_nc_free_entries(_nc_head);
_nc_get_type(0);
_nc_first_name(0);
_nc_keyname_leaks();
#if BROKEN_LINKER || USE_REENTRANT
_nc_names_leaks();
_nc_codes_leaks();
FreeIfNeeded(_nc_prescreen.real_acs_map);
#endif
if ((s = _nc_home_terminfo()) != 0)
free(s);
#endif /* NO_LEAKS */
returnVoid;
}
/* prototype is to get gcc to accept the noreturn attribute */
static void
ExitProgram(int code)
{
int n;
for (n = 0; n < termcount; ++n) {
ENTRY *new_head = _nc_head;
ENTRY *new_tail = _nc_tail;
_nc_head = entered[n].head;
_nc_tail = entered[n].tail;
_nc_free_entries(entered[n].head);
_nc_head = new_head;
_nc_tail = new_tail;
}
_nc_leaks_dump_entry();
free(entries);
free(entered);
_nc_free_tic(code);
}
_nc_leaks_tinfo(void)
{
#if NO_LEAKS
char *s;
#endif
T((T_CALLED("_nc_free_tinfo()")));
#if NO_LEAKS
_nc_globals.leak_checking = TRUE;
_nc_free_tparm();
_nc_tgetent_leaks();
if (TerminalOf(CURRENT_SCREEN) != 0) {
del_curterm(TerminalOf(CURRENT_SCREEN));
}
_nc_forget_prescr();
_nc_comp_captab_leaks();
_nc_free_entries(_nc_head);
_nc_get_type(0);
_nc_first_name(0);
_nc_db_iterator_leaks();
_nc_keyname_leaks();
#if BROKEN_LINKER || USE_REENTRANT
_nc_names_leaks();
_nc_codes_leaks();
FreeIfNeeded(_nc_prescreen.real_acs_map);
#endif
_nc_comp_error_leaks();
if ((s = _nc_home_terminfo()) != 0)
free(s);
#ifdef TRACE
T((T_RETURN("")));
trace(0);
_nc_trace_buf(-1, (size_t) 0);
#endif
#endif /* NO_LEAKS */
returnVoid;
}
_nc_resolve_uses2(bool fullresolve, bool literal)
/* try to resolve all use capabilities */
{
ENTRY *qp, *rp, *lastread = 0;
bool keepgoing;
unsigned i;
int unresolved, total_unresolved, multiples;
DEBUG(2, ("RESOLUTION BEGINNING"));
/*
* Check for multiple occurrences of the same name.
*/
multiples = 0;
for_entry_list(qp) {
int matchcount = 0;
for_entry_list(rp) {
if (qp > rp
&& _nc_entry_match(qp->tterm.term_names, rp->tterm.term_names)) {
matchcount++;
if (matchcount == 1) {
(void) fprintf(stderr, "Name collision between %s",
_nc_first_name(qp->tterm.term_names));
multiples++;
}
if (matchcount >= 1)
(void) fprintf(stderr, " %s", _nc_first_name(rp->tterm.term_names));
}
}
if (matchcount >= 1)
(void) putc('\n', stderr);
}
if (multiples > 0)
return (FALSE);
DEBUG(2, ("NO MULTIPLE NAME OCCURRENCES"));
/*
* First resolution stage: compute link pointers corresponding to names.
*/
total_unresolved = 0;
_nc_curr_col = -1;
for_entry_list(qp) {
unresolved = 0;
for (i = 0; i < qp->nuses; i++) {
bool foundit;
char *child = _nc_first_name(qp->tterm.term_names);
char *lookfor = qp->uses[i].name;
long lookline = qp->uses[i].line;
foundit = FALSE;
_nc_set_type(child);
/* first, try to resolve from in-core records */
for_entry_list(rp) {
if (rp != qp
&& _nc_name_match(rp->tterm.term_names, lookfor, "|")) {
DEBUG(2, ("%s: resolving use=%s (in core)",
child, lookfor));
qp->uses[i].link = rp;
foundit = TRUE;
}
}
/* if that didn't work, try to merge in a compiled entry */
if (!foundit) {
TERMTYPE thisterm;
char filename[PATH_MAX];
memset(&thisterm, 0, sizeof(thisterm));
if (_nc_read_entry(lookfor, filename, &thisterm) == 1) {
DEBUG(2, ("%s: resolving use=%s (compiled)",
child, lookfor));
rp = typeMalloc(ENTRY, 1);
if (rp == 0)
_nc_err_abort(MSG_NO_MEMORY);
rp->tterm = thisterm;
rp->nuses = 0;
rp->next = lastread;
lastread = rp;
qp->uses[i].link = rp;
foundit = TRUE;
}
}
/* no good, mark this one unresolvable and complain */
if (!foundit) {
unresolved++;
total_unresolved++;
_nc_curr_line = lookline;
_nc_warning("resolution of use=%s failed", lookfor);
qp->uses[i].link = 0;
}
}
}
if (total_unresolved) {
/* free entries read in off disk */
_nc_free_entries(lastread);
return (FALSE);
}
DEBUG(2, ("NAME RESOLUTION COMPLETED OK"));
/*
* OK, at this point all (char *) references in `name' members
* have been successfully converted to (ENTRY *) pointers in
* `link' members. Time to do the actual merges.
*/
if (fullresolve) {
do {
TERMTYPE merged;
keepgoing = FALSE;
for_entry_list(qp) {
if (qp->nuses > 0) {
DEBUG(2, ("%s: attempting merge",
_nc_first_name(qp->tterm.term_names)));
/*
* If any of the use entries we're looking for is
* incomplete, punt. We'll catch this entry on a
* subsequent pass.
*/
for (i = 0; i < qp->nuses; i++)
if (qp->uses[i].link->nuses) {
DEBUG(2, ("%s: use entry %d unresolved",
_nc_first_name(qp->tterm.term_names), i));
goto incomplete;
}
/*
* First, make sure there is no garbage in the
* merge block. As a side effect, copy into
* the merged entry the name field and string
* table pointer.
*/
_nc_copy_termtype(&merged, &(qp->tterm));
/*
* Now merge in each use entry in the proper
* (reverse) order.
*/
for (; qp->nuses; qp->nuses--)
_nc_merge_entry(&merged,
&qp->uses[qp->nuses - 1].link->tterm);
/*
* Now merge in the original entry.
*/
_nc_merge_entry(&merged, &qp->tterm);
/*
* Replace the original entry with the merged one.
*/
FreeIfNeeded(qp->tterm.Booleans);
FreeIfNeeded(qp->tterm.Numbers);
FreeIfNeeded(qp->tterm.Strings);
#if NCURSES_XNAMES
FreeIfNeeded(qp->tterm.ext_Names);
#endif
qp->tterm = merged;
_nc_wrap_entry(qp, TRUE);
/*
* We know every entry is resolvable because name resolution
* didn't bomb. So go back for another pass.
*/
/* FALLTHRU */
incomplete:
keepgoing = TRUE;
}
}
} while
(keepgoing);
DEBUG(2, ("MERGES COMPLETED OK"));
}
/*
* We'd like to free entries read in off disk at this point, but can't.
* The merge_entry() code doesn't copy the strings in the use entries,
* it just aliases them. If this ever changes, do a
* free_entries(lastread) here.
*/
DEBUG(2, ("RESOLUTION FINISHED"));
if (fullresolve)
if (_nc_check_termtype != 0) {
_nc_curr_col = -1;
for_entry_list(qp) {
_nc_curr_line = qp->startline;
_nc_set_type(_nc_first_name(qp->tterm.term_names));
_nc_check_termtype2(&qp->tterm, literal);
}
DEBUG(2, ("SANITY CHECK FINISHED"));
}
_nc_freeall(void)
{
WINDOWLIST *p, *q;
char *s;
T((T_CALLED("_nc_freeall()")));
#if NO_LEAKS
_nc_free_tparm();
if (_nc_oldnums != 0) {
FreeAndNull(_nc_oldnums);
}
#endif
if (SP != 0) {
while (_nc_windows != 0) {
/* Delete only windows that're not a parent */
for (p = _nc_windows; p != 0; p = p->next) {
bool found = FALSE;
for (q = _nc_windows; q != 0; q = q->next) {
if ((p != q)
&& (q->win._flags & _SUBWIN)
&& (&(p->win) == q->win._parent)) {
found = TRUE;
break;
}
}
if (!found) {
delwin(&(p->win));
break;
}
}
}
delscreen(SP);
}
del_curterm(cur_term);
_nc_free_entries(_nc_head);
_nc_get_type(0);
_nc_first_name(0);
#if USE_WIDEC_SUPPORT
FreeIfNeeded(_nc_wacs);
#endif
#if NO_LEAKS
_nc_alloc_entry_leaks();
_nc_captoinfo_leaks();
_nc_comp_scan_leaks();
#endif
if ((s = _nc_home_terminfo()) != 0)
free(s);
(void) _nc_printf_string(0, 0);
#ifdef TRACE
(void) _nc_trace_buf(-1, 0);
#endif
#if HAVE_LIBDBMALLOC
malloc_dump(malloc_errfd);
#elif HAVE_LIBDMALLOC
#elif HAVE_LIBMPATROL
__mp_summary();
#elif HAVE_PURIFY
purify_all_inuse();
#endif
returnVoid;
}
/*
* Get an entry for terminal name in buffer _nc_termcap from the termcap
* file.
*/
int
_nc_read_termcap_entry(const char *const name, TERMTYPE *const tp)
{
ENTRY *ep;
char *p;
char *cp;
char *dummy;
char **fname;
char *home;
int i;
char pathbuf[PBUFSIZ]; /* holds raw path of filenames */
char *pathvec[PVECSIZ]; /* to point to names in pathbuf */
char **pvec; /* holds usable tail of path vector */
char *termpath;
_nc_termcap[0] = '\0'; /* in case */
dummy = NULL;
fname = pathvec;
pvec = pathvec;
p = pathbuf;
cp = getenv("TERMCAP");
/*
* TERMCAP can have one of two things in it. It can be the
* name of a file to use instead of /etc/termcap. In this
* case it better start with a "/". Or it can be an entry to
* use so we don't have to read the file. In this case it
* has to already have the newlines crunched out. If TERMCAP
* does not hold a file name then a path of names is searched
* instead. The path is found in the TERMPATH variable, or
* becomes "$HOME/.termcap /etc/termcap" if no TERMPATH exists.
*/
if (!cp || *cp != '/') { /* no TERMCAP or it holds an entry */
if ( (termpath = getenv("TERMPATH")) )
strncpy(pathbuf, termpath, PBUFSIZ);
else {
if ( (home = getenv("HOME")) ) {/* set up default */
strncpy(pathbuf, home, PBUFSIZ - 1); /* $HOME first */
pathbuf[PBUFSIZ - 2] = '\0'; /* -2 because we add a slash */
p += strlen(pathbuf); /* path, looking in */
*p++ = '/';
} /* if no $HOME look in current directory */
strncpy(p, _PATH_DEF, PBUFSIZ - (p - pathbuf));
}
}
else /* user-defined name in TERMCAP */
strncpy(pathbuf, cp, PBUFSIZ); /* still can be tokenized */
/* For safety */
if (issetugid())
strcpy(pathbuf, _PATH_DEF_SEC);
pathbuf[PBUFSIZ - 1] = '\0';
*fname++ = pathbuf; /* tokenize path into vector of names */
while (*++p)
if (*p == ' ' || *p == ':') {
*p = '\0';
while (*++p)
if (*p != ' ' && *p != ':')
break;
if (*p == '\0')
break;
*fname++ = p;
if (fname >= pathvec + PVECSIZ) {
fname--;
break;
}
}
*fname = (char *) 0; /* mark end of vector */
if (cp && *cp && *cp != '/')
if (cgetset(cp) < 0)
return(-2);
i = cgetent(&dummy, pathvec, (char *)name);
if (i == 0) {
char *pd, *ps, *tok, *s, *tcs;
size_t len;
pd = _nc_termcap;
ps = dummy;
if ((tok = strchr(ps, ':')) == NULL) {
len = strlen(ps);
if (len >= TBUFSIZ)
i = -1;
else
strcpy(pd, ps);
goto done;
}
len = tok - ps + 1;
if (pd + len + 1 - _nc_termcap >= TBUFSIZ) {
i = -1;
goto done;
}
memcpy(pd, ps, len);
ps += len;
pd += len;
*pd = '\0';
tcs = pd - 1;
for (;;) {
while ((tok = strsep(&ps, ":")) != NULL &&
*(tok - 2) != '\\' &&
(*tok == '\0' || *tok == '\\' || !isgraph(UChar(*tok))))
;
if (tok == NULL)
break;
for (s = tcs; s != NULL && s[1] != '\0';
s = strchr(s, ':')) {
s++;
if (s[0] == tok[0] && s[1] == tok[1])
goto skip_it;
}
len = strlen(tok);
if (pd + len + 1 - _nc_termcap >= TBUFSIZ) {
i = -1;
break;
}
memcpy(pd, tok, len);
pd += len;
*pd++ = ':';
*pd = '\0';
skip_it: ;
}
}
done:
if (dummy)
free(dummy);
/*
* From here on is ncurses-specific glue code
*/
if (i < 0)
return(TGETENT_ERR);
_nc_set_source("TERMCAP");
_nc_read_entry_source((FILE *)NULL, _nc_termcap, FALSE, TRUE, NULLHOOK);
if (_nc_head == (ENTRY *)NULL)
return(TGETENT_ERR);
/* resolve all use references */
_nc_resolve_uses2(TRUE, FALSE);
for_entry_list(ep)
if (_nc_name_match(ep->tterm.term_names, name, "|:"))
{
/*
* Make a local copy of the terminal capabilities, delinked
* from the list.
*/
memcpy(tp, &ep->tterm, sizeof(TERMTYPE));
_nc_delink_entry(_nc_head, &(ep->tterm));
free(ep);
_nc_free_entries(_nc_head);
_nc_head = _nc_tail = NULL; /* do not reuse! */
return TGETENT_YES; /* OK */
}
_nc_free_entries(_nc_head);
_nc_head = _nc_tail = NULL; /* do not reuse! */
return(TGETENT_NO); /* not found */
}
static void
ExitProgram(int code)
{
_nc_free_entries(_nc_head);
_nc_free_tic(code);
}
