ncurses 5.6 - patch 20061223
[ncurses.git] / tack / init.c
1 /*
2 ** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
3 **
4 ** This file is part of TACK.
5 **
6 ** TACK is free software; you can redistribute it and/or modify
7 ** it under the terms of the GNU General Public License as published by
8 ** the Free Software Foundation; either version 2, or (at your option)
9 ** any later version.
10 **
11 ** TACK is distributed in the hope that it will be useful,
12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 ** GNU General Public License for more details.
15 **
16 ** You should have received a copy of the GNU General Public License
17 ** along with TACK; see the file COPYING.  If not, write to
18 ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 ** Boston, MA 02110-1301, USA
20 */
21 /* initialization and wrapup code */
22
23 #include <tack.h>
24
25 MODULE_ID("$Id: init.c,v 1.7 2006/11/26 00:16:01 tom Exp $")
26
27 #if NCURSES_VERSION_MAJOR >= 5 || NCURSES_VERSION_PATCH >= 981219
28 #define _nc_get_curterm(p) _nc_get_tty_mode(p)
29 #endif
30
31 FILE *debug_fp;
32 char temp[1024];
33 char tty_basename[64];
34
35 void
36 put_name(const char *cap, const char *name)
37 {                               /* send the cap name followed by the cap */
38         if (cap) {
39                 ptext(name);
40                 tc_putp(cap);
41         }
42 }
43
44 static void
45 report_cap(const char *tag, const char *s)
46 {                               /* expand the cap or print *** missing *** */
47         int i;
48
49         ptext(tag);
50         for (i = char_count; i < 13; i++) {
51                 putchp(' ');
52         }
53         put_str(" = ");
54         if (s) {
55                 putln(expand(s));
56         } else {
57                 putln("*** missing ***");
58         }
59 }
60
61
62 void
63 reset_init(void)
64 {                               /* send the reset and init strings */
65         int i;
66
67         ptext("Terminal reset");
68         i = char_count;
69         put_name(reset_1string, " (rs1)");
70         put_name(reset_2string, " (rs2)");
71         /* run the reset file */
72         if (reset_file && reset_file[0]) {
73                 FILE *fp;
74                 int ch;
75
76                 can_test("rf", FLAG_TESTED);
77                 if ((fp = fopen(reset_file, "r"))) {    /* send the reset file */
78                         sprintf(temp, " (rf) %s", reset_file);
79                         ptextln(temp);
80                         while (1) {
81                                 ch = getc(fp);
82                                 if (ch == EOF)
83                                         break;
84                                 put_this(ch);
85                         }
86                         fclose(fp);
87                 } else {
88                         sprintf(temp, "\nCannot open reset file (rf) %s", reset_file);
89                         ptextln(temp);
90                 }
91         }
92         put_name(reset_3string, " (rs3)");
93         if (i != char_count) {
94                 put_crlf();
95         }
96         ptext(" init");
97         put_name(init_1string, " (is1)");
98         put_name(init_2string, " (is2)");
99         if (set_tab && clear_all_tabs && init_tabs != 8) {
100                 put_crlf();
101                 tc_putp(clear_all_tabs);
102                 for (char_count = 0; char_count < columns; char_count++) {
103                         put_this(' ');
104                         if ((char_count & 7) == 7) {
105                                 tc_putp(set_tab);
106                         }
107                 }
108                 put_cr();
109         }
110         /* run the initialization file */
111         if (init_file && init_file[0]) {
112                 FILE *fp;
113                 int ch;
114
115                 can_test("if", FLAG_TESTED);
116                 if ((fp = fopen(init_file, "r"))) {     /* send the init file */
117                         sprintf(temp, " (if) %s", init_file);
118                         ptextln(temp);
119                         while (1) {
120                                 ch = getc(fp);
121                                 if (ch == EOF)
122                                         break;
123                                 put_this(ch);
124                         }
125                         fclose(fp);
126                 } else {
127                         sprintf(temp, "\nCannot open init file (if) %s", init_file);
128                         ptextln(temp);
129                 }
130         }
131         if (init_prog) {
132                 can_test("iprog", FLAG_TESTED);
133                 (void) system(init_prog);
134         }
135         put_name(init_3string, " (is3)");
136
137         fflush(stdout);
138 }
139
140 /*
141 **      display_basic()
142 **
143 **      display the basic terminal definitions
144 */
145 void
146 display_basic(void)
147 {
148         put_str("Name: ");
149         putln(ttytype);
150
151         report_cap("\\r ^M (cr)", carriage_return);
152         report_cap("\\n ^J (ind)", scroll_forward);
153         report_cap("\\b ^H (cub1)", cursor_left);
154         report_cap("\\t ^I (ht)", tab);
155 /*      report_cap("\\f ^L (ff)", form_feed);   */
156         if (newline) {
157                 /* OK if missing */
158                 report_cap("      (nel)", newline);
159         }
160         report_cap("      (clear)", clear_screen);
161         if (!cursor_home && cursor_address) {
162                 report_cap("(cup) (home)", TPARM_2(cursor_address, 0, 0));
163         } else {
164                 report_cap("      (home)", cursor_home);
165         }
166 #ifdef user9
167         report_cap("ENQ   (u9)", user9);
168 #endif
169 #ifdef user8
170         report_cap("ACK   (u8)", user8);
171 #endif
172
173         sprintf(temp, "\nTerminal size: %d x %d.  Baud rate: %u.  Frame size: %d.%d",
174                 columns, lines,
175                 tty_baud_rate,
176                 tty_frame_size >> 1,
177                 (tty_frame_size & 1) * 5);
178         putln(temp);
179 }
180
181 /*
182 **      curses_setup(exec_name)
183 **
184 **      Startup ncurses
185 */
186 void
187 curses_setup(
188         char *exec_name)
189 {
190         int status;
191         static TERMTYPE term;
192         char tty_filename[2048];
193
194         tty_init();
195
196         /**
197            See if the terminal is in the terminfo data base.  This call has
198         two useful benefits, 1) it returns the filename of the terminfo entry,
199         and 2) it searches only terminfo's.  This allows us to abort before
200         ncurses starts scanning the termcap file.
201         **/
202         if ((status = _nc_read_entry(tty_basename, tty_filename, &term)) == 0) {
203                 const TERMTYPE *fallback = _nc_fallback(tty_basename);
204
205                 if (fallback) {
206                     term = *fallback;
207                     sprintf(tty_filename, "(fallback)%s", tty_basename);
208                     status = 1;
209                 } else {
210                     fprintf(stderr, "Terminal not found: TERM=%s\n", tty_basename);
211                     show_usage(exec_name);
212                     exit(1);
213                 }
214         }
215         if (status == -1) {
216                 fprintf(stderr, "Terminfo database is inaccessible\n");
217                 exit(1);
218         }
219
220         /**
221            This call will load the terminfo data base and set the cur-term
222         variable.  Only terminals that actually exist will get here so its
223         OK to ignore errors.  This is a good thing since ncurses does not
224         permit (os) or (gn) to be set.
225         **/
226         setupterm(tty_basename, 1, &status);
227
228         /**
229            Get the current terminal definitions.  This must be done before
230         getting the baudrate.
231         **/
232         _nc_get_curterm(&cur_term->Nttyb);
233         tty_baud_rate = baudrate();
234         tty_cps = (tty_baud_rate << 1) / tty_frame_size;
235
236         /* set up the defaults */
237         replace_mode = TRUE;
238         scan_mode = 0;
239         char_count = 0;
240         select_delay_type = debug_level = 0;
241         char_mask = (meta_on && meta_on[0] == '\0') ? ALLOW_PARITY : STRIP_PARITY;
242         /* Don't change the XON/XOFF modes yet. */
243         select_xon_xoff = initial_stty_query(TTY_XON_XOFF) ? 1 : needs_xon_xoff;
244
245         fflush(stdout); /* flush any output */
246         tty_set();
247
248         go_home();      /* set can_go_home */
249         put_clear();    /* set can_clear_screen */
250
251         if (send_reset_init) {
252                 reset_init();
253         }
254
255         /*
256            I assume that the reset and init strings may not have the correct
257            pads.  (Because that part of the test comes much later.)  Because
258            of this, I allow the terminal some time to catch up.
259         */
260         fflush(stdout); /* waste some time */
261         sleep(1);       /* waste more time */
262         charset_can_test();
263         can_test("lines cols cr nxon rf if iprog rmp smcup rmcup", FLAG_CAN_TEST);
264         edit_init();                    /* initialize the edit data base */
265
266         if (send_reset_init && enter_ca_mode) {
267                 tc_putp(enter_ca_mode);
268                 put_clear();    /* just in case we switched pages */
269         }
270         put_crlf();
271         ptext("Using terminfo from: ");
272         ptextln(tty_filename);
273         put_crlf();
274
275         if (tty_can_sync == SYNC_NEEDED) {
276                 verify_time();
277         }
278
279         display_basic();
280 }
281
282 /*
283 **      bye_kids(exit-condition)
284 **
285 **      Shutdown the terminal, clear the signals, and exit
286 */
287 void
288 bye_kids(int n)
289 {                               /* reset the tty and exit */
290         ignoresig();
291         if (send_reset_init) {
292                 if (exit_ca_mode) {
293                         tc_putp(exit_ca_mode);
294                 }
295                 if (initial_stty_query(TTY_XON_XOFF)) {
296                         if (enter_xon_mode) {
297                                 tc_putp(enter_xon_mode);
298                         }
299                 } else if (exit_xon_mode) {
300                         tc_putp(exit_xon_mode);
301                 }
302         }
303         if (debug_fp) {
304                 fclose(debug_fp);
305         }
306         if (log_fp) {
307                 fclose(log_fp);
308         }
309         tty_reset();
310         fclose(stdin);
311         fclose(stdout);
312         fclose(stderr);
313         if (not_a_tty)
314                 sleep(1);
315         exit(n);
316 }