1 /**************************************************************************** 2 * Copyright (c) 1998-2012,2013 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * 31 * and: Eric S. Raymond <esr@snark.thyrsus.com> * 32 * and: Thomas E. Dickey 1996-on * 33 * and: Juergen Pfeifer 2009 * 34 ****************************************************************************/ 35 36 /* 37 * Terminal setup routines common to termcap and terminfo: 38 * 39 * use_env(bool) 40 * use_tioctl(bool) 41 * setupterm(char *, int, int *) 42 */ 43 44 #include <curses.priv.h> 45 #include <tic.h> /* for MAX_NAME_SIZE */ 46 47 #if HAVE_LOCALE_H 48 #include <locale.h> 49 #endif 50 51 MODULE_ID("$Id: lib_setup.c,v 1.158 2013/06/22 19:59:08 tom Exp $") 52 53 /**************************************************************************** 54 * 55 * Terminal size computation 56 * 57 ****************************************************************************/ 58 59 #if HAVE_SIZECHANGE 60 # if !defined(sun) || !TERMIOS 61 # if HAVE_SYS_IOCTL_H 62 # include <sys/ioctl.h> 63 # endif 64 # endif 65 #endif 66 67 #if NEED_PTEM_H 68 /* On SCO, they neglected to define struct winsize in termios.h -- it's only 69 * in termio.h and ptem.h (the former conflicts with other definitions). 70 */ 71 # include <sys/stream.h> 72 # include <sys/ptem.h> 73 #endif 74 75 #if HAVE_LANGINFO_CODESET 76 #include <langinfo.h> 77 #endif 78 79 /* 80 * SCO defines TIOCGSIZE and the corresponding struct. Other systems (SunOS, 81 * Solaris, IRIX) define TIOCGWINSZ and struct winsize. 82 */ 83 #ifdef TIOCGSIZE 84 # define IOCTL_WINSIZE TIOCGSIZE 85 # define STRUCT_WINSIZE struct ttysize 86 # define WINSIZE_ROWS(n) (int)n.ts_lines 87 # define WINSIZE_COLS(n) (int)n.ts_cols 88 #else 89 # ifdef TIOCGWINSZ 90 # define IOCTL_WINSIZE TIOCGWINSZ 91 # define STRUCT_WINSIZE struct winsize 92 # define WINSIZE_ROWS(n) (int)n.ws_row 93 # define WINSIZE_COLS(n) (int)n.ws_col 94 # endif 95 #endif 96 97 /* 98 * Reduce explicit use of "cur_term" global variable. 99 */ 100 #undef CUR 101 #define CUR termp->type. 102 103 /* 104 * Wrap global variables in this module. 105 */ 106 #if USE_REENTRANT 107 108 NCURSES_EXPORT(char *) 109 NCURSES_PUBLIC_VAR(ttytype) (void) 110 { 111 static char empty[] = ""; 112 char *result = empty; 113 114 #if NCURSES_SP_FUNCS 115 if (CURRENT_SCREEN) { 116 TERMINAL *termp = TerminalOf(CURRENT_SCREEN); 117 if (termp != 0) { 118 result = termp->type.term_names; 119 } 120 } 121 #else 122 if (cur_term != 0) { 123 result = cur_term->type.term_names; 124 } 125 #endif 126 return result; 127 } 128 129 NCURSES_EXPORT(int *) 130 _nc_ptr_Lines(SCREEN *sp) 131 { 132 return ptrLines(sp); 133 } 134 135 NCURSES_EXPORT(int) 136 NCURSES_PUBLIC_VAR(LINES) (void) 137 { 138 return *_nc_ptr_Lines(CURRENT_SCREEN); 139 } 140 141 NCURSES_EXPORT(int *) 142 _nc_ptr_Cols(SCREEN *sp) 143 { 144 return ptrCols(sp); 145 } 146 147 NCURSES_EXPORT(int) 148 NCURSES_PUBLIC_VAR(COLS) (void) 149 { 150 return *_nc_ptr_Cols(CURRENT_SCREEN); 151 } 152 153 NCURSES_EXPORT(int *) 154 _nc_ptr_Tabsize(SCREEN *sp) 155 { 156 return ptrTabsize(sp); 157 } 158 159 NCURSES_EXPORT(int) 160 NCURSES_PUBLIC_VAR(TABSIZE) (void) 161 { 162 return *_nc_ptr_Tabsize(CURRENT_SCREEN); 163 } 164 #else 165 NCURSES_EXPORT_VAR(char) ttytype[NAMESIZE] = ""; 166 NCURSES_EXPORT_VAR(int) LINES = 0; 167 NCURSES_EXPORT_VAR(int) COLS = 0; 168 NCURSES_EXPORT_VAR(int) TABSIZE = 8; 169 #endif 170 171 #if NCURSES_EXT_FUNCS 172 NCURSES_EXPORT(int) 173 NCURSES_SP_NAME(set_tabsize) (NCURSES_SP_DCLx int value) 174 { 175 int code = OK; 176 #if USE_REENTRANT 177 if (SP_PARM) { 178 SP_PARM->_TABSIZE = value; 179 } else { 180 code = ERR; 181 } 182 #else 183 (void) SP_PARM; 184 TABSIZE = value; 185 #endif 186 return code; 187 } 188 189 #if NCURSES_SP_FUNCS 190 NCURSES_EXPORT(int) 191 set_tabsize(int value) 192 { 193 return NCURSES_SP_NAME(set_tabsize) (CURRENT_SCREEN, value); 194 } 195 #endif 196 #endif /* NCURSES_EXT_FUNCS */ 197 198 #if USE_SIGWINCH 199 /* 200 * If we have a pending SIGWINCH, set the flag in each screen. 201 */ 202 NCURSES_EXPORT(int) 203 _nc_handle_sigwinch(SCREEN *sp) 204 { 205 SCREEN *scan; 206 207 if (_nc_globals.have_sigwinch) { 208 _nc_globals.have_sigwinch = 0; 209 210 for (each_screen(scan)) { 211 scan->_sig_winch = TRUE; 212 } 213 } 214 215 return (sp ? sp->_sig_winch : 0); 216 } 217 218 #endif 219 220 NCURSES_EXPORT(void) 221 NCURSES_SP_NAME(use_env) (NCURSES_SP_DCLx bool f) 222 { 223 T((T_CALLED("use_env(%p,%d)"), (void *) SP_PARM, (int) f)); 224 #if NCURSES_SP_FUNCS 225 START_TRACE(); 226 if (IsPreScreen(SP_PARM)) { 227 SP_PARM->_use_env = f; 228 } 229 #else 230 _nc_prescreen.use_env = f; 231 #endif 232 returnVoid; 233 } 234 235 NCURSES_EXPORT(void) 236 NCURSES_SP_NAME(use_tioctl) (NCURSES_SP_DCLx bool f) 237 { 238 T((T_CALLED("use_tioctl(%p,%d)"), (void *) SP_PARM, (int) f)); 239 #if NCURSES_SP_FUNCS 240 START_TRACE(); 241 if (IsPreScreen(SP_PARM)) { 242 SP_PARM->_use_tioctl = f; 243 } 244 #else 245 _nc_prescreen.use_tioctl = f; 246 #endif 247 returnVoid; 248 } 249 250 #if NCURSES_SP_FUNCS 251 NCURSES_EXPORT(void) 252 use_env(bool f) 253 { 254 T((T_CALLED("use_env(%d)"), (int) f)); 255 START_TRACE(); 256 _nc_prescreen.use_env = f; 257 returnVoid; 258 } 259 260 NCURSES_EXPORT(void) 261 use_tioctl(bool f) 262 { 263 T((T_CALLED("use_tioctl(%d)"), (int) f)); 264 START_TRACE(); 265 _nc_prescreen.use_tioctl = f; 266 returnVoid; 267 } 268 #endif 269 270 NCURSES_EXPORT(void) 271 _nc_get_screensize(SCREEN *sp, 272 #ifdef USE_TERM_DRIVER 273 TERMINAL * termp, 274 #endif 275 int *linep, int *colp) 276 /* Obtain lines/columns values from the environment and/or terminfo entry */ 277 { 278 #ifdef USE_TERM_DRIVER 279 TERMINAL_CONTROL_BLOCK *TCB; 280 int my_tabsize; 281 282 assert(termp != 0 && linep != 0 && colp != 0); 283 TCB = (TERMINAL_CONTROL_BLOCK *) termp; 284 285 my_tabsize = TCB->info.tabsize; 286 TCB->drv->size(TCB, linep, colp); 287 288 #if USE_REENTRANT 289 if (sp != 0) { 290 sp->_TABSIZE = my_tabsize; 291 } 292 #else 293 (void) sp; 294 TABSIZE = my_tabsize; 295 #endif 296 T(("TABSIZE = %d", my_tabsize)); 297 #else /* !USE_TERM_DRIVER */ 298 TERMINAL *termp = cur_term; 299 int my_tabsize; 300 301 /* figure out the size of the screen */ 302 T(("screen size: terminfo lines = %d columns = %d", lines, columns)); 303 304 *linep = (int) lines; 305 *colp = (int) columns; 306 307 if (_nc_prescreen.use_env || _nc_prescreen.use_tioctl) { 308 int value; 309 310 #ifdef __EMX__ 311 { 312 int screendata[2]; 313 _scrsize(screendata); 314 *colp = screendata[0]; 315 *linep = ((sp != 0 && sp->_filtered) 316 ? 1 317 : screendata[1]); 318 T(("EMX screen size: environment LINES = %d COLUMNS = %d", 319 *linep, *colp)); 320 } 321 #endif 322 #if HAVE_SIZECHANGE 323 /* try asking the OS */ 324 if (isatty(cur_term->Filedes)) { 325 STRUCT_WINSIZE size; 326 327 errno = 0; 328 do { 329 if (ioctl(cur_term->Filedes, IOCTL_WINSIZE, &size) >= 0) { 330 *linep = ((sp != 0 && sp->_filtered) 331 ? 1 332 : WINSIZE_ROWS(size)); 333 *colp = WINSIZE_COLS(size); 334 T(("SYS screen size: environment LINES = %d COLUMNS = %d", 335 *linep, *colp)); 336 break; 337 } 338 } while 339 (errno == EINTR); 340 } 341 #endif /* HAVE_SIZECHANGE */ 342 343 if (_nc_prescreen.use_env) { 344 if (_nc_prescreen.use_tioctl) { 345 /* 346 * If environment variables are used, update them. 347 */ 348 if ((sp == 0 || !sp->_filtered) && _nc_getenv_num("LINES") > 0) { 349 _nc_setenv_num("LINES", *linep); 350 } 351 if (_nc_getenv_num("COLUMNS") > 0) { 352 _nc_setenv_num("COLUMNS", *colp); 353 } 354 } 355 356 /* 357 * Finally, look for environment variables. 358 * 359 * Solaris lets users override either dimension with an environment 360 * variable. 361 */ 362 if ((value = _nc_getenv_num("LINES")) > 0) { 363 *linep = value; 364 T(("screen size: environment LINES = %d", *linep)); 365 } 366 if ((value = _nc_getenv_num("COLUMNS")) > 0) { 367 *colp = value; 368 T(("screen size: environment COLUMNS = %d", *colp)); 369 } 370 } 371 372 /* if we can't get dynamic info about the size, use static */ 373 if (*linep <= 0) { 374 *linep = (int) lines; 375 } 376 if (*colp <= 0) { 377 *colp = (int) columns; 378 } 379 380 /* the ultimate fallback, assume fixed 24x80 size */ 381 if (*linep <= 0) { 382 *linep = 24; 383 } 384 if (*colp <= 0) { 385 *colp = 80; 386 } 387 388 /* 389 * Put the derived values back in the screen-size caps, so 390 * tigetnum() and tgetnum() will do the right thing. 391 */ 392 lines = (short) (*linep); 393 columns = (short) (*colp); 394 } 395 396 T(("screen size is %dx%d", *linep, *colp)); 397 398 if (VALID_NUMERIC(init_tabs)) 399 my_tabsize = (int) init_tabs; 400 else 401 my_tabsize = 8; 402 403 #if USE_REENTRANT 404 if (sp != 0) 405 sp->_TABSIZE = my_tabsize; 406 #else 407 TABSIZE = my_tabsize; 408 #endif 409 T(("TABSIZE = %d", TABSIZE)); 410 #endif /* USE_TERM_DRIVER */ 411 } 412 413 #if USE_SIZECHANGE 414 NCURSES_EXPORT(void) 415 _nc_update_screensize(SCREEN *sp) 416 { 417 int new_lines; 418 int new_cols; 419 420 #ifdef USE_TERM_DRIVER 421 int old_lines; 422 int old_cols; 423 424 assert(sp != 0); 425 426 CallDriver_2(sp, getsize, &old_lines, &old_cols); 427 428 #else 429 TERMINAL *termp = cur_term; 430 int old_lines = lines; 431 int old_cols = columns; 432 #endif 433 434 TINFO_GET_SIZE(sp, sp->_term, &new_lines, &new_cols); 435 436 /* 437 * See is_term_resized() and resizeterm(). 438 * We're doing it this way because those functions belong to the upper 439 * ncurses library, while this resides in the lower terminfo library. 440 */ 441 if (sp != 0 && sp->_resize != 0) { 442 if ((new_lines != old_lines) || (new_cols != old_cols)) { 443 sp->_resize(NCURSES_SP_ARGx new_lines, new_cols); 444 } else if (sp->_sig_winch && (sp->_ungetch != 0)) { 445 sp->_ungetch(SP_PARM, KEY_RESIZE); /* so application can know this */ 446 } 447 sp->_sig_winch = FALSE; 448 } 449 } 450 #endif 451 452 /**************************************************************************** 453 * 454 * Terminal setup 455 * 456 ****************************************************************************/ 457 458 #if NCURSES_USE_DATABASE || NCURSES_USE_TERMCAP 459 /* 460 * Return 1 if entry found, 0 if not found, -1 if database not accessible, 461 * just like tgetent(). 462 */ 463 int 464 _nc_setup_tinfo(const char *const tn, TERMTYPE *const tp) 465 { 466 char filename[PATH_MAX]; 467 int status = _nc_read_entry(tn, filename, tp); 468 469 /* 470 * If we have an entry, force all of the cancelled strings to null 471 * pointers so we don't have to test them in the rest of the library. 472 * (The terminfo compiler bypasses this logic, since it must know if 473 * a string is cancelled, for merging entries). 474 */ 475 if (status == TGETENT_YES) { 476 unsigned n; 477 for_each_boolean(n, tp) { 478 if (!VALID_BOOLEAN(tp->Booleans[n])) 479 tp->Booleans[n] = FALSE; 480 } 481 for_each_string(n, tp) { 482 if (tp->Strings[n] == CANCELLED_STRING) 483 tp->Strings[n] = ABSENT_STRING; 484 } 485 } 486 return (status); 487 } 488 #endif 489 490 /* 491 ** Take the real command character out of the CC environment variable 492 ** and substitute it in for the prototype given in 'command_character'. 493 */ 494 void 495 _nc_tinfo_cmdch(TERMINAL * termp, int proto) 496 { 497 unsigned i; 498 char CC; 499 char *tmp; 500 501 /* 502 * Only use the character if the string is a single character, 503 * since it is fairly common for developers to set the C compiler 504 * name as an environment variable - using the same symbol. 505 */ 506 if ((tmp = getenv("CC")) != 0 && strlen(tmp) == 1) { 507 CC = *tmp; 508 for_each_string(i, &(termp->type)) { 509 for (tmp = termp->type.Strings[i]; tmp && *tmp; tmp++) { 510 if (UChar(*tmp) == proto) 511 *tmp = CC; 512 } 513 } 514 } 515 } 516 517 /* 518 * Find the locale which is in effect. 519 */ 520 NCURSES_EXPORT(char *) 521 _nc_get_locale(void) 522 { 523 char *env; 524 #if HAVE_LOCALE_H 525 /* 526 * This is preferable to using getenv() since it ensures that we are using 527 * the locale which was actually initialized by the application. 528 */ 529 env = setlocale(LC_CTYPE, 0); 530 #else 531 if (((env = getenv("LC_ALL")) != 0 && *env != '\0') 532 || ((env = getenv("LC_CTYPE")) != 0 && *env != '\0') 533 || ((env = getenv("LANG")) != 0 && *env != '\0')) { 534 ; 535 } 536 #endif 537 T(("_nc_get_locale %s", _nc_visbuf(env))); 538 return env; 539 } 540 541 /* 542 * Check if we are running in a UTF-8 locale. 543 */ 544 NCURSES_EXPORT(int) 545 _nc_unicode_locale(void) 546 { 547 int result = 0; 548 #if defined(__MINGW32__) && USE_WIDEC_SUPPORT 549 result = 1; 550 #elif HAVE_LANGINFO_CODESET 551 char *env = nl_langinfo(CODESET); 552 result = !strcmp(env, "UTF-8"); 553 T(("_nc_unicode_locale(%s) ->%d", env, result)); 554 #else 555 char *env = _nc_get_locale(); 556 if (env != 0) { 557 if (strstr(env, ".UTF-8") != 0) { 558 result = 1; 559 T(("_nc_unicode_locale(%s) ->%d", env, result)); 560 } 561 } 562 #endif 563 return result; 564 } 565 566 #define CONTROL_N(s) ((s) != 0 && strstr(s, "\016") != 0) 567 #define CONTROL_O(s) ((s) != 0 && strstr(s, "\017") != 0) 568 569 /* 570 * Check for known broken cases where a UTF-8 locale breaks the alternate 571 * character set. 572 */ 573 NCURSES_EXPORT(int) 574 _nc_locale_breaks_acs(TERMINAL * termp) 575 { 576 const char *env_name = "NCURSES_NO_UTF8_ACS"; 577 char *env; 578 int value; 579 int result = 0; 580 581 if (getenv(env_name) != 0) { 582 result = _nc_getenv_num(env_name); 583 } else if ((value = tigetnum("U8")) >= 0) { 584 result = value; /* use extension feature */ 585 } else if ((env = getenv("TERM")) != 0) { 586 if (strstr(env, "linux")) { 587 result = 1; /* always broken */ 588 } else if (strstr(env, "screen") != 0 589 && ((env = getenv("TERMCAP")) != 0 590 && strstr(env, "screen") != 0) 591 && strstr(env, "hhII00") != 0) { 592 if (CONTROL_N(enter_alt_charset_mode) || 593 CONTROL_O(enter_alt_charset_mode) || 594 CONTROL_N(set_attributes) || 595 CONTROL_O(set_attributes)) { 596 result = 1; 597 } 598 } 599 } 600 return result; 601 } 602 603 NCURSES_EXPORT(int) 604 TINFO_SETUP_TERM(TERMINAL ** tp, 605 NCURSES_CONST char *tname, 606 int Filedes, 607 int *errret, 608 int reuse) 609 { 610 #ifdef USE_TERM_DRIVER 611 TERMINAL_CONTROL_BLOCK *TCB = 0; 612 #else 613 int status; 614 #endif 615 TERMINAL *termp; 616 SCREEN *sp = 0; 617 int code = ERR; 618 619 START_TRACE(); 620 621 #ifdef USE_TERM_DRIVER 622 T((T_CALLED("_nc_setupterm_ex(%p,%s,%d,%p)"), 623 (void *) tp, _nc_visbuf(tname), Filedes, (void *) errret)); 624 625 if (tp == 0) { 626 ret_error0(TGETENT_ERR, 627 "Invalid parameter, internal error.\n"); 628 } else 629 termp = *tp; 630 #else 631 termp = cur_term; 632 T((T_CALLED("setupterm(%s,%d,%p)"), _nc_visbuf(tname), Filedes, (void *) errret)); 633 #endif 634 635 if (tname == 0) { 636 tname = getenv("TERM"); 637 if (tname == 0 || *tname == '\0') { 638 #ifdef USE_TERM_DRIVER 639 tname = "unknown"; 640 #else 641 ret_error0(TGETENT_ERR, "TERM environment variable not set.\n"); 642 #endif 643 } 644 } 645 646 if (strlen(tname) > MAX_NAME_SIZE) { 647 ret_error(TGETENT_ERR, 648 "TERM environment must be <= %d characters.\n", 649 MAX_NAME_SIZE); 650 } 651 652 T(("your terminal name is %s", tname)); 653 654 /* 655 * Allow output redirection. This is what SVr3 does. If stdout is 656 * directed to a file, screen updates go to standard error. 657 */ 658 if (Filedes == STDOUT_FILENO && !isatty(Filedes)) 659 Filedes = STDERR_FILENO; 660 661 /* 662 * Check if we have already initialized to use this terminal. If so, we 663 * do not need to re-read the terminfo entry, or obtain TTY settings. 664 * 665 * This is an improvement on SVr4 curses. If an application mixes curses 666 * and termcap calls, it may call both initscr and tgetent. This is not 667 * really a good thing to do, but can happen if someone tries using ncurses 668 * with the readline library. The problem we are fixing is that when 669 * tgetent calls setupterm, the resulting Ottyb struct in cur_term is 670 * zeroed. A subsequent call to endwin uses the zeroed terminal settings 671 * rather than the ones saved in initscr. So we check if cur_term appears 672 * to contain terminal settings for the same output file as our current 673 * call - and copy those terminal settings. (SVr4 curses does not do this, 674 * however applications that are working around the problem will still work 675 * properly with this feature). 676 */ 677 if (reuse 678 && (termp != 0) 679 && termp->Filedes == Filedes 680 && termp->_termname != 0 681 && !strcmp(termp->_termname, tname) 682 && _nc_name_match(termp->type.term_names, tname, "|")) { 683 T(("reusing existing terminal information and mode-settings")); 684 code = OK; 685 #ifdef USE_TERM_DRIVER 686 TCB = (TERMINAL_CONTROL_BLOCK *) termp; 687 #endif 688 } else { 689 #ifdef USE_TERM_DRIVER 690 TERMINAL_CONTROL_BLOCK *my_tcb; 691 my_tcb = typeCalloc(TERMINAL_CONTROL_BLOCK, 1); 692 termp = &(my_tcb->term); 693 #else 694 termp = typeCalloc(TERMINAL, 1); 695 #endif 696 if (termp == 0) { 697 ret_error0(TGETENT_ERR, 698 "Not enough memory to create terminal structure.\n"); 699 } 700 #ifdef USE_TERM_DRIVER 701 INIT_TERM_DRIVER(); 702 TCB = (TERMINAL_CONTROL_BLOCK *) termp; 703 code = _nc_globals.term_driver(TCB, tname, errret); 704 if (code == OK) { 705 termp->Filedes = (short) Filedes; 706 termp->_termname = strdup(tname); 707 } else { 708 ret_error0(TGETENT_ERR, 709 "Could not find any driver to handle this terminal.\n"); 710 } 711 #else 712 #if NCURSES_USE_DATABASE || NCURSES_USE_TERMCAP 713 status = _nc_setup_tinfo(tname, &termp->type); 714 #else 715 status = TGETENT_NO; 716 #endif 717 718 /* try fallback list if entry on disk */ 719 if (status != TGETENT_YES) { 720 const TERMTYPE *fallback = _nc_fallback(tname); 721 722 if (fallback) { 723 _nc_copy_termtype(&(termp->type), fallback); 724 status = TGETENT_YES; 725 } 726 } 727 728 if (status != TGETENT_YES) { 729 del_curterm(termp); 730 if (status == TGETENT_ERR) { 731 ret_error0(status, "terminals database is inaccessible\n"); 732 } else if (status == TGETENT_NO) { 733 ret_error1(status, "unknown terminal type.\n", tname); 734 } 735 } 736 #if !USE_REENTRANT 737 strncpy(ttytype, termp->type.term_names, (size_t) (NAMESIZE - 1)); 738 ttytype[NAMESIZE - 1] = '\0'; 739 #endif 740 741 termp->Filedes = (short) Filedes; 742 termp->_termname = strdup(tname); 743 744 set_curterm(termp); 745 746 if (command_character) 747 _nc_tinfo_cmdch(termp, UChar(*command_character)); 748 749 /* 750 * If an application calls setupterm() rather than initscr() or 751 * newterm(), we will not have the def_prog_mode() call in 752 * _nc_setupscreen(). Do it now anyway, so we can initialize the 753 * baudrate. 754 */ 755 if (isatty(Filedes)) { 756 def_prog_mode(); 757 baudrate(); 758 } 759 code = OK; 760 #endif 761 } 762 763 #ifdef USE_TERM_DRIVER 764 *tp = termp; 765 NCURSES_SP_NAME(set_curterm) (sp, termp); 766 TCB->drv->init(TCB); 767 #else 768 sp = SP; 769 #endif 770 771 /* 772 * We should always check the screensize, just in case. 773 */ 774 TINFO_GET_SIZE(sp, termp, ptrLines(sp), ptrCols(sp)); 775 776 if (errret) 777 *errret = TGETENT_YES; 778 779 #ifndef USE_TERM_DRIVER 780 if (generic_type) { 781 /* 782 * BSD 4.3's termcap contains mis-typed "gn" for wy99. Do a sanity 783 * check before giving up. 784 */ 785 if ((VALID_STRING(cursor_address) 786 || (VALID_STRING(cursor_down) && VALID_STRING(cursor_home))) 787 && VALID_STRING(clear_screen)) { 788 ret_error1(TGETENT_YES, "terminal is not really generic.\n", tname); 789 } else { 790 del_curterm(termp); 791 ret_error1(TGETENT_NO, "I need something more specific.\n", tname); 792 } 793 } else if (hard_copy) { 794 ret_error1(TGETENT_YES, "I can't handle hardcopy terminals.\n", tname); 795 } 796 #endif 797 returnCode(code); 798 } 799 800 #if NCURSES_SP_FUNCS 801 /* 802 * In case of handling multiple screens, we need to have a screen before 803 * initialization in setupscreen takes place. This is to extend the substitute 804 * for some of the stuff in _nc_prescreen, especially for slk and ripoff 805 * handling which should be done per screen. 806 */ 807 NCURSES_EXPORT(SCREEN *) 808 new_prescr(void) 809 { 810 static SCREEN *sp; 811 812 START_TRACE(); 813 T((T_CALLED("new_prescr()"))); 814 815 if (sp == 0) { 816 sp = _nc_alloc_screen_sp(); 817 if (sp != 0) { 818 sp->rsp = sp->rippedoff; 819 sp->_filtered = _nc_prescreen.filter_mode; 820 sp->_use_env = _nc_prescreen.use_env; 821 #if NCURSES_NO_PADDING 822 sp->_no_padding = _nc_prescreen._no_padding; 823 #endif 824 sp->slk_format = 0; 825 sp->_slk = 0; 826 sp->_prescreen = TRUE; 827 SP_PRE_INIT(sp); 828 #if USE_REENTRANT 829 sp->_TABSIZE = _nc_prescreen._TABSIZE; 830 sp->_ESCDELAY = _nc_prescreen._ESCDELAY; 831 #endif 832 } 833 } 834 returnSP(sp); 835 } 836 #endif 837 838 #ifdef USE_TERM_DRIVER 839 /* 840 * This entrypoint is called from tgetent() to allow a special case of reusing 841 * the same TERMINAL data (see comment). 842 */ 843 NCURSES_EXPORT(int) 844 _nc_setupterm(NCURSES_CONST char *tname, 845 int Filedes, 846 int *errret, 847 int reuse) 848 { 849 int res; 850 TERMINAL *termp = 0; 851 res = TINFO_SETUP_TERM(&termp, tname, Filedes, errret, reuse); 852 if (ERR != res) 853 NCURSES_SP_NAME(set_curterm) (CURRENT_SCREEN_PRE, termp); 854 return res; 855 } 856 #endif 857 858 /* 859 * setupterm(termname, Filedes, errret) 860 * 861 * Find and read the appropriate object file for the terminal 862 * Make cur_term point to the structure. 863 */ 864 NCURSES_EXPORT(int) 865 setupterm(NCURSES_CONST char *tname, int Filedes, int *errret) 866 { 867 return _nc_setupterm(tname, Filedes, errret, FALSE); 868 } 869