initscr(void) { static bool initialized = FALSE; NCURSES_CONST char *name; int value; START_TRACE(); T((T_CALLED("initscr()"))); /* Portable applications must not call initscr() more than once */ if (!initialized) { initialized = TRUE; if ((name = getenv("TERM")) == 0 || *name == '\0') name = "unknown"; #ifdef __CYGWIN__ /* * 2002/9/21 * Work around a bug in Cygwin. Full-screen subprocesses run from * bash, in turn spawned from another full-screen process, will dump * core when attempting to write to stdout. Opening /dev/tty * explicitly seems to fix the problem. */ if (isatty(fileno(stdout))) { FILE *fp = fopen("/dev/tty", "w"); if (fp != 0 && isatty(fileno(fp))) { fclose(stdout); dup2(fileno(fp), STDOUT_FILENO); stdout = fdopen(STDOUT_FILENO, "w"); } } #endif if (newterm(name, stdout, stdin) == 0) { fprintf(stderr, "Error opening terminal: %s.\n", name); exit(EXIT_FAILURE); } /* allow user to set maximum escape delay from the environment */ if ((value = _nc_getenv_num("ESCDELAY")) >= 0) { ESCDELAY = value; } /* def_shell_mode - done in newterm/_nc_setupscreen */ def_prog_mode(); } returnWin(stdscr); }
NCURSES_SP_NAME(baudrate) (NCURSES_SP_DCL0) { int result; T((T_CALLED("baudrate(%p)"), (void *) SP_PARM)); /* * In debugging, allow the environment symbol to override when we're * redirecting to a file, so we can construct repeatable test-cases * that take into account costs that depend on baudrate. */ #ifdef TRACE if (IsValidTIScreen(SP_PARM) && !NC_ISATTY(fileno(SP_PARM ? SP_PARM->_ofp : stdout)) && getenv("BAUDRATE") != 0) { int ret; if ((ret = _nc_getenv_num("BAUDRATE")) <= 0) ret = 9600; ospeed = (NCURSES_OSPEED) _nc_ospeed(ret); returnCode(ret); } #endif if (IsValidTIScreen(SP_PARM)) { #ifdef USE_OLD_TTY result = (int) cfgetospeed(&(TerminalOf(SP_PARM)->Nttyb)); ospeed = (NCURSES_OSPEED) _nc_ospeed(result); #else /* !USE_OLD_TTY */ #ifdef TERMIOS ospeed = (NCURSES_OSPEED) cfgetospeed(&(TerminalOf(SP_PARM)->Nttyb)); #else ospeed = (NCURSES_OSPEED) TerminalOf(SP_PARM)->Nttyb.sg_ospeed; #endif result = _nc_baudrate(ospeed); #endif TerminalOf(SP_PARM)->_baudrate = result; } else { result = ERR; } returnCode(result); }
baudrate(void) { int result; T((T_CALLED("baudrate()"))); /* * In debugging, allow the environment symbol to override when we're * redirecting to a file, so we can construct repeatable test-cases * that take into account costs that depend on baudrate. */ #ifdef TRACE if (!isatty(fileno(SP ? SP->_ofp : stdout)) && getenv("BAUDRATE") != 0) { int ret; if ((ret = _nc_getenv_num("BAUDRATE")) <= 0) ret = 9600; ospeed = _nc_ospeed(ret); returnCode(ret); } #endif if (cur_term != 0) { #ifdef USE_OLD_TTY result = cfgetospeed(&cur_term->Nttyb); ospeed = _nc_ospeed(result); #else /* !USE_OLD_TTY */ #ifdef TERMIOS ospeed = cfgetospeed(&cur_term->Nttyb); #else ospeed = cur_term->Nttyb.sg_ospeed; #endif result = _nc_baudrate(ospeed); #endif cur_term->_baudrate = result; } else { result = ERR; } returnCode(result); }
newterm(NCURSES_CONST char *name, FILE *ofp, FILE *ifp) { int value; int errret; SCREEN *current; SCREEN *result = 0; TERMINAL *its_term; START_TRACE(); T((T_CALLED("newterm(\"%s\",%p,%p)"), name, ofp, ifp)); _nc_init_pthreads(); _nc_lock_global(curses); current = SP; its_term = (SP ? SP->_term : 0); /* this loads the capability entry, then sets LINES and COLS */ if (setupterm(name, fileno(ofp), &errret) != ERR) { int slk_format = _nc_globals.slk_format; /* * This actually allocates the screen structure, and saves the original * terminal settings. */ _nc_set_screen(0); /* allow user to set maximum escape delay from the environment */ if ((value = _nc_getenv_num("ESCDELAY")) >= 0) { set_escdelay(value); } if (_nc_setupscreen(LINES, COLS, ofp, _nc_prescreen.filter_mode, slk_format) == ERR) { _nc_set_screen(current); result = 0; } else { assert(SP != 0); /* * In setupterm() we did a set_curterm(), but it was before we set * SP. So the "current" screen's terminal pointer was overwritten * with a different terminal. Later, in _nc_setupscreen(), we set * SP and the terminal pointer in the new screen. * * Restore the terminal-pointer for the pre-existing screen, if * any. */ if (current) current->_term = its_term; /* if the terminal type has real soft labels, set those up */ if (slk_format && num_labels > 0 && SLK_STDFMT(slk_format)) _nc_slk_initialize(stdscr, COLS); SP->_ifd = fileno(ifp); typeahead(fileno(ifp)); #ifdef TERMIOS SP->_use_meta = ((cur_term->Ottyb.c_cflag & CSIZE) == CS8 && !(cur_term->Ottyb.c_iflag & ISTRIP)); #else SP->_use_meta = FALSE; #endif SP->_endwin = FALSE; /* * Check whether we can optimize scrolling under dumb terminals in * case we do not have any of these capabilities, scrolling * optimization will be useless. */ SP->_scrolling = ((scroll_forward && scroll_reverse) || ((parm_rindex || parm_insert_line || insert_line) && (parm_index || parm_delete_line || delete_line))); baudrate(); /* sets a field in the SP structure */ SP->_keytry = 0; /* * Check for mismatched graphic-rendition capabilities. Most SVr4 * terminfo trees contain entries that have rmul or rmso equated to * sgr0 (Solaris curses copes with those entries). We do this only * for curses, since many termcap applications assume that * smso/rmso and smul/rmul are paired, and will not function * properly if we remove rmso or rmul. Curses applications * shouldn't be looking at this detail. */ #define SGR0_TEST(mode) (mode != 0) && (exit_attribute_mode == 0 || strcmp(mode, exit_attribute_mode)) SP->_use_rmso = SGR0_TEST(exit_standout_mode); SP->_use_rmul = SGR0_TEST(exit_underline_mode); /* compute movement costs so we can do better move optimization */ _nc_mvcur_init(); /* initialize terminal to a sane state */ _nc_screen_init(); /* Initialize the terminal line settings. */ _nc_initscr(); _nc_signal_handler(TRUE); result = SP; } } _nc_unlock_global(curses); returnSP(result); }
SCREEN * newterm(NCURSES_CONST char *name, FILE * ofp, FILE * ifp) { int errret; int slk_format = _nc_slk_format; SCREEN *current; #ifdef TRACE int t = _nc_getenv_num("NCURSES_TRACE"); if (t >= 0) trace(t); #endif T((T_CALLED("newterm(\"%s\",%p,%p)"), name, ofp, ifp)); /* this loads the capability entry, then sets LINES and COLS */ if (setupterm(name, fileno(ofp), &errret) == ERR) return 0; /* implement filter mode */ if (filter_mode) { LINES = 1; if (VALID_NUMERIC(init_tabs)) TABSIZE = init_tabs; else TABSIZE = 8; T(("TABSIZE = %d", TABSIZE)); clear_screen = 0; cursor_down = parm_down_cursor = 0; cursor_address = 0; cursor_up = parm_up_cursor = 0; row_address = 0; cursor_home = carriage_return; } /* If we must simulate soft labels, grab off the line to be used. We assume that we must simulate, if it is none of the standard formats (4-4 or 3-2-3) for which there may be some hardware support. */ if (num_labels <= 0 || !SLK_STDFMT(slk_format)) if (slk_format) { if (ERR == _nc_ripoffline(-SLK_LINES(slk_format), _nc_slk_initialize)) return 0; } /* this actually allocates the screen structure, and saves the * original terminal settings. */ current = SP; _nc_set_screen(0); if (_nc_setupscreen(LINES, COLS, ofp) == ERR) { _nc_set_screen(current); return 0; } /* if the terminal type has real soft labels, set those up */ if (slk_format && num_labels > 0 && SLK_STDFMT(slk_format)) _nc_slk_initialize(stdscr, COLS); SP->_ifd = fileno(ifp); SP->_checkfd = fileno(ifp); typeahead(fileno(ifp)); #ifdef TERMIOS SP->_use_meta = ((cur_term->Ottyb.c_cflag & CSIZE) == CS8 && !(cur_term->Ottyb.c_iflag & ISTRIP)); #else SP->_use_meta = FALSE; #endif SP->_endwin = FALSE; /* Check whether we can optimize scrolling under dumb terminals in case * we do not have any of these capabilities, scrolling optimization * will be useless. */ SP->_scrolling = ((scroll_forward && scroll_reverse) || ((parm_rindex || parm_insert_line || insert_line) && (parm_index || parm_delete_line || delete_line))); baudrate(); /* sets a field in the SP structure */ SP->_keytry = 0; /* * Check for mismatched graphic-rendition capabilities. Most SVr4 * terminfo trees contain entries that have rmul or rmso equated to * sgr0 (Solaris curses copes with those entries). We do this only for * curses, since many termcap applications assume that smso/rmso and * smul/rmul are paired, and will not function properly if we remove * rmso or rmul. Curses applications shouldn't be looking at this * detail. */ #define SGR0_TEST(mode) (mode != 0) && (exit_attribute_mode == 0 || strcmp(mode, exit_attribute_mode)) SP->_use_rmso = SGR0_TEST(exit_standout_mode); SP->_use_rmul = SGR0_TEST(exit_underline_mode); #if USE_WIDEC_SUPPORT /* * XFree86 xterm can be configured to support UTF-8 based on environment * variable settings. */ { char *s; s = getenv("LC_ALL"); if (s == NULL || *s == '\0') { s = getenv("LC_CTYPE"); if (s == NULL || *s == '\0') { s = getenv("LANG"); } } if (s != NULL && *s != '\0' && strstr(s, "UTF-8") != NULL) { SP->_outch = _nc_utf8_outch; } } #endif /* compute movement costs so we can do better move optimization */ _nc_mvcur_init(); /* initialize terminal to a sane state */ _nc_screen_init(); /* Initialize the terminal line settings. */ _nc_initscr(); _nc_signal_handler(TRUE); T((T_RETURN("%p"), SP)); return (SP); }
NCURSES_SP_NAME(newterm) (NCURSES_SP_DCLx NCURSES_CONST char *name, FILE *ofp, FILE *ifp) { int value; int errret; SCREEN *result = 0; SCREEN *current; TERMINAL *its_term; FILE *_ofp = ofp ? ofp : stdout; FILE *_ifp = ifp ? ifp : stdin; int cols; int slk_format; int filter_mode; TERMINAL *new_term = 0; START_TRACE(); T((T_CALLED("newterm(%p, \"%s\", %p,%p)"), (void *) SP_PARM, name, (void *) ofp, (void *) ifp)); #if NCURSES_SP_FUNCS assert(SP_PARM != 0); if (SP_PARM == 0) returnSP(SP_PARM); #endif _nc_init_pthreads(); _nc_lock_global(curses); current = CURRENT_SCREEN; its_term = (current ? current->_term : 0); INIT_TERM_DRIVER(); /* this loads the capability entry, then sets LINES and COLS */ if ( #if NCURSES_SP_FUNCS SP_PARM->_prescreen && #endif TINFO_SETUP_TERM(&new_term, name, fileno(_ofp), &errret, FALSE) != ERR) { _nc_set_screen(0); #ifdef USE_TERM_DRIVER assert(new_term != 0); #endif #if NCURSES_SP_FUNCS slk_format = SP_PARM->slk_format; filter_mode = SP_PARM->_filtered; #else slk_format = _nc_globals.slk_format; filter_mode = _nc_prescreen.filter_mode; #endif /* * This actually allocates the screen structure, and saves the original * terminal settings. */ if (NCURSES_SP_NAME(_nc_setupscreen) ( #if NCURSES_SP_FUNCS &SP_PARM, #endif *(ptrLines(SP_PARM)), *(ptrCols(SP_PARM)), _ofp, filter_mode, slk_format) == ERR) { _nc_set_screen(current); result = 0; } else { #ifdef USE_TERM_DRIVER TERMINAL_CONTROL_BLOCK *TCB; #elif !NCURSES_SP_FUNCS SP_PARM = CURRENT_SCREEN; #endif assert(SP_PARM != 0); cols = *(ptrCols(SP_PARM)); #ifdef USE_TERM_DRIVER _nc_set_screen(SP_PARM); TCB = (TERMINAL_CONTROL_BLOCK *) new_term; TCB->csp = SP_PARM; #endif /* * In setupterm() we did a set_curterm(), but it was before we set * CURRENT_SCREEN. So the "current" screen's terminal pointer was * overwritten with a different terminal. Later, in * _nc_setupscreen(), we set CURRENT_SCREEN and the terminal * pointer in the new screen. * * Restore the terminal-pointer for the pre-existing screen, if * any. */ if (current) current->_term = its_term; #ifdef USE_TERM_DRIVER SP_PARM->_term = new_term; #else new_term = SP_PARM->_term; #endif /* allow user to set maximum escape delay from the environment */ if ((value = _nc_getenv_num("ESCDELAY")) >= 0) { NCURSES_SP_NAME(set_escdelay) (NCURSES_SP_ARGx value); } /* if the terminal type has real soft labels, set those up */ if (slk_format && NumLabels > 0 && SLK_STDFMT(slk_format)) _nc_slk_initialize(StdScreen(SP_PARM), cols); SP_PARM->_ifd = fileno(_ifp); NCURSES_SP_NAME(typeahead) (NCURSES_SP_ARGx fileno(_ifp)); #ifdef TERMIOS SP_PARM->_use_meta = ((new_term->Ottyb.c_cflag & CSIZE) == CS8 && !(new_term->Ottyb.c_iflag & ISTRIP)); #else SP_PARM->_use_meta = FALSE; #endif SP_PARM->_endwin = FALSE; #ifndef USE_TERM_DRIVER /* * Check whether we can optimize scrolling under dumb terminals in * case we do not have any of these capabilities, scrolling * optimization will be useless. */ SP_PARM->_scrolling = ((scroll_forward && scroll_reverse) || ((parm_rindex || parm_insert_line || insert_line) && (parm_index || parm_delete_line || delete_line))); #endif NCURSES_SP_NAME(baudrate) (NCURSES_SP_ARG); /* sets a field in the screen structure */ SP_PARM->_keytry = 0; /* compute movement costs so we can do better move optimization */ #ifdef USE_TERM_DRIVER TCBOf(SP_PARM)->drv->scinit(SP_PARM); #else /* * Check for mismatched graphic-rendition capabilities. Most SVr4 * terminfo trees contain entries that have rmul or rmso equated to * sgr0 (Solaris curses copes with those entries). We do this only * for curses, since many termcap applications assume that * smso/rmso and smul/rmul are paired, and will not function * properly if we remove rmso or rmul. Curses applications * shouldn't be looking at this detail. */ #define SGR0_TEST(mode) (mode != 0) && (exit_attribute_mode == 0 || strcmp(mode, exit_attribute_mode)) SP_PARM->_use_rmso = SGR0_TEST(exit_standout_mode); SP_PARM->_use_rmul = SGR0_TEST(exit_underline_mode); /* compute movement costs so we can do better move optimization */ _nc_mvcur_init(); /* initialize terminal to a sane state */ _nc_screen_init(); #endif /* Initialize the terminal line settings. */ _nc_initscr(NCURSES_SP_ARG); _nc_signal_handler(TRUE); result = SP_PARM; } } _nc_unlock_global(curses); returnSP(result); }
static void _nc_get_screensize(int *linep, int *colp) /* Obtain lines/columns values from the environment and/or terminfo entry */ { /* figure out the size of the screen */ T(("screen size: terminfo lines = %d columns = %d", lines, columns)); if (!_use_env) { *linep = (int) lines; *colp = (int) columns; } else { /* usually want to query LINES and COLUMNS from environment */ int value; *linep = *colp = 0; /* first, look for environment variables */ if ((value = _nc_getenv_num("LINES")) > 0) { *linep = value; } if ((value = _nc_getenv_num("COLUMNS")) > 0) { *colp = value; } T(("screen size: environment LINES = %d COLUMNS = %d", *linep, *colp)); #ifdef __EMX__ if (*linep <= 0 || *colp <= 0) { int screendata[2]; _scrsize(screendata); *colp = screendata[0]; *linep = screendata[1]; T(("EMX screen size: environment LINES = %d COLUMNS = %d", *linep, *colp)); } #endif #if HAVE_SIZECHANGE /* if that didn't work, maybe we can try asking the OS */ if (*linep <= 0 || *colp <= 0) { if (isatty(cur_term->Filedes)) { STRUCT_WINSIZE size; errno = 0; do { if (ioctl(cur_term->Filedes, IOCTL_WINSIZE, &size) < 0 && errno != EINTR) goto failure; } while (errno == EINTR); /* * Solaris lets users override either dimension with an * environment variable. */ if (*linep <= 0) *linep = WINSIZE_ROWS(size); if (*colp <= 0) *colp = WINSIZE_COLS(size); } /* FALLTHRU */ failure:; } #endif /* HAVE_SIZECHANGE */ /* if we can't get dynamic info about the size, use static */ if (*linep <= 0) { *linep = (int) lines; } if (*colp <= 0) { *colp = (int) columns; } /* the ultimate fallback, assume fixed 24x80 size */ if (*linep <= 0) { *linep = 24; } if (*colp <= 0) { *colp = 80; } /* * Put the derived values back in the screen-size caps, so * tigetnum() and tgetnum() will do the right thing. */ lines = (short) (*linep); columns = (short) (*colp); } T(("screen size is %dx%d", *linep, *colp)); if (VALID_NUMERIC(init_tabs)) TABSIZE = (int) init_tabs; else TABSIZE = 8; T(("TABSIZE = %d", TABSIZE)); }