*** empty log message ***
[emacs.git] / src / term.c
blob8e1443f45073ce9c7beb8472d5b13b61196e5ca5
1 /* terminal control module for terminals described by TERMCAP
2 Copyright (C) 1985, 86, 87, 93, 94, 95, 98
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* New redisplay, TTY faces by Gerd Moellmann <gerd@acm.org>. */
25 #include <config.h>
26 #include <stdio.h>
27 #include <ctype.h>
28 #include <string.h>
29 #include "termchar.h"
30 #include "termopts.h"
31 #include "lisp.h"
32 #include "charset.h"
33 #include "coding.h"
34 #include "keyboard.h"
35 #include "frame.h"
36 #include "disptab.h"
37 #include "termhooks.h"
38 #include "dispextern.h"
39 #include "window.h"
41 /* For now, don't try to include termcap.h. On some systems,
42 configure finds a non-standard termcap.h that the main build
43 won't find. */
45 #if defined HAVE_TERMCAP_H && 0
46 #include <termcap.h>
47 #else
48 extern void tputs P_ ((const char *, int, int (*)(int)));
49 extern int tgetent P_ ((char *, const char *));
50 extern int tgetflag P_ ((char *id));
51 extern int tgetnum P_ ((char *id));
52 #endif
54 #include "cm.h"
55 #ifdef HAVE_X_WINDOWS
56 #include "xterm.h"
57 #endif
58 #ifdef macintosh
59 #include "macterm.h"
60 #endif
62 static void turn_on_face P_ ((struct frame *, int face_id));
63 static void turn_off_face P_ ((struct frame *, int face_id));
64 static void tty_show_cursor P_ ((void));
65 static void tty_hide_cursor P_ ((void));
67 #define max(a, b) ((a) > (b) ? (a) : (b))
68 #define min(a, b) ((a) < (b) ? (a) : (b))
70 #define OUTPUT(a) \
71 tputs (a, (int) (FRAME_HEIGHT (XFRAME (selected_frame)) - curY), cmputc)
72 #define OUTPUT1(a) tputs (a, 1, cmputc)
73 #define OUTPUTL(a, lines) tputs (a, lines, cmputc)
75 #define OUTPUT_IF(a) \
76 do { \
77 if (a) \
78 tputs (a, (int) (FRAME_HEIGHT (XFRAME (selected_frame)) \
79 - curY), cmputc); \
80 } while (0)
82 #define OUTPUT1_IF(a) do { if (a) tputs (a, 1, cmputc); } while (0)
84 /* Function to use to ring the bell. */
86 Lisp_Object Vring_bell_function;
88 /* Terminal characteristics that higher levels want to look at.
89 These are all extern'd in termchar.h */
91 int must_write_spaces; /* Nonzero means spaces in the text
92 must actually be output; can't just skip
93 over some columns to leave them blank. */
94 int min_padding_speed; /* Speed below which no padding necessary */
96 int line_ins_del_ok; /* Terminal can insert and delete lines */
97 int char_ins_del_ok; /* Terminal can insert and delete chars */
98 int scroll_region_ok; /* Terminal supports setting the
99 scroll window */
100 int scroll_region_cost; /* Cost of setting a scroll window,
101 measured in characters */
102 int memory_below_frame; /* Terminal remembers lines
103 scrolled off bottom */
104 int fast_clear_end_of_line; /* Terminal has a `ce' string */
106 /* Nonzero means no need to redraw the entire frame on resuming
107 a suspended Emacs. This is useful on terminals with multiple pages,
108 where one page is used for Emacs and another for all else. */
110 int no_redraw_on_reenter;
112 /* Hook functions that you can set to snap out the functions in this file.
113 These are all extern'd in termhooks.h */
115 void (*cursor_to_hook) P_ ((int, int));
116 void (*raw_cursor_to_hook) P_ ((int, int));
117 void (*clear_to_end_hook) P_ ((void));
118 void (*clear_frame_hook) P_ ((void));
119 void (*clear_end_of_line_hook) P_ ((int));
121 void (*ins_del_lines_hook) P_ ((int, int));
123 void (*change_line_highlight_hook) P_ ((int, int, int, int));
124 void (*reassert_line_highlight_hook) P_ ((int, int));
126 void (*delete_glyphs_hook) P_ ((int));
128 void (*ring_bell_hook) P_ ((void));
130 void (*reset_terminal_modes_hook) P_ ((void));
131 void (*set_terminal_modes_hook) P_ ((void));
132 void (*update_begin_hook) P_ ((struct frame *));
133 void (*update_end_hook) P_ ((struct frame *));
134 void (*set_terminal_window_hook) P_ ((int));
135 void (*insert_glyphs_hook) P_ ((struct glyph *, int));
136 void (*write_glyphs_hook) P_ ((struct glyph *, int));
137 void (*delete_glyphs_hook) P_ ((int));
139 int (*read_socket_hook) P_ ((int, struct input_event *, int, int));
141 void (*frame_up_to_date_hook) P_ ((struct frame *));
143 /* Return the current position of the mouse.
145 Set *f to the frame the mouse is in, or zero if the mouse is in no
146 Emacs frame. If it is set to zero, all the other arguments are
147 garbage.
149 If the motion started in a scroll bar, set *bar_window to the
150 scroll bar's window, *part to the part the mouse is currently over,
151 *x to the position of the mouse along the scroll bar, and *y to the
152 overall length of the scroll bar.
154 Otherwise, set *bar_window to Qnil, and *x and *y to the column and
155 row of the character cell the mouse is over.
157 Set *time to the time the mouse was at the returned position.
159 This should clear mouse_moved until the next motion
160 event arrives. */
161 void (*mouse_position_hook) P_ ((FRAME_PTR *f, int insist,
162 Lisp_Object *bar_window,
163 enum scroll_bar_part *part,
164 Lisp_Object *x,
165 Lisp_Object *y,
166 unsigned long *time));
168 /* When reading from a minibuffer in a different frame, Emacs wants
169 to shift the highlight from the selected frame to the mini-buffer's
170 frame; under X, this means it lies about where the focus is.
171 This hook tells the window system code to re-decide where to put
172 the highlight. */
173 void (*frame_rehighlight_hook) P_ ((FRAME_PTR f));
175 /* If we're displaying frames using a window system that can stack
176 frames on top of each other, this hook allows you to bring a frame
177 to the front, or bury it behind all the other windows. If this
178 hook is zero, that means the device we're displaying on doesn't
179 support overlapping frames, so there's no need to raise or lower
180 anything.
182 If RAISE is non-zero, F is brought to the front, before all other
183 windows. If RAISE is zero, F is sent to the back, behind all other
184 windows. */
185 void (*frame_raise_lower_hook) P_ ((FRAME_PTR f, int raise));
187 /* Set the vertical scroll bar for WINDOW to have its upper left corner
188 at (TOP, LEFT), and be LENGTH rows high. Set its handle to
189 indicate that we are displaying PORTION characters out of a total
190 of WHOLE characters, starting at POSITION. If WINDOW doesn't yet
191 have a scroll bar, create one for it. */
193 void (*set_vertical_scroll_bar_hook)
194 P_ ((struct window *window,
195 int portion, int whole, int position));
198 /* The following three hooks are used when we're doing a thorough
199 redisplay of the frame. We don't explicitly know which scroll bars
200 are going to be deleted, because keeping track of when windows go
201 away is a real pain - can you say set-window-configuration?
202 Instead, we just assert at the beginning of redisplay that *all*
203 scroll bars are to be removed, and then save scroll bars from the
204 fiery pit when we actually redisplay their window. */
206 /* Arrange for all scroll bars on FRAME to be removed at the next call
207 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
208 `*redeem_scroll_bar_hook' is applied to its window before the judgment.
210 This should be applied to each frame each time its window tree is
211 redisplayed, even if it is not displaying scroll bars at the moment;
212 if the HAS_SCROLL_BARS flag has just been turned off, only calling
213 this and the judge_scroll_bars_hook will get rid of them.
215 If non-zero, this hook should be safe to apply to any frame,
216 whether or not it can support scroll bars, and whether or not it is
217 currently displaying them. */
218 void (*condemn_scroll_bars_hook) P_ ((FRAME_PTR frame));
220 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
221 Note that it's okay to redeem a scroll bar that is not condemned. */
222 void (*redeem_scroll_bar_hook) P_ ((struct window *window));
224 /* Remove all scroll bars on FRAME that haven't been saved since the
225 last call to `*condemn_scroll_bars_hook'.
227 This should be applied to each frame after each time its window
228 tree is redisplayed, even if it is not displaying scroll bars at the
229 moment; if the HAS_SCROLL_BARS flag has just been turned off, only
230 calling this and condemn_scroll_bars_hook will get rid of them.
232 If non-zero, this hook should be safe to apply to any frame,
233 whether or not it can support scroll bars, and whether or not it is
234 currently displaying them. */
235 void (*judge_scroll_bars_hook) P_ ((FRAME_PTR FRAME));
237 /* Hook to call in estimate_mode_line_height, if any. */
239 int (* estimate_mode_line_height_hook) P_ ((struct frame *f, enum face_id));
242 /* Strings, numbers and flags taken from the termcap entry. */
244 char *TS_ins_line; /* "al" */
245 char *TS_ins_multi_lines; /* "AL" (one parameter, # lines to insert) */
246 char *TS_bell; /* "bl" */
247 char *TS_clr_to_bottom; /* "cd" */
248 char *TS_clr_line; /* "ce", clear to end of line */
249 char *TS_clr_frame; /* "cl" */
250 char *TS_set_scroll_region; /* "cs" (2 params, first line and last line) */
251 char *TS_set_scroll_region_1; /* "cS" (4 params: total lines,
252 lines above scroll region, lines below it,
253 total lines again) */
254 char *TS_del_char; /* "dc" */
255 char *TS_del_multi_chars; /* "DC" (one parameter, # chars to delete) */
256 char *TS_del_line; /* "dl" */
257 char *TS_del_multi_lines; /* "DL" (one parameter, # lines to delete) */
258 char *TS_delete_mode; /* "dm", enter character-delete mode */
259 char *TS_end_delete_mode; /* "ed", leave character-delete mode */
260 char *TS_end_insert_mode; /* "ei", leave character-insert mode */
261 char *TS_ins_char; /* "ic" */
262 char *TS_ins_multi_chars; /* "IC" (one parameter, # chars to insert) */
263 char *TS_insert_mode; /* "im", enter character-insert mode */
264 char *TS_pad_inserted_char; /* "ip". Just padding, no commands. */
265 char *TS_end_keypad_mode; /* "ke" */
266 char *TS_keypad_mode; /* "ks" */
267 char *TS_pad_char; /* "pc", char to use as padding */
268 char *TS_repeat; /* "rp" (2 params, # times to repeat
269 and character to be repeated) */
270 char *TS_end_standout_mode; /* "se" */
271 char *TS_fwd_scroll; /* "sf" */
272 char *TS_standout_mode; /* "so" */
273 char *TS_rev_scroll; /* "sr" */
274 char *TS_end_termcap_modes; /* "te" */
275 char *TS_termcap_modes; /* "ti" */
276 char *TS_visible_bell; /* "vb" */
277 char *TS_cursor_normal; /* "ve" */
278 char *TS_cursor_visible; /* "vs" */
279 char *TS_cursor_invisible; /* "vi" */
280 char *TS_set_window; /* "wi" (4 params, start and end of window,
281 each as vpos and hpos) */
283 /* Value of the "NC" (no_color_video) capability, or 0 if not
284 present. */
286 static int TN_no_color_video;
288 /* Meaning of bits in no_color_video. Each bit set means that the
289 corresponding attribute cannot be combined with colors. */
291 enum no_color_bit
293 NC_STANDOUT = 1 << 0,
294 NC_UNDERLINE = 1 << 1,
295 NC_REVERSE = 1 << 2,
296 NC_BLINK = 1 << 3,
297 NC_DIM = 1 << 4,
298 NC_BOLD = 1 << 5,
299 NC_INVIS = 1 << 6,
300 NC_PROTECT = 1 << 7,
301 NC_ALT_CHARSET = 1 << 8
304 /* "md" -- turn on bold (extra bright mode). */
306 char *TS_enter_bold_mode;
308 /* "mh" -- turn on half-bright mode. */
310 char *TS_enter_dim_mode;
312 /* "mb" -- enter blinking mode. */
314 char *TS_enter_blink_mode;
316 /* "mr" -- enter reverse video mode. */
318 char *TS_enter_reverse_mode;
320 /* "us"/"ue" -- start/end underlining. */
322 char *TS_exit_underline_mode, *TS_enter_underline_mode;
324 /* "ug" -- number of blanks left by underline. */
326 int TN_magic_cookie_glitch_ul;
328 /* "as"/"ae" -- start/end alternate character set. Not really
329 supported, yet. */
331 char *TS_enter_alt_charset_mode, *TS_exit_alt_charset_mode;
333 /* "me" -- switch appearances off. */
335 char *TS_exit_attribute_mode;
337 /* "Co" -- number of colors. */
339 int TN_max_colors;
341 /* "pa" -- max. number of color pairs on screen. Not handled yet.
342 Could be a problem if not equal to TN_max_colors * TN_max_colors. */
344 int TN_max_pairs;
346 /* "op" -- SVr4 set default pair to its original value. */
348 char *TS_orig_pair;
350 /* "AF"/"AB" or "Sf"/"Sb"-- set ANSI or SVr4 foreground/background color.
351 1 param, the color index. */
353 char *TS_set_foreground, *TS_set_background;
355 int TF_hazeltine; /* termcap hz flag. */
356 int TF_insmode_motion; /* termcap mi flag: can move while in insert mode. */
357 int TF_standout_motion; /* termcap mi flag: can move while in standout mode. */
358 int TF_underscore; /* termcap ul flag: _ underlines if over-struck on
359 non-blank position. Must clear before writing _. */
360 int TF_teleray; /* termcap xt flag: many weird consequences.
361 For t1061. */
363 int TF_xs; /* Nonzero for "xs". If set together with
364 TN_standout_width == 0, it means don't bother
365 to write any end-standout cookies. */
367 int TN_standout_width; /* termcap sg number: width occupied by standout
368 markers */
370 static int RPov; /* # chars to start a TS_repeat */
372 static int delete_in_insert_mode; /* delete mode == insert mode */
374 static int se_is_so; /* 1 if same string both enters and leaves
375 standout mode */
377 /* internal state */
379 /* The largest frame width in any call to calculate_costs. */
381 int max_frame_width;
383 /* The largest frame height in any call to calculate_costs. */
385 int max_frame_height;
387 /* Number of chars of space used for standout marker at beginning of line,
388 or'd with 0100. Zero if no standout marker at all.
389 The length of these vectors is max_frame_height.
391 Used IFF TN_standout_width >= 0. */
393 static char *chars_wasted;
394 static char *copybuf;
396 /* nonzero means supposed to write text in standout mode. */
398 int standout_requested;
400 int insert_mode; /* Nonzero when in insert mode. */
401 int standout_mode; /* Nonzero when in standout mode. */
403 /* Size of window specified by higher levels.
404 This is the number of lines, from the top of frame downwards,
405 which can participate in insert-line/delete-line operations.
407 Effectively it excludes the bottom frame_height - specified_window_size
408 lines from those operations. */
410 int specified_window;
412 /* Frame currently being redisplayed; 0 if not currently redisplaying.
413 (Direct output does not count). */
415 FRAME_PTR updating_frame;
417 /* Provided for lisp packages. */
419 static int system_uses_terminfo;
421 char *tparam ();
423 extern char *tgetstr ();
426 #ifdef WINDOWSNT
428 /* We aren't X windows, but we aren't termcap either. This makes me
429 uncertain as to what value to use for frame.output_method. For
430 this file, we'll define FRAME_TERMCAP_P to be zero so that our
431 output hooks get called instead of the termcap functions. Probably
432 the best long-term solution is to define an output_windows_nt... */
434 #undef FRAME_TERMCAP_P
435 #define FRAME_TERMCAP_P(_f_) 0
436 #endif /* WINDOWSNT */
438 void
439 ring_bell ()
441 if (! NILP (Vring_bell_function))
443 Lisp_Object function;
445 /* Temporarily set the global variable to nil
446 so that if we get an error, it stays nil
447 and we don't call it over and over.
449 We don't specbind it, because that would carefully
450 restore the bad value if there's an error
451 and make the loop of errors happen anyway. */
452 function = Vring_bell_function;
453 Vring_bell_function = Qnil;
455 call0 (function);
457 Vring_bell_function = function;
458 return;
461 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
463 (*ring_bell_hook) ();
464 return;
466 OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
469 void
470 set_terminal_modes ()
472 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
474 (*set_terminal_modes_hook) ();
475 return;
477 OUTPUT_IF (TS_termcap_modes);
478 OUTPUT_IF (TS_cursor_visible);
479 OUTPUT_IF (TS_keypad_mode);
480 losecursor ();
483 void
484 reset_terminal_modes ()
486 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
488 if (reset_terminal_modes_hook)
489 (*reset_terminal_modes_hook) ();
490 return;
492 if (TN_standout_width < 0)
493 turn_off_highlight ();
494 turn_off_insert ();
495 OUTPUT_IF (TS_end_keypad_mode);
496 OUTPUT_IF (TS_cursor_normal);
497 OUTPUT_IF (TS_end_termcap_modes);
498 OUTPUT_IF (TS_orig_pair);
499 /* Output raw CR so kernel can track the cursor hpos. */
500 /* But on magic-cookie terminals this can erase an end-standout marker and
501 cause the rest of the frame to be in standout, so move down first. */
502 if (TN_standout_width >= 0)
503 cmputc ('\n');
504 cmputc ('\r');
507 void
508 update_begin (f)
509 FRAME_PTR f;
511 updating_frame = f;
512 if (! FRAME_TERMCAP_P (updating_frame))
513 (*update_begin_hook) (f);
514 else
515 tty_hide_cursor ();
518 void
519 update_end (f)
520 FRAME_PTR f;
522 if (! FRAME_TERMCAP_P (updating_frame))
524 (*update_end_hook) (f);
525 updating_frame = 0;
526 return;
529 if (!XWINDOW (selected_window)->cursor_off_p)
530 tty_show_cursor ();
532 turn_off_insert ();
533 background_highlight ();
534 standout_requested = 0;
535 updating_frame = 0;
538 void
539 set_terminal_window (size)
540 int size;
542 if (! FRAME_TERMCAP_P (updating_frame))
544 (*set_terminal_window_hook) (size);
545 return;
547 specified_window = size ? size : FRAME_HEIGHT (XFRAME (selected_frame));
548 if (!scroll_region_ok)
549 return;
550 set_scroll_region (0, specified_window);
553 void
554 set_scroll_region (start, stop)
555 int start, stop;
557 char *buf;
558 struct frame *sf = XFRAME (selected_frame);
560 if (TS_set_scroll_region)
562 buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
564 else if (TS_set_scroll_region_1)
566 buf = tparam (TS_set_scroll_region_1, 0, 0,
567 FRAME_HEIGHT (sf), start,
568 FRAME_HEIGHT (sf) - stop,
569 FRAME_HEIGHT (sf));
571 else
573 buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_WIDTH (sf));
575 OUTPUT (buf);
576 xfree (buf);
577 losecursor ();
580 void
581 turn_on_insert ()
583 if (!insert_mode)
584 OUTPUT (TS_insert_mode);
585 insert_mode = 1;
588 void
589 turn_off_insert ()
591 if (insert_mode)
592 OUTPUT (TS_end_insert_mode);
593 insert_mode = 0;
596 /* Handle highlighting when TN_standout_width (termcap sg) is not specified.
597 In these terminals, output is affected by the value of standout
598 mode when the output is written.
600 These functions are called on all terminals, but do nothing
601 on terminals whose standout mode does not work that way. */
603 void
604 turn_off_highlight ()
606 if (TN_standout_width < 0)
608 if (standout_mode)
609 OUTPUT_IF (TS_end_standout_mode);
610 standout_mode = 0;
614 void
615 turn_on_highlight ()
617 if (TN_standout_width < 0)
619 if (!standout_mode)
620 OUTPUT_IF (TS_standout_mode);
621 standout_mode = 1;
626 /* Make cursor invisible. */
628 static void
629 tty_hide_cursor ()
631 OUTPUT_IF (TS_cursor_invisible);
635 /* Ensure that cursor is visible. */
637 static void
638 tty_show_cursor ()
640 OUTPUT_IF (TS_cursor_normal);
641 OUTPUT_IF (TS_cursor_visible);
645 /* Set standout mode to the state it should be in for
646 empty space inside windows. What this is,
647 depends on the user option inverse-video. */
649 void
650 background_highlight ()
652 if (TN_standout_width >= 0)
653 return;
654 if (inverse_video)
655 turn_on_highlight ();
656 else
657 turn_off_highlight ();
660 /* Set standout mode to the mode specified for the text to be output. */
662 static void
663 highlight_if_desired ()
665 if (TN_standout_width >= 0)
666 return;
667 if (!inverse_video == !standout_requested)
668 turn_off_highlight ();
669 else
670 turn_on_highlight ();
673 /* Handle standout mode for terminals in which TN_standout_width >= 0.
674 On these terminals, standout is controlled by markers that
675 live inside the terminal's memory. TN_standout_width is the width
676 that the marker occupies in memory. Standout runs from the marker
677 to the end of the line on some terminals, or to the next
678 turn-off-standout marker (TS_end_standout_mode) string
679 on other terminals. */
681 /* Write a standout marker or end-standout marker at the front of the line
682 at vertical position vpos. */
684 void
685 write_standout_marker (flag, vpos)
686 int flag, vpos;
688 if (flag || (TS_end_standout_mode && !TF_teleray && !se_is_so
689 && !(TF_xs && TN_standout_width == 0)))
691 cmgoto (vpos, 0);
692 cmplus (TN_standout_width);
693 OUTPUT (flag ? TS_standout_mode : TS_end_standout_mode);
694 chars_wasted[curY] = TN_standout_width | 0100;
698 /* External interface to control of standout mode.
699 Call this when about to modify line at position VPOS
700 and not change whether it is highlighted. */
702 void
703 reassert_line_highlight (highlight, vpos)
704 int highlight;
705 int vpos;
707 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
708 if (! FRAME_TERMCAP_P (f))
710 (*reassert_line_highlight_hook) (highlight, vpos);
711 return;
713 if (TN_standout_width < 0)
714 /* Handle terminals where standout takes affect at output time */
715 standout_requested = highlight;
716 else if (chars_wasted && chars_wasted[vpos] == 0)
717 /* For terminals with standout markers, write one on this line
718 if there isn't one already. */
719 write_standout_marker (inverse_video ? !highlight : highlight, vpos);
722 /* Call this when about to modify line at position VPOS
723 and change whether it is highlighted. */
725 void
726 change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
727 int new_highlight, vpos, y, first_unused_hpos;
729 standout_requested = new_highlight;
730 if (! FRAME_TERMCAP_P (updating_frame))
732 (*change_line_highlight_hook) (new_highlight, vpos, y, first_unused_hpos);
733 return;
736 cursor_to (vpos, 0);
738 if (TN_standout_width < 0)
739 background_highlight ();
740 /* If line starts with a marker, delete the marker */
741 else if (TS_clr_line && chars_wasted[curY])
743 turn_off_insert ();
744 /* On Teleray, make sure to erase the SO marker. */
745 if (TF_teleray)
747 cmgoto (curY - 1, FRAME_WIDTH (XFRAME (selected_frame)) - 4);
748 OUTPUT ("\033S");
749 curY++; /* ESC S moves to next line where the TS_standout_mode was */
750 curX = 0;
752 else
753 cmgoto (curY, 0); /* reposition to kill standout marker */
755 clear_end_of_line_raw (first_unused_hpos);
756 reassert_line_highlight (new_highlight, curY);
760 /* Move cursor to row/column position VPOS/HPOS. HPOS/VPOS are
761 frame-relative coordinates. */
763 void
764 cursor_to (vpos, hpos)
765 int vpos, hpos;
767 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
769 if (! FRAME_TERMCAP_P (f) && cursor_to_hook)
771 (*cursor_to_hook) (vpos, hpos);
772 return;
775 /* Detect the case where we are called from reset_sys_modes
776 and the costs have never been calculated. Do nothing. */
777 if (chars_wasted == 0)
778 return;
780 hpos += chars_wasted[vpos] & 077;
781 if (curY == vpos && curX == hpos)
782 return;
783 if (!TF_standout_motion)
784 background_highlight ();
785 if (!TF_insmode_motion)
786 turn_off_insert ();
787 cmgoto (vpos, hpos);
790 /* Similar but don't take any account of the wasted characters. */
792 void
793 raw_cursor_to (row, col)
794 int row, col;
796 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
797 if (! FRAME_TERMCAP_P (f))
799 (*raw_cursor_to_hook) (row, col);
800 return;
802 if (curY == row && curX == col)
803 return;
804 if (!TF_standout_motion)
805 background_highlight ();
806 if (!TF_insmode_motion)
807 turn_off_insert ();
808 cmgoto (row, col);
811 /* Erase operations */
813 /* clear from cursor to end of frame */
814 void
815 clear_to_end ()
817 register int i;
819 if (clear_to_end_hook && ! FRAME_TERMCAP_P (updating_frame))
821 (*clear_to_end_hook) ();
822 return;
824 if (TS_clr_to_bottom)
826 background_highlight ();
827 OUTPUT (TS_clr_to_bottom);
828 bzero (chars_wasted + curY,
829 FRAME_HEIGHT (XFRAME (selected_frame)) - curY);
831 else
833 for (i = curY; i < FRAME_HEIGHT (XFRAME (selected_frame)); i++)
835 cursor_to (i, 0);
836 clear_end_of_line_raw (FRAME_WIDTH (XFRAME (selected_frame)));
841 /* Clear entire frame */
843 void
844 clear_frame ()
846 struct frame *sf = XFRAME (selected_frame);
848 if (clear_frame_hook
849 && ! FRAME_TERMCAP_P ((updating_frame ? updating_frame : sf)))
851 (*clear_frame_hook) ();
852 return;
854 if (TS_clr_frame)
856 background_highlight ();
857 OUTPUT (TS_clr_frame);
858 bzero (chars_wasted, FRAME_HEIGHT (sf));
859 cmat (0, 0);
861 else
863 cursor_to (0, 0);
864 clear_to_end ();
868 /* Clear to end of line, but do not clear any standout marker.
869 Assumes that the cursor is positioned at a character of real text,
870 which implies it cannot be before a standout marker
871 unless the marker has zero width.
873 Note that the cursor may be moved. */
875 void
876 clear_end_of_line (first_unused_hpos)
877 int first_unused_hpos;
879 if (FRAME_TERMCAP_P (XFRAME (selected_frame))
880 && chars_wasted != 0
881 && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
882 write_glyphs (&space_glyph, 1);
883 clear_end_of_line_raw (first_unused_hpos);
886 /* Clear from cursor to end of line.
887 Assume that the line is already clear starting at column first_unused_hpos.
888 If the cursor is at a standout marker, erase the marker.
890 Note that the cursor may be moved, on terminals lacking a `ce' string. */
892 void
893 clear_end_of_line_raw (first_unused_hpos)
894 int first_unused_hpos;
896 register int i;
898 if (clear_end_of_line_hook
899 && ! FRAME_TERMCAP_P ((updating_frame
900 ? updating_frame
901 : XFRAME (selected_frame))))
903 (*clear_end_of_line_hook) (first_unused_hpos);
904 return;
907 /* Detect the case where we are called from reset_sys_modes
908 and the costs have never been calculated. Do nothing. */
909 if (chars_wasted == 0)
910 return;
912 first_unused_hpos += chars_wasted[curY] & 077;
913 if (curX >= first_unused_hpos)
914 return;
915 /* Notice if we are erasing a magic cookie */
916 if (curX == 0)
917 chars_wasted[curY] = 0;
918 background_highlight ();
919 if (TS_clr_line)
921 OUTPUT1 (TS_clr_line);
923 else
924 { /* have to do it the hard way */
925 struct frame *sf = XFRAME (selected_frame);
926 turn_off_insert ();
928 /* Do not write in last row last col with Auto-wrap on. */
929 if (AutoWrap && curY == FRAME_HEIGHT (sf) - 1
930 && first_unused_hpos == FRAME_WIDTH (sf))
931 first_unused_hpos--;
933 for (i = curX; i < first_unused_hpos; i++)
935 if (termscript)
936 fputc (' ', termscript);
937 putchar (' ');
939 cmplus (first_unused_hpos - curX);
943 /* Encode SRC_LEN glyphs starting at SRC to terminal output codes and
944 store them at DST. Do not write more than DST_LEN bytes. That may
945 require stopping before all SRC_LEN input glyphs have been
946 converted.
948 We store the number of glyphs actually converted in *CONSUMED. The
949 return value is the number of bytes store in DST. */
952 encode_terminal_code (src, dst, src_len, dst_len, consumed)
953 struct glyph *src;
954 int src_len;
955 unsigned char *dst;
956 int dst_len, *consumed;
958 struct glyph *src_start = src, *src_end = src + src_len;
959 unsigned char *dst_start = dst, *dst_end = dst + dst_len;
960 register GLYPH g;
961 unsigned int c;
962 unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *buf;
963 int len;
964 register int tlen = GLYPH_TABLE_LENGTH;
965 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
966 int result;
967 struct coding_system *coding;
969 /* If terminal_coding does any conversion, use it, otherwise use
970 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
971 because it always return 1 if the member src_multibyte is 1. */
972 coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
973 ? &terminal_coding
974 : &safe_terminal_coding);
976 while (src < src_end)
978 /* We must skip glyphs to be padded for a wide character. */
979 if (! CHAR_GLYPH_PADDING_P (*src))
981 g = GLYPH_FROM_CHAR_GLYPH (src[0]);
983 if (g < 0 || g >= tlen)
985 /* This glyph doesn't has an entry in Vglyph_table. */
986 if (! CHAR_VALID_P (src->u.ch, 0))
988 len = 1;
989 buf = " ";
990 coding->src_multibyte = 0;
992 else
994 len = CHAR_STRING (src->u.ch, workbuf);
995 buf = workbuf;
996 coding->src_multibyte = 1;
999 else
1001 /* This glyph has an entry in Vglyph_table,
1002 so process any alias before testing for simpleness. */
1003 GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
1005 if (GLYPH_SIMPLE_P (tbase, tlen, g))
1007 /* We set the multi-byte form of a character in G
1008 (that should be an ASCII character) at
1009 WORKBUF. */
1010 workbuf[0] = FAST_GLYPH_CHAR (g);
1011 len = 1;
1012 buf = workbuf;
1013 coding->src_multibyte = 0;
1015 else
1017 /* We have a string in Vglyph_table. */
1018 len = GLYPH_LENGTH (tbase, g);
1019 buf = GLYPH_STRING (tbase, g);
1020 coding->src_multibyte = STRING_MULTIBYTE (tbase[g]);
1024 result = encode_coding (coding, buf, dst, len, dst_end - dst);
1025 len -= coding->consumed;
1026 dst += coding->produced;
1027 if (result == CODING_FINISH_INSUFFICIENT_DST
1028 || (result == CODING_FINISH_INSUFFICIENT_SRC
1029 && len > dst_end - dst))
1030 /* The remaining output buffer is too short. We must
1031 break the loop here without increasing SRC so that the
1032 next call of this function starts from the same glyph. */
1033 break;
1035 if (len > 0)
1037 /* This is the case that a code of the range 0200..0237
1038 exists in buf. We must just write out such a code. */
1039 buf += coding->consumed;
1040 while (len--)
1041 *dst++ = *buf++;
1044 src++;
1047 *consumed = src - src_start;
1048 return (dst - dst_start);
1052 void
1053 write_glyphs (string, len)
1054 register struct glyph *string;
1055 register int len;
1057 int produced, consumed;
1058 struct frame *sf = XFRAME (selected_frame);
1059 struct frame *f = updating_frame ? updating_frame : sf;
1060 unsigned char conversion_buffer[1024];
1061 int conversion_buffer_size = sizeof conversion_buffer;
1063 if (write_glyphs_hook
1064 && ! FRAME_TERMCAP_P (f))
1066 (*write_glyphs_hook) (string, len);
1067 return;
1070 turn_off_insert ();
1072 /* Don't dare write in last column of bottom line, if Auto-Wrap,
1073 since that would scroll the whole frame on some terminals. */
1075 if (AutoWrap
1076 && curY + 1 == FRAME_HEIGHT (sf)
1077 && (curX + len - (chars_wasted[curY] & 077) == FRAME_WIDTH (sf)))
1078 len --;
1079 if (len <= 0)
1080 return;
1082 cmplus (len);
1084 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
1085 the tail. */
1086 terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
1088 while (len > 0)
1090 /* Identify a run of glyphs with the same face. */
1091 int face_id = string->face_id;
1092 int n;
1094 for (n = 1; n < len; ++n)
1095 if (string[n].face_id != face_id)
1096 break;
1098 /* Turn appearance modes of the face of the run on. */
1099 highlight_if_desired ();
1100 turn_on_face (f, face_id);
1102 while (n > 0)
1104 /* We use a fixed size (1024 bytes) of conversion buffer.
1105 Usually it is sufficient, but if not, we just repeat the
1106 loop. */
1107 produced = encode_terminal_code (string, conversion_buffer,
1108 n, conversion_buffer_size,
1109 &consumed);
1110 if (produced > 0)
1112 fwrite (conversion_buffer, 1, produced, stdout);
1113 if (ferror (stdout))
1114 clearerr (stdout);
1115 if (termscript)
1116 fwrite (conversion_buffer, 1, produced, termscript);
1118 len -= consumed;
1119 n -= consumed;
1120 string += consumed;
1123 /* Turn appearance modes off. */
1124 turn_off_face (f, face_id);
1125 turn_off_highlight ();
1128 /* We may have to output some codes to terminate the writing. */
1129 if (CODING_REQUIRE_FLUSHING (&terminal_coding))
1131 terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
1132 encode_coding (&terminal_coding, "", conversion_buffer,
1133 0, conversion_buffer_size);
1134 if (terminal_coding.produced > 0)
1136 fwrite (conversion_buffer, 1, terminal_coding.produced, stdout);
1137 if (ferror (stdout))
1138 clearerr (stdout);
1139 if (termscript)
1140 fwrite (conversion_buffer, 1, terminal_coding.produced,
1141 termscript);
1145 cmcheckmagic ();
1148 /* If start is zero, insert blanks instead of a string at start */
1150 void
1151 insert_glyphs (start, len)
1152 register struct glyph *start;
1153 register int len;
1155 char *buf;
1156 struct glyph *glyph = NULL;
1157 struct frame *f, *sf;
1159 if (len <= 0)
1160 return;
1162 if (insert_glyphs_hook)
1164 (*insert_glyphs_hook) (start, len);
1165 return;
1168 sf = XFRAME (selected_frame);
1169 f = updating_frame ? updating_frame : sf;
1171 if (TS_ins_multi_chars)
1173 buf = tparam (TS_ins_multi_chars, 0, 0, len);
1174 OUTPUT1 (buf);
1175 xfree (buf);
1176 if (start)
1177 write_glyphs (start, len);
1178 return;
1181 turn_on_insert ();
1182 cmplus (len);
1183 /* The bit CODING_MODE_LAST_BLOCK should be set to 1 only at the tail. */
1184 terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
1185 while (len-- > 0)
1187 int produced, consumed;
1188 unsigned char conversion_buffer[1024];
1189 int conversion_buffer_size = sizeof conversion_buffer;
1191 OUTPUT1_IF (TS_ins_char);
1192 if (!start)
1194 conversion_buffer[0] = SPACEGLYPH;
1195 produced = 1;
1197 else
1199 highlight_if_desired ();
1200 turn_on_face (f, start->face_id);
1201 glyph = start;
1202 ++start;
1203 /* We must open sufficient space for a character which
1204 occupies more than one column. */
1205 while (len && CHAR_GLYPH_PADDING_P (*start))
1207 OUTPUT1_IF (TS_ins_char);
1208 start++, len--;
1211 if (len <= 0)
1212 /* This is the last glyph. */
1213 terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
1215 /* The size of conversion buffer (1024 bytes) is surely
1216 sufficient for just one glyph. */
1217 produced = encode_terminal_code (glyph, conversion_buffer, 1,
1218 conversion_buffer_size, &consumed);
1221 if (produced > 0)
1223 fwrite (conversion_buffer, 1, produced, stdout);
1224 if (ferror (stdout))
1225 clearerr (stdout);
1226 if (termscript)
1227 fwrite (conversion_buffer, 1, produced, termscript);
1230 OUTPUT1_IF (TS_pad_inserted_char);
1231 if (start)
1233 turn_off_face (f, glyph->face_id);
1234 turn_off_highlight ();
1238 cmcheckmagic ();
1241 void
1242 delete_glyphs (n)
1243 register int n;
1245 char *buf;
1246 register int i;
1248 if (delete_glyphs_hook && ! FRAME_TERMCAP_P (updating_frame))
1250 (*delete_glyphs_hook) (n);
1251 return;
1254 if (delete_in_insert_mode)
1256 turn_on_insert ();
1258 else
1260 turn_off_insert ();
1261 OUTPUT_IF (TS_delete_mode);
1264 if (TS_del_multi_chars)
1266 buf = tparam (TS_del_multi_chars, 0, 0, n);
1267 OUTPUT1 (buf);
1268 xfree (buf);
1270 else
1271 for (i = 0; i < n; i++)
1272 OUTPUT1 (TS_del_char);
1273 if (!delete_in_insert_mode)
1274 OUTPUT_IF (TS_end_delete_mode);
1277 /* Insert N lines at vpos VPOS. If N is negative, delete -N lines. */
1279 void
1280 ins_del_lines (vpos, n)
1281 int vpos, n;
1283 char *multi = n > 0 ? TS_ins_multi_lines : TS_del_multi_lines;
1284 char *single = n > 0 ? TS_ins_line : TS_del_line;
1285 char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;
1286 struct frame *sf;
1288 register int i = n > 0 ? n : -n;
1289 register char *buf;
1291 if (ins_del_lines_hook && ! FRAME_TERMCAP_P (updating_frame))
1293 (*ins_del_lines_hook) (vpos, n);
1294 return;
1297 sf = XFRAME (selected_frame);
1299 /* If the lines below the insertion are being pushed
1300 into the end of the window, this is the same as clearing;
1301 and we know the lines are already clear, since the matching
1302 deletion has already been done. So can ignore this. */
1303 /* If the lines below the deletion are blank lines coming
1304 out of the end of the window, don't bother,
1305 as there will be a matching inslines later that will flush them. */
1306 if (scroll_region_ok && vpos + i >= specified_window)
1307 return;
1308 if (!memory_below_frame && vpos + i >= FRAME_HEIGHT (sf))
1309 return;
1311 if (multi)
1313 raw_cursor_to (vpos, 0);
1314 background_highlight ();
1315 buf = tparam (multi, 0, 0, i);
1316 OUTPUT (buf);
1317 xfree (buf);
1319 else if (single)
1321 raw_cursor_to (vpos, 0);
1322 background_highlight ();
1323 while (--i >= 0)
1324 OUTPUT (single);
1325 if (TF_teleray)
1326 curX = 0;
1328 else
1330 set_scroll_region (vpos, specified_window);
1331 if (n < 0)
1332 raw_cursor_to (specified_window - 1, 0);
1333 else
1334 raw_cursor_to (vpos, 0);
1335 background_highlight ();
1336 while (--i >= 0)
1337 OUTPUTL (scroll, specified_window - vpos);
1338 set_scroll_region (0, specified_window);
1341 if (TN_standout_width >= 0)
1343 register int lower_limit
1344 = (scroll_region_ok
1345 ? specified_window
1346 : FRAME_HEIGHT (sf));
1348 if (n < 0)
1350 bcopy (&chars_wasted[vpos - n], &chars_wasted[vpos],
1351 lower_limit - vpos + n);
1352 bzero (&chars_wasted[lower_limit + n], - n);
1354 else
1356 bcopy (&chars_wasted[vpos], &copybuf[vpos], lower_limit - vpos - n);
1357 bcopy (&copybuf[vpos], &chars_wasted[vpos + n],
1358 lower_limit - vpos - n);
1359 bzero (&chars_wasted[vpos], n);
1362 if (!scroll_region_ok && memory_below_frame && n < 0)
1364 cursor_to (FRAME_HEIGHT (sf) + n, 0);
1365 clear_to_end ();
1369 /* Compute cost of sending "str", in characters,
1370 not counting any line-dependent padding. */
1373 string_cost (str)
1374 char *str;
1376 cost = 0;
1377 if (str)
1378 tputs (str, 0, evalcost);
1379 return cost;
1382 /* Compute cost of sending "str", in characters,
1383 counting any line-dependent padding at one line. */
1385 static int
1386 string_cost_one_line (str)
1387 char *str;
1389 cost = 0;
1390 if (str)
1391 tputs (str, 1, evalcost);
1392 return cost;
1395 /* Compute per line amount of line-dependent padding,
1396 in tenths of characters. */
1399 per_line_cost (str)
1400 register char *str;
1402 cost = 0;
1403 if (str)
1404 tputs (str, 0, evalcost);
1405 cost = - cost;
1406 if (str)
1407 tputs (str, 10, evalcost);
1408 return cost;
1411 #ifndef old
1412 /* char_ins_del_cost[n] is cost of inserting N characters.
1413 char_ins_del_cost[-n] is cost of deleting N characters.
1414 The length of this vector is based on max_frame_width. */
1416 int *char_ins_del_vector;
1418 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH ((f))])
1419 #endif
1421 /* ARGSUSED */
1422 static void
1423 calculate_ins_del_char_costs (frame)
1424 FRAME_PTR frame;
1426 int ins_startup_cost, del_startup_cost;
1427 int ins_cost_per_char, del_cost_per_char;
1428 register int i;
1429 register int *p;
1431 if (TS_ins_multi_chars)
1433 ins_cost_per_char = 0;
1434 ins_startup_cost = string_cost_one_line (TS_ins_multi_chars);
1436 else if (TS_ins_char || TS_pad_inserted_char
1437 || (TS_insert_mode && TS_end_insert_mode))
1439 ins_startup_cost = (30 * (string_cost (TS_insert_mode)
1440 + string_cost (TS_end_insert_mode))) / 100;
1441 ins_cost_per_char = (string_cost_one_line (TS_ins_char)
1442 + string_cost_one_line (TS_pad_inserted_char));
1444 else
1446 ins_startup_cost = 9999;
1447 ins_cost_per_char = 0;
1450 if (TS_del_multi_chars)
1452 del_cost_per_char = 0;
1453 del_startup_cost = string_cost_one_line (TS_del_multi_chars);
1455 else if (TS_del_char)
1457 del_startup_cost = (string_cost (TS_delete_mode)
1458 + string_cost (TS_end_delete_mode));
1459 if (delete_in_insert_mode)
1460 del_startup_cost /= 2;
1461 del_cost_per_char = string_cost_one_line (TS_del_char);
1463 else
1465 del_startup_cost = 9999;
1466 del_cost_per_char = 0;
1469 /* Delete costs are at negative offsets */
1470 p = &char_ins_del_cost (frame)[0];
1471 for (i = FRAME_WIDTH (frame); --i >= 0;)
1472 *--p = (del_startup_cost += del_cost_per_char);
1474 /* Doing nothing is free */
1475 p = &char_ins_del_cost (frame)[0];
1476 *p++ = 0;
1478 /* Insert costs are at positive offsets */
1479 for (i = FRAME_WIDTH (frame); --i >= 0;)
1480 *p++ = (ins_startup_cost += ins_cost_per_char);
1483 void
1484 calculate_costs (frame)
1485 FRAME_PTR frame;
1487 register char *f = (TS_set_scroll_region
1488 ? TS_set_scroll_region
1489 : TS_set_scroll_region_1);
1491 FRAME_COST_BAUD_RATE (frame) = baud_rate;
1493 scroll_region_cost = string_cost (f);
1495 /* These variables are only used for terminal stuff. They are allocated
1496 once for the terminal frame of X-windows emacs, but not used afterwards.
1498 char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
1499 X turns off char_ins_del_ok.
1501 chars_wasted and copybuf are only used here in term.c in cases where
1502 the term hook isn't called. */
1504 max_frame_height = max (max_frame_height, FRAME_HEIGHT (frame));
1505 max_frame_width = max (max_frame_width, FRAME_WIDTH (frame));
1507 if (chars_wasted != 0)
1508 chars_wasted = (char *) xrealloc (chars_wasted, max_frame_height);
1509 else
1510 chars_wasted = (char *) xmalloc (max_frame_height);
1512 if (copybuf != 0)
1513 copybuf = (char *) xrealloc (copybuf, max_frame_height);
1514 else
1515 copybuf = (char *) xmalloc (max_frame_height);
1517 if (char_ins_del_vector != 0)
1518 char_ins_del_vector
1519 = (int *) xrealloc (char_ins_del_vector,
1520 (sizeof (int)
1521 + 2 * max_frame_width * sizeof (int)));
1522 else
1523 char_ins_del_vector
1524 = (int *) xmalloc (sizeof (int)
1525 + 2 * max_frame_width * sizeof (int));
1527 bzero (chars_wasted, max_frame_height);
1528 bzero (copybuf, max_frame_height);
1529 bzero (char_ins_del_vector, (sizeof (int)
1530 + 2 * max_frame_width * sizeof (int)));
1532 if (f && (!TS_ins_line && !TS_del_line))
1533 do_line_insertion_deletion_costs (frame,
1534 TS_rev_scroll, TS_ins_multi_lines,
1535 TS_fwd_scroll, TS_del_multi_lines,
1536 f, f, 1);
1537 else
1538 do_line_insertion_deletion_costs (frame,
1539 TS_ins_line, TS_ins_multi_lines,
1540 TS_del_line, TS_del_multi_lines,
1541 0, 0, 1);
1543 calculate_ins_del_char_costs (frame);
1545 /* Don't use TS_repeat if its padding is worse than sending the chars */
1546 if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
1547 RPov = string_cost (TS_repeat);
1548 else
1549 RPov = FRAME_WIDTH (frame) * 2;
1551 cmcostinit (); /* set up cursor motion costs */
1554 struct fkey_table {
1555 char *cap, *name;
1558 /* Termcap capability names that correspond directly to X keysyms.
1559 Some of these (marked "terminfo") aren't supplied by old-style
1560 (Berkeley) termcap entries. They're listed in X keysym order;
1561 except we put the keypad keys first, so that if they clash with
1562 other keys (as on the IBM PC keyboard) they get overridden.
1565 static struct fkey_table keys[] =
1567 "kh", "home", /* termcap */
1568 "kl", "left", /* termcap */
1569 "ku", "up", /* termcap */
1570 "kr", "right", /* termcap */
1571 "kd", "down", /* termcap */
1572 "%8", "prior", /* terminfo */
1573 "%5", "next", /* terminfo */
1574 "@7", "end", /* terminfo */
1575 "@1", "begin", /* terminfo */
1576 "*6", "select", /* terminfo */
1577 "%9", "print", /* terminfo */
1578 "@4", "execute", /* terminfo --- actually the `command' key */
1580 * "insert" --- see below
1582 "&8", "undo", /* terminfo */
1583 "%0", "redo", /* terminfo */
1584 "%7", "menu", /* terminfo --- actually the `options' key */
1585 "@0", "find", /* terminfo */
1586 "@2", "cancel", /* terminfo */
1587 "%1", "help", /* terminfo */
1589 * "break" goes here, but can't be reliably intercepted with termcap
1591 "&4", "reset", /* terminfo --- actually `restart' */
1593 * "system" and "user" --- no termcaps
1595 "kE", "clearline", /* terminfo */
1596 "kA", "insertline", /* terminfo */
1597 "kL", "deleteline", /* terminfo */
1598 "kI", "insertchar", /* terminfo */
1599 "kD", "deletechar", /* terminfo */
1600 "kB", "backtab", /* terminfo */
1602 * "kp_backtab", "kp-space", "kp-tab" --- no termcaps
1604 "@8", "kp-enter", /* terminfo */
1606 * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1607 * "kp-multiply", "kp-add", "kp-separator",
1608 * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1609 * --- no termcaps for any of these.
1611 "K4", "kp-1", /* terminfo */
1613 * "kp-2" --- no termcap
1615 "K5", "kp-3", /* terminfo */
1617 * "kp-4" --- no termcap
1619 "K2", "kp-5", /* terminfo */
1621 * "kp-6" --- no termcap
1623 "K1", "kp-7", /* terminfo */
1625 * "kp-8" --- no termcap
1627 "K3", "kp-9", /* terminfo */
1629 * "kp-equal" --- no termcap
1631 "k1", "f1",
1632 "k2", "f2",
1633 "k3", "f3",
1634 "k4", "f4",
1635 "k5", "f5",
1636 "k6", "f6",
1637 "k7", "f7",
1638 "k8", "f8",
1639 "k9", "f9",
1642 static char **term_get_fkeys_arg;
1643 static Lisp_Object term_get_fkeys_1 ();
1645 /* Find the escape codes sent by the function keys for Vfunction_key_map.
1646 This function scans the termcap function key sequence entries, and
1647 adds entries to Vfunction_key_map for each function key it finds. */
1649 void
1650 term_get_fkeys (address)
1651 char **address;
1653 /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1654 errors during the call. The only errors should be from Fdefine_key
1655 when given a key sequence containing an invalid prefix key. If the
1656 termcap defines function keys which use a prefix that is already bound
1657 to a command by the default bindings, we should silently ignore that
1658 function key specification, rather than giving the user an error and
1659 refusing to run at all on such a terminal. */
1661 extern Lisp_Object Fidentity ();
1662 term_get_fkeys_arg = address;
1663 internal_condition_case (term_get_fkeys_1, Qerror, Fidentity);
1666 static Lisp_Object
1667 term_get_fkeys_1 ()
1669 int i;
1671 char **address = term_get_fkeys_arg;
1673 /* This can happen if CANNOT_DUMP or with strange options. */
1674 if (!initialized)
1675 Vfunction_key_map = Fmake_sparse_keymap (Qnil);
1677 for (i = 0; i < (sizeof (keys)/sizeof (keys[0])); i++)
1679 char *sequence = tgetstr (keys[i].cap, address);
1680 if (sequence)
1681 Fdefine_key (Vfunction_key_map, build_string (sequence),
1682 Fmake_vector (make_number (1),
1683 intern (keys[i].name)));
1686 /* The uses of the "k0" capability are inconsistent; sometimes it
1687 describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1688 We will attempt to politely accommodate both systems by testing for
1689 "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1692 char *k_semi = tgetstr ("k;", address);
1693 char *k0 = tgetstr ("k0", address);
1694 char *k0_name = "f10";
1696 if (k_semi)
1698 Fdefine_key (Vfunction_key_map, build_string (k_semi),
1699 Fmake_vector (make_number (1), intern ("f10")));
1700 k0_name = "f0";
1703 if (k0)
1704 Fdefine_key (Vfunction_key_map, build_string (k0),
1705 Fmake_vector (make_number (1), intern (k0_name)));
1708 /* Set up cookies for numbered function keys above f10. */
1710 char fcap[3], fkey[4];
1712 fcap[0] = 'F'; fcap[2] = '\0';
1713 for (i = 11; i < 64; i++)
1715 if (i <= 19)
1716 fcap[1] = '1' + i - 11;
1717 else if (i <= 45)
1718 fcap[1] = 'A' + i - 20;
1719 else
1720 fcap[1] = 'a' + i - 46;
1723 char *sequence = tgetstr (fcap, address);
1724 if (sequence)
1726 sprintf (fkey, "f%d", i);
1727 Fdefine_key (Vfunction_key_map, build_string (sequence),
1728 Fmake_vector (make_number (1),
1729 intern (fkey)));
1736 * Various mappings to try and get a better fit.
1739 #define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
1740 if (!tgetstr (cap1, address)) \
1742 char *sequence = tgetstr (cap2, address); \
1743 if (sequence) \
1744 Fdefine_key (Vfunction_key_map, build_string (sequence), \
1745 Fmake_vector (make_number (1), \
1746 intern (sym))); \
1749 /* if there's no key_next keycap, map key_npage to `next' keysym */
1750 CONDITIONAL_REASSIGN ("%5", "kN", "next");
1751 /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1752 CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1753 /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1754 CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1755 /* if there's no key_end keycap, map key_ll to 'end' keysym */
1756 CONDITIONAL_REASSIGN ("@7", "kH", "end");
1758 /* IBM has their own non-standard dialect of terminfo.
1759 If the standard name isn't found, try the IBM name. */
1760 CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
1761 CONDITIONAL_REASSIGN ("@4", "kJ", "execute"); /* actually "action" */
1762 CONDITIONAL_REASSIGN ("@4", "kc", "execute"); /* actually "command" */
1763 CONDITIONAL_REASSIGN ("%7", "ki", "menu");
1764 CONDITIONAL_REASSIGN ("@7", "kw", "end");
1765 CONDITIONAL_REASSIGN ("F1", "k<", "f11");
1766 CONDITIONAL_REASSIGN ("F2", "k>", "f12");
1767 CONDITIONAL_REASSIGN ("%1", "kq", "help");
1768 CONDITIONAL_REASSIGN ("*6", "kU", "select");
1769 #undef CONDITIONAL_REASSIGN
1772 return Qnil;
1776 /***********************************************************************
1777 Character Display Information
1778 ***********************************************************************/
1780 static void append_glyph P_ ((struct it *));
1783 /* Append glyphs to IT's glyph_row. Called from produce_glyphs for
1784 terminal frames if IT->glyph_row != NULL. IT->c is the character
1785 for which to produce glyphs; IT->face_id contains the character's
1786 face. Padding glyphs are appended if IT->c has a IT->pixel_width >
1787 1. */
1789 static void
1790 append_glyph (it)
1791 struct it *it;
1793 struct glyph *glyph, *end;
1794 int i;
1796 xassert (it->glyph_row);
1797 glyph = (it->glyph_row->glyphs[it->area]
1798 + it->glyph_row->used[it->area]);
1799 end = it->glyph_row->glyphs[1 + it->area];
1801 for (i = 0;
1802 i < it->pixel_width && glyph < end;
1803 ++i)
1805 glyph->type = CHAR_GLYPH;
1806 glyph->pixel_width = 1;
1807 glyph->u.ch = it->c;
1808 glyph->face_id = it->face_id;
1809 glyph->padding_p = i > 0;
1810 glyph->charpos = CHARPOS (it->position);
1811 glyph->object = it->object;
1813 ++it->glyph_row->used[it->area];
1814 ++glyph;
1819 /* Produce glyphs for the display element described by IT. The
1820 function fills output fields of IT with pixel information like the
1821 pixel width and height of a character, and maybe produces glyphs at
1822 the same time if IT->glyph_row is non-null. See the explanation of
1823 struct display_iterator in dispextern.h for an overview. */
1825 void
1826 produce_glyphs (it)
1827 struct it *it;
1829 /* If a hook is installed, let it do the work. */
1830 xassert (it->what == IT_CHARACTER
1831 || it->what == IT_COMPOSITION
1832 || it->what == IT_IMAGE
1833 || it->what == IT_STRETCH);
1835 /* Nothing but characters are supported on terminal frames. For a
1836 composition sequence, it->c is the first character of the
1837 sequence. */
1838 xassert (it->what == IT_CHARACTER
1839 || it->what == IT_COMPOSITION);
1841 if (it->c >= 040 && it->c < 0177)
1843 it->pixel_width = it->nglyphs = 1;
1844 if (it->glyph_row)
1845 append_glyph (it);
1847 else if (it->c == '\n')
1848 it->pixel_width = it->nglyphs = 0;
1849 else if (it->c == '\t')
1851 int absolute_x = (it->current_x
1852 + it->continuation_lines_width);
1853 int next_tab_x
1854 = (((1 + absolute_x + it->tab_width - 1)
1855 / it->tab_width)
1856 * it->tab_width);
1857 int nspaces;
1859 /* If part of the TAB has been displayed on the previous line
1860 which is continued now, continuation_lines_width will have
1861 been incremented already by the part that fitted on the
1862 continued line. So, we will get the right number of spaces
1863 here. */
1864 nspaces = next_tab_x - absolute_x;
1866 if (it->glyph_row)
1868 int n = nspaces;
1870 it->c = ' ';
1871 it->pixel_width = it->len = 1;
1873 while (n--)
1874 append_glyph (it);
1876 it->c = '\t';
1879 it->pixel_width = nspaces;
1880 it->nglyphs = nspaces;
1882 else if (SINGLE_BYTE_CHAR_P (it->c))
1884 /* Coming here means that it->c is from display table, thus we
1885 must send the code as is to the terminal. Although there's
1886 no way to know how many columns it occupies on a screen, it
1887 is a good assumption that a single byte code has 1-column
1888 width. */
1889 it->pixel_width = it->nglyphs = 1;
1890 if (it->glyph_row)
1891 append_glyph (it);
1893 else
1895 /* A multi-byte character. The display width is fixed for all
1896 characters of the set. Some of the glyphs may have to be
1897 ignored because they are already displayed in a continued
1898 line. */
1899 int charset = CHAR_CHARSET (it->c);
1901 it->pixel_width = CHARSET_WIDTH (charset);
1902 it->nglyphs = it->pixel_width;
1904 if (it->glyph_row)
1905 append_glyph (it);
1908 /* Advance current_x by the pixel width as a convenience for
1909 the caller. */
1910 if (it->area == TEXT_AREA)
1911 it->current_x += it->pixel_width;
1912 it->ascent = it->max_ascent = it->phys_ascent = it->max_phys_ascent = 0;
1913 it->descent = it->max_descent = it->phys_descent = it->max_phys_descent = 1;
1917 /* Get information about special display element WHAT in an
1918 environment described by IT. WHAT is one of IT_TRUNCATION or
1919 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
1920 non-null glyph_row member. This function ensures that fields like
1921 face_id, c, len of IT are left untouched. */
1923 void
1924 produce_special_glyphs (it, what)
1925 struct it *it;
1926 enum display_element_type what;
1928 struct it temp_it;
1930 temp_it = *it;
1931 temp_it.dp = NULL;
1932 temp_it.what = IT_CHARACTER;
1933 temp_it.len = 1;
1934 temp_it.object = make_number (0);
1935 bzero (&temp_it.current, sizeof temp_it.current);
1937 if (what == IT_CONTINUATION)
1939 /* Continuation glyph. */
1940 if (it->dp
1941 && INTEGERP (DISP_CONTINUE_GLYPH (it->dp))
1942 && GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (it->dp))))
1944 temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_CONTINUE_GLYPH (it->dp)));
1945 temp_it.len = CHAR_BYTES (temp_it.c);
1947 else
1948 temp_it.c = '\\';
1950 produce_glyphs (&temp_it);
1951 it->pixel_width = temp_it.pixel_width;
1952 it->nglyphs = temp_it.pixel_width;
1954 else if (what == IT_TRUNCATION)
1956 /* Truncation glyph. */
1957 if (it->dp
1958 && INTEGERP (DISP_TRUNC_GLYPH (it->dp))
1959 && GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (it->dp))))
1961 temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_TRUNC_GLYPH (it->dp)));
1962 temp_it.len = CHAR_BYTES (temp_it.c);
1964 else
1965 temp_it.c = '$';
1967 produce_glyphs (&temp_it);
1968 it->pixel_width = temp_it.pixel_width;
1969 it->nglyphs = temp_it.pixel_width;
1971 else
1972 abort ();
1976 /* Return an estimation of the pixel height of mode or top lines on
1977 frame F. FACE_ID specifies what line's height to estimate. */
1980 estimate_mode_line_height (f, face_id)
1981 struct frame *f;
1982 enum face_id face_id;
1984 if (estimate_mode_line_height_hook)
1985 return estimate_mode_line_height_hook (f, face_id);
1986 else
1987 return 1;
1992 /***********************************************************************
1993 Faces
1994 ***********************************************************************/
1996 /* Value is non-zero if attribute ATTR may be used. ATTR should be
1997 one of the enumerators from enum no_color_bit, or a bit set built
1998 from them. Some display attributes may not be used together with
1999 color; the termcap capability `NC' specifies which ones. */
2001 #define MAY_USE_WITH_COLORS_P(ATTR) \
2002 (TN_max_colors > 0 \
2003 ? (TN_no_color_video & (ATTR)) == 0 \
2004 : 1)
2006 /* Turn appearances of face FACE_ID on tty frame F on. */
2008 static void
2009 turn_on_face (f, face_id)
2010 struct frame *f;
2011 int face_id;
2013 struct face *face = FACE_FROM_ID (f, face_id);
2015 xassert (face != NULL);
2017 if (face->tty_bold_p)
2019 if (MAY_USE_WITH_COLORS_P (NC_BOLD))
2020 OUTPUT1_IF (TS_enter_bold_mode);
2022 else if (face->tty_dim_p)
2023 if (MAY_USE_WITH_COLORS_P (NC_DIM))
2024 OUTPUT1_IF (TS_enter_dim_mode);
2026 /* Alternate charset and blinking not yet used. */
2027 if (face->tty_alt_charset_p
2028 && MAY_USE_WITH_COLORS_P (NC_ALT_CHARSET))
2029 OUTPUT1_IF (TS_enter_alt_charset_mode);
2031 if (face->tty_blinking_p
2032 && MAY_USE_WITH_COLORS_P (NC_BLINK))
2033 OUTPUT1_IF (TS_enter_blink_mode);
2035 if (face->tty_underline_p
2036 /* Don't underline if that's difficult. */
2037 && TN_magic_cookie_glitch_ul <= 0
2038 && MAY_USE_WITH_COLORS_P (NC_UNDERLINE))
2039 OUTPUT1_IF (TS_enter_underline_mode);
2041 if (MAY_USE_WITH_COLORS_P (NC_REVERSE))
2042 if (face->tty_reverse_p
2043 || face->foreground == FACE_TTY_DEFAULT_BG_COLOR
2044 || face->background == FACE_TTY_DEFAULT_FG_COLOR)
2045 OUTPUT1_IF (TS_enter_reverse_mode);
2047 if (TN_max_colors > 0)
2049 char *p;
2051 if (face->foreground != FACE_TTY_DEFAULT_COLOR
2052 && face->foreground != FACE_TTY_DEFAULT_FG_COLOR
2053 && face->foreground != FACE_TTY_DEFAULT_BG_COLOR
2054 && TS_set_foreground)
2056 p = tparam (TS_set_foreground, NULL, 0, (int) face->foreground);
2057 OUTPUT (p);
2058 xfree (p);
2061 if (face->background != FACE_TTY_DEFAULT_COLOR
2062 && face->background != FACE_TTY_DEFAULT_BG_COLOR
2063 && face->background != FACE_TTY_DEFAULT_FG_COLOR
2064 && TS_set_background)
2066 p = tparam (TS_set_background, NULL, 0, (int) face->background);
2067 OUTPUT (p);
2068 xfree (p);
2074 /* Turn off appearances of face FACE_ID on tty frame F. */
2076 static void
2077 turn_off_face (f, face_id)
2078 struct frame *f;
2079 int face_id;
2081 struct face *face = FACE_FROM_ID (f, face_id);
2083 xassert (face != NULL);
2085 if (TS_exit_attribute_mode)
2087 /* Capability "me" will turn off appearance modes double-bright,
2088 half-bright, reverse-video, standout, underline. It may or
2089 may not turn off alt-char-mode. */
2090 if (face->tty_bold_p
2091 || face->tty_dim_p
2092 || face->tty_reverse_p
2093 || face->tty_alt_charset_p
2094 || face->tty_blinking_p
2095 || face->tty_underline_p)
2097 OUTPUT1_IF (TS_exit_attribute_mode);
2098 if (strcmp (TS_exit_attribute_mode, TS_end_standout_mode) == 0)
2099 standout_mode = 0;
2102 if (face->tty_alt_charset_p)
2103 OUTPUT_IF (TS_exit_alt_charset_mode);
2105 else
2107 /* If we don't have "me" we can only have those appearances
2108 that have exit sequences defined. */
2109 if (face->tty_alt_charset_p)
2110 OUTPUT_IF (TS_exit_alt_charset_mode);
2112 if (face->tty_underline_p
2113 /* We don't underline if that's difficult. */
2114 && TN_magic_cookie_glitch_ul <= 0)
2115 OUTPUT_IF (TS_exit_underline_mode);
2118 /* Switch back to default colors. */
2119 if (TN_max_colors > 0
2120 && ((face->foreground != FACE_TTY_DEFAULT_COLOR
2121 && face->foreground != FACE_TTY_DEFAULT_FG_COLOR)
2122 || (face->background != FACE_TTY_DEFAULT_COLOR
2123 && face->background != FACE_TTY_DEFAULT_BG_COLOR)))
2124 OUTPUT1_IF (TS_orig_pair);
2128 /* Return non-zero if the terminal is capable to display colors. */
2130 DEFUN ("tty-display-color-p", Ftty_display_color_p, Stty_display_color_p,
2131 0, 1, 0,
2132 "Return non-nil if TTY can display colors on FRAME.")
2133 (frame)
2134 Lisp_Object frame;
2136 return TN_max_colors > 0 ? Qt : Qnil;
2142 /***********************************************************************
2143 Initialization
2144 ***********************************************************************/
2146 void
2147 term_init (terminal_type)
2148 char *terminal_type;
2150 char *area;
2151 char **address = &area;
2152 char buffer[2044];
2153 register char *p;
2154 int status;
2155 struct frame *sf = XFRAME (selected_frame);
2157 #ifdef WINDOWSNT
2158 initialize_w32_display ();
2160 Wcm_clear ();
2162 area = (char *) xmalloc (2044);
2164 if (area == 0)
2165 abort ();
2167 FrameRows = FRAME_HEIGHT (sf);
2168 FrameCols = FRAME_WIDTH (sf);
2169 specified_window = FRAME_HEIGHT (sf);
2171 delete_in_insert_mode = 1;
2173 UseTabs = 0;
2174 scroll_region_ok = 0;
2176 /* Seems to insert lines when it's not supposed to, messing
2177 up the display. In doing a trace, it didn't seem to be
2178 called much, so I don't think we're losing anything by
2179 turning it off. */
2181 line_ins_del_ok = 0;
2182 char_ins_del_ok = 1;
2184 baud_rate = 19200;
2186 FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
2187 FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
2188 TN_max_colors = 16; /* Required to be non-zero for tty-display-color-p */
2190 return;
2191 #else /* not WINDOWSNT */
2193 Wcm_clear ();
2195 status = tgetent (buffer, terminal_type);
2196 if (status < 0)
2198 #ifdef TERMINFO
2199 fatal ("Cannot open terminfo database file");
2200 #else
2201 fatal ("Cannot open termcap database file");
2202 #endif
2204 if (status == 0)
2206 #ifdef TERMINFO
2207 fatal ("Terminal type %s is not defined.\n\
2208 If that is not the actual type of terminal you have,\n\
2209 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2210 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2211 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
2212 terminal_type);
2213 #else
2214 fatal ("Terminal type %s is not defined.\n\
2215 If that is not the actual type of terminal you have,\n\
2216 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2217 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2218 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
2219 terminal_type);
2220 #endif
2222 #ifdef TERMINFO
2223 area = (char *) xmalloc (2044);
2224 #else
2225 area = (char *) xmalloc (strlen (buffer));
2226 #endif /* not TERMINFO */
2227 if (area == 0)
2228 abort ();
2230 TS_ins_line = tgetstr ("al", address);
2231 TS_ins_multi_lines = tgetstr ("AL", address);
2232 TS_bell = tgetstr ("bl", address);
2233 BackTab = tgetstr ("bt", address);
2234 TS_clr_to_bottom = tgetstr ("cd", address);
2235 TS_clr_line = tgetstr ("ce", address);
2236 TS_clr_frame = tgetstr ("cl", address);
2237 ColPosition = NULL; /* tgetstr ("ch", address); */
2238 AbsPosition = tgetstr ("cm", address);
2239 CR = tgetstr ("cr", address);
2240 TS_set_scroll_region = tgetstr ("cs", address);
2241 TS_set_scroll_region_1 = tgetstr ("cS", address);
2242 RowPosition = tgetstr ("cv", address);
2243 TS_del_char = tgetstr ("dc", address);
2244 TS_del_multi_chars = tgetstr ("DC", address);
2245 TS_del_line = tgetstr ("dl", address);
2246 TS_del_multi_lines = tgetstr ("DL", address);
2247 TS_delete_mode = tgetstr ("dm", address);
2248 TS_end_delete_mode = tgetstr ("ed", address);
2249 TS_end_insert_mode = tgetstr ("ei", address);
2250 Home = tgetstr ("ho", address);
2251 TS_ins_char = tgetstr ("ic", address);
2252 TS_ins_multi_chars = tgetstr ("IC", address);
2253 TS_insert_mode = tgetstr ("im", address);
2254 TS_pad_inserted_char = tgetstr ("ip", address);
2255 TS_end_keypad_mode = tgetstr ("ke", address);
2256 TS_keypad_mode = tgetstr ("ks", address);
2257 LastLine = tgetstr ("ll", address);
2258 Right = tgetstr ("nd", address);
2259 Down = tgetstr ("do", address);
2260 if (!Down)
2261 Down = tgetstr ("nl", address); /* Obsolete name for "do" */
2262 #ifdef VMS
2263 /* VMS puts a carriage return before each linefeed,
2264 so it is not safe to use linefeeds. */
2265 if (Down && Down[0] == '\n' && Down[1] == '\0')
2266 Down = 0;
2267 #endif /* VMS */
2268 if (tgetflag ("bs"))
2269 Left = "\b"; /* can't possibly be longer! */
2270 else /* (Actually, "bs" is obsolete...) */
2271 Left = tgetstr ("le", address);
2272 if (!Left)
2273 Left = tgetstr ("bc", address); /* Obsolete name for "le" */
2274 TS_pad_char = tgetstr ("pc", address);
2275 TS_repeat = tgetstr ("rp", address);
2276 TS_end_standout_mode = tgetstr ("se", address);
2277 TS_fwd_scroll = tgetstr ("sf", address);
2278 TS_standout_mode = tgetstr ("so", address);
2279 TS_rev_scroll = tgetstr ("sr", address);
2280 Wcm.cm_tab = tgetstr ("ta", address);
2281 TS_end_termcap_modes = tgetstr ("te", address);
2282 TS_termcap_modes = tgetstr ("ti", address);
2283 Up = tgetstr ("up", address);
2284 TS_visible_bell = tgetstr ("vb", address);
2285 TS_cursor_normal = tgetstr ("ve", address);
2286 TS_cursor_visible = tgetstr ("vs", address);
2287 TS_cursor_invisible = tgetstr ("vi", address);
2288 TS_set_window = tgetstr ("wi", address);
2290 TS_enter_underline_mode = tgetstr ("us", address);
2291 TS_exit_underline_mode = tgetstr ("ue", address);
2292 TN_magic_cookie_glitch_ul = tgetnum ("ug");
2293 TS_enter_bold_mode = tgetstr ("md", address);
2294 TS_enter_dim_mode = tgetstr ("mh", address);
2295 TS_enter_blink_mode = tgetstr ("mb", address);
2296 TS_enter_reverse_mode = tgetstr ("mr", address);
2297 TS_enter_alt_charset_mode = tgetstr ("as", address);
2298 TS_exit_alt_charset_mode = tgetstr ("ae", address);
2299 TS_exit_attribute_mode = tgetstr ("me", address);
2301 MultiUp = tgetstr ("UP", address);
2302 MultiDown = tgetstr ("DO", address);
2303 MultiLeft = tgetstr ("LE", address);
2304 MultiRight = tgetstr ("RI", address);
2306 /* SVr4/ANSI color suppert. If "op" isn't available, don't support
2307 color because we can't switch back to the default foreground and
2308 background. */
2309 TS_orig_pair = tgetstr ("op", address);
2310 if (TS_orig_pair)
2312 TS_set_foreground = tgetstr ("AF", address);
2313 TS_set_background = tgetstr ("AB", address);
2314 if (!TS_set_foreground)
2316 /* SVr4. */
2317 TS_set_foreground = tgetstr ("Sf", address);
2318 TS_set_background = tgetstr ("Sb", address);
2321 TN_max_colors = tgetnum ("Co");
2322 TN_max_pairs = tgetnum ("pa");
2324 TN_no_color_video = tgetnum ("NC");
2325 if (TN_no_color_video == -1)
2326 TN_no_color_video = 0;
2329 MagicWrap = tgetflag ("xn");
2330 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
2331 the former flag imply the latter. */
2332 AutoWrap = MagicWrap || tgetflag ("am");
2333 memory_below_frame = tgetflag ("db");
2334 TF_hazeltine = tgetflag ("hz");
2335 must_write_spaces = tgetflag ("in");
2336 meta_key = tgetflag ("km") || tgetflag ("MT");
2337 TF_insmode_motion = tgetflag ("mi");
2338 TF_standout_motion = tgetflag ("ms");
2339 TF_underscore = tgetflag ("ul");
2340 TF_xs = tgetflag ("xs");
2341 TF_teleray = tgetflag ("xt");
2343 term_get_fkeys (address);
2345 /* Get frame size from system, or else from termcap. */
2347 int height, width;
2348 get_frame_size (&width, &height);
2349 FRAME_WIDTH (sf) = width;
2350 FRAME_HEIGHT (sf) = height;
2353 if (FRAME_WIDTH (sf) <= 0)
2354 SET_FRAME_WIDTH (sf, tgetnum ("co"));
2355 else
2356 /* Keep width and external_width consistent */
2357 SET_FRAME_WIDTH (sf, FRAME_WIDTH (sf));
2358 if (FRAME_HEIGHT (sf) <= 0)
2359 FRAME_HEIGHT (sf) = tgetnum ("li");
2361 if (FRAME_HEIGHT (sf) < 3 || FRAME_WIDTH (sf) < 3)
2362 fatal ("Screen size %dx%d is too small",
2363 FRAME_HEIGHT (sf), FRAME_WIDTH (sf));
2365 min_padding_speed = tgetnum ("pb");
2366 TN_standout_width = tgetnum ("sg");
2367 TabWidth = tgetnum ("tw");
2369 #ifdef VMS
2370 /* These capabilities commonly use ^J.
2371 I don't know why, but sending them on VMS does not work;
2372 it causes following spaces to be lost, sometimes.
2373 For now, the simplest fix is to avoid using these capabilities ever. */
2374 if (Down && Down[0] == '\n')
2375 Down = 0;
2376 #endif /* VMS */
2378 if (!TS_bell)
2379 TS_bell = "\07";
2381 if (!TS_fwd_scroll)
2382 TS_fwd_scroll = Down;
2384 PC = TS_pad_char ? *TS_pad_char : 0;
2386 if (TabWidth < 0)
2387 TabWidth = 8;
2389 /* Turned off since /etc/termcap seems to have :ta= for most terminals
2390 and newer termcap doc does not seem to say there is a default.
2391 if (!Wcm.cm_tab)
2392 Wcm.cm_tab = "\t";
2395 if (TS_standout_mode == 0)
2397 TN_standout_width = tgetnum ("ug");
2398 TS_end_standout_mode = tgetstr ("ue", address);
2399 TS_standout_mode = tgetstr ("us", address);
2402 /* If no `se' string, try using a `me' string instead.
2403 If that fails, we can't use standout mode at all. */
2404 if (TS_end_standout_mode == 0)
2406 char *s = tgetstr ("me", address);
2407 if (s != 0)
2408 TS_end_standout_mode = s;
2409 else
2410 TS_standout_mode = 0;
2413 if (TF_teleray)
2415 Wcm.cm_tab = 0;
2416 /* Teleray: most programs want a space in front of TS_standout_mode,
2417 but Emacs can do without it (and give one extra column). */
2418 TS_standout_mode = "\033RD";
2419 TN_standout_width = 1;
2420 /* But that means we cannot rely on ^M to go to column zero! */
2421 CR = 0;
2422 /* LF can't be trusted either -- can alter hpos */
2423 /* if move at column 0 thru a line with TS_standout_mode */
2424 Down = 0;
2427 /* Special handling for certain terminal types known to need it */
2429 if (!strcmp (terminal_type, "supdup"))
2431 memory_below_frame = 1;
2432 Wcm.cm_losewrap = 1;
2434 if (!strncmp (terminal_type, "c10", 3)
2435 || !strcmp (terminal_type, "perq"))
2437 /* Supply a makeshift :wi string.
2438 This string is not valid in general since it works only
2439 for windows starting at the upper left corner;
2440 but that is all Emacs uses.
2442 This string works only if the frame is using
2443 the top of the video memory, because addressing is memory-relative.
2444 So first check the :ti string to see if that is true.
2446 It would be simpler if the :wi string could go in the termcap
2447 entry, but it can't because it is not fully valid.
2448 If it were in the termcap entry, it would confuse other programs. */
2449 if (!TS_set_window)
2451 p = TS_termcap_modes;
2452 while (*p && strcmp (p, "\033v "))
2453 p++;
2454 if (*p)
2455 TS_set_window = "\033v%C %C %C %C ";
2457 /* Termcap entry often fails to have :in: flag */
2458 must_write_spaces = 1;
2459 /* :ti string typically fails to have \E^G! in it */
2460 /* This limits scope of insert-char to one line. */
2461 strcpy (area, TS_termcap_modes);
2462 strcat (area, "\033\007!");
2463 TS_termcap_modes = area;
2464 area += strlen (area) + 1;
2465 p = AbsPosition;
2466 /* Change all %+ parameters to %C, to handle
2467 values above 96 correctly for the C100. */
2468 while (*p)
2470 if (p[0] == '%' && p[1] == '+')
2471 p[1] = 'C';
2472 p++;
2476 FrameRows = FRAME_HEIGHT (sf);
2477 FrameCols = FRAME_WIDTH (sf);
2478 specified_window = FRAME_HEIGHT (sf);
2480 if (Wcm_init () == -1) /* can't do cursor motion */
2481 #ifdef VMS
2482 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2483 It lacks the ability to position the cursor.\n\
2484 If that is not the actual type of terminal you have, use either the\n\
2485 DCL command `SET TERMINAL/DEVICE= ...' for DEC-compatible terminals,\n\
2486 or `define EMACS_TERM \"terminal type\"' for non-DEC terminals.",
2487 terminal_type);
2488 #else /* not VMS */
2489 # ifdef TERMINFO
2490 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2491 It lacks the ability to position the cursor.\n\
2492 If that is not the actual type of terminal you have,\n\
2493 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2494 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2495 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
2496 terminal_type);
2497 # else /* TERMCAP */
2498 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2499 It lacks the ability to position the cursor.\n\
2500 If that is not the actual type of terminal you have,\n\
2501 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2502 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2503 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
2504 terminal_type);
2505 # endif /* TERMINFO */
2506 #endif /*VMS */
2507 if (FRAME_HEIGHT (sf) <= 0
2508 || FRAME_WIDTH (sf) <= 0)
2509 fatal ("The frame size has not been specified");
2511 delete_in_insert_mode
2512 = TS_delete_mode && TS_insert_mode
2513 && !strcmp (TS_delete_mode, TS_insert_mode);
2515 se_is_so = (TS_standout_mode
2516 && TS_end_standout_mode
2517 && !strcmp (TS_standout_mode, TS_end_standout_mode));
2519 /* Remove width of standout marker from usable width of line */
2520 if (TN_standout_width > 0)
2521 SET_FRAME_WIDTH (sf, FRAME_WIDTH (sf) - TN_standout_width);
2523 UseTabs = tabs_safe_p () && TabWidth == 8;
2525 scroll_region_ok
2526 = (Wcm.cm_abs
2527 && (TS_set_window || TS_set_scroll_region || TS_set_scroll_region_1));
2529 line_ins_del_ok = (((TS_ins_line || TS_ins_multi_lines)
2530 && (TS_del_line || TS_del_multi_lines))
2531 || (scroll_region_ok && TS_fwd_scroll && TS_rev_scroll));
2533 char_ins_del_ok = ((TS_ins_char || TS_insert_mode
2534 || TS_pad_inserted_char || TS_ins_multi_chars)
2535 && (TS_del_char || TS_del_multi_chars));
2537 fast_clear_end_of_line = TS_clr_line != 0;
2539 init_baud_rate ();
2540 if (read_socket_hook) /* Baudrate is somewhat */
2541 /* meaningless in this case */
2542 baud_rate = 9600;
2544 FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
2545 FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
2546 #endif /* WINDOWSNT */
2549 /* VARARGS 1 */
2550 void
2551 fatal (str, arg1, arg2)
2552 char *str, *arg1, *arg2;
2554 fprintf (stderr, "emacs: ");
2555 fprintf (stderr, str, arg1, arg2);
2556 fprintf (stderr, "\n");
2557 fflush (stderr);
2558 exit (1);
2561 void
2562 syms_of_term ()
2564 DEFVAR_BOOL ("system-uses-terminfo", &system_uses_terminfo,
2565 "Non-nil means the system uses terminfo rather than termcap.\n\
2566 This variable can be used by terminal emulator packages.");
2567 #ifdef TERMINFO
2568 system_uses_terminfo = 1;
2569 #else
2570 system_uses_terminfo = 0;
2571 #endif
2573 DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
2574 "Non-nil means call this function to ring the bell.\n\
2575 The function should accept no arguments.");
2576 Vring_bell_function = Qnil;
2578 defsubr (&Stty_display_color_p);