253
|
1 /* terminal control module for terminals described by TERMCAP
|
621
|
2 Copyright (C) 1985, 1986, 1987, 1992 Free Software Foundation, Inc.
|
253
|
3
|
|
4 This file is part of GNU Emacs.
|
|
5
|
|
6 GNU Emacs is free software; you can redistribute it and/or modify
|
|
7 it under the terms of the GNU General Public License as published by
|
621
|
8 the Free Software Foundation; either version 2, or (at your option)
|
253
|
9 any later version.
|
|
10
|
|
11 GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to
|
|
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
19
|
|
20
|
|
21 #include <stdio.h>
|
|
22 #include <ctype.h>
|
|
23 #include "config.h"
|
|
24 #include "termchar.h"
|
|
25 #include "termopts.h"
|
|
26 #include "cm.h"
|
|
27 #undef NULL
|
|
28 #include "lisp.h"
|
|
29 #include "screen.h"
|
|
30 #include "disptab.h"
|
|
31 #include "termhooks.h"
|
533
|
32 #include "keyboard.h"
|
253
|
33
|
|
34 #define max(a, b) ((a) > (b) ? (a) : (b))
|
|
35 #define min(a, b) ((a) < (b) ? (a) : (b))
|
|
36
|
|
37 #define OUTPUT(a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc)
|
|
38 #define OUTPUT1(a) tputs (a, 1, cmputc)
|
|
39 #define OUTPUTL(a, lines) tputs (a, lines, cmputc)
|
|
40 #define OUTPUT_IF(a) { if (a) tputs (a, SCREEN_HEIGHT (selected_screen) - curY, cmputc); }
|
|
41 #define OUTPUT1_IF(a) { if (a) tputs (a, 1, cmputc); }
|
|
42
|
|
43 /* Terminal charateristics that higher levels want to look at.
|
|
44 These are all extern'd in termchar.h */
|
|
45
|
|
46 #ifndef MULTI_SCREEN
|
|
47 int screen_width; /* Number of usable columns */
|
|
48 int screen_height; /* Number of lines */
|
|
49 #endif
|
|
50
|
|
51 int must_write_spaces; /* Nonzero means spaces in the text
|
|
52 must actually be output; can't just skip
|
|
53 over some columns to leave them blank. */
|
|
54 int min_padding_speed; /* Speed below which no padding necessary */
|
|
55
|
|
56 int line_ins_del_ok; /* Terminal can insert and delete lines */
|
|
57 int char_ins_del_ok; /* Terminal can insert and delete chars */
|
|
58 int scroll_region_ok; /* Terminal supports setting the
|
|
59 scroll window */
|
|
60 int memory_below_screen; /* Terminal remembers lines
|
|
61 scrolled off bottom */
|
|
62 int fast_clear_end_of_line; /* Terminal has a `ce' string */
|
|
63
|
|
64 int dont_calculate_costs; /* Nonzero means don't bother computing */
|
|
65 /* various cost tables; we won't use them. */
|
|
66
|
|
67 /* Nonzero means no need to redraw the entire screen on resuming
|
|
68 a suspended Emacs. This is useful on terminals with multiple pages,
|
|
69 where one page is used for Emacs and another for all else. */
|
|
70 int no_redraw_on_reenter;
|
|
71
|
|
72 /* Hook functions that you can set to snap out the functions in this file.
|
|
73 These are all extern'd in termhooks.h */
|
|
74
|
|
75 int (*cursor_to_hook) ();
|
|
76 int (*raw_cursor_to_hook) ();
|
|
77
|
|
78 int (*clear_to_end_hook) ();
|
|
79 int (*clear_screen_hook) ();
|
|
80 int (*clear_end_of_line_hook) ();
|
|
81
|
|
82 int (*ins_del_lines_hook) ();
|
|
83
|
|
84 int (*change_line_highlight_hook) ();
|
|
85 int (*reassert_line_highlight_hook) ();
|
|
86
|
|
87 int (*insert_glyphs_hook) ();
|
|
88 int (*write_glyphs_hook) ();
|
|
89 int (*delete_glyphs_hook) ();
|
|
90
|
|
91 int (*ring_bell_hook) ();
|
|
92
|
|
93 int (*reset_terminal_modes_hook) ();
|
|
94 int (*set_terminal_modes_hook) ();
|
|
95 int (*update_begin_hook) ();
|
|
96 int (*update_end_hook) ();
|
|
97 int (*set_terminal_window_hook) ();
|
|
98
|
|
99 int (*read_socket_hook) ();
|
|
100
|
425
|
101 /* Return the current position of the mouse. This should clear
|
|
102 mouse_moved until the next motion event arrives. */
|
|
103 void (*mouse_position_hook) ( /* SCREEN_PTR *s,
|
|
104 Lisp_Object *x,
|
|
105 Lisp_Object *y,
|
|
106 Lisp_Object *time */ );
|
253
|
107
|
339
|
108 /* When reading from a minibuffer in a different screen, Emacs wants
|
|
109 to shift the highlight from the selected screen to the minibuffer's
|
|
110 screen; under X, this means it lies about where the focus is.
|
|
111 This hook tells the window system code to re-decide where to put
|
|
112 the highlight. */
|
340
|
113 void (*screen_rehighlight_hook) ( /* SCREEN_PTR s */ );
|
339
|
114
|
253
|
115 /* Strings, numbers and flags taken from the termcap entry. */
|
|
116
|
|
117 char *TS_ins_line; /* termcap "al" */
|
|
118 char *TS_ins_multi_lines; /* "AL" (one parameter, # lines to insert) */
|
|
119 char *TS_bell; /* "bl" */
|
|
120 char *TS_clr_to_bottom; /* "cd" */
|
|
121 char *TS_clr_line; /* "ce", clear to end of line */
|
|
122 char *TS_clr_screen; /* "cl" */
|
|
123 char *TS_set_scroll_region; /* "cs" (2 params, first line and last line) */
|
|
124 char *TS_set_scroll_region_1; /* "cS" (4 params: total lines,
|
|
125 lines above scroll region, lines below it,
|
|
126 total lines again) */
|
|
127 char *TS_del_char; /* "dc" */
|
|
128 char *TS_del_multi_chars; /* "DC" (one parameter, # chars to delete) */
|
|
129 char *TS_del_line; /* "dl" */
|
|
130 char *TS_del_multi_lines; /* "DL" (one parameter, # lines to delete) */
|
|
131 char *TS_delete_mode; /* "dm", enter character-delete mode */
|
|
132 char *TS_end_delete_mode; /* "ed", leave character-delete mode */
|
|
133 char *TS_end_insert_mode; /* "ei", leave character-insert mode */
|
|
134 char *TS_ins_char; /* "ic" */
|
|
135 char *TS_ins_multi_chars; /* "IC" (one parameter, # chars to insert) */
|
|
136 char *TS_insert_mode; /* "im", enter character-insert mode */
|
|
137 char *TS_pad_inserted_char; /* "ip". Just padding, no commands. */
|
|
138 char *TS_end_keypad_mode; /* "ke" */
|
|
139 char *TS_keypad_mode; /* "ks" */
|
|
140 char *TS_pad_char; /* "pc", char to use as padding */
|
|
141 char *TS_repeat; /* "rp" (2 params, # times to repeat
|
|
142 and character to be repeated) */
|
|
143 char *TS_end_standout_mode; /* "se" */
|
|
144 char *TS_fwd_scroll; /* "sf" */
|
|
145 char *TS_standout_mode; /* "so" */
|
|
146 char *TS_rev_scroll; /* "sr" */
|
|
147 char *TS_end_termcap_modes; /* "te" */
|
|
148 char *TS_termcap_modes; /* "ti" */
|
|
149 char *TS_visible_bell; /* "vb" */
|
|
150 char *TS_end_visual_mode; /* "ve" */
|
|
151 char *TS_visual_mode; /* "vi" */
|
|
152 char *TS_set_window; /* "wi" (4 params, start and end of window,
|
|
153 each as vpos and hpos) */
|
|
154
|
|
155 int TF_hazeltine; /* termcap hz flag. */
|
|
156 int TF_insmode_motion; /* termcap mi flag: can move while in insert mode. */
|
|
157 int TF_standout_motion; /* termcap mi flag: can move while in standout mode. */
|
|
158 int TF_underscore; /* termcap ul flag: _ underlines if overstruck on
|
|
159 nonblank position. Must clear before writing _. */
|
|
160 int TF_teleray; /* termcap xt flag: many weird consequences.
|
|
161 For t1061. */
|
|
162
|
|
163 int TF_xs; /* Nonzero for "xs". If set together with
|
|
164 TN_standout_width == 0, it means don't bother
|
|
165 to write any end-standout cookies. */
|
|
166
|
|
167 int TN_standout_width; /* termcap sg number: width occupied by standout
|
|
168 markers */
|
|
169
|
|
170 static int RPov; /* # chars to start a TS_repeat */
|
|
171
|
|
172 static int delete_in_insert_mode; /* delete mode == insert mode */
|
|
173
|
|
174 static int se_is_so; /* 1 if same string both enters and leaves
|
|
175 standout mode */
|
|
176
|
|
177 /* internal state */
|
|
178
|
|
179 /* Number of chars of space used for standout marker at beginning of line,
|
|
180 or'd with 0100. Zero if no standout marker at all.
|
|
181
|
|
182 Used IFF TN_standout_width >= 0. */
|
|
183
|
|
184 static char *chars_wasted;
|
|
185 static char *copybuf;
|
|
186
|
|
187 /* nonzero means supposed to write text in standout mode. */
|
|
188 int standout_requested;
|
|
189
|
|
190 int insert_mode; /* Nonzero when in insert mode. */
|
|
191 int standout_mode; /* Nonzero when in standout mode. */
|
|
192
|
|
193 /* Size of window specified by higher levels.
|
|
194 This is the number of lines, from the top of screen downwards,
|
|
195 which can participate in insert-line/delete-line operations.
|
|
196
|
|
197 Effectively it excludes the bottom screen_height - specified_window_size
|
|
198 lines from those operations. */
|
|
199
|
|
200 int specified_window;
|
|
201
|
|
202 /* Screen currently being redisplayed; 0 if not currently redisplaying.
|
|
203 (Direct output does not count). */
|
|
204
|
|
205 SCREEN_PTR updating_screen;
|
|
206
|
|
207 char *tparam ();
|
|
208
|
|
209 ring_bell ()
|
|
210 {
|
|
211 if (! SCREEN_IS_TERMCAP (selected_screen))
|
|
212 {
|
|
213 (*ring_bell_hook) ();
|
|
214 return;
|
|
215 }
|
|
216 OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
|
|
217 }
|
|
218
|
|
219 set_terminal_modes ()
|
|
220 {
|
|
221 if (! SCREEN_IS_TERMCAP (selected_screen))
|
|
222 {
|
|
223 (*set_terminal_modes_hook) ();
|
|
224 return;
|
|
225 }
|
|
226 OUTPUT_IF (TS_termcap_modes);
|
|
227 OUTPUT_IF (TS_visual_mode);
|
|
228 OUTPUT_IF (TS_keypad_mode);
|
|
229 losecursor ();
|
|
230 }
|
|
231
|
|
232 reset_terminal_modes ()
|
|
233 {
|
|
234 if (! SCREEN_IS_TERMCAP (selected_screen))
|
|
235 {
|
|
236 (*reset_terminal_modes_hook) ();
|
|
237 return;
|
|
238 }
|
|
239 if (TN_standout_width < 0)
|
|
240 turn_off_highlight ();
|
|
241 turn_off_insert ();
|
|
242 OUTPUT_IF (TS_end_keypad_mode);
|
|
243 OUTPUT_IF (TS_end_visual_mode);
|
|
244 OUTPUT_IF (TS_end_termcap_modes);
|
|
245 /* Output raw CR so kernel can track the cursor hpos. */
|
|
246 /* But on magic-cookie terminals this can erase an end-standout marker and
|
|
247 cause the rest of the screen to be in standout, so move down first. */
|
|
248 if (TN_standout_width >= 0)
|
|
249 cmputc ('\n');
|
|
250 cmputc ('\r');
|
|
251 }
|
|
252
|
|
253 update_begin (s)
|
|
254 SCREEN_PTR s;
|
|
255 {
|
|
256 updating_screen = s;
|
|
257 if (! SCREEN_IS_TERMCAP (updating_screen))
|
|
258 (*update_begin_hook) (s);
|
|
259 }
|
|
260
|
|
261 update_end (s)
|
|
262 SCREEN_PTR s;
|
|
263 {
|
|
264 if (! SCREEN_IS_TERMCAP (updating_screen))
|
|
265 {
|
|
266 (*update_end_hook) (s);
|
|
267 updating_screen = 0;
|
|
268 return;
|
|
269 }
|
|
270 turn_off_insert ();
|
|
271 background_highlight ();
|
|
272 standout_requested = 0;
|
|
273 updating_screen = 0;
|
|
274 }
|
|
275
|
|
276 set_terminal_window (size)
|
|
277 int size;
|
|
278 {
|
|
279 if (! SCREEN_IS_TERMCAP (updating_screen))
|
|
280 {
|
|
281 (*set_terminal_window_hook) (size);
|
|
282 return;
|
|
283 }
|
|
284 specified_window = size ? size : SCREEN_HEIGHT (selected_screen);
|
|
285 if (!scroll_region_ok)
|
|
286 return;
|
|
287 set_scroll_region (0, specified_window);
|
|
288 }
|
|
289
|
|
290 set_scroll_region (start, stop)
|
|
291 int start, stop;
|
|
292 {
|
|
293 char *buf;
|
|
294 if (TS_set_scroll_region)
|
|
295 {
|
|
296 buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
|
|
297 }
|
|
298 else if (TS_set_scroll_region_1)
|
|
299 {
|
|
300 buf = tparam (TS_set_scroll_region_1, 0, 0,
|
|
301 SCREEN_HEIGHT (selected_screen), start,
|
|
302 SCREEN_HEIGHT (selected_screen) - stop,
|
|
303 SCREEN_HEIGHT (selected_screen));
|
|
304 }
|
|
305 else
|
|
306 {
|
|
307 buf = tparam (TS_set_window, 0, 0, start, 0, stop, SCREEN_WIDTH (selected_screen));
|
|
308 }
|
|
309 OUTPUT (buf);
|
|
310 free (buf);
|
|
311 losecursor ();
|
|
312 }
|
|
313
|
|
314 turn_on_insert ()
|
|
315 {
|
|
316 if (!insert_mode)
|
|
317 OUTPUT (TS_insert_mode);
|
|
318 insert_mode = 1;
|
|
319 }
|
|
320
|
|
321 turn_off_insert ()
|
|
322 {
|
|
323 if (insert_mode)
|
|
324 OUTPUT (TS_end_insert_mode);
|
|
325 insert_mode = 0;
|
|
326 }
|
|
327
|
|
328 /* Handle highlighting when TN_standout_width (termcap sg) is not specified.
|
|
329 In these terminals, output is affected by the value of standout
|
|
330 mode when the output is written.
|
|
331
|
|
332 These functions are called on all terminals, but do nothing
|
|
333 on terminals whose standout mode does not work that way. */
|
|
334
|
|
335 turn_off_highlight ()
|
|
336 {
|
|
337 if (TN_standout_width < 0)
|
|
338 {
|
|
339 if (standout_mode)
|
|
340 OUTPUT_IF (TS_end_standout_mode);
|
|
341 standout_mode = 0;
|
|
342 }
|
|
343 }
|
|
344
|
|
345 turn_on_highlight ()
|
|
346 {
|
|
347 if (TN_standout_width < 0)
|
|
348 {
|
|
349 if (!standout_mode)
|
|
350 OUTPUT_IF (TS_standout_mode);
|
|
351 standout_mode = 1;
|
|
352 }
|
|
353 }
|
|
354
|
|
355 /* Set standout mode to the state it should be in for
|
|
356 empty space inside windows. What this is,
|
|
357 depends on the user option inverse-video. */
|
|
358
|
|
359 background_highlight ()
|
|
360 {
|
|
361 if (TN_standout_width >= 0)
|
|
362 return;
|
|
363 if (inverse_video)
|
|
364 turn_on_highlight ();
|
|
365 else
|
|
366 turn_off_highlight ();
|
|
367 }
|
|
368
|
|
369 /* Set standout mode to the mode specified for the text to be output. */
|
|
370
|
|
371 static
|
|
372 highlight_if_desired ()
|
|
373 {
|
|
374 if (TN_standout_width >= 0)
|
|
375 return;
|
|
376 if (!inverse_video == !standout_requested)
|
|
377 turn_off_highlight ();
|
|
378 else
|
|
379 turn_on_highlight ();
|
|
380 }
|
|
381
|
|
382 /* Handle standout mode for terminals in which TN_standout_width >= 0.
|
|
383 On these terminals, standout is controlled by markers that
|
|
384 live inside the screen memory. TN_standout_width is the width
|
|
385 that the marker occupies in memory. Standout runs from the marker
|
|
386 to the end of the line on some terminals, or to the next
|
|
387 turn-off-standout marker (TS_end_standout_mode) string
|
|
388 on other terminals. */
|
|
389
|
|
390 /* Write a standout marker or end-standout marker at the front of the line
|
|
391 at vertical position vpos. */
|
|
392
|
|
393 write_standout_marker (flag, vpos)
|
|
394 int flag, vpos;
|
|
395 {
|
|
396 if (flag || (TS_end_standout_mode && !TF_teleray && !se_is_so
|
|
397 && !(TF_xs && TN_standout_width == 0)))
|
|
398 {
|
|
399 cmgoto (vpos, 0);
|
|
400 cmplus (TN_standout_width);
|
|
401 OUTPUT (flag ? TS_standout_mode : TS_end_standout_mode);
|
|
402 chars_wasted[curY] = TN_standout_width | 0100;
|
|
403 }
|
|
404 }
|
|
405
|
|
406 /* External interface to control of standout mode.
|
|
407 Call this when about to modify line at position VPOS
|
|
408 and not change whether it is highlighted. */
|
|
409
|
|
410 reassert_line_highlight (highlight, vpos)
|
|
411 int highlight;
|
|
412 int vpos;
|
|
413 {
|
|
414 if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
|
|
415 {
|
|
416 (*reassert_line_highlight_hook) (highlight, vpos);
|
|
417 return;
|
|
418 }
|
|
419 if (TN_standout_width < 0)
|
|
420 /* Handle terminals where standout takes affect at output time */
|
|
421 standout_requested = highlight;
|
|
422 else if (chars_wasted[vpos] == 0)
|
|
423 /* For terminals with standout markers, write one on this line
|
|
424 if there isn't one already. */
|
|
425 write_standout_marker (highlight, vpos);
|
|
426 }
|
|
427
|
|
428 /* Call this when about to modify line at position VPOS
|
|
429 and change whether it is highlighted. */
|
|
430
|
|
431 change_line_highlight (new_highlight, vpos, first_unused_hpos)
|
|
432 int new_highlight, vpos, first_unused_hpos;
|
|
433 {
|
|
434 standout_requested = new_highlight;
|
|
435 if (! SCREEN_IS_TERMCAP (updating_screen))
|
|
436 {
|
|
437 (*change_line_highlight_hook) (new_highlight, vpos, first_unused_hpos);
|
|
438 return;
|
|
439 }
|
|
440
|
|
441 cursor_to (vpos, 0);
|
|
442
|
|
443 if (TN_standout_width < 0)
|
|
444 background_highlight ();
|
|
445 /* If line starts with a marker, delete the marker */
|
|
446 else if (TS_clr_line && chars_wasted[curY])
|
|
447 {
|
|
448 turn_off_insert ();
|
|
449 /* On Teleray, make sure to erase the SO marker. */
|
|
450 if (TF_teleray)
|
|
451 {
|
|
452 cmgoto (curY - 1, SCREEN_WIDTH (selected_screen) - 4);
|
|
453 OUTPUT ("\033S");
|
|
454 curY++; /* ESC S moves to next line where the TS_standout_mode was */
|
|
455 curX = 0;
|
|
456 }
|
|
457 else
|
|
458 cmgoto (curY, 0); /* reposition to kill standout marker */
|
|
459 }
|
|
460 clear_end_of_line_raw (first_unused_hpos);
|
|
461 reassert_line_highlight (new_highlight, curY);
|
|
462 }
|
|
463
|
|
464
|
|
465 /* Move to absolute position, specified origin 0 */
|
|
466
|
|
467 cursor_to (row, col)
|
621
|
468 int row, col;
|
253
|
469 {
|
|
470 if (! SCREEN_IS_TERMCAP ((updating_screen
|
|
471 ? updating_screen
|
|
472 : selected_screen))
|
|
473 && cursor_to_hook)
|
|
474 {
|
|
475 (*cursor_to_hook) (row, col);
|
|
476 return;
|
|
477 }
|
|
478
|
|
479 col += chars_wasted[row] & 077;
|
|
480 if (curY == row && curX == col)
|
|
481 return;
|
|
482 if (!TF_standout_motion)
|
|
483 background_highlight ();
|
|
484 if (!TF_insmode_motion)
|
|
485 turn_off_insert ();
|
|
486 cmgoto (row, col);
|
|
487 }
|
|
488
|
|
489 /* Similar but don't take any account of the wasted characters. */
|
|
490
|
|
491 raw_cursor_to (row, col)
|
621
|
492 int row, col;
|
253
|
493 {
|
|
494 if (! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
|
|
495 {
|
|
496 (*raw_cursor_to_hook) (row, col);
|
|
497 return;
|
|
498 }
|
|
499 if (curY == row && curX == col)
|
|
500 return;
|
|
501 if (!TF_standout_motion)
|
|
502 background_highlight ();
|
|
503 if (!TF_insmode_motion)
|
|
504 turn_off_insert ();
|
|
505 cmgoto (row, col);
|
|
506 }
|
|
507
|
|
508 /* Erase operations */
|
|
509
|
|
510 /* clear from cursor to end of screen */
|
|
511 clear_to_end ()
|
|
512 {
|
|
513 register int i;
|
|
514
|
|
515 if (clear_to_end_hook && SCREEN_IS_TERMCAP (updating_screen))
|
|
516 {
|
|
517 (*clear_to_end_hook) ();
|
|
518 return;
|
|
519 }
|
|
520 if (TS_clr_to_bottom)
|
|
521 {
|
|
522 background_highlight ();
|
|
523 OUTPUT (TS_clr_to_bottom);
|
|
524 bzero (chars_wasted + curY, SCREEN_HEIGHT (selected_screen) - curY);
|
|
525 }
|
|
526 else
|
|
527 {
|
|
528 for (i = curY; i < SCREEN_HEIGHT (selected_screen); i++)
|
|
529 {
|
|
530 cursor_to (i, 0);
|
|
531 clear_end_of_line_raw (SCREEN_WIDTH (selected_screen));
|
|
532 }
|
|
533 }
|
|
534 }
|
|
535
|
|
536 /* Clear entire screen */
|
|
537
|
|
538 clear_screen ()
|
|
539 {
|
|
540 if (clear_screen_hook
|
|
541 && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
|
|
542 {
|
|
543 (*clear_screen_hook) ();
|
|
544 return;
|
|
545 }
|
|
546 if (TS_clr_screen)
|
|
547 {
|
|
548 background_highlight ();
|
|
549 OUTPUT (TS_clr_screen);
|
|
550 bzero (chars_wasted, SCREEN_HEIGHT (selected_screen));
|
|
551 cmat (0, 0);
|
|
552 }
|
|
553 else
|
|
554 {
|
|
555 cursor_to (0, 0);
|
|
556 clear_to_end ();
|
|
557 }
|
|
558 }
|
|
559
|
|
560 /* Clear to end of line, but do not clear any standout marker.
|
|
561 Assumes that the cursor is positioned at a character of real text,
|
|
562 which implies it cannot be before a standout marker
|
|
563 unless the marker has zero width.
|
|
564
|
|
565 Note that the cursor may be moved. */
|
|
566
|
|
567 clear_end_of_line (first_unused_hpos)
|
|
568 int first_unused_hpos;
|
|
569 {
|
|
570 static GLYPH buf[1] = {SPACEGLYPH};
|
|
571 if (SCREEN_IS_TERMCAP (selected_screen)
|
|
572 && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
|
|
573 write_glyphs (buf, 1);
|
|
574 clear_end_of_line_raw (first_unused_hpos);
|
|
575 }
|
|
576
|
|
577 /* Clear from cursor to end of line.
|
|
578 Assume that the line is already clear starting at column first_unused_hpos.
|
|
579 If the cursor is at a standout marker, erase the marker.
|
|
580
|
|
581 Note that the cursor may be moved, on terminals lacking a `ce' string. */
|
|
582
|
|
583 clear_end_of_line_raw (first_unused_hpos)
|
|
584 int first_unused_hpos;
|
|
585 {
|
|
586 register int i;
|
|
587
|
|
588 if (clear_end_of_line_hook
|
|
589 && ! SCREEN_IS_TERMCAP ((updating_screen
|
|
590 ? updating_screen
|
|
591 : selected_screen)))
|
|
592 {
|
|
593 (*clear_end_of_line_hook) (first_unused_hpos);
|
|
594 return;
|
|
595 }
|
|
596
|
|
597 first_unused_hpos += chars_wasted[curY] & 077;
|
|
598 if (curX >= first_unused_hpos)
|
|
599 return;
|
|
600 /* Notice if we are erasing a magic cookie */
|
|
601 if (curX == 0)
|
|
602 chars_wasted[curY] = 0;
|
|
603 background_highlight ();
|
|
604 if (TS_clr_line)
|
|
605 {
|
|
606 OUTPUT1 (TS_clr_line);
|
|
607 }
|
|
608 else
|
|
609 { /* have to do it the hard way */
|
|
610 turn_off_insert ();
|
|
611
|
|
612 /* Do not write in last row last col with Autowrap on. */
|
|
613 if (AutoWrap && curY == SCREEN_HEIGHT (selected_screen) - 1
|
|
614 && first_unused_hpos == SCREEN_WIDTH (selected_screen))
|
|
615 first_unused_hpos--;
|
|
616
|
|
617 for (i = curX; i < first_unused_hpos; i++)
|
|
618 {
|
|
619 if (termscript)
|
|
620 fputc (' ', termscript);
|
|
621 putchar (' ');
|
|
622 }
|
|
623 cmplus (first_unused_hpos - curX);
|
|
624 }
|
|
625 }
|
|
626
|
|
627
|
|
628 write_glyphs (string, len)
|
|
629 register GLYPH *string;
|
|
630 register int len;
|
|
631 {
|
|
632 register GLYPH g;
|
|
633 register int tlen = GLYPH_TABLE_LENGTH;
|
|
634 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
|
|
635
|
|
636 if (write_glyphs_hook
|
|
637 && ! SCREEN_IS_TERMCAP ((updating_screen ? updating_screen : selected_screen)))
|
|
638 {
|
|
639 (*write_glyphs_hook) (string, len);
|
|
640 return;
|
|
641 }
|
|
642
|
|
643 highlight_if_desired ();
|
|
644 turn_off_insert ();
|
|
645
|
|
646 /* Don't dare write in last column of bottom line, if AutoWrap,
|
|
647 since that would scroll the whole screen on some terminals. */
|
|
648
|
|
649 if (AutoWrap
|
|
650 && curY + 1 == SCREEN_HEIGHT (selected_screen)
|
|
651 && (curX + len - (chars_wasted[curY] & 077)
|
|
652 == SCREEN_WIDTH (selected_screen)))
|
|
653 len --;
|
|
654
|
|
655 cmplus (len);
|
|
656 while (--len >= 0)
|
|
657 {
|
|
658 g = *string++;
|
|
659 /* Check quickly for G beyond length of table.
|
|
660 That implies it isn't an alias and is simple. */
|
|
661 if (g >= tlen)
|
|
662 {
|
|
663 simple:
|
|
664 putc (g & 0xff, stdout);
|
|
665 if (ferror (stdout))
|
|
666 clearerr (stdout);
|
|
667 if (termscript)
|
|
668 putc (g & 0xff, termscript);
|
|
669 }
|
|
670 else
|
|
671 {
|
|
672 /* G has an entry in Vglyph_table,
|
|
673 so process any alias and then test for simpleness. */
|
|
674 while (GLYPH_ALIAS_P (tbase, tlen, g))
|
|
675 g = GLYPH_ALIAS (tbase, g);
|
|
676 if (GLYPH_SIMPLE_P (tbase, tlen, g))
|
|
677 goto simple;
|
|
678 else
|
|
679 {
|
|
680 /* Here if G (or its definition as an alias) is not simple. */
|
|
681 fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
|
|
682 stdout);
|
|
683 if (ferror (stdout))
|
|
684 clearerr (stdout);
|
|
685 if (termscript)
|
|
686 fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
|
|
687 termscript);
|
|
688 }
|
|
689 }
|
|
690 }
|
|
691 }
|
|
692
|
|
693 /* If start is zero, insert blanks instead of a string at start */
|
|
694
|
|
695 insert_glyphs (start, len)
|
|
696 register GLYPH *start;
|
|
697 register int len;
|
|
698 {
|
|
699 char *buf;
|
|
700 register GLYPH g;
|
|
701 register int tlen = GLYPH_TABLE_LENGTH;
|
|
702 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
|
|
703
|
|
704 if (insert_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
|
|
705 {
|
|
706 (*insert_glyphs_hook) (start, len);
|
|
707 return;
|
|
708 }
|
|
709 highlight_if_desired ();
|
|
710
|
|
711 if (TS_ins_multi_chars)
|
|
712 {
|
|
713 buf = tparam (TS_ins_multi_chars, 0, 0, len);
|
|
714 OUTPUT1 (buf);
|
|
715 free (buf);
|
|
716 if (start)
|
|
717 write_glyphs (start, len);
|
|
718 return;
|
|
719 }
|
|
720
|
|
721 turn_on_insert ();
|
|
722 cmplus (len);
|
|
723 while (--len >= 0)
|
|
724 {
|
|
725 OUTPUT1_IF (TS_ins_char);
|
|
726 if (!start)
|
|
727 g = SPACEGLYPH;
|
|
728 else
|
|
729 g = *start++;
|
|
730
|
|
731 if (GLYPH_SIMPLE_P (tbase, tlen, g))
|
|
732 {
|
|
733 putc (g & 0xff, stdout);
|
|
734 if (ferror (stdout))
|
|
735 clearerr (stdout);
|
|
736 if (termscript)
|
|
737 putc (g & 0xff, termscript);
|
|
738 }
|
|
739 else
|
|
740 {
|
|
741 fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g), stdout);
|
|
742 if (ferror (stdout))
|
|
743 clearerr (stdout);
|
|
744 if (termscript)
|
|
745 fwrite (GLYPH_STRING (tbase, g), 1, GLYPH_LENGTH (tbase, g),
|
|
746 termscript);
|
|
747 }
|
|
748
|
|
749 OUTPUT1_IF (TS_pad_inserted_char);
|
|
750 }
|
|
751 }
|
|
752
|
|
753 delete_glyphs (n)
|
|
754 register int n;
|
|
755 {
|
|
756 char *buf;
|
|
757 register int i;
|
|
758
|
|
759 if (delete_glyphs_hook && ! SCREEN_IS_TERMCAP (updating_screen))
|
|
760 {
|
|
761 (*delete_glyphs_hook) (n);
|
|
762 return;
|
|
763 }
|
|
764
|
|
765 if (delete_in_insert_mode)
|
|
766 {
|
|
767 turn_on_insert ();
|
|
768 }
|
|
769 else
|
|
770 {
|
|
771 turn_off_insert ();
|
|
772 OUTPUT_IF (TS_delete_mode);
|
|
773 }
|
|
774
|
|
775 if (TS_del_multi_chars)
|
|
776 {
|
|
777 buf = tparam (TS_del_multi_chars, 0, 0, n);
|
|
778 OUTPUT1 (buf);
|
|
779 free (buf);
|
|
780 }
|
|
781 else
|
|
782 for (i = 0; i < n; i++)
|
|
783 OUTPUT1 (TS_del_char);
|
|
784 if (!delete_in_insert_mode)
|
|
785 OUTPUT_IF (TS_end_delete_mode);
|
|
786 }
|
|
787
|
|
788 /* Insert N lines at vpos VPOS. If N is negative, delete -N lines. */
|
|
789
|
|
790 ins_del_lines (vpos, n)
|
|
791 int vpos, n;
|
|
792 {
|
|
793 char *multi = n > 0 ? TS_ins_multi_lines : TS_del_multi_lines;
|
|
794 char *single = n > 0 ? TS_ins_line : TS_del_line;
|
|
795 char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;
|
|
796
|
|
797 register int i = n > 0 ? n : -n;
|
|
798 register char *buf;
|
|
799
|
|
800 if (ins_del_lines_hook && ! SCREEN_IS_TERMCAP (updating_screen))
|
|
801 {
|
|
802 (*ins_del_lines_hook) (vpos, n);
|
|
803 return;
|
|
804 }
|
|
805
|
|
806 /* If the lines below the insertion are being pushed
|
|
807 into the end of the window, this is the same as clearing;
|
|
808 and we know the lines are already clear, since the matching
|
|
809 deletion has already been done. So can ignore this. */
|
|
810 /* If the lines below the deletion are blank lines coming
|
|
811 out of the end of the window, don't bother,
|
|
812 as there will be a matching inslines later that will flush them. */
|
|
813 if (scroll_region_ok && vpos + i >= specified_window)
|
|
814 return;
|
|
815 if (!memory_below_screen && vpos + i >= SCREEN_HEIGHT (selected_screen))
|
|
816 return;
|
|
817
|
|
818 if (multi)
|
|
819 {
|
|
820 raw_cursor_to (vpos, 0);
|
|
821 background_highlight ();
|
|
822 buf = tparam (multi, 0, 0, i);
|
|
823 OUTPUT (buf);
|
|
824 free (buf);
|
|
825 }
|
|
826 else if (single)
|
|
827 {
|
|
828 raw_cursor_to (vpos, 0);
|
|
829 background_highlight ();
|
|
830 while (--i >= 0)
|
|
831 OUTPUT (single);
|
|
832 if (TF_teleray)
|
|
833 curX = 0;
|
|
834 }
|
|
835 else
|
|
836 {
|
|
837 set_scroll_region (vpos, specified_window);
|
|
838 if (n < 0)
|
|
839 raw_cursor_to (specified_window - 1, 0);
|
|
840 else
|
|
841 raw_cursor_to (vpos, 0);
|
|
842 background_highlight ();
|
|
843 while (--i >= 0)
|
|
844 OUTPUTL (scroll, specified_window - vpos);
|
|
845 set_scroll_region (0, specified_window);
|
|
846 }
|
|
847
|
|
848 if (TN_standout_width >= 0)
|
|
849 {
|
|
850 register lower_limit
|
|
851 = (scroll_region_ok
|
|
852 ? specified_window
|
|
853 : SCREEN_HEIGHT (selected_screen));
|
|
854
|
|
855 if (n < 0)
|
|
856 {
|
|
857 bcopy (&chars_wasted[vpos - n], &chars_wasted[vpos],
|
|
858 lower_limit - vpos + n);
|
|
859 bzero (&chars_wasted[lower_limit + n], - n);
|
|
860 }
|
|
861 else
|
|
862 {
|
|
863 bcopy (&chars_wasted[vpos], ©buf[vpos], lower_limit - vpos - n);
|
|
864 bcopy (©buf[vpos], &chars_wasted[vpos + n],
|
|
865 lower_limit - vpos - n);
|
|
866 bzero (&chars_wasted[vpos], n);
|
|
867 }
|
|
868 }
|
|
869 if (!scroll_region_ok && memory_below_screen && n < 0)
|
|
870 {
|
|
871 cursor_to (SCREEN_HEIGHT (selected_screen) + n, 0);
|
|
872 clear_to_end ();
|
|
873 }
|
|
874 }
|
|
875
|
|
876 /* Compute cost of sending "str", in characters,
|
|
877 not counting any line-dependent padding. */
|
|
878
|
|
879 int
|
|
880 string_cost (str)
|
|
881 char *str;
|
|
882 {
|
|
883 cost = 0;
|
|
884 if (str)
|
|
885 tputs (str, 0, evalcost);
|
|
886 return cost;
|
|
887 }
|
|
888
|
|
889 /* Compute cost of sending "str", in characters,
|
|
890 counting any line-dependent padding at one line. */
|
|
891
|
|
892 static int
|
|
893 string_cost_one_line (str)
|
|
894 char *str;
|
|
895 {
|
|
896 cost = 0;
|
|
897 if (str)
|
|
898 tputs (str, 1, evalcost);
|
|
899 return cost;
|
|
900 }
|
|
901
|
|
902 /* Compute per line amount of line-dependent padding,
|
|
903 in tenths of characters. */
|
|
904
|
|
905 int
|
|
906 per_line_cost (str)
|
|
907 register char *str;
|
|
908 {
|
|
909 cost = 0;
|
|
910 if (str)
|
|
911 tputs (str, 0, evalcost);
|
|
912 cost = - cost;
|
|
913 if (str)
|
|
914 tputs (str, 10, evalcost);
|
|
915 return cost;
|
|
916 }
|
|
917
|
|
918 #ifndef old
|
|
919 /* char_ins_del_cost[n] is cost of inserting N characters.
|
|
920 char_ins_del_cost[-n] is cost of deleting N characters. */
|
|
921
|
|
922 int *char_ins_del_vector;
|
|
923
|
|
924 #define char_ins_del_cost(s) (&char_ins_del_vector[SCREEN_WIDTH ((s))])
|
|
925 #endif
|
|
926
|
|
927 /* ARGSUSED */
|
|
928 static void
|
|
929 calculate_ins_del_char_costs (screen)
|
|
930 SCREEN_PTR screen;
|
|
931 {
|
|
932 int ins_startup_cost, del_startup_cost;
|
|
933 int ins_cost_per_char, del_cost_per_char;
|
|
934 register int i;
|
|
935 register int *p;
|
|
936
|
|
937 if (TS_ins_multi_chars)
|
|
938 {
|
|
939 ins_cost_per_char = 0;
|
|
940 ins_startup_cost = string_cost_one_line (TS_ins_multi_chars);
|
|
941 }
|
|
942 else if (TS_ins_char || TS_pad_inserted_char
|
|
943 || (TS_insert_mode && TS_end_insert_mode))
|
|
944 {
|
|
945 ins_startup_cost = (30 * (string_cost (TS_insert_mode)
|
|
946 + string_cost (TS_end_insert_mode))) / 100;
|
|
947 ins_cost_per_char = (string_cost_one_line (TS_ins_char)
|
|
948 + string_cost_one_line (TS_pad_inserted_char));
|
|
949 }
|
|
950 else
|
|
951 {
|
|
952 ins_startup_cost = 9999;
|
|
953 ins_cost_per_char = 0;
|
|
954 }
|
|
955
|
|
956 if (TS_del_multi_chars)
|
|
957 {
|
|
958 del_cost_per_char = 0;
|
|
959 del_startup_cost = string_cost_one_line (TS_del_multi_chars);
|
|
960 }
|
|
961 else if (TS_del_char)
|
|
962 {
|
|
963 del_startup_cost = (string_cost (TS_delete_mode)
|
|
964 + string_cost (TS_end_delete_mode));
|
|
965 if (delete_in_insert_mode)
|
|
966 del_startup_cost /= 2;
|
|
967 del_cost_per_char = string_cost_one_line (TS_del_char);
|
|
968 }
|
|
969 else
|
|
970 {
|
|
971 del_startup_cost = 9999;
|
|
972 del_cost_per_char = 0;
|
|
973 }
|
|
974
|
|
975 /* Delete costs are at negative offsets */
|
|
976 p = &char_ins_del_cost (screen)[0];
|
|
977 for (i = SCREEN_WIDTH (selected_screen); --i >= 0;)
|
|
978 *--p = (del_startup_cost += del_cost_per_char);
|
|
979
|
|
980 /* Doing nothing is free */
|
|
981 p = &char_ins_del_cost (screen)[0];
|
|
982 *p++ = 0;
|
|
983
|
|
984 /* Insert costs are at positive offsets */
|
|
985 for (i = SCREEN_WIDTH (screen); --i >= 0;)
|
|
986 *p++ = (ins_startup_cost += ins_cost_per_char);
|
|
987 }
|
|
988
|
|
989 #ifdef HAVE_X_WINDOWS
|
|
990 extern int x_screen_planes;
|
|
991 #endif
|
|
992
|
|
993 calculate_costs (screen)
|
|
994 SCREEN_PTR screen;
|
|
995 {
|
|
996 register char *s = TS_set_scroll_region ?
|
|
997 TS_set_scroll_region
|
|
998 : TS_set_scroll_region_1;
|
|
999
|
|
1000 if (dont_calculate_costs)
|
|
1001 return;
|
|
1002
|
|
1003 #ifdef HAVE_X_WINDOWS
|
|
1004 if (SCREEN_IS_X (screen))
|
|
1005 {
|
|
1006 do_line_insertion_deletion_costs (screen, 0, ".5*", 0, ".5*",
|
|
1007 0, 0, x_screen_planes);
|
|
1008 return;
|
|
1009 }
|
|
1010 #endif
|
|
1011
|
|
1012 /* These variables are only used for terminal stuff. They are allocated
|
|
1013 once for the terminal screen of X-windows emacs, but not used afterwards.
|
|
1014
|
|
1015 char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
|
|
1016 X turns off char_ins_del_ok.
|
|
1017
|
|
1018 chars_wasted and copybuf are only used here in term.c in cases where
|
|
1019 the term hook isn't called. */
|
|
1020
|
|
1021 if (chars_wasted != 0)
|
|
1022 chars_wasted = (char *) xrealloc (chars_wasted, SCREEN_HEIGHT (screen));
|
|
1023 else
|
|
1024 chars_wasted = (char *) xmalloc (SCREEN_HEIGHT (screen));
|
|
1025
|
|
1026 if (copybuf != 0)
|
|
1027 copybuf = (char *) xrealloc (copybuf, SCREEN_HEIGHT (screen));
|
|
1028 else
|
|
1029 copybuf = (char *) xmalloc (SCREEN_HEIGHT (screen));
|
|
1030
|
|
1031 if (char_ins_del_vector != 0)
|
|
1032 char_ins_del_vector
|
|
1033 = (int *) xrealloc (char_ins_del_vector,
|
|
1034 (sizeof (int)
|
|
1035 + 2 * SCREEN_WIDTH (screen) * sizeof (int)));
|
|
1036 else
|
|
1037 char_ins_del_vector
|
|
1038 = (int *) xmalloc (sizeof (int)
|
|
1039 + 2 * SCREEN_WIDTH (screen) * sizeof (int));
|
|
1040
|
|
1041 bzero (chars_wasted, SCREEN_HEIGHT (screen));
|
|
1042 bzero (copybuf, SCREEN_HEIGHT (screen));
|
|
1043 bzero (char_ins_del_vector, (sizeof (int)
|
|
1044 + 2 * SCREEN_WIDTH (screen) * sizeof (int)));
|
|
1045
|
|
1046 if (s && (!TS_ins_line && !TS_del_line))
|
|
1047 do_line_insertion_deletion_costs (screen,
|
|
1048 TS_rev_scroll, TS_ins_multi_lines,
|
|
1049 TS_fwd_scroll, TS_del_multi_lines,
|
|
1050 s, s, 1);
|
|
1051 else
|
|
1052 do_line_insertion_deletion_costs (screen,
|
|
1053 TS_ins_line, TS_ins_multi_lines,
|
|
1054 TS_del_line, TS_del_multi_lines,
|
|
1055 0, 0, 1);
|
|
1056
|
|
1057 calculate_ins_del_char_costs (screen);
|
|
1058
|
|
1059 /* Don't use TS_repeat if its padding is worse than sending the chars */
|
|
1060 if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
|
|
1061 RPov = string_cost (TS_repeat);
|
|
1062 else
|
|
1063 RPov = SCREEN_WIDTH (screen) * 2;
|
|
1064
|
|
1065 cmcostinit (); /* set up cursor motion costs */
|
|
1066 }
|
|
1067
|
533
|
1068 /* Find the escape codes sent by the function keys for Vfunction_key_map.
|
|
1069 This function scans the termcap function key sequence entries, and
|
|
1070 adds entries to Vfunction_key_map for each function key it finds. */
|
|
1071
|
|
1072 void
|
|
1073 term_get_fkeys (address)
|
|
1074 char **address;
|
|
1075 {
|
|
1076 extern char *tgetstr ();
|
|
1077 struct fkey_table {
|
|
1078 char *cap, *name;
|
|
1079 };
|
|
1080 static struct fkey_table keys[] = {
|
|
1081 "kl", "left",
|
|
1082 "kr", "right",
|
|
1083 "ku", "up",
|
|
1084 "kd", "down",
|
|
1085 "kh", "home",
|
|
1086 "k1", "f1",
|
|
1087 "k2", "f2",
|
|
1088 "k3", "f3",
|
|
1089 "k4", "f4",
|
|
1090 "k5", "f5",
|
|
1091 "k6", "f6",
|
|
1092 "k7", "f7",
|
|
1093 "k8", "f8",
|
|
1094 "k9", "f9",
|
|
1095 "k0", "f10",
|
|
1096 "kH", "home-down",
|
|
1097 "ka", "clear-tabs",
|
|
1098 "kt", "clear-tab",
|
|
1099 "kT", "set-tab",
|
|
1100 "kC", "clear",
|
|
1101 "kL", "deleteline",
|
|
1102 "kM", "exit-insert",
|
|
1103 "kE", "clear-eol",
|
|
1104 "kS", "clear-eos",
|
|
1105 "kI", "insert",
|
|
1106 "kA", "insertline",
|
|
1107 "kN", "next",
|
|
1108 "kP", "prior",
|
|
1109 "kF", "scroll-forward",
|
|
1110 "kR", "scroll-reverse"
|
|
1111 };
|
|
1112 int i;
|
|
1113
|
|
1114 for (i = 0; i < (sizeof (keys)/sizeof (keys[0])); i++)
|
|
1115 {
|
|
1116 char *sequence = tgetstr (keys[i].cap, address);
|
|
1117 if (sequence)
|
|
1118 Fdefine_key (Vfunction_key_map,
|
|
1119 build_string (sequence),
|
|
1120 Fmake_vector (make_number (1), intern (keys[i].name)));
|
|
1121 }
|
|
1122 }
|
|
1123
|
|
1124
|
253
|
1125 term_init (terminal_type)
|
|
1126 char *terminal_type;
|
|
1127 {
|
|
1128 char *area;
|
|
1129 char **address = &area;
|
|
1130 char buffer[2044];
|
|
1131 register char *p;
|
|
1132 int status;
|
|
1133
|
|
1134 extern char *tgetstr ();
|
|
1135
|
|
1136 Wcm_clear ();
|
|
1137 dont_calculate_costs = 0;
|
|
1138
|
|
1139 status = tgetent (buffer, terminal_type);
|
|
1140 if (status < 0)
|
|
1141 fatal ("Cannot open termcap database file.\n");
|
|
1142 if (status == 0)
|
|
1143 fatal ("Terminal type %s is not defined.\n", terminal_type);
|
|
1144
|
|
1145 #ifdef TERMINFO
|
|
1146 area = (char *) malloc (2044);
|
|
1147 #else
|
|
1148 area = (char *) malloc (strlen (buffer));
|
|
1149 #endif /* not TERMINFO */
|
|
1150 if (area == 0)
|
|
1151 abort ();
|
|
1152
|
|
1153 TS_ins_line = tgetstr ("al", address);
|
|
1154 TS_ins_multi_lines = tgetstr ("AL", address);
|
|
1155 TS_bell = tgetstr ("bl", address);
|
|
1156 BackTab = tgetstr ("bt", address);
|
|
1157 TS_clr_to_bottom = tgetstr ("cd", address);
|
|
1158 TS_clr_line = tgetstr ("ce", address);
|
|
1159 TS_clr_screen = tgetstr ("cl", address);
|
|
1160 ColPosition = tgetstr ("ch", address);
|
|
1161 AbsPosition = tgetstr ("cm", address);
|
|
1162 CR = tgetstr ("cr", address);
|
|
1163 TS_set_scroll_region = tgetstr ("cs", address);
|
|
1164 TS_set_scroll_region_1 = tgetstr ("cS", address);
|
|
1165 RowPosition = tgetstr ("cv", address);
|
|
1166 TS_del_char = tgetstr ("dc", address);
|
|
1167 TS_del_multi_chars = tgetstr ("DC", address);
|
|
1168 TS_del_line = tgetstr ("dl", address);
|
|
1169 TS_del_multi_lines = tgetstr ("DL", address);
|
|
1170 TS_delete_mode = tgetstr ("dm", address);
|
|
1171 TS_end_delete_mode = tgetstr ("ed", address);
|
|
1172 TS_end_insert_mode = tgetstr ("ei", address);
|
|
1173 Home = tgetstr ("ho", address);
|
|
1174 TS_ins_char = tgetstr ("ic", address);
|
|
1175 TS_ins_multi_chars = tgetstr ("IC", address);
|
|
1176 TS_insert_mode = tgetstr ("im", address);
|
|
1177 TS_pad_inserted_char = tgetstr ("ip", address);
|
|
1178 TS_end_keypad_mode = tgetstr ("ke", address);
|
|
1179 TS_keypad_mode = tgetstr ("ks", address);
|
|
1180 LastLine = tgetstr ("ll", address);
|
|
1181 Right = tgetstr ("nd", address);
|
|
1182 Down = tgetstr ("do", address);
|
|
1183 if (!Down)
|
|
1184 Down = tgetstr ("nl", address); /* Obsolete name for "do" */
|
|
1185 #ifdef VMS
|
|
1186 /* VMS puts a carriage return before each linefeed,
|
|
1187 so it is not safe to use linefeeds. */
|
|
1188 if (Down && Down[0] == '\n' && Down[1] == '\0')
|
|
1189 Down = 0;
|
|
1190 #endif /* VMS */
|
|
1191 if (tgetflag ("bs"))
|
|
1192 Left = "\b"; /* can't possibly be longer! */
|
|
1193 else /* (Actually, "bs" is obsolete...) */
|
|
1194 Left = tgetstr ("le", address);
|
|
1195 if (!Left)
|
|
1196 Left = tgetstr ("bc", address); /* Obsolete name for "le" */
|
|
1197 TS_pad_char = tgetstr ("pc", address);
|
|
1198 TS_repeat = tgetstr ("rp", address);
|
|
1199 TS_end_standout_mode = tgetstr ("se", address);
|
|
1200 TS_fwd_scroll = tgetstr ("sf", address);
|
|
1201 TS_standout_mode = tgetstr ("so", address);
|
|
1202 TS_rev_scroll = tgetstr ("sr", address);
|
|
1203 Wcm.cm_tab = tgetstr ("ta", address);
|
|
1204 TS_end_termcap_modes = tgetstr ("te", address);
|
|
1205 TS_termcap_modes = tgetstr ("ti", address);
|
|
1206 Up = tgetstr ("up", address);
|
|
1207 TS_visible_bell = tgetstr ("vb", address);
|
|
1208 TS_end_visual_mode = tgetstr ("ve", address);
|
|
1209 TS_visual_mode = tgetstr ("vs", address);
|
|
1210 TS_set_window = tgetstr ("wi", address);
|
|
1211 MultiUp = tgetstr ("UP", address);
|
|
1212 MultiDown = tgetstr ("DO", address);
|
|
1213 MultiLeft = tgetstr ("LE", address);
|
|
1214 MultiRight = tgetstr ("RI", address);
|
|
1215
|
|
1216 AutoWrap = tgetflag ("am");
|
|
1217 memory_below_screen = tgetflag ("db");
|
|
1218 TF_hazeltine = tgetflag ("hz");
|
|
1219 must_write_spaces = tgetflag ("in");
|
|
1220 meta_key = tgetflag ("km") || tgetflag ("MT");
|
|
1221 TF_insmode_motion = tgetflag ("mi");
|
|
1222 TF_standout_motion = tgetflag ("ms");
|
|
1223 TF_underscore = tgetflag ("ul");
|
|
1224 MagicWrap = tgetflag ("xn");
|
|
1225 TF_xs = tgetflag ("xs");
|
|
1226 TF_teleray = tgetflag ("xt");
|
|
1227
|
533
|
1228 term_get_fkeys (address);
|
|
1229
|
253
|
1230 /* Get screen size from system, or else from termcap. */
|
|
1231 get_screen_size (&SCREEN_WIDTH (selected_screen),
|
|
1232 &SCREEN_HEIGHT (selected_screen));
|
|
1233 if (SCREEN_WIDTH (selected_screen) <= 0)
|
|
1234 SCREEN_WIDTH (selected_screen) = tgetnum ("co");
|
|
1235 if (SCREEN_HEIGHT (selected_screen) <= 0)
|
|
1236 SCREEN_HEIGHT (selected_screen) = tgetnum ("li");
|
|
1237
|
|
1238 min_padding_speed = tgetnum ("pb");
|
|
1239 TN_standout_width = tgetnum ("sg");
|
|
1240 TabWidth = tgetnum ("tw");
|
|
1241
|
|
1242 #ifdef VMS
|
|
1243 /* These capabilities commonly use ^J.
|
|
1244 I don't know why, but sending them on VMS does not work;
|
|
1245 it causes following spaces to be lost, sometimes.
|
|
1246 For now, the simplest fix is to avoid using these capabilities ever. */
|
|
1247 if (Down && Down[0] == '\n')
|
|
1248 Down = 0;
|
|
1249 #endif /* VMS */
|
|
1250
|
|
1251 if (!TS_bell)
|
|
1252 TS_bell = "\07";
|
|
1253
|
|
1254 if (!TS_fwd_scroll)
|
|
1255 TS_fwd_scroll = Down;
|
|
1256
|
|
1257 PC = TS_pad_char ? *TS_pad_char : 0;
|
|
1258
|
|
1259 if (TabWidth < 0)
|
|
1260 TabWidth = 8;
|
|
1261
|
|
1262 /* Turned off since /etc/termcap seems to have :ta= for most terminals
|
|
1263 and newer termcap doc does not seem to say there is a default.
|
|
1264 if (!Wcm.cm_tab)
|
|
1265 Wcm.cm_tab = "\t";
|
|
1266 */
|
|
1267
|
|
1268 if (TS_standout_mode == 0)
|
|
1269 {
|
|
1270 TN_standout_width = tgetnum ("ug");
|
|
1271 TS_end_standout_mode = tgetstr ("ue", address);
|
|
1272 TS_standout_mode = tgetstr ("us", address);
|
|
1273 }
|
|
1274
|
|
1275 if (TF_teleray)
|
|
1276 {
|
|
1277 Wcm.cm_tab = 0;
|
|
1278 /* Teleray: most programs want a space in front of TS_standout_mode,
|
|
1279 but Emacs can do without it (and give one extra column). */
|
|
1280 TS_standout_mode = "\033RD";
|
|
1281 TN_standout_width = 1;
|
|
1282 /* But that means we cannot rely on ^M to go to column zero! */
|
|
1283 CR = 0;
|
|
1284 /* LF can't be trusted either -- can alter hpos */
|
|
1285 /* if move at column 0 thru a line with TS_standout_mode */
|
|
1286 Down = 0;
|
|
1287 }
|
|
1288
|
|
1289 /* Special handling for certain terminal types known to need it */
|
|
1290
|
|
1291 if (!strcmp (terminal_type, "supdup"))
|
|
1292 {
|
|
1293 memory_below_screen = 1;
|
|
1294 Wcm.cm_losewrap = 1;
|
|
1295 }
|
|
1296 if (!strncmp (terminal_type, "c10", 3)
|
|
1297 || !strcmp (terminal_type, "perq"))
|
|
1298 {
|
|
1299 /* Supply a makeshift :wi string.
|
|
1300 This string is not valid in general since it works only
|
|
1301 for windows starting at the upper left corner;
|
|
1302 but that is all Emacs uses.
|
|
1303
|
|
1304 This string works only if the screen is using
|
|
1305 the top of the video memory, because addressing is memory-relative.
|
|
1306 So first check the :ti string to see if that is true.
|
|
1307
|
|
1308 It would be simpler if the :wi string could go in the termcap
|
|
1309 entry, but it can't because it is not fully valid.
|
|
1310 If it were in the termcap entry, it would confuse other programs. */
|
|
1311 if (!TS_set_window)
|
|
1312 {
|
|
1313 p = TS_termcap_modes;
|
|
1314 while (*p && strcmp (p, "\033v "))
|
|
1315 p++;
|
|
1316 if (*p)
|
|
1317 TS_set_window = "\033v%C %C %C %C ";
|
|
1318 }
|
|
1319 /* Termcap entry often fails to have :in: flag */
|
|
1320 must_write_spaces = 1;
|
|
1321 /* :ti string typically fails to have \E^G! in it */
|
|
1322 /* This limits scope of insert-char to one line. */
|
|
1323 strcpy (area, TS_termcap_modes);
|
|
1324 strcat (area, "\033\007!");
|
|
1325 TS_termcap_modes = area;
|
|
1326 area += strlen (area) + 1;
|
|
1327 p = AbsPosition;
|
|
1328 /* Change all %+ parameters to %C, to handle
|
|
1329 values above 96 correctly for the C100. */
|
|
1330 while (*p)
|
|
1331 {
|
|
1332 if (p[0] == '%' && p[1] == '+')
|
|
1333 p[1] = 'C';
|
|
1334 p++;
|
|
1335 }
|
|
1336 }
|
|
1337
|
|
1338 ScreenRows = SCREEN_HEIGHT (selected_screen);
|
|
1339 ScreenCols = SCREEN_WIDTH (selected_screen);
|
|
1340 specified_window = SCREEN_HEIGHT (selected_screen);
|
|
1341
|
|
1342 if (Wcm_init () == -1) /* can't do cursor motion */
|
|
1343 #ifdef VMS
|
|
1344 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
|
|
1345 It lacks the ability to position the cursor.\n\
|
|
1346 If that is not the actual type of terminal you have, use either the\n\
|
|
1347 DCL command `SET TERMINAL/DEVICE= ...' for DEC-compatible terminals,\n\
|
|
1348 or `define EMACS_TERM \"terminal type\"' for non-DEC terminals.\n",
|
|
1349 terminal_type);
|
|
1350 #else
|
|
1351 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
|
|
1352 It lacks the ability to position the cursor.\n\
|
|
1353 If that is not the actual type of terminal you have,\n\
|
|
1354 use the C-shell command `setenv TERM ...' to specify the correct type.\n\
|
|
1355 It may be necessary to do `unsetenv TERMCAP' as well.\n",
|
|
1356 terminal_type);
|
|
1357 #endif
|
|
1358 if (SCREEN_HEIGHT (selected_screen) <= 0
|
|
1359 || SCREEN_WIDTH (selected_screen) <= 0)
|
|
1360 fatal ("The screen size has not been specified.");
|
|
1361
|
|
1362 delete_in_insert_mode
|
|
1363 = TS_delete_mode && TS_insert_mode
|
|
1364 && !strcmp (TS_delete_mode, TS_insert_mode);
|
|
1365
|
|
1366 se_is_so = (TS_standout_mode
|
|
1367 && TS_end_standout_mode
|
|
1368 && !strcmp (TS_standout_mode, TS_end_standout_mode));
|
|
1369
|
|
1370 /* Remove width of standout marker from usable width of line */
|
|
1371 if (TN_standout_width > 0)
|
|
1372 SCREEN_WIDTH (selected_screen) -= TN_standout_width;
|
|
1373
|
|
1374 UseTabs = tabs_safe_p () && TabWidth == 8;
|
|
1375
|
|
1376 scroll_region_ok
|
|
1377 = (Wcm.cm_abs
|
|
1378 && (TS_set_window || TS_set_scroll_region || TS_set_scroll_region_1));
|
|
1379
|
|
1380 line_ins_del_ok = (((TS_ins_line || TS_ins_multi_lines)
|
|
1381 && (TS_del_line || TS_del_multi_lines))
|
|
1382 || (scroll_region_ok && TS_fwd_scroll && TS_rev_scroll));
|
|
1383
|
|
1384 char_ins_del_ok = ((TS_ins_char || TS_insert_mode
|
|
1385 || TS_pad_inserted_char || TS_ins_multi_chars)
|
|
1386 && (TS_del_char || TS_del_multi_chars));
|
|
1387
|
|
1388 fast_clear_end_of_line = TS_clr_line != 0;
|
|
1389
|
|
1390 init_baud_rate ();
|
|
1391 if (read_socket_hook) /* Baudrate is somewhat */
|
|
1392 /* meaningless in this case */
|
|
1393 baud_rate = 9600;
|
|
1394 }
|
|
1395
|
|
1396 /* VARARGS 1 */
|
|
1397 fatal (str, arg1, arg2)
|
621
|
1398 char *str, *arg1, *arg2;
|
253
|
1399 {
|
|
1400 fprintf (stderr, "emacs: ");
|
|
1401 fprintf (stderr, str, arg1, arg2);
|
|
1402 fflush (stderr);
|
|
1403 exit (1);
|
|
1404 }
|