1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
33 * All Rights Reserved
34 *
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
37 * contributors.
38 */
39
40 #pragma ident "%Z%%M% %I% %E% SMI"
41
42 /*LINTLIBRARY*/
43
44 #include <stdio.h>
45 #include <sys/types.h>
46 #include <fcntl.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <unistd.h>
50 #include <errno.h>
51 #include "curses_inc.h"
52
53 #define TERMPATH "/usr/share/lib/terminfo/"
54 #define TERMPATHLEN 512
55
56 extern bool _use_env; /* in curses.c */
57
58 chtype bit_attributes[NUM_ATTRIBUTES] = {
59 A_STANDOUT,
60 A_UNDERLINE,
61 A_ALTCHARSET,
62 A_REVERSE,
63 A_BLINK,
64 A_DIM,
65 A_BOLD,
66 A_INVIS,
67 A_PROTECT
68 };
69
70 char *Def_term = "unknown", /* default terminal type */
71 term_parm_err[32], ttytype[BUFSIZ], _frst_tblstr[1400];
72
73 TERMINAL _first_term, *cur_term = &_first_term;
74 struct _bool_struct _frst_bools, *cur_bools = &_frst_bools;
75 struct _num_struct _frst_nums, *cur_nums = &_frst_nums;
76 struct _str_struct _frst_strs, *cur_strs = &_frst_strs;
77
78 /* _called_before is used/cleared by delterm.c and restart.c */
79 char _called_before = 0;
80 short term_errno = -1;
81
82 #ifdef SYSV
83 int prog_istermios = -1;
84 int shell_istermios = -1;
85 #endif
86
87 #ifdef DUMPTI
88 extern char *boolfnames[], *boolnames[], *boolcodes[],
89 *numfnames[], *numnames[], *numcodes[],
90 *strfnames[], *strnames[], *strcodes[];
91
92 main(int argc, char **argv) /* FOR DEBUG ONLY */
93 {
94 if (argc > 1)
95 setupterm(argv[1], 1, (int *)0);
96 else
97 setupterm((char *)0, 1, (int *)0);
98 return (0);
99 }
100
101 _Pr(int ch) /* FOR DEBUG ONLY */
102 {
103 if (ch >= 0200) {
104 printf("M-");
105 ch -= 0200;
106 }
107 if ((ch < ' ') || (ch == 0177))
108 printf("^%c", ch ^ 0100);
109 else
110 printf("%c", ch);
111 }
112
113 _Sprint(int n, char *string) /* FOR DEBUG ONLY */
114 {
115 int ch;
116
117 if (n == -1) {
118 printf(".\n");
119 return;
120 }
121 printf(", string = '");
122 while (ch = *string++)
123 _Pr(ch&0377);
124
125 printf("'.\n");
126 }
127
128 _Mprint(int n, char *memory) /* FOR DEBUG ONLY */
129 {
130 unsigned char ch;
131
132 while (ch = *memory++, n-- > 0)
133 _Pr(ch&0377);
134 }
135
136 #define _Vr2getshi() _Vr2getsh(ip-2)
137
138 #if vax || pdp11
139 #define _Vr2getsh(ip) (* (short *)(ip))
140 #endif /* vax || pdp11 */
141
142 #ifndef _Vr2getsh
143 /*
144 * Here is a more portable version, which does not assume byte ordering
145 * in shorts, sign extension, etc.
146 */
147 _Vr2getsh(char *p)
148 {
149 int rv;
150
151 if (*p == (char)0377)
152 return (-1);
153 rv = (unsigned char) *p++;
154 rv += (unsigned char) *p * 256;
155 return (rv);
156 }
157 #endif /* _Vr2getsh */
158
159 #endif /* DUMPTI */
160
161 #define _Getshi() _Getsh(ip); ip += 2
162
163 /*
164 * "function" to get a short from a pointer. The short is in a standard
165 * format: two bytes, the first is the low order byte, the second is
166 * the high order byte (base 256). The only negative numbers allowed are
167 * -1 and -2, which are represented as 255,255 and 255,254 This format
168 * happens to be the same as the hardware on the pdp-11, vax, and 386,
169 * making it fast and convenient and small to do this on a pdp-11.
170 */
171
172 #if vax || pdp11 || i386
173 #define _Getsh(ip) (* (short *)ip)
174 #endif /* vax || pdp11 */
175 /*
176 * The following macro is partly due to Mike Laman, laman@sdcsvax
177 * NCR @ Torrey Pines. - Tony Hansen
178 */
179 #if u3b || u3b15 || u3b2 || m68000
180 #define _Getsh(ip) ((short)(*((unsigned char *)ip) | (*(ip+1) << 8)))
181 #endif /* u3b || u3b15 || u3b2 || m68000 */
182
183 #ifndef _Getsh
184 /*
185 * Here is a more portable version, which does not assume byte ordering
186 * in shorts, sign extension, etc. For the sake of the porters,
187 * two alternative implementations, for the machines that don't have
188 * casting to "unsigned char", are also given, but commented out.
189 * Not ANSI C implementation assumes that the * C preprocessor does
190 * sign-extension the same as on the machine being compiled for.
191 */
192 static int
193 _Getsh(char *p)
194 {
195 int rv, rv2;
196
197 rv = (unsigned char) p[0];
198 rv2 = (unsigned char) p[1];
199
200 /* the following stuff is only for porting. See the comment above */
201
202 #ifdef FOR_PORTING
203 #if CHAR_MIN < 0
204 rv = (*p++) & 0377;
205 rv2 = (*p) & 0377;
206 #else /* CHAR_MIN < 0 */
207 rv = *p++;
208 rv2 = *p;
209 #endif /* CHAR_MIN < 0 */
210
211 #endif /* FOR_PORTING */
212
213 if ((rv2 == 0377) && ((rv == 0377) || (rv == 0376)))
214 return (-1);
215 return (rv + (rv2 * 256));
216 }
217 #endif /* _Getsh */
218
219 /*
220 * setupterm: low level routine to dig up terminfo from database
221 * and read it in. Parms are terminal type (0 means use getenv("TERM"),
222 * file descriptor all output will go to (for ioctls), and a pointer
223 * to an int into which the error return code goes (0 means to bomb
224 * out with an error message if there's an error). Thus,
225 * setupterm((char *)0, 1, (int *)0) is a reasonable way for a simple
226 * program to set up.
227 */
228 int
229 setupterm(char *term, int filenum, int *errret)
230 /* filenum - This is a UNIX file descriptor, not a stdio ptr. */
231 {
232 char tiebuf[4096];
233 char fname[TERMPATHLEN];
234 char *ip;
235 char *cp;
236 int n, tfd;
237 char *lcp, *ccp, **on_sequences, **str_array;
238 int snames, nbools, nints, nstrs, sstrtab;
239 char *strtab;
240 #ifdef DUMPTI
241 int Vr2val;
242 #endif /* DUMPTI */
243
244 (void) mbgetwidth();
245
246 if (term == NULL)
247 term = getenv("TERM");
248
249 if (term == NULL || *term == '\0')
250 term = Def_term;
251
252 tfd = -1;
253 errno = 0; /* ehr3 */
254
255 if (errret != 0)
256 *errret = -1;
257
258 if (((cp = getenv("TERMINFO")) != 0) && *cp) {
259 /* $TERMINFO/?/$TERM */
260 if (snprintf(fname, sizeof (fname),
261 "%s/%c/%s", cp, *term, term) >= sizeof (fname)) {
262 term_errno = TERMINFO_TOO_LONG;
263 goto out_err;
264 }
265
266 tfd = open(fname, 0);
267 #ifdef DUMPTI
268 printf("looking in file %s\n", fname);
269 #endif /* DUMPTI */
270 if ((tfd < 0) && (errno == EACCES))
271 goto cant_read;
272 }
273
274 if (tfd < 0) {
275 /* /usr/share/lib/terminfo/?/$TERM */
276 if (snprintf(fname, sizeof (fname),
277 "%s/%c/%s", TERMPATH, *term, term) >= sizeof (fname)) {
278 term_errno = TERMINFO_TOO_LONG;
279 goto out_err;
280 }
281
282 tfd = open(fname, 0);
283 #ifdef DUMPTI
284 printf("looking in file %s\n", fname);
285 #endif /* DUMPTI */
286
287 }
288
289 if (tfd < 0) {
290 if (errno == EACCES) {
291 cant_read:
292 term_errno = NOT_READABLE;
293 } else {
294 if (access(TERMPATH, 0) == -1)
295 term_errno = UNACCESSIBLE;
296 else {
297 term_errno = NO_TERMINAL;
298 if (errret != 0)
299 *errret = 0;
300 }
301 }
302 /*
303 * if the length of the specified terminal name is longer
304 * than 31, it will be chopped after the 31st byte.
305 * This should be a rare case.
306 */
307 (void) strncpy(term_parm_err, term, 31);
308 term_parm_err[31] = '\0';
309 goto out_err;
310 }
311
312 /* LINTED */
313 n = (int)read(tfd, tiebuf, sizeof (tiebuf));
314 (void) close(tfd);
315
316 if (n <= 0) {
317 corrupt:
318 term_errno = CORRUPTED;
319 goto out_err;
320 } else
321 if (n == sizeof (tiebuf)) {
322 term_errno = ENTRY_TOO_LONG;
323 goto out_err;
324 }
325 cp = ttytype;
326 ip = tiebuf;
327
328 /* Pick up header */
329 snames = _Getshi();
330 #ifdef DUMPTI
331 Vr2val = _Vr2getshi();
332 printf("Magic number = %d, %#o [%d, %#o].\n", snames,
333 snames, Vr2val, Vr2val);
334 #endif /* DUMPTI */
335 if (snames != MAGNUM)
336 goto corrupt;
337 snames = _Getshi();
338 #ifdef DUMPTI
339 Vr2val = _Vr2getshi();
340 printf("Size of names = %d, %#o [%d, %#o].\n", snames,
341 snames, Vr2val, Vr2val);
342 #endif /* DUMPTI */
343
344 nbools = _Getshi();
345 #ifdef DUMPTI
346 Vr2val = _Vr2getshi();
347 printf("Number of bools = %d, %#o [%d, %#o].\n", nbools,
348 nbools, Vr2val, Vr2val);
349 #endif /* DUMPTI */
350
351 nints = _Getshi();
352 #ifdef DUMPTI
353 Vr2val = _Vr2getshi();
354 printf("Number of ints = %d, %#o [%d, %#o].\n", nints, nints,
355 Vr2val, Vr2val);
356 #endif /* DUMPTI */
357
358 nstrs = _Getshi();
359 #ifdef DUMPTI
360 Vr2val = _Vr2getshi();
361 printf("Number of strings = %d, %#o [%d, %#o].\n", nstrs, nstrs,
362 Vr2val, Vr2val);
363 #endif /* DUMPTI */
364
365 sstrtab = _Getshi();
366 #ifdef DUMPTI
367 Vr2val = _Vr2getshi();
368 printf("Size of string table = %d, %#o [%d, %#o].\n", sstrtab,
369 sstrtab, Vr2val, Vr2val);
370 printf("Names are: %.*s.\n", snames, ip);
371 #endif /* DUMPTI */
372
373 /* allocate all of the space */
374 strtab = NULL;
375 if (_called_before) {
376 /* 2nd or more times through */
377 if ((cur_term = (TERMINAL *)
378 calloc(sizeof (TERMINAL), 1)) == NULL)
379 goto badmalloc;
380 if ((cur_bools = (struct _bool_struct *)
381 calloc(sizeof (struct _bool_struct), 1)) == NULL)
382 goto freeterminal;
383 if ((cur_nums = (struct _num_struct *)
384 calloc(sizeof (struct _num_struct), 1)) == NULL)
385 goto freebools;
386 if ((cur_strs = (struct _str_struct *)
387 calloc(sizeof (struct _str_struct), 1)) == NULL) {
388 freenums:
389 free((char *)cur_nums);
390 freebools:
391 free((char *)cur_bools);
392 freeterminal:
393 free((char *)cur_term);
394 badmalloc:
395 term_errno = TERM_BAD_MALLOC;
396 #ifdef DEBUG
397 strcpy(term_parm_err, "setupterm");
398 #endif /* DEBUG */
399 out_err:
400 if (errret == 0) {
401 termerr();
402 exit(-term_errno);
403 } else
404 return (ERR);
405 }
406 } else {
407 /* First time through */
408 _called_before = TRUE;
409 cur_term = &_first_term;
410 cur_bools = &_frst_bools;
411 cur_nums = &_frst_nums;
412 cur_strs = &_frst_strs;
413 if (sstrtab < sizeof (_frst_tblstr))
414 strtab = _frst_tblstr;
415 }
416
417 if (strtab == NULL) {
418 if ((strtab = (char *)malloc((unsigned)sstrtab)) == NULL) {
419 if (cur_strs != &_frst_strs)
420 free((char *)cur_strs);
421 goto freenums;
422 }
423 }
424
425 /* no more catchable errors */
426 if (errret)
427 *errret = 1;
428
429 (void) strncpy(cur_term->_termname, term, 14);
430 /* In case the name is exactly 15 characters */
431 cur_term->_termname[14] = '\0';
432 cur_term->_bools = cur_bools;
433 cur_term->_nums = cur_nums;
434 cur_term->_strs = cur_strs;
435 cur_term->_strtab = strtab;
436 cur_term->sgr_mode = cur_term->sgr_faked = A_NORMAL;
437
438 if (filenum == 1 && !isatty(filenum))
439 filenum = 2; /* Allow output redirect */
440 /* LINTED */
441 cur_term->Filedes = (short)filenum;
442 _blast_keys(cur_term);
443 cur_term->_iwait = cur_term->fl_typeahdok = cur_term->_chars_on_queue =
444 cur_term->_fl_rawmode = cur_term->_ungotten = 0;
445 cur_term->_cursorstate = 1;
446 cur_term->_delay = cur_term->_inputfd = cur_term->_check_fd = -1;
447 (void) memset((char *)cur_term->_regs, 0, 26 * sizeof (short));
448
449 #ifndef DUMPTI
450 (void) def_shell_mode();
451 /* This is a useful default for PROGTTY, too */
452 #ifdef SYSV
453 if (shell_istermios < 0) {
454 int i;
455
456 SHELLTTY.c_lflag = SHELLTTYS.c_lflag;
457 SHELLTTY.c_oflag = SHELLTTYS.c_oflag;
458 SHELLTTY.c_iflag = SHELLTTYS.c_iflag;
459 SHELLTTY.c_cflag = SHELLTTYS.c_cflag;
460 for (i = 0; i < NCC; i++)
461 SHELLTTY.c_cc[i] = SHELLTTYS.c_cc[i];
462 PROGTTY = SHELLTTY;
463 prog_istermios = -1;
464
465 PROGTTYS.c_lflag = PROGTTY.c_lflag;
466 PROGTTYS.c_oflag = PROGTTY.c_oflag;
467 PROGTTYS.c_iflag = PROGTTY.c_iflag;
468 PROGTTYS.c_cflag = PROGTTY.c_cflag;
469 for (i = 0; i < NCC; i++)
470 PROGTTYS.c_cc[i] = PROGTTY.c_cc[i];
471 } else {
472 PROGTTYS = SHELLTTYS;
473 prog_istermios = 0;
474 }
475 #else /* SYSV */
476 PROGTTY = SHELLTTY;
477 #endif /* SYSV */
478 #endif /* DUMPTI */
479
480 /* Skip names of terminals */
481 (void) memcpy((char *)cp, (char *)ip, (snames * sizeof (*cp)));
482 ip += snames;
483
484 /*
485 * Pull out the booleans.
486 * The for loop below takes care of a new curses with an old tic
487 * file and visa-versa. nbools says how many bools the tic file has.
488 * So, we only loop for as long as there are bools to read.
489 * However, if this is an old curses that doesn't have all the
490 * bools that this new tic has dumped, then the extra if
491 * "if (cp < fp)" says that if we are going to read into our structure
492 * passed its size don't do it but we still need to keep bumping
493 * up the pointer of what we read in from the terminfo file.
494 */
495 {
496 char *fp = &cur_bools->Sentinel;
497 char s;
498 #ifdef DUMPTI
499 int tempindex = 0;
500 #endif /* DUMPTI */
501 cp = &cur_bools->_auto_left_margin;
502 while (nbools--) {
503 s = *ip++;
504 #ifdef DUMPTI
505 printf("Bool %s [%s] (%s) = %d.\n",
506 boolfnames[tempindex], boolnames[tempindex],
507 boolcodes[tempindex], s);
508 tempindex++;
509 #endif /* DUMPTI */
510 if (cp < fp)
511 *cp++ = s & 01;
512 }
513 if (cp < fp)
514 (void) memset(cp, 0, ((fp - cp) * sizeof (bool)));
515 }
516
517 /* Force proper alignment */
518 if (((unsigned long) ip) & 1)
519 ip++;
520
521 /*
522 * Pull out the numbers.
523 */
524 {
525 short *sp = &cur_nums->_columns;
526 short *fp = &cur_nums->Sentinel;
527 int s;
528 #ifdef DUMPTI
529 int tempindex = 0;
530 #endif /* DUMPTI */
531
532 while (nints--) {
533 s = _Getshi();
534 #ifdef DUMPTI
535 Vr2val = _Vr2getshi();
536 printf("Num %s [%s] (%s) = %d [%d].\n",
537 numfnames[tempindex], numnames[tempindex],
538 numcodes[tempindex], s, Vr2val);
539 tempindex++;
540 #endif /* DUMPTI */
541 if (sp < fp)
542 if (s < 0)
543 *sp++ = -1;
544 else
545 /* LINTED */
546 *sp++ = (short)s;
547 }
548 if (sp < fp)
549 (void) memset((char *)sp, '\377',
550 ((fp - sp) * sizeof (short)));
551 }
552
553 if (_use_env) {
554 /*
555 * This ioctl defines the window size and overrides what
556 * it says in terminfo.
557 */
558 {
559 struct winsize w;
560
561 if (ioctl(filenum, TIOCGWINSZ, &w) != -1) {
562 if (w.ws_row != 0)
563 cur_nums->_lines = w.ws_row;
564 if (w.ws_col != 0)
565 cur_nums->_columns = w.ws_col;
566 #ifdef DUMPTI
567 printf("ioctl TIOCGWINSZ override: "
568 "(lines, columns) = (%d, %d)\n",
569 w.ws_row, w.ws_col);
570 #endif /* DUMPTI */
571 }
572 }
573
574 /*
575 * Check $LINES and $COLUMNS.
576 */
577 {
578 int ilines, icolumns;
579
580 lcp = getenv("LINES");
581 ccp = getenv("COLUMNS");
582 if (lcp)
583 if ((ilines = atoi(lcp)) > 0) {
584 /* LINTED */
585 cur_nums->_lines = (short)ilines;
586 #ifdef DUMPTI
587 printf("$LINES override: lines = %d\n",
588 ilines);
589 #endif /* DUMPTI */
590 }
591 if (ccp)
592 if ((icolumns = atoi(ccp)) > 0) {
593 /* LINTED */
594 cur_nums->_columns = (short)icolumns;
595 #ifdef DUMPTI
596 printf("$COLUMNS override: columns = "
597 "%d\n", icolumns);
598 #endif /* DUMPTI */
599 }
600 }
601 }
602
603 /* Pull out the strings. */
604 {
605 char **pp = &cur_strs->strs._back_tab;
606 char **fp = &cur_strs->strs4.Sentinel;
607 #ifdef DUMPTI
608 int tempindex = 0;
609 char *startstr = ip + sizeof (short) *
610 nstrs;
611
612 printf("string table = '");
613 _Mprint(sstrtab, startstr);
614 printf("'\n");
615 #endif /* DUMPTI */
616
617 while (nstrs--) {
618 n = _Getshi();
619 #ifdef DUMPTI
620 Vr2val = _Vr2getshi();
621 printf("String %s [%s] (%s) offset = %d [%d]",
622 strfnames[tempindex], strnames[tempindex],
623 strcodes[tempindex], n, Vr2val);
624 tempindex++;
625 #endif /* DUMPTI */
626 if (pp < fp) {
627 #ifdef DUMPTI
628 _Sprint(n, startstr+n);
629 #endif /* DUMPTI */
630 if (n < 0)
631 *pp++ = NULL;
632 else
633 *pp++ = strtab + n;
634 }
635 #ifdef DUMPTI
636 else
637 _Sprint(-1, (char *)0);
638 #endif /* DUMPTI */
639 }
640 if (pp < fp)
641 (void) memset((char *)pp, 0, ((fp - pp) * sizeof (charptr)));
642 }
643
644 (void) memcpy(strtab, ip, sstrtab);
645
646 #ifndef DUMPTI
647
648 /*
649 * If tabs are being expanded in software, turn this off
650 * so output won't get messed up. Also, don't use tab
651 * or backtab, even if the terminal has them, since the
652 * user might not have hardware tabs set right.
653 */
654 #ifdef SYSV
655 if ((PROGTTYS.c_oflag & TABDLY) == TAB3) {
656 PROGTTYS.c_oflag &= ~TABDLY;
657 (void) reset_prog_mode();
658 goto next;
659 }
660 #else /* SYSV */
661 if ((PROGTTY.sg_flags & XTABS) == XTABS) {
662 PROGTTY.sg_flags &= ~XTABS;
663 (void) reset_prog_mode();
664 goto next;
665 }
666 #endif /* SYSV */
667 if (dest_tabs_magic_smso) {
668 next:
669 cur_strs->strs2._tab = cur_strs->strs._back_tab = NULL;
670 }
671
672 #ifdef LTILDE
673 ioctl(cur_term -> Filedes, TIOCLGET, &n);
674 #endif /* LTILDE */
675 #endif /* DUMPTI */
676
677 #ifdef _VR2_COMPAT_CODE
678 (void) memcpy(&cur_term->_b1, &cur_bools->_auto_left_margin,
679 (char *)&cur_term->_c1 - (char *)&cur_term->_b1);
680 (void) memcpy((char *)&cur_term->_c1, (char *)&cur_nums->_columns,
681 (char *)&cur_term->_Vr2_Astrs._s1 - (char *)&cur_term->_c1);
682 (void) memcpy((char *)&cur_term->_Vr2_Astrs._s1,
683 (char *)&cur_strs->strs._back_tab,
684 (char *)&cur_term->Filedes - (char *)&cur_term->_Vr2_Astrs._s1);
685 #endif /* _VR2_COMPAT_CODE */
686
687 on_sequences = cur_term->turn_on_seq;
688 str_array = (char **)cur_strs;
689 {
690 static char offsets[] = {
691 35, /* enter_standout_mode, */
692 36, /* enter_underline_mode, */
693 25, /* enter_alt_charset_mode, */
694 34, /* enter_reverse_mode, */
695 26, /* enter_blink_mode, */
696 30, /* enter_dim_mode, */
697 27, /* enter_bold_mode, */
698 32, /* enter_secure_mode, */
699 33, /* enter_protected_mode, */
700 };
701
702 for (n = 0; n < NUM_ATTRIBUTES; n++) {
703 if ((on_sequences[n] = str_array[offsets[n]]) != 0)
704 cur_term->bit_vector |= bit_attributes[n];
705 }
706 }
707
708 if (!(set_attributes)) {
709 static char faked_attrs[] = { 1, 3, 4, 6 },
710 offsets[] = {
711 43, /* exit_standout_mode, */
712 44, /* exit_underline_mode, */
713 38, /* exit_alt_charset_mode, */
714 };
715 char **off_sequences = cur_term->turn_off_seq;
716 int i;
717
718 if ((max_attributes == -1) && (ceol_standout_glitch ||
719 (magic_cookie_glitch >= 0)))
720 max_attributes = 1;
721
722 /* Figure out what attributes need to be faked. */
723 /* See vidupdate.c */
724
725 for (n = 0; n < sizeof (faked_attrs); n++) {
726 if (on_sequences[0] != NULL) {
727 if ((!on_sequences[i = faked_attrs[n]]) ||
728 (strcmp(on_sequences[i],
729 on_sequences[0]) == 0)) {
730 cur_term->sgr_faked |=
731 bit_attributes[i];
732 }
733 } else {
734 if (!on_sequences[i = faked_attrs[n]]) {
735 cur_term->sgr_faked |=
736 bit_attributes[i];
737 }
738 }
739 }
740
741 cur_term->check_turn_off = A_STANDOUT | A_UNDERLINE |
742 A_ALTCHARSET;
743
744 for (n = 0; n < sizeof (offsets); n++) {
745 if ((!(off_sequences[n] = str_array[offsets[n]])) ||
746 ((n > 0) && off_sequences[0] &&
747 (strcmp(off_sequences[n], off_sequences[0]) ==
748 0)) || ((n == 2) && (exit_attribute_mode) &&
749 (strcmp(exit_attribute_mode, off_sequences[n]) ==
750 0))) {
751 cur_term->check_turn_off &= ~bit_attributes[n];
752 }
753 }
754 }
755 cur_term->cursor_seq[0] = cursor_invisible;
756 cur_term->cursor_seq[1] = cursor_normal;
757 cur_term->cursor_seq[2] = cursor_visible;
758 cur_term->_pairs_tbl = (_Color_pair *) NULL;
759 cur_term->_color_tbl = (_Color *) NULL;
760
761 return (OK);
762 }
763
764 void
765 _blast_keys(TERMINAL *terminal)
766 {
767 terminal->_keys = NULL;
768 terminal->internal_keys = NULL;
769 terminal->_ksz = terminal->_first_macro = 0;
770 terminal->_lastkey_ordered = terminal->_lastmacro_ordered = -1;
771 (void) memset((char *)terminal->funckeystarter, 0, 0400 *
772 sizeof (bool));
773 }
774
775 #ifndef DUMPTI
776
777 int
778 reset_prog_mode(void)
779 {
780 #ifdef SYSV
781 if (_BRS(PROGTTYS)) {
782 if (prog_istermios < 0) {
783 int i;
784
785 PROGTTY.c_lflag = PROGTTYS.c_lflag;
786 PROGTTY.c_oflag = PROGTTYS.c_oflag;
787 PROGTTY.c_iflag = PROGTTYS.c_iflag;
788 PROGTTY.c_cflag = PROGTTYS.c_cflag;
789 for (i = 0; i < NCC; i++)
790 PROGTTY.c_cc[i] = PROGTTYS.c_cc[i];
791 (void) ioctl(cur_term -> Filedes, TCSETAW, &PROGTTY);
792 } else
793 (void) ioctl(cur_term -> Filedes, TCSETSW, &PROGTTYS);
794 }
795 #else /* SYSV */
796 if (_BR(PROGTTY))
797 (void) ioctl(cur_term -> Filedes, TIOCSETN, &PROGTTY);
798 #endif /* SYSV */
799
800 #ifdef LTILDE
801 ioctl(cur_term -> Filedes, TIOCLGET, &cur_term -> oldlmode);
802 cur_term -> newlmode = cur_term -> oldlmode & ~LTILDE;
803 if (cur_term -> newlmode != cur_term -> oldlmode)
804 ioctl(cur_term -> Filedes, TIOCLSET, &cur_term -> newlmode);
805 #endif /* LTILDE */
806 #ifdef DIOCSETT
807 if (cur_term -> old.st_termt == 0)
808 ioctl(cur_term->Filedes, DIOCGETT, &cur_term -> old);
809 cur_term -> new = cur_term -> old;
810 cur_term -> new.st_termt = 0;
811 cur_term -> new.st_flgs |= TM_SET;
812 ioctl(cur_term->Filedes, DIOCSETT, &cur_term -> new);
813 #endif /* DIOCSETT */
814 return (OK);
815 }
816
817 int
818 def_shell_mode(void)
819 {
820 #ifdef SYSV
821 if ((shell_istermios =
822 ioctl(cur_term -> Filedes, TCGETS, &SHELLTTYS)) < 0) {
823 int i;
824
825 (void) ioctl(cur_term -> Filedes, TCGETA, &SHELLTTY);
826 SHELLTTYS.c_lflag = SHELLTTY.c_lflag;
827 SHELLTTYS.c_oflag = SHELLTTY.c_oflag;
828 SHELLTTYS.c_iflag = SHELLTTY.c_iflag;
829 SHELLTTYS.c_cflag = SHELLTTY.c_cflag;
830 for (i = 0; i < NCC; i++)
831 SHELLTTYS.c_cc[i] = SHELLTTY.c_cc[i];
832 }
833 #else /* SYSV */
834 (void) ioctl(cur_term -> Filedes, TIOCGETP, &SHELLTTY);
835 #endif /* SYSV */
836 return (OK);
837 }
838
839 #endif /* DUMPTI */