_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); }