/* * Determine the erase, interrupt, and kill characters from the termcap * entry and command line and update their values in 'mode'. */ void set_control_chars(void) { char *bp, *p, bs_char, buf[1024]; bp = buf; p = tgetstr("kb", &bp); if (p == NULL || p[1] != '\0') p = tgetstr("bc", &bp); if (p != NULL && p[1] == '\0') bs_char = p[0]; else if (tgetflag("bs")) bs_char = CTRL('h'); else bs_char = 0; if (erasech == 0 && bs_char != 0 && !tgetflag("os")) erasech = -1; if (erasech < 0) erasech = (bs_char != 0) ? bs_char : CTRL('h'); if (mode.c_cc[VERASE] == 0 || erasech != 0) mode.c_cc[VERASE] = erasech ? erasech : CERASE; if (mode.c_cc[VINTR] == 0 || intrchar != 0) mode.c_cc[VINTR] = intrchar ? intrchar : CINTR; if (mode.c_cc[VKILL] == 0 || killch != 0) mode.c_cc[VKILL] = killch ? killch : CKILL; }
InitScreen() { /* Set up all this fun stuff: returns zero if all okay, or; -1 indicating no terminal name associated with this shell, -2..-n No termcap for this terminal type known */ int tgetent(), /* get termcap entry */ err; char termname[40]; char *termenv; if ((termenv = getenv("TERM")) == NULL) return(-1); if (strcpy(termname, termenv) == NULL) return(-1); if ((err = tgetent(_terminal, termname)) != 1) return(err-2); _line = 0; /* where are we right now?? */ _col = 0; /* assume zero, zero... */ /* load in all those pesky values */ _clearscreen = tgetstr("cl", &ptr); _moveto = tgetstr("cm", &ptr); _up = tgetstr("up", &ptr); _down = tgetstr("do", &ptr); _right = tgetstr("nd", &ptr); _left = tgetstr("bc", &ptr); _setbold = tgetstr("so", &ptr); _clearbold = tgetstr("se", &ptr); _setunderline = tgetstr("us", &ptr); _clearunderline = tgetstr("ue", &ptr); _setinverse = tgetstr("so", &ptr); _clearinverse = tgetstr("se", &ptr); _sethalfbright = tgetstr("hs", &ptr); _clearhalfbright = tgetstr("he", &ptr); _cleartoeoln = tgetstr("ce", &ptr); _cleartoeos = tgetstr("cd", &ptr); _lines = tgetnum("li"); _columns = tgetnum("co"); tabspacing = ((tabspacing=tgetnum("it"))<= 0 ? 8 : tabspacing); _automargin = tgetflag("am"); _eatnewlineglitch = tgetflag("xn"); _transmit_on = tgetstr("ks", &ptr); _transmit_off = tgetstr("ke", &ptr); _set_memlock = tgetstr("ml", &ptr); _clear_memlock = tgetstr("mu", &ptr); _start_termcap = tgetstr("ti", &ptr); _end_termcap = tgetstr("te", &ptr); if (!_left) { _left = "\b"; } return(0); }
void startup(void) { char *term; char *tptr; char *tbufptr, *pc; tptr = (char *) alloc(1024); tbufptr = tbuf; if(!(term = getenv("TERM"))) error("Can't get TERM."); if(!strncmp(term, "5620", 4)) flags.nonull = 1; /* this should be a termcap flag */ if(tgetent(tptr, term) < 1) error("Unknown terminal type: %s.", term); if ((pc = tgetstr("pc", &tbufptr))) PC = *pc; if(!(BC = tgetstr("le", &tbufptr))) { if(!tgetflag("bs")) error("Terminal must backspace."); BC = tbufptr; tbufptr += 2; *BC = '\b'; } HO = tgetstr("ho", &tbufptr); CO = tgetnum("co"); LI = tgetnum("li"); if(CO < COLNO || LI < ROWNO+2) setclipped(); if(!(CL = tgetstr("cl", &tbufptr))) error("Hack needs CL."); ND = tgetstr("nd", &tbufptr); if(tgetflag("os")) error("Hack can't have OS."); CE = tgetstr("ce", &tbufptr); UP = tgetstr("up", &tbufptr); /* It seems that xd is no longer supported, and we should use a linefeed instead; unfortunately this requires resetting CRMOD, and many output routines will have to be modified slightly. Let's leave that till the next release. */ XD = tgetstr("xd", &tbufptr); /* not: XD = tgetstr("do", &tbufptr); */ if(!(CM = tgetstr("cm", &tbufptr))) { if(!UP && !HO) error("Hack needs CM or UP or HO."); printf("Playing hack on terminals without cm is suspect...\n"); getret(); } SO = tgetstr("so", &tbufptr); SE = tgetstr("se", &tbufptr); SG = tgetnum("sg"); /* -1: not fnd; else # of spaces left by so */ if(!SO || !SE || (SG > 0)) SO = SE = 0; CD = tgetstr("cd", &tbufptr); set_whole_screen(); /* uses LI and CD */ if(tbufptr-tbuf > sizeof(tbuf)) error("TERMCAP entry too big...\n"); free(tptr); }
int main(int argc, char **argv) { int c; const char *termtype; FILE *f; char termcap[1024]; setlocale(LC_ALL, ""); termtype = getenv("TERM"); if (termtype == NULL || (argv[0][0] == 'c' && !isatty(1))) termtype = "lpr"; while ((c=getopt(argc, argv, "it:T:")) != -1) switch(c) { case 't': case 'T': /* for nroff compatibility */ termtype = optarg; break; case 'i': iflag = 1; break; default: usage(); } switch(tgetent(termcap, termtype)) { case 1: break; default: warnx("trouble reading termcap"); /* FALLTHROUGH */ case 0: /* No such terminal type - assume dumb */ (void)strcpy(termcap, "dumb:os:col#80:cr=^M:sf=^J:am:"); break; } initcap(); if ( (tgetflag("os") && ENTER_BOLD==NULL ) || (tgetflag("ul") && ENTER_UNDERLINE==NULL && UNDER_CHAR==NULL)) must_overstrike = 1; initbuf(); if (optind == argc) filter(stdin); else for (; optind<argc; optind++) { f = fopen(argv[optind],"r"); if (f == NULL) err(1, "%s", argv[optind]); else filter(f); } exit(0); }
int main (int argc, char **argv) { char *term; char *buf; term = argv[1]; printf ("TERM: %s\n", term); buf = (char *) tgetent (0, term); if ((int) buf <= 0) { printf ("No entry.\n"); return 0; } printf ("Entry: %s\n", buf); tprint ("cm"); tprint ("AL"); printf ("co: %d\n", tgetnum ("co")); printf ("am: %d\n", tgetflag ("am")); return 0; }
void zap(void) { register char *namp; register bool **fp; register char ***sp; int flag; char *string; #ifndef UCVISUAL namp = "ambsdadbeohcinmincnsosulxbxnxtxx"; #else namp = "ambsdadbeohchzinmincnsosulxbxnxtxx"; #endif fp = sflags; do { flag = tgetflag(namp); *(*fp++) = flag; namp += 2; } while (*namp); namp = "albcbtcdceclcmcrcsdcdldmdoedeik0k1k2k3k4k5k6k7k8k9hoicimipkdkekhklkrkskullndnlpcrcscsesfsosrtatetiupvbvsveALDLUPDOLERI"; sp = sstrs; do { string = tgetstr(namp, &aoftspace); *(*sp++) = string; namp += 2; } while (*namp); }
/* * Get a particular flag capability. */ static int GetFlagCap(const char *termcapName, const char *terminfoName) { #ifdef IL_USE_TERMCAP return tgetflag((char *)termcapName); #else return (tigetflag((char *)terminfoName) > 0); #endif }
int main(int argc, char **argv) { int ch, exitval, n; char *cptr, *term, buf[1024], tbuf[1024]; const char *p; term = NULL; while ((ch = getopt(argc, argv, "T:")) != -1) switch(ch) { case 'T': term = optarg; break; case '?': default: usage(); } argc -= optind; argv += optind; if (argc < 1) usage(); if (!term && !(term = getenv("TERM"))) errx(2, "no terminal type specified and no TERM environmental variable."); if (tgetent(tbuf, term) != 1) err(3, "tgetent failure"); for (exitval = 0; (p = *argv) != NULL; ++argv) { switch (*p) { case 'c': if (!strcmp(p, "clear")) p = "cl"; break; case 'i': if (!strcmp(p, "init")) p = "is"; break; case 'l': if (!strcmp(p, "longname")) { prlongname(tbuf); continue; } break; case 'r': if (!strcmp(p, "reset")) p = "rs"; break; } cptr = buf; if (tgetstr(p, &cptr)) argv = process(p, buf, argv); else if ((n = tgetnum(p)) != -1) (void)printf("%d\n", n); else exitval = !tgetflag(p); } exit(exitval); }
static void initcap(void) { static char tcapbuf[2048]; char *bp = tcapbuf; cursor_right = tgetstr("ri", &bp); if (cursor_right == NULL) cursor_right = tgetstr("nd", &bp); cursor_up = tgetstr("up", &bp); cursor_left = tgetstr("le", &bp); if (cursor_left == NULL) cursor_left = tgetstr("bc", &bp); underline_char = tgetstr("uc", &bp); exit_underline_mode = tgetstr("ue", &bp); exit_attribute_mode = tgetstr("me", &bp); exit_standout_mode = tgetstr("se", &bp); enter_reverse_mode = tgetstr("mr", &bp); enter_underline_mode = tgetstr("us", &bp); enter_dim_mode = tgetstr("mh", &bp); enter_bold_mode = tgetstr("md", &bp); enter_standout_mode = tgetstr("se", &bp); if (!enter_bold_mode && enter_reverse_mode) enter_bold_mode = enter_reverse_mode; if (!!enter_bold_mode && enter_standout_mode) enter_bold_mode = enter_standout_mode; if (!enter_underline_mode && enter_standout_mode) { enter_underline_mode = enter_standout_mode; exit_underline_mode = exit_standout_mode; } if (!enter_dim_mode && enter_standout_mode) enter_dim_mode = enter_standout_mode; if (!enter_reverse_mode && enter_standout_mode) enter_reverse_mode = enter_standout_mode; if (!exit_attribute_mode && exit_standout_mode) exit_attribute_mode = exit_standout_mode; must_use_uc = under_char && !enter_underline_mode; over_strike = tgetflag("os"); transparent_underline = tgetflag("ul"); }
static void initcap(void) { static char tcapbuf[512]; char *bp = tcapbuf; /* This nonsense attempts to work with both old and new termcap */ CURS_UP = tgetstr("up", &bp); CURS_RIGHT = tgetstr("ri", &bp); if (CURS_RIGHT == NULL) CURS_RIGHT = tgetstr("nd", &bp); CURS_LEFT = tgetstr("le", &bp); if (CURS_LEFT == NULL) CURS_LEFT = tgetstr("bc", &bp); if (CURS_LEFT == NULL && tgetflag("bs")) CURS_LEFT = "\b"; ENTER_STANDOUT = tgetstr("so", &bp); EXIT_STANDOUT = tgetstr("se", &bp); ENTER_UNDERLINE = tgetstr("us", &bp); EXIT_UNDERLINE = tgetstr("ue", &bp); ENTER_DIM = tgetstr("mh", &bp); ENTER_BOLD = tgetstr("md", &bp); ENTER_REVERSE = tgetstr("mr", &bp); EXIT_ATTRIBUTES = tgetstr("me", &bp); if (!ENTER_BOLD && ENTER_REVERSE) ENTER_BOLD = ENTER_REVERSE; if (!ENTER_BOLD && ENTER_STANDOUT) ENTER_BOLD = ENTER_STANDOUT; if (!ENTER_UNDERLINE && ENTER_STANDOUT) { ENTER_UNDERLINE = ENTER_STANDOUT; EXIT_UNDERLINE = EXIT_STANDOUT; } if (!ENTER_DIM && ENTER_STANDOUT) ENTER_DIM = ENTER_STANDOUT; if (!ENTER_REVERSE && ENTER_STANDOUT) ENTER_REVERSE = ENTER_STANDOUT; if (!EXIT_ATTRIBUTES && EXIT_STANDOUT) EXIT_ATTRIBUTES = EXIT_STANDOUT; /* * Note that we use REVERSE for the alternate character set, * not the as/ae capabilities. This is because we are modelling * the model 37 teletype (since that's what nroff outputs) and * the typical as/ae is more of a graphics set, not the greek * letters the 37 has. */ UNDER_CHAR = tgetstr("uc", &bp); must_use_uc = (UNDER_CHAR && !ENTER_UNDERLINE); }
int main(int argc, char *argv[]) { char *op = output; char *rp = result; const char *t = getenv("TERM"); char *prop, *pe; int n; if (argc != 2) { fprintf(stderr, "%s [props]\n", argv[0]); exit(1); } if (t == NULL) t = "dumb"; if ((n = tgetent(buf, t)) != 1) { fprintf(stderr, "%s is not a known terminal type\n", t); putw(0, stdout); exit(1); } prop = argv[1]; pe = prop + strlen(prop) - 2; while(prop < pe) { id[0] = *prop++; id[1] = *prop++; if (*prop == '$') { char *r = tgetstr(id, &op); if (r) { size_t l = strlen(r); memcpy(rp, r, l); rp += l; } *rp++= 0; prop++; continue; } if (*prop == '#') { n = tgetnum(id); prop++; } else n = tgetflag(id); /* Intentionally native type and endian */ memcpy(rp, &n, sizeof(n)); rp += sizeof(n); } putw(rp - result, stdout); fwrite(result, rp - result, 1, stdout); return 0; }
/* * This routine gets all the terminal flags from the termcap database */ static void zap() { register char *namp; register bool **fp; register char ***sp; #ifdef DEBUG register char *cp; #endif namp = "ambsdadbeohchzinmimsncnsosulxbxnxtxsxx"; fp = sflags; do { *(*fp++) = tgetflag(namp); #ifdef DEBUG fprintf(outf, "%2.2s = %s\n", namp, *fp[-1] ? "TRUE" : "FALSE"); #endif namp += 2; } while (*namp); namp = "albcbtcdceclcmcrcsdcdldmdoedeik0k1k2k3k4k5k6k7k8k9hoicimipkdkekhklkrkskullmandnlpcrcscsesfsosrtatetiucueupusvbvsveALDLUPDOLERI"; sp = sstrs; do { *(*sp++) = tgetstr(namp, &aoftspace); #ifdef DEBUG fprintf(outf, "%2.2s = %s", namp, *sp[-1] == NULL ? "NULL\n" : "\""); if (*sp[-1] != NULL) { for (cp = *sp[-1]; *cp; cp++) fprintf(outf, "%s", unctrl(*cp)); fprintf(outf, "\"\n"); } #endif namp += 2; } while (*namp); if (XS) SO = SE = NULL; else { if (tgetnum("sg") > 0) SO = NULL; if (tgetnum("ug") > 0) US = NULL; if (!SO && US) { SO = US; SE = UE; } } if (DO && !NL) NL = DO; }
SCM gucu_tget (SCM id) { SCM_ASSERT (scm_is_string (id), id, SCM_ARG1, "tget"); int ret; char *c_str; c_str = scm_to_locale_string (id); ret = tgetnum (id); if (id != -1) return scm_from_int (ret); ret = tgetflag (id); if (id == 0) return SCM_BOOL_T; }
static TACommandVerdict tgetflag_cmd(TAThread thread, TAInputStream stream) { char* id; int res; // Prepare id = readString(&stream); START_TARGET_OPERATION(thread); // Execute res = tgetflag(id); END_TARGET_OPERATION(thread); // Response writeInt(thread, res); sendResponse(thread); return taDefaultVerdict; }
static void zap(void) { int tgetflag(char *id); register char *namp; register bool **fp; register char ***sp; namp = "ambsdadbeohchzinmincnsosulxbxnxtxx"; fp = sflags; do { *(*fp++) = tgetflag(namp); namp += 2; } while (*namp); namp = "albcbtcdceclcmcrcsdcdldmdoedeik0k1k2k3k4k5k6k7k8k9hoicimipkdkekhklkrkskullndnlpcrcscsesfsosrtatetiupvbvsveALDLUPDOLERI"; sp = sstrs; do { *(*sp++) = tgetstr(namp, &aoftspace); namp += 2; } while (*namp); }
/* * Set up various conversions in 'mode', including parity, tabs, returns, * echo, and case, according to the termcap entry. If the program we're * running was named with a leading upper-case character, map external * uppercase to internal lowercase. */ void set_conversions(int usingupper) { if (tgetflag("UC") || usingupper) { #ifdef IUCLC mode.c_iflag |= IUCLC; mode.c_oflag |= OLCUC; #endif } else if (tgetflag("LC")) { #ifdef IUCLC mode.c_iflag &= ~IUCLC; mode.c_oflag &= ~OLCUC; #endif } mode.c_iflag &= ~(PARMRK | INPCK); mode.c_lflag |= ICANON; if (tgetflag("EP")) { mode.c_cflag |= PARENB; mode.c_cflag &= ~PARODD; } if (tgetflag("OP")) { mode.c_cflag |= PARENB; mode.c_cflag |= PARODD; } #ifdef ONLCR mode.c_oflag |= ONLCR; #endif mode.c_iflag |= ICRNL; mode.c_lflag |= ECHO; mode.c_oflag |= OXTABS; if (tgetflag("NL")) { /* Newline, not linefeed. */ #ifdef ONLCR mode.c_oflag &= ~ONLCR; #endif mode.c_iflag &= ~ICRNL; } if (tgetflag("HD")) /* Half duplex. */ mode.c_lflag &= ~ECHO; if (tgetflag("pt")) /* Print tabs. */ mode.c_oflag &= ~OXTABS; mode.c_lflag |= (ECHOE | ECHOK); }
t_bool ft_tinit(t_term *term) { struct termios tc; if ((term->name = ft_getenv("TERM")) == NULL || tgetent(NULL, term->name) <= 0) term->name = DEFAULT_TERM; if (tgetent(NULL, term->name) <= 0) return (false); if (tcgetattr(0, &tc) < 0) return (false); ft_memcpy(&(term->save), &tc, sizeof(struct termios)); tc.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON); tc.c_cc[VMIN] = 1; tc.c_cc[VTIME] = 0; if (tcsetattr(0, TCSADRAIN, &tc) < 0) return (false); term->save_am = (tgetflag("am")) ? true : false; TPS("ti"), TPS("vi"), TPS("RA"); ft_tupdate(term); return (true); }
static int ztgetflag(char *s) { char **b; /* ncurses can tell if an existing boolean capability is * * off, but other curses variants can't, so we fudge it. * * This feature of ncurses appears to have gone away as * * of NCURSES_MAJOR_VERSION == 5, so don't rely on it. */ switch (tgetflag(s)) { case -1: break; case 0: for (b = (char **)boolcodes; *b; ++b) if (s[0] == (*b)[0] && s[1] == (*b)[1]) return 0; break; default: return 1; } return -1; }
void set_title (char *s) { #if defined(USE_NCURSES) || defined (USE_NCURSES_W) if (tgetflag ("hs")) { // terminal has status line support char buf[255] = {0}; char *p = buf; // tgetstr modifies its second argument, let buf keep pointing to the beginning char *ok; // tgetstr's return value is apparently undocumented, except that it's NULL on errors ok = tgetstr ("tsl", &p); // "to status line" if (ok == NULL) return; strcpy (p - 1, s); // tgetstr leaves us *after* the null, so skip back a bit p += strlen (s) - 1; // same here ok = tgetstr ("fsl", &p); // "from status line" if (ok == NULL) return; putp (buf); } #else // assume pdcurses PDC_set_title(s); #endif }
int tcutil_init (void) { char *termtype, *p, *bp; int a, rv; /* Check we have a real terminal */ if(!isatty(0)) return(0); /* Get terminal type */ termtype = getenv("TERM"); if(!termtype) return(0); /* Get termcap */ rv = tgetent(termcapbuf, termtype); if(rv != 1) return(0); bp = termentbuf; /* Look up padding */ p = tgetstr("pc", &bp); if(p) PC = *p; else PC = 0; /* Can the terminal backspace? We may need this. */ can_bs = tgetflag("bs"); /* Set BC and UP to NULL so we can use tgoto to emit other caps needing arguments. */ BC = (char *) NULL; UP = (char *) NULL; /* Look up operations */ for(a = 0; a < NUM_OPS; a++) { p = tgetstr(ops_tc[a], &bp); if(p) ops[a] = p; else ops[a] = (char *) NULL; } /* Look up attributes */ for(a = 0; a < NUM_ATTR; a++) { p = tgetstr(attr_tc[a], &bp); if(p) attr[a] = p; else attr[a] = (char *) NULL; } /* Turn off buffering */ setvbuf(stdout, (char *) NULL, _IONBF, 0); /* Should really turn off output processing * and arrange for restoration on exit, but that * would mean we have to handle all the other * stuff (like newlines) ourselves too. */ /* Success! */ return(1); }
/* * Read termcap and set some global variables. Initialize input trie to * decode escape sequences. */ static int tcapterminalinfo(int termcap_wins) { char *p, *tgetstr(); char tcbuf[2*1024]; char *tv_stype; char err_str[72]; int err; char *_ku, *_kd, *_kl, *_kr, *_kppu, *_kppd, *_kphome, *_kpend, *_kpdel, *_kf1, *_kf2, *_kf3, *_kf4, *_kf5, *_kf6, *_kf7, *_kf8, *_kf9, *_kf10, *_kf11, *_kf12; if (!(tv_stype = getenv("TERM")) || !strncpy(term_name, tv_stype, sizeof(term_name))){ if(Pmaster){ return(-1); } else{ puts("Environment variable TERM not defined!"); exit(1); } } term_name[sizeof(term_name)-1] = '\0'; if((err = tgetent(tcbuf, tv_stype)) != 1){ if(Pmaster){ return(err - 2); } else{ snprintf(err_str, sizeof(err_str), "Unknown terminal type %s!", tv_stype); puts(err_str); exit(1); } } p = tcapbuf; _clearscreen = tgetstr("cl", &p); _moveto = tgetstr("cm", &p); _up = tgetstr("up", &p); _down = tgetstr("do", &p); _right = tgetstr("nd", &p); _left = tgetstr("bs", &p); _setinverse = tgetstr("so", &p); _clearinverse = tgetstr("se", &p); _setunderline = tgetstr("us", &p); _clearunderline = tgetstr("ue", &p); _setbold = tgetstr("md", &p); _clearallattr = tgetstr("me", &p); _cleartoeoln = tgetstr("ce", &p); _cleartoeos = tgetstr("cd", &p); _deletechar = tgetstr("dc", &p); _insertchar = tgetstr("ic", &p); _startinsert = tgetstr("im", &p); _endinsert = tgetstr("ei", &p); _deleteline = tgetstr("dl", &p); _insertline = tgetstr("al", &p); _scrollregion = tgetstr("cs", &p); _scrolldown = tgetstr("sf", &p); _scrollup = tgetstr("sr", &p); _termcap_init = tgetstr("ti", &p); _termcap_end = tgetstr("te", &p); _startdelete = tgetstr("dm", &p); _enddelete = tgetstr("ed", &p); _ku = tgetstr("ku", &p); _kd = tgetstr("kd", &p); _kl = tgetstr("kl", &p); _kr = tgetstr("kr", &p); _kppu = tgetstr("kP", &p); _kppd = tgetstr("kN", &p); _kphome = tgetstr("kh", &p); _kpend = tgetstr("kH", &p); _kpdel = tgetstr("kD", &p); _kf1 = tgetstr("k1", &p); _kf2 = tgetstr("k2", &p); _kf3 = tgetstr("k3", &p); _kf4 = tgetstr("k4", &p); _kf5 = tgetstr("k5", &p); _kf6 = tgetstr("k6", &p); _kf7 = tgetstr("k7", &p); _kf8 = tgetstr("k8", &p); _kf9 = tgetstr("k9", &p); if((_kf10 = tgetstr("k;", &p)) == NULL) _kf10 = tgetstr("k0", &p); _kf11 = tgetstr("F1", &p); _kf12 = tgetstr("F2", &p); _colors = tgetnum("Co"); _pairs = tgetnum("pa"); _setaf = tgetstr("AF", &p); _setab = tgetstr("AB", &p); _setf = tgetstr("Sf", &p); _setb = tgetstr("Sb", &p); _scp = tgetstr("sp", &p); _op = tgetstr("op", &p); _oc = tgetstr("oc", &p); _bce = tgetflag("ut"); if (p >= &tcapbuf[TCAPSLEN]){ puts("Terminal description too big!\n"); if(Pmaster) return(-3); else exit(1); } _tlines = tgetnum("li"); if(_tlines == -1){ char *er; int rr; /* tgetnum failed, try $LINES */ er = getenv("LINES"); if(er && (rr = atoi(er)) > 0) _tlines = rr; } _tcolumns = tgetnum("co"); if(_tcolumns == -1){ char *ec; int cc; /* tgetnum failed, try $COLUMNS */ ec = getenv("COLUMNS"); if(ec && (cc = atoi(ec)) > 0) _tcolumns = cc; } /* * Add default keypad sequences to the trie. * Since these come first, they will override any conflicting termcap * or terminfo escape sequences defined below. An escape sequence is * considered conflicting if one is a prefix of the other. * So, without TERMCAP_WINS, there will likely be some termcap/terminfo * escape sequences that don't work, because they conflict with default * sequences defined here. */ if(!termcap_wins) setup_dflt_esc_seq(); /* * add termcap/info escape sequences to the trie... */ if(_ku != NULL && _kd != NULL && _kl != NULL && _kr != NULL){ kpinsert(_ku, KEY_UP, termcap_wins); kpinsert(_kd, KEY_DOWN, termcap_wins); kpinsert(_kl, KEY_LEFT, termcap_wins); kpinsert(_kr, KEY_RIGHT, termcap_wins); } if(_kppu != NULL && _kppd != NULL){ kpinsert(_kppu, KEY_PGUP, termcap_wins); kpinsert(_kppd, KEY_PGDN, termcap_wins); } kpinsert(_kphome, KEY_HOME, termcap_wins); kpinsert(_kpend, KEY_END, termcap_wins); kpinsert(_kpdel, KEY_DEL, termcap_wins); kpinsert(_kf1, F1, termcap_wins); kpinsert(_kf2, F2, termcap_wins); kpinsert(_kf3, F3, termcap_wins); kpinsert(_kf4, F4, termcap_wins); kpinsert(_kf5, F5, termcap_wins); kpinsert(_kf6, F6, termcap_wins); kpinsert(_kf7, F7, termcap_wins); kpinsert(_kf8, F8, termcap_wins); kpinsert(_kf9, F9, termcap_wins); kpinsert(_kf10, F10, termcap_wins); kpinsert(_kf11, F11, termcap_wins); kpinsert(_kf12, F12, termcap_wins); /* * Add default keypad sequences to the trie. * Since these come after the termcap/terminfo escape sequences above, * the termcap/info sequences will override any conflicting default * escape sequences defined here. * So, with TERMCAP_WINS, some of the default sequences will be missing. * This means that you'd better get all of your termcap/terminfo entries * correct if you define TERMCAP_WINS. */ if(termcap_wins) setup_dflt_esc_seq(); if(Pmaster) return(0); else return(TRUE); }
int main(int ac, char **av) { int skip; char *cp; if (ac < 3) { fprintf(stderr, "usage: %s str1 str2 [ -w -! -noask -go -f file -F file ]\n", __progname); exit(1); } cp = getenv("TERM"); if (cp == 0) { beginul = nullstr; endul = nullstr; } else { if (tgetent(tcp_buf, cp) != 1) { beginul = nullstr; endul = nullstr; } else { cp = cap_buf; if (tgetflag("os") || tgetflag("ul")) { ul_ = 1; } else { ul_ = 0; beginul = tgetstr("us", &cp); if (beginul == 0) { beginul = tgetstr("so", &cp); if (beginul == 0) { beginul = nullstr; endul = nullstr; } else { endul = tgetstr("se", &cp); } } else { endul = tgetstr("ue", &cp); } } } } { static char tmp[] = "/tmp/qsubst.XXXXXX"; int fd; fd = mkstemp(&tmp[0]); if (fd < 0) { fprintf(stderr, "%s: cannot create temp file: %s\n", __progname, strerror(errno)); exit(1); } tempf = fdopen(fd, "w+"); } if ((access(av[1], R_OK | W_OK) == 0) && (access(av[ac - 1], R_OK | W_OK) < 0) && (access(av[ac - 2], R_OK | W_OK) < 0)) { fprintf(stderr, "%s: argument order has changed, it's now: str1 str2 files...\n", __progname); } str1 = av[1]; str2 = av[2]; av += 2; ac -= 2; s1l = strlen(str1); s2l = strlen(str2); if (s1l > BUF_SIZ) { fprintf(stderr, "%s: search string too long (max %d chars)\n", __progname, BUF_SIZ); exit(1); } tcgetattr(0, &orig_tio); signal(SIGTSTP, sigtstp); allfly = 0; cabove = 2; cbelow = 2; skip = 0; for (ac--, av++; ac; ac--, av++) { if (skip > 0) { skip--; continue; } if (**av == '-') { ++*av; if (!strcmp(*av, "debug")) { debugging++; } else if (!strcmp(*av, "w")) { wordmode = !wordmode; } else if ((strcmp(*av, "!") == 0) || (strcmp(*av, "go") == 0) || (strcmp(*av, "noask") == 0)) { allfly = 1; } else if ((strcmp(*av, "nogo") == 0) || (strcmp(*av, "ask") == 0)) { allfly = 0; } else if (**av == 'c') { cabove = atoi(++*av); cbelow = cabove; limit_above_below(); } else if (**av == 'C') { ++*av; if (**av == 'A') { cabove = atoi(++*av); limit_above_below(); } else if (**av == 'B') { cbelow = atoi(++*av); limit_above_below(); } else { fprintf(stderr, "%s: -C must be -CA or -CB\n", __progname); } } else if ((strcmp(*av, "f") == 0) || (strcmp(*av, "F") == 0)) { if (++skip >= ac) { fprintf(stderr, "%s: -%s what?\n", __progname, *av); } else { if (**av == 'f') { process_file(av[skip]); } else { process_indir_file(av[skip]); } } } } else { process_file(*av); } } exit(0); }
void init_termcap(int interactive) { char *bufptr; char *PCptr; char *term_name; char *getenv(); int status; /* set defaults in case we aren't smart */ screen_width = MAX_COLS; screen_length = 0; if (!interactive) { /* pretend we have a dumb terminal */ smart_terminal = No; return; } /* assume we have a smart terminal until proven otherwise */ smart_terminal = Yes; /* get the terminal name */ term_name = getenv("TERM"); /* if there is no TERM, assume it's a dumb terminal */ /* patch courtesy of Sam Horrocks at telegraph.ics.uci.edu */ if (term_name == NULL) { smart_terminal = No; return; } /* now get the termcap entry */ if ((status = tgetent(termcap_buf, term_name)) != 1) { if (status == -1) { fprintf(stderr, "%s: can't open termcap file\n", myname); } else { fprintf(stderr, "%s: no termcap entry for a `%s' terminal\n", myname, term_name); } /* pretend it's dumb and proceed */ smart_terminal = No; return; } /* "hardcopy" immediately indicates a very stupid terminal */ if (tgetflag("hc")) { smart_terminal = No; return; } /* set up common terminal capabilities */ if ((screen_length = tgetnum("li")) <= 0) { screen_length = smart_terminal = 0; return; } /* screen_width is a little different */ if ((screen_width = tgetnum("co")) == -1) { screen_width = 79; } else { screen_width -= 1; } /* terminals that overstrike need special attention */ overstrike = tgetflag("os"); /* initialize the pointer into the termcap string buffer */ bufptr = string_buffer; /* get "ce", clear to end */ if (!overstrike) { clear_line = tgetstr("ce", &bufptr); } /* get necessary capabilities */ if ((clear_screen = tgetstr("cl", &bufptr)) == NULL || (cursor_motion = tgetstr("cm", &bufptr)) == NULL) { smart_terminal = No; return; } /* get some more sophisticated stuff -- these are optional */ clear_to_end = tgetstr("cd", &bufptr); terminal_init = tgetstr("ti", &bufptr); terminal_end = tgetstr("te", &bufptr); start_standout = tgetstr("so", &bufptr); end_standout = tgetstr("se", &bufptr); /* pad character */ PC = (PCptr = tgetstr("pc", &bufptr)) ? *PCptr : 0; /* set convenience strings */ (void) strcpy(home, tgoto(cursor_motion, 0, 0)); /* (lower_left is set in get_screensize) */ /* get the actual screen size with an ioctl, if needed */ /* * This may change screen_width and screen_length, and it always sets * lower_left. */ get_screensize(); /* if stdout is not a terminal, pretend we are a dumb terminal */ #ifdef SGTTY if (ioctl(STDOUT, TIOCGETP, &old_settings) == -1) { smart_terminal = No; } #endif #ifdef TERMIO if (ioctl(STDOUT, TCGETA, &old_settings) == -1) { smart_terminal = No; } #endif #ifdef TERMIOS if (tcgetattr(STDOUT, &old_settings) == -1) { smart_terminal = No; } #endif }
/* Initialize the terminal which is known as TERMINAL_NAME. If this terminal doesn't have cursor addressability, `terminal_is_dumb_p' becomes nonzero. The variables SCREENHEIGHT and SCREENWIDTH are set to the dimensions that this terminal actually has. The variable TERMINAL_HAS_META_P becomes nonzero if this terminal supports a Meta key. Finally, the terminal screen is cleared. */ void terminal_initialize_terminal (char *terminal_name) { char *buffer; terminal_is_dumb_p = 0; if (terminal_initialize_terminal_hook) { (*terminal_initialize_terminal_hook) (terminal_name); return; } term_name = terminal_name ? terminal_name : getenv ("TERM"); if (!term_name) term_name = "dumb"; if (!term_string_buffer) term_string_buffer = xmalloc (2048); if (!term_buffer) term_buffer = xmalloc (2048); buffer = term_string_buffer; term_clrpag = term_cr = term_clreol = NULL; /* HP-UX 11.x returns 0 for OK [email protected]. */ if (tgetent (term_buffer, term_name) < 0) { terminal_is_dumb_p = 1; screenwidth = 80; screenheight = 24; term_cr = "\r"; term_up = term_dn = audible_bell = visible_bell = NULL; term_ku = term_kd = term_kl = term_kr = NULL; term_kP = term_kN = NULL; term_kh = term_ke = NULL; term_kD = NULL; return; } BC = tgetstr ("pc", &buffer); PC = BC ? *BC : 0; #if defined (HAVE_TERMIOS_H) { struct termios ti; if (tcgetattr (fileno(stdout), &ti) != -1) ospeed = cfgetospeed (&ti); else ospeed = B9600; } #else # if defined (TIOCGETP) { struct sgttyb sg; if (ioctl (fileno (stdout), TIOCGETP, &sg) != -1) ospeed = sg.sg_ospeed; else ospeed = B9600; } # else ospeed = B9600; # endif /* !TIOCGETP */ #endif term_cr = tgetstr ("cr", &buffer); term_clreol = tgetstr ("ce", &buffer); term_clrpag = tgetstr ("cl", &buffer); term_goto = tgetstr ("cm", &buffer); /* Find out about this terminal's scrolling capability. */ term_AL = tgetstr ("AL", &buffer); term_DL = tgetstr ("DL", &buffer); term_al = tgetstr ("al", &buffer); term_dl = tgetstr ("dl", &buffer); terminal_can_scroll = ((term_AL || term_al) && (term_DL || term_dl)); term_invbeg = tgetstr ("mr", &buffer); if (term_invbeg) term_invend = tgetstr ("me", &buffer); else term_invend = NULL; if (!term_cr) term_cr = "\r"; terminal_get_screen_size (); term_up = tgetstr ("up", &buffer); term_dn = tgetstr ("dn", &buffer); visible_bell = tgetstr ("vb", &buffer); terminal_has_visible_bell_p = (visible_bell != NULL); audible_bell = tgetstr ("bl", &buffer); if (!audible_bell) audible_bell = "\007"; term_begin_use = tgetstr ("ti", &buffer); term_end_use = tgetstr ("te", &buffer); term_keypad_on = tgetstr ("ks", &buffer); term_keypad_off = tgetstr ("ke", &buffer); /* Check to see if this terminal has a meta key. */ terminal_has_meta_p = (tgetflag ("km") || tgetflag ("MT")); if (terminal_has_meta_p) { term_mm = tgetstr ("mm", &buffer); } else { term_mm = NULL; } /* Attempt to find the arrow keys. */ term_ku = tgetstr ("ku", &buffer); term_kd = tgetstr ("kd", &buffer); term_kr = tgetstr ("kr", &buffer); term_kl = tgetstr ("kl", &buffer); term_kP = tgetstr ("kP", &buffer); term_kN = tgetstr ("kN", &buffer); #if defined(INFOKEY) term_kh = tgetstr ("kh", &buffer); term_ke = tgetstr ("@7", &buffer); term_ki = tgetstr ("kI", &buffer); term_kx = tgetstr ("kD", &buffer); #endif /* defined(INFOKEY) */ /* Home and end keys. */ term_kh = tgetstr ("kh", &buffer); term_ke = tgetstr ("@7", &buffer); term_kD = tgetstr ("kD", &buffer); /* If this terminal is not cursor addressable, then it is really dumb. */ if (!term_goto) terminal_is_dumb_p = 1; }
/* * term_init: does all terminal initialization... reads termcap info, sets * the terminal to CBREAK, no ECHO mode. Chooses the best of the terminal * attributes to use .. for the version of this function that is called for * wserv, we set the termial to RAW, no ECHO, so that all the signals are * ignored.. fixes quite a few problems... -phone, jan 1993.. */ void term_init(void) { #ifndef STTY_ONLY char bp[TGETENT_BUFSIZ], *term, *ptr; if ((term = getenv("TERM")) == NULL) { fprintf(stderr, "irc: No TERM variable set!\n"); fprintf(stderr,"irc: You may still run irc by using the -d switch\n"); exit(1); } if (tgetent(bp, term) < 1) { fprintf(stderr, "irc: No termcap entry for %s.\n", term); fprintf(stderr,"irc: You may still run irc by using the -d switch\n"); exit(1); } if ((co = tgetnum("co")) == -1) co = 80; if ((li = tgetnum("li")) == -1) li = 24; ptr = termcap; /* * Thanks to Max Bell ([email protected]) for info about TVI * terminals and the sg terminal capability */ SG = tgetnum("sg"); CM = tgetstr("cm", &ptr); CL = tgetstr("cl", &ptr); if ((CM == NULL) || (CL == NULL)) { fprintf(stderr, "This terminal does not have the necessary " "capabilities to run IRCII\n" "in full screen mode. You may still run " "irc by using the -d switch\n"); exit(1); } if ((CR = tgetstr("cr", &ptr)) == NULL) CR = "\r"; if ((NL = tgetstr("nl", &ptr)) == NULL) NL = "\n"; if ((CE = tgetstr("ce", &ptr)) != NULL) term_clear_to_eol_func = term_CE_clear_to_eol; else term_clear_to_eol_func = term_null_function; TE = tgetstr("te", &ptr); if (!use_termcap_enterexit() && TE && (TI = tgetstr("ti", &ptr)) != NULL ) tputs_x(TI); else TE = TI = NULL; /* if ((ND = tgetstr("nd", &ptr)) || (ND = tgetstr("kr", &ptr))) */ if ((ND = tgetstr("nd", &ptr)) != NULL) term_cursor_right_func = term_ND_cursor_right; else term_cursor_right_func = term_null_function; /* if ((LE = tgetstr("le", &ptr)) || (LE = tgetstr("kl", &ptr))) */ if ((LE = tgetstr("le", &ptr)) != NULL) term_cursor_left_func = term_LE_cursor_left; else if (tgetflag("bs")) term_cursor_left_func = term_BS_cursor_left; else term_cursor_left_func = term_null_function; SF = tgetstr("sf", &ptr); SR = tgetstr("sr", &ptr); if ((CS = tgetstr("cs", &ptr)) != NULL) term_scroll_func = term_CS_scroll; else if ((AL = tgetstr("AL", &ptr)) && (DL = tgetstr("DL", &ptr))) term_scroll_func = term_param_ALDL_scroll; else if ((AL = tgetstr("al", &ptr)) && (DL = tgetstr("dl", &ptr))) term_scroll_func = term_ALDL_scroll; else term_scroll_func = (int (*)(int, int, int)) term_null_function; if ((IC = tgetstr("ic", &ptr)) != NULL) term_insert_func = term_IC_insert; else { if ((IM = tgetstr("im", &ptr)) && (EI = tgetstr("ei", &ptr))) term_insert_func = term_IMEI_insert; else term_insert_func = (int (*)(u_int)) term_null_function; } if ((DC = tgetstr("dc", &ptr)) != NULL) term_delete_func = term_DC_delete; else term_delete_func = term_null_function; SO = tgetstr("so", &ptr); SE = tgetstr("se", &ptr); if ((SO == NULL) || (SE == NULL)) { SO = CP(empty_string()); SE = CP(empty_string()); } US = tgetstr("us", &ptr); UE = tgetstr("ue", &ptr); if ((US == NULL) || (UE == NULL)) { US = CP(empty_string()); UE = CP(empty_string()); } MD = tgetstr("md", &ptr); ME = tgetstr("me", &ptr); if ((MD == NULL) || (ME == NULL)) { MD = CP(empty_string()); ME = CP(empty_string()); } if ((BL = tgetstr("bl", &ptr)) == NULL) BL = "\007"; #endif /* STTY_ONLY */ if (getenv("IRC_DEBUG")|| (tty_des = open("/dev/tty", O_RDWR, 0)) == -1) tty_des = 0; tcgetattr(tty_des, &oldb); newb = oldb; newb.c_lflag &= ~(ICANON | ECHO); /* set equivalent of * CBREAK and no ECHO */ newb.c_cc[VMIN] = 1; /* read() satified after 1 char */ newb.c_cc[VTIME] = 0; /* No timer */ #ifndef _POSIX_VDISABLE # define _POSIX_VDISABLE 0 #endif newb.c_cc[VQUIT] = _POSIX_VDISABLE; #ifdef VDISCARD newb.c_cc[VDISCARD] = _POSIX_VDISABLE; #endif #ifdef VDSUSP newb.c_cc[VDSUSP] = _POSIX_VDISABLE; #endif #ifdef VSUSP newb.c_cc[VSUSP] = _POSIX_VDISABLE; #endif #ifndef STTY_ONLY if (!use_flow_control()) newb.c_iflag &= ~IXON; /* No XON/XOFF */ #endif /* STTY_ONLY */ tcsetattr(tty_des, TCSADRAIN, &newb); }
/* * Terminal I/O */ void initterm(void) { char buf[TBUFSIZ]; static char clearbuf[TBUFSIZ]; char *clearptr, *padstr; char *term; int tgrp; struct winsize win; retry: if (!(no_tty = tcgetattr(STDOUT_FILENO, &otty))) { docrterase = (otty.c_cc[VERASE] != _POSIX_VDISABLE); docrtkill = (otty.c_cc[VKILL] != _POSIX_VDISABLE); /* * Wait until we're in the foreground before we save the * the terminal modes. */ if ((tgrp = tcgetpgrp(STDOUT_FILENO)) < 0) { perror("tcgetpgrp"); exit(1); } if (tgrp != getpgrp()) { kill(0, SIGTTOU); goto retry; } if ((term = getenv("TERM")) == 0 || tgetent(buf, term) <= 0) { dumb++; ul_opt = 0; } else { if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0) { Lpp = tgetnum("li"); Mcol = tgetnum("co"); } else { if ((Lpp = win.ws_row) == 0) Lpp = tgetnum("li"); if ((Mcol = win.ws_col) == 0) Mcol = tgetnum("co"); } if (Lpp <= 0 || tgetflag("hc")) { hard++; /* Hard copy terminal */ Lpp = 24; } if (tgetflag("xn")) { /* Eat newline at last column + 1 */ eatnl++; } if (Mcol <= 0) Mcol = 80; if (strcmp(__progname, "page") == 0 || (!hard && tgetflag("ns"))) noscroll++; Wrap = tgetflag("am"); bad_so = tgetflag ("xs"); clearptr = clearbuf; eraseln = tgetstr("ce", &clearptr); Clear = tgetstr("cl", &clearptr); Senter = tgetstr("so", &clearptr); Sexit = tgetstr("se", &clearptr); if ((soglitch = tgetnum("sg")) < 0) soglitch = 0; /* * Setup for underlining. Some terminals don't need it, * others have start/stop sequences, still others have * an underline char sequence which is assumed to move * the cursor forward one character. If underline seq * isn't available, settle for standout sequence. */ if (tgetflag("ul") || tgetflag("os")) ul_opt = 0; if ((chUL = tgetstr("uc", &clearptr)) == NULL) chUL = ""; if (((ULenter = tgetstr("us", &clearptr)) == NULL || (ULexit = tgetstr("ue", &clearptr)) == NULL) && !*chUL) { if ((ULenter = Senter) == NULL || (ULexit = Sexit) == NULL) { ULenter = ""; ULexit = ""; } else ulglitch = soglitch; } else { if ((ulglitch = tgetnum("ug")) < 0) ulglitch = 0; } if ((padstr = tgetstr("pc", &clearptr))) PC = *padstr; Home = tgetstr("ho", &clearptr); if (Home == 0 || *Home == '\0') { cursorm = tgetstr("cm", &clearptr); if (cursorm != NULL) { strlcpy(cursorhome, tgoto(cursorm, 0, 0), sizeof(cursorhome)); Home = cursorhome; } } EodClr = tgetstr("cd", &clearptr); if ((chBS = tgetstr("bc", &clearptr)) == NULL) chBS = "\b"; if (tgetstr("te", &clearptr) != NULL && tgetstr("ti", &clearptr) != NULL) altscr = 1; } if ((shell = getenv("SHELL")) == NULL) shell = _PATH_BSHELL; } no_intty = !isatty(STDIN_FILENO); tcgetattr(STDERR_FILENO, &otty); slow_tty = cfgetospeed(&otty) < B1200; hardtabs = !(otty.c_oflag & OXTABS); ntty = otty; if (!no_tty) { ntty.c_lflag &= ~(ICANON|ECHO); ntty.c_cc[VMIN] = 1; /* read at least 1 char */ ntty.c_cc[VTIME] = 0; /* no timeout */ } }
/* * Set up various conversions in 'mode', including parity, tabs, returns, * echo, and case, according to the termcap entry. If the program we're * running was named with a leading upper-case character, map external * uppercase to internal lowercase. */ static void set_conversions(void) { #ifdef __OBSOLETE__ /* * Conversion logic for some *really* ancient terminal glitches, * not supported in terminfo. Left here for succeeding generations * to marvel at. */ if (tgetflag("UC")) { #ifdef IUCLC mode.c_iflag |= IUCLC; mode.c_oflag |= OLCUC; #endif } else if (tgetflag("LC")) { #ifdef IUCLC mode.c_iflag &= ~IUCLC; mode.c_oflag &= ~OLCUC; #endif } mode.c_iflag &= ~(PARMRK | INPCK); mode.c_lflag |= ICANON; if (tgetflag("EP")) { mode.c_cflag |= PARENB; mode.c_cflag &= ~PARODD; } if (tgetflag("OP")) { mode.c_cflag |= PARENB; mode.c_cflag |= PARODD; } #endif /* __OBSOLETE__ */ #ifdef TERMIOS #ifdef ONLCR mode.c_oflag |= ONLCR; #endif mode.c_iflag |= ICRNL; mode.c_lflag |= ECHO; #ifdef OXTABS mode.c_oflag |= OXTABS; #endif /* OXTABS */ /* test used to be tgetflag("NL") */ if (newline != (char *) 0 && newline[0] == '\n' && !newline[1]) { /* Newline, not linefeed. */ #ifdef ONLCR mode.c_oflag &= ~ONLCR; #endif mode.c_iflag &= ~ICRNL; } #ifdef __OBSOLETE__ if (tgetflag("HD")) /* Half duplex. */ mode.c_lflag &= ~ECHO; #endif /* __OBSOLETE__ */ #ifdef OXTABS /* test used to be tgetflag("pt") */ if (has_hardware_tabs) /* Print tabs. */ mode.c_oflag &= ~OXTABS; #endif /* OXTABS */ mode.c_lflag |= (ECHOE | ECHOK); #endif }
/* * Figure out what kind of terminal we're dealing with, and then read in * its termcap entry. */ static const char * get_termcap_entry(char *userarg) { int errret; char *p; const char *ttype; #if HAVE_GETTTYNAM struct ttyent *t; #else FILE *fp; #endif char *ttypath; if (userarg) { ttype = userarg; goto found; } /* Try the environment. */ if ((ttype = getenv("TERM")) != 0) goto map; if ((ttypath = ttyname(STDERR_FILENO)) != 0) { p = _nc_basename(ttypath); #if HAVE_GETTTYNAM /* * We have the 4.3BSD library call getttynam(3); that means * there's an /etc/ttys to look up device-to-type mappings in. * Try ttyname(3); check for dialup or other mapping. */ if ((t = getttynam(p))) { ttype = t->ty_type; goto map; } #else if ((fp = fopen("/etc/ttytype", "r")) != 0 || (fp = fopen("/etc/ttys", "r")) != 0) { char buffer[BUFSIZ]; char *s, *t, *d; while (fgets(buffer, sizeof(buffer), fp) != NULL) { for (s = buffer, t = d = 0; *s; s++) { if (isspace(UChar(*s))) *s = '\0'; else if (t == 0) t = s; else if (d == 0 && s != buffer && s[-1] == '\0') d = s; } if (t != 0 && d != 0 && !strcmp(d, p)) { ttype = strdup(t); fclose(fp); goto map; } } fclose(fp); } #endif /* HAVE_GETTTYNAM */ } /* If still undefined, use "unknown". */ ttype = "unknown"; map:ttype = mapped(ttype); /* * If not a path, remove TERMCAP from the environment so we get a * real entry from /etc/termcap. This prevents us from being fooled * by out of date stuff in the environment. */ found:if ((p = getenv("TERMCAP")) != 0 && !_nc_is_abs_path(p)) { /* 'unsetenv("TERMCAP")' is not portable. * The 'environ' array is better. */ int n; for (n = 0; environ[n] != 0; n++) { if (!strncmp("TERMCAP=", environ[n], 8)) { while ((environ[n] = environ[n + 1]) != 0) { n++; } break; } } } /* * ttype now contains a pointer to the type of the terminal. * If the first character is '?', ask the user. */ if (ttype[0] == '?') { if (ttype[1] != '\0') ttype = askuser(ttype + 1); else ttype = askuser(0); } /* Find the terminfo entry. If it doesn't exist, ask the user. */ while (setupterm((NCURSES_CONST char *) ttype, STDOUT_FILENO, &errret) != OK) { if (errret == 0) { (void) fprintf(stderr, "%s: unknown terminal type %s\n", _nc_progname, ttype); ttype = 0; } else { (void) fprintf(stderr, "%s: can't initialize terminal type %s (error %d)\n", _nc_progname, ttype, errret); ttype = 0; } ttype = askuser(ttype); } #if BROKEN_LINKER tgetflag("am"); /* force lib_termcap.o to be linked for 'ospeed' */ #endif return (ttype); }
void getTCstr(void) { char *ent; char *suc; char *pt = funcstr; int r; ent = getenv("TERM") ? getenv("TERM") : DEFAULT_TERM; if (ent == NULL) { fprintf(stderr, "TERM is not set\n"); reset_exit(SIGNAL_ARGLIST); } r = tgetent(bp, ent); if (r != 1) { /* Can't find termcap entry */ fprintf(stderr, "Can't find termcap entry %s\n", ent); reset_exit(SIGNAL_ARGLIST); } GETSTR(T_ce, "ce"); /* clear to the end of line */ GETSTR(T_cd, "cd"); /* clear to the end of display */ GETSTR(T_kr, "nd"); /* cursor right */ if (suc == NULL) GETSTR(T_kr, "kr"); if (tgetflag("bs")) T_kl = "\b"; /* cursor left */ else { GETSTR(T_kl, "le"); if (suc == NULL) GETSTR(T_kl, "kb"); if (suc == NULL) GETSTR(T_kl, "kl"); } GETSTR(T_cr, "cr"); /* carriage return */ GETSTR(T_ta, "ta"); /* tab */ GETSTR(T_sc, "sc"); /* save cursor */ GETSTR(T_rc, "rc"); /* restore cursor */ GETSTR(T_so, "so"); /* standout mode */ GETSTR(T_se, "se"); /* standout mode end */ GETSTR(T_us, "us"); /* underline mode */ GETSTR(T_ue, "ue"); /* underline mode end */ GETSTR(T_md, "md"); /* bold mode */ GETSTR(T_me, "me"); /* bold mode end */ GETSTR(T_cl, "cl"); /* clear screen */ GETSTR(T_cm, "cm"); /* cursor move */ GETSTR(T_al, "al"); /* append line */ GETSTR(T_sr, "sr"); /* scroll reverse */ GETSTR(T_ti, "ti"); /* terminal init */ GETSTR(T_te, "te"); /* terminal end */ GETSTR(T_nd, "nd"); /* move right one space */ GETSTR(T_eA, "eA"); /* enable alternative charset */ GETSTR(T_as, "as"); /* alternative (graphic) charset start */ GETSTR(T_ae, "ae"); /* alternative (graphic) charset end */ GETSTR(T_ac, "ac"); /* graphics charset pairs */ GETSTR(T_op, "op"); /* set default color pair to its original value */ #if defined( CYGWIN ) && CYGWIN < 1 /* for TERM=pcansi on MS-DOS prompt. */ #if 0 T_eA = ""; T_as = "\033[12m"; T_ae = "\033[10m"; T_ac = "l\001k\002m\003j\004x\005q\006n\020a\024v\025w\026u\027t\031"; #endif T_eA = ""; T_as = ""; T_ae = ""; T_ac = ""; #endif /* CYGWIN */ LINES = COLS = 0; setlinescols(); setgraphchar(); }
static int my_tgetflag(char *s) { return tgetflag(s); }