Use AREF, ASET and ASIZE macros.
[emacs.git] / src / term.c
blobc33d0553a1ada05075aa477e53af2ac7fa85c7cd
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 #ifdef HAVE_TERMCAP_H
42 #include <termcap.h>
43 #else
44 extern void tputs P_ ((const char *, int, int (*)(int)));
45 extern int tgetent P_ ((char *, const char *));
46 extern int tgetflag P_ ((char *id));
47 extern int tgetnum P_ ((char *id));
48 #endif
50 #include "cm.h"
51 #ifdef HAVE_X_WINDOWS
52 #include "xterm.h"
53 #endif
54 #ifdef macintosh
55 #include "macterm.h"
56 #endif
58 static void turn_on_face P_ ((struct frame *, int face_id));
59 static void turn_off_face P_ ((struct frame *, int face_id));
60 static void tty_show_cursor P_ ((void));
61 static void tty_hide_cursor P_ ((void));
63 #define max(a, b) ((a) > (b) ? (a) : (b))
64 #define min(a, b) ((a) < (b) ? (a) : (b))
66 #define OUTPUT(a) \
67 tputs (a, (int) (FRAME_HEIGHT (XFRAME (selected_frame)) - curY), cmputc)
68 #define OUTPUT1(a) tputs (a, 1, cmputc)
69 #define OUTPUTL(a, lines) tputs (a, lines, cmputc)
71 #define OUTPUT_IF(a) \
72 do { \
73 if (a) \
74 tputs (a, (int) (FRAME_HEIGHT (XFRAME (selected_frame)) \
75 - curY), cmputc); \
76 } while (0)
78 #define OUTPUT1_IF(a) do { if (a) tputs (a, 1, cmputc); } while (0)
80 /* Function to use to ring the bell. */
82 Lisp_Object Vring_bell_function;
84 /* Terminal characteristics that higher levels want to look at.
85 These are all extern'd in termchar.h */
87 int must_write_spaces; /* Nonzero means spaces in the text
88 must actually be output; can't just skip
89 over some columns to leave them blank. */
90 int min_padding_speed; /* Speed below which no padding necessary */
92 int line_ins_del_ok; /* Terminal can insert and delete lines */
93 int char_ins_del_ok; /* Terminal can insert and delete chars */
94 int scroll_region_ok; /* Terminal supports setting the
95 scroll window */
96 int scroll_region_cost; /* Cost of setting a scroll window,
97 measured in characters */
98 int memory_below_frame; /* Terminal remembers lines
99 scrolled off bottom */
100 int fast_clear_end_of_line; /* Terminal has a `ce' string */
102 /* Nonzero means no need to redraw the entire frame on resuming
103 a suspended Emacs. This is useful on terminals with multiple pages,
104 where one page is used for Emacs and another for all else. */
106 int no_redraw_on_reenter;
108 /* Hook functions that you can set to snap out the functions in this file.
109 These are all extern'd in termhooks.h */
111 void (*cursor_to_hook) P_ ((int, int));
112 void (*raw_cursor_to_hook) P_ ((int, int));
113 void (*clear_to_end_hook) P_ ((void));
114 void (*clear_frame_hook) P_ ((void));
115 void (*clear_end_of_line_hook) P_ ((int));
117 void (*ins_del_lines_hook) P_ ((int, int));
119 void (*change_line_highlight_hook) P_ ((int, int, int, int));
120 void (*reassert_line_highlight_hook) P_ ((int, int));
122 void (*delete_glyphs_hook) P_ ((int));
124 void (*ring_bell_hook) P_ ((void));
126 void (*reset_terminal_modes_hook) P_ ((void));
127 void (*set_terminal_modes_hook) P_ ((void));
128 void (*update_begin_hook) P_ ((struct frame *));
129 void (*update_end_hook) P_ ((struct frame *));
130 void (*set_terminal_window_hook) P_ ((int));
131 void (*insert_glyphs_hook) P_ ((struct glyph *, int));
132 void (*write_glyphs_hook) P_ ((struct glyph *, int));
133 void (*delete_glyphs_hook) P_ ((int));
135 int (*read_socket_hook) P_ ((int, struct input_event *, int, int));
137 void (*frame_up_to_date_hook) P_ ((struct frame *));
139 /* Return the current position of the mouse.
141 Set *f to the frame the mouse is in, or zero if the mouse is in no
142 Emacs frame. If it is set to zero, all the other arguments are
143 garbage.
145 If the motion started in a scroll bar, set *bar_window to the
146 scroll bar's window, *part to the part the mouse is currently over,
147 *x to the position of the mouse along the scroll bar, and *y to the
148 overall length of the scroll bar.
150 Otherwise, set *bar_window to Qnil, and *x and *y to the column and
151 row of the character cell the mouse is over.
153 Set *time to the time the mouse was at the returned position.
155 This should clear mouse_moved until the next motion
156 event arrives. */
157 void (*mouse_position_hook) P_ ((FRAME_PTR *f, int insist,
158 Lisp_Object *bar_window,
159 enum scroll_bar_part *part,
160 Lisp_Object *x,
161 Lisp_Object *y,
162 unsigned long *time));
164 /* When reading from a minibuffer in a different frame, Emacs wants
165 to shift the highlight from the selected frame to the mini-buffer's
166 frame; under X, this means it lies about where the focus is.
167 This hook tells the window system code to re-decide where to put
168 the highlight. */
169 void (*frame_rehighlight_hook) P_ ((FRAME_PTR f));
171 /* If we're displaying frames using a window system that can stack
172 frames on top of each other, this hook allows you to bring a frame
173 to the front, or bury it behind all the other windows. If this
174 hook is zero, that means the device we're displaying on doesn't
175 support overlapping frames, so there's no need to raise or lower
176 anything.
178 If RAISE is non-zero, F is brought to the front, before all other
179 windows. If RAISE is zero, F is sent to the back, behind all other
180 windows. */
181 void (*frame_raise_lower_hook) P_ ((FRAME_PTR f, int raise));
183 /* Set the vertical scroll bar for WINDOW to have its upper left corner
184 at (TOP, LEFT), and be LENGTH rows high. Set its handle to
185 indicate that we are displaying PORTION characters out of a total
186 of WHOLE characters, starting at POSITION. If WINDOW doesn't yet
187 have a scroll bar, create one for it. */
189 void (*set_vertical_scroll_bar_hook)
190 P_ ((struct window *window,
191 int portion, int whole, int position));
194 /* The following three hooks are used when we're doing a thorough
195 redisplay of the frame. We don't explicitly know which scroll bars
196 are going to be deleted, because keeping track of when windows go
197 away is a real pain - can you say set-window-configuration?
198 Instead, we just assert at the beginning of redisplay that *all*
199 scroll bars are to be removed, and then save scroll bars from the
200 fiery pit when we actually redisplay their window. */
202 /* Arrange for all scroll bars on FRAME to be removed at the next call
203 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
204 `*redeem_scroll_bar_hook' is applied to its window before the judgment.
206 This should be applied to each frame each time its window tree is
207 redisplayed, even if it is not displaying scroll bars at the moment;
208 if the HAS_SCROLL_BARS flag has just been turned off, only calling
209 this and the judge_scroll_bars_hook will get rid of them.
211 If non-zero, this hook should be safe to apply to any frame,
212 whether or not it can support scroll bars, and whether or not it is
213 currently displaying them. */
214 void (*condemn_scroll_bars_hook) P_ ((FRAME_PTR frame));
216 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
217 Note that it's okay to redeem a scroll bar that is not condemned. */
218 void (*redeem_scroll_bar_hook) P_ ((struct window *window));
220 /* Remove all scroll bars on FRAME that haven't been saved since the
221 last call to `*condemn_scroll_bars_hook'.
223 This should be applied to each frame after each time its window
224 tree is redisplayed, even if it is not displaying scroll bars at the
225 moment; if the HAS_SCROLL_BARS flag has just been turned off, only
226 calling this and condemn_scroll_bars_hook will get rid of them.
228 If non-zero, this hook should be safe to apply to any frame,
229 whether or not it can support scroll bars, and whether or not it is
230 currently displaying them. */
231 void (*judge_scroll_bars_hook) P_ ((FRAME_PTR FRAME));
233 /* Hook to call in estimate_mode_line_height, if any. */
235 int (* estimate_mode_line_height_hook) P_ ((struct frame *f, enum face_id));
238 /* Strings, numbers and flags taken from the termcap entry. */
240 char *TS_ins_line; /* "al" */
241 char *TS_ins_multi_lines; /* "AL" (one parameter, # lines to insert) */
242 char *TS_bell; /* "bl" */
243 char *TS_clr_to_bottom; /* "cd" */
244 char *TS_clr_line; /* "ce", clear to end of line */
245 char *TS_clr_frame; /* "cl" */
246 char *TS_set_scroll_region; /* "cs" (2 params, first line and last line) */
247 char *TS_set_scroll_region_1; /* "cS" (4 params: total lines,
248 lines above scroll region, lines below it,
249 total lines again) */
250 char *TS_del_char; /* "dc" */
251 char *TS_del_multi_chars; /* "DC" (one parameter, # chars to delete) */
252 char *TS_del_line; /* "dl" */
253 char *TS_del_multi_lines; /* "DL" (one parameter, # lines to delete) */
254 char *TS_delete_mode; /* "dm", enter character-delete mode */
255 char *TS_end_delete_mode; /* "ed", leave character-delete mode */
256 char *TS_end_insert_mode; /* "ei", leave character-insert mode */
257 char *TS_ins_char; /* "ic" */
258 char *TS_ins_multi_chars; /* "IC" (one parameter, # chars to insert) */
259 char *TS_insert_mode; /* "im", enter character-insert mode */
260 char *TS_pad_inserted_char; /* "ip". Just padding, no commands. */
261 char *TS_end_keypad_mode; /* "ke" */
262 char *TS_keypad_mode; /* "ks" */
263 char *TS_pad_char; /* "pc", char to use as padding */
264 char *TS_repeat; /* "rp" (2 params, # times to repeat
265 and character to be repeated) */
266 char *TS_end_standout_mode; /* "se" */
267 char *TS_fwd_scroll; /* "sf" */
268 char *TS_standout_mode; /* "so" */
269 char *TS_rev_scroll; /* "sr" */
270 char *TS_end_termcap_modes; /* "te" */
271 char *TS_termcap_modes; /* "ti" */
272 char *TS_visible_bell; /* "vb" */
273 char *TS_cursor_normal; /* "ve" */
274 char *TS_cursor_visible; /* "vs" */
275 char *TS_cursor_invisible; /* "vi" */
276 char *TS_set_window; /* "wi" (4 params, start and end of window,
277 each as vpos and hpos) */
279 /* Value of the "NC" (no_color_video) capability, or 0 if not
280 present. */
282 static int TN_no_color_video;
284 /* Meaning of bits in no_color_video. Each bit set means that the
285 corresponding attribute cannot be combined with colors. */
287 enum no_color_bit
289 NC_STANDOUT = 1 << 0,
290 NC_UNDERLINE = 1 << 1,
291 NC_REVERSE = 1 << 2,
292 NC_BLINK = 1 << 3,
293 NC_DIM = 1 << 4,
294 NC_BOLD = 1 << 5,
295 NC_INVIS = 1 << 6,
296 NC_PROTECT = 1 << 7,
297 NC_ALT_CHARSET = 1 << 8
300 /* "md" -- turn on bold (extra bright mode). */
302 char *TS_enter_bold_mode;
304 /* "mh" -- turn on half-bright mode. */
306 char *TS_enter_dim_mode;
308 /* "mb" -- enter blinking mode. */
310 char *TS_enter_blink_mode;
312 /* "mr" -- enter reverse video mode. */
314 char *TS_enter_reverse_mode;
316 /* "us"/"ue" -- start/end underlining. */
318 char *TS_exit_underline_mode, *TS_enter_underline_mode;
320 /* "ug" -- number of blanks left by underline. */
322 int TN_magic_cookie_glitch_ul;
324 /* "as"/"ae" -- start/end alternate character set. Not really
325 supported, yet. */
327 char *TS_enter_alt_charset_mode, *TS_exit_alt_charset_mode;
329 /* "me" -- switch appearances off. */
331 char *TS_exit_attribute_mode;
333 /* "Co" -- number of colors. */
335 int TN_max_colors;
337 /* "pa" -- max. number of color pairs on screen. Not handled yet.
338 Could be a problem if not equal to TN_max_colors * TN_max_colors. */
340 int TN_max_pairs;
342 /* "op" -- SVr4 set default pair to its original value. */
344 char *TS_orig_pair;
346 /* "AF"/"AB" or "Sf"/"Sb"-- set ANSI or SVr4 foreground/background color.
347 1 param, the color index. */
349 char *TS_set_foreground, *TS_set_background;
351 int TF_hazeltine; /* termcap hz flag. */
352 int TF_insmode_motion; /* termcap mi flag: can move while in insert mode. */
353 int TF_standout_motion; /* termcap mi flag: can move while in standout mode. */
354 int TF_underscore; /* termcap ul flag: _ underlines if over-struck on
355 non-blank position. Must clear before writing _. */
356 int TF_teleray; /* termcap xt flag: many weird consequences.
357 For t1061. */
359 int TF_xs; /* Nonzero for "xs". If set together with
360 TN_standout_width == 0, it means don't bother
361 to write any end-standout cookies. */
363 int TN_standout_width; /* termcap sg number: width occupied by standout
364 markers */
366 static int RPov; /* # chars to start a TS_repeat */
368 static int delete_in_insert_mode; /* delete mode == insert mode */
370 static int se_is_so; /* 1 if same string both enters and leaves
371 standout mode */
373 /* internal state */
375 /* The largest frame width in any call to calculate_costs. */
377 int max_frame_width;
379 /* The largest frame height in any call to calculate_costs. */
381 int max_frame_height;
383 /* Number of chars of space used for standout marker at beginning of line,
384 or'd with 0100. Zero if no standout marker at all.
385 The length of these vectors is max_frame_height.
387 Used IFF TN_standout_width >= 0. */
389 static char *chars_wasted;
390 static char *copybuf;
392 /* nonzero means supposed to write text in standout mode. */
394 int standout_requested;
396 int insert_mode; /* Nonzero when in insert mode. */
397 int standout_mode; /* Nonzero when in standout mode. */
399 /* Size of window specified by higher levels.
400 This is the number of lines, from the top of frame downwards,
401 which can participate in insert-line/delete-line operations.
403 Effectively it excludes the bottom frame_height - specified_window_size
404 lines from those operations. */
406 int specified_window;
408 /* Frame currently being redisplayed; 0 if not currently redisplaying.
409 (Direct output does not count). */
411 FRAME_PTR updating_frame;
413 /* Provided for lisp packages. */
415 static int system_uses_terminfo;
417 char *tparam ();
419 extern char *tgetstr ();
422 #ifdef WINDOWSNT
424 /* We aren't X windows, but we aren't termcap either. This makes me
425 uncertain as to what value to use for frame.output_method. For
426 this file, we'll define FRAME_TERMCAP_P to be zero so that our
427 output hooks get called instead of the termcap functions. Probably
428 the best long-term solution is to define an output_windows_nt... */
430 #undef FRAME_TERMCAP_P
431 #define FRAME_TERMCAP_P(_f_) 0
432 #endif /* WINDOWSNT */
434 void
435 ring_bell ()
437 if (! NILP (Vring_bell_function))
439 Lisp_Object function;
441 /* Temporarily set the global variable to nil
442 so that if we get an error, it stays nil
443 and we don't call it over and over.
445 We don't specbind it, because that would carefully
446 restore the bad value if there's an error
447 and make the loop of errors happen anyway. */
448 function = Vring_bell_function;
449 Vring_bell_function = Qnil;
451 call0 (function);
453 Vring_bell_function = function;
454 return;
457 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
459 (*ring_bell_hook) ();
460 return;
462 OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
465 void
466 set_terminal_modes ()
468 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
470 (*set_terminal_modes_hook) ();
471 return;
473 OUTPUT_IF (TS_termcap_modes);
474 OUTPUT_IF (TS_cursor_visible);
475 OUTPUT_IF (TS_keypad_mode);
476 losecursor ();
479 void
480 reset_terminal_modes ()
482 if (! FRAME_TERMCAP_P (XFRAME (selected_frame)))
484 if (reset_terminal_modes_hook)
485 (*reset_terminal_modes_hook) ();
486 return;
488 if (TN_standout_width < 0)
489 turn_off_highlight ();
490 turn_off_insert ();
491 OUTPUT_IF (TS_end_keypad_mode);
492 OUTPUT_IF (TS_cursor_normal);
493 OUTPUT_IF (TS_end_termcap_modes);
494 OUTPUT_IF (TS_orig_pair);
495 /* Output raw CR so kernel can track the cursor hpos. */
496 /* But on magic-cookie terminals this can erase an end-standout marker and
497 cause the rest of the frame to be in standout, so move down first. */
498 if (TN_standout_width >= 0)
499 cmputc ('\n');
500 cmputc ('\r');
503 void
504 update_begin (f)
505 FRAME_PTR f;
507 updating_frame = f;
508 if (! FRAME_TERMCAP_P (updating_frame))
509 (*update_begin_hook) (f);
510 else
511 tty_hide_cursor ();
514 void
515 update_end (f)
516 FRAME_PTR f;
518 if (! FRAME_TERMCAP_P (updating_frame))
520 (*update_end_hook) (f);
521 updating_frame = 0;
522 return;
525 if (!XWINDOW (selected_window)->cursor_off_p)
526 tty_show_cursor ();
528 turn_off_insert ();
529 background_highlight ();
530 standout_requested = 0;
531 updating_frame = 0;
534 void
535 set_terminal_window (size)
536 int size;
538 if (! FRAME_TERMCAP_P (updating_frame))
540 (*set_terminal_window_hook) (size);
541 return;
543 specified_window = size ? size : FRAME_HEIGHT (XFRAME (selected_frame));
544 if (!scroll_region_ok)
545 return;
546 set_scroll_region (0, specified_window);
549 void
550 set_scroll_region (start, stop)
551 int start, stop;
553 char *buf;
554 struct frame *sf = XFRAME (selected_frame);
556 if (TS_set_scroll_region)
558 buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
560 else if (TS_set_scroll_region_1)
562 buf = tparam (TS_set_scroll_region_1, 0, 0,
563 FRAME_HEIGHT (sf), start,
564 FRAME_HEIGHT (sf) - stop,
565 FRAME_HEIGHT (sf));
567 else
569 buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_WIDTH (sf));
571 OUTPUT (buf);
572 xfree (buf);
573 losecursor ();
576 void
577 turn_on_insert ()
579 if (!insert_mode)
580 OUTPUT (TS_insert_mode);
581 insert_mode = 1;
584 void
585 turn_off_insert ()
587 if (insert_mode)
588 OUTPUT (TS_end_insert_mode);
589 insert_mode = 0;
592 /* Handle highlighting when TN_standout_width (termcap sg) is not specified.
593 In these terminals, output is affected by the value of standout
594 mode when the output is written.
596 These functions are called on all terminals, but do nothing
597 on terminals whose standout mode does not work that way. */
599 void
600 turn_off_highlight ()
602 if (TN_standout_width < 0)
604 if (standout_mode)
605 OUTPUT_IF (TS_end_standout_mode);
606 standout_mode = 0;
610 void
611 turn_on_highlight ()
613 if (TN_standout_width < 0)
615 if (!standout_mode)
616 OUTPUT_IF (TS_standout_mode);
617 standout_mode = 1;
622 /* Make cursor invisible. */
624 static void
625 tty_hide_cursor ()
627 OUTPUT_IF (TS_cursor_invisible);
631 /* Ensure that cursor is visible. */
633 static void
634 tty_show_cursor ()
636 OUTPUT_IF (TS_cursor_normal);
637 OUTPUT_IF (TS_cursor_visible);
641 /* Set standout mode to the state it should be in for
642 empty space inside windows. What this is,
643 depends on the user option inverse-video. */
645 void
646 background_highlight ()
648 if (TN_standout_width >= 0)
649 return;
650 if (inverse_video)
651 turn_on_highlight ();
652 else
653 turn_off_highlight ();
656 /* Set standout mode to the mode specified for the text to be output. */
658 static void
659 highlight_if_desired ()
661 if (TN_standout_width >= 0)
662 return;
663 if (!inverse_video == !standout_requested)
664 turn_off_highlight ();
665 else
666 turn_on_highlight ();
669 /* Handle standout mode for terminals in which TN_standout_width >= 0.
670 On these terminals, standout is controlled by markers that
671 live inside the terminal's memory. TN_standout_width is the width
672 that the marker occupies in memory. Standout runs from the marker
673 to the end of the line on some terminals, or to the next
674 turn-off-standout marker (TS_end_standout_mode) string
675 on other terminals. */
677 /* Write a standout marker or end-standout marker at the front of the line
678 at vertical position vpos. */
680 void
681 write_standout_marker (flag, vpos)
682 int flag, vpos;
684 if (flag || (TS_end_standout_mode && !TF_teleray && !se_is_so
685 && !(TF_xs && TN_standout_width == 0)))
687 cmgoto (vpos, 0);
688 cmplus (TN_standout_width);
689 OUTPUT (flag ? TS_standout_mode : TS_end_standout_mode);
690 chars_wasted[curY] = TN_standout_width | 0100;
694 /* External interface to control of standout mode.
695 Call this when about to modify line at position VPOS
696 and not change whether it is highlighted. */
698 void
699 reassert_line_highlight (highlight, vpos)
700 int highlight;
701 int vpos;
703 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
704 if (! FRAME_TERMCAP_P (f))
706 (*reassert_line_highlight_hook) (highlight, vpos);
707 return;
709 if (TN_standout_width < 0)
710 /* Handle terminals where standout takes affect at output time */
711 standout_requested = highlight;
712 else if (chars_wasted && chars_wasted[vpos] == 0)
713 /* For terminals with standout markers, write one on this line
714 if there isn't one already. */
715 write_standout_marker (highlight, vpos);
718 /* Call this when about to modify line at position VPOS
719 and change whether it is highlighted. */
721 void
722 change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
723 int new_highlight, vpos, y, first_unused_hpos;
725 standout_requested = new_highlight;
726 if (! FRAME_TERMCAP_P (updating_frame))
728 (*change_line_highlight_hook) (new_highlight, vpos, y, first_unused_hpos);
729 return;
732 cursor_to (vpos, 0);
734 if (TN_standout_width < 0)
735 background_highlight ();
736 /* If line starts with a marker, delete the marker */
737 else if (TS_clr_line && chars_wasted[curY])
739 turn_off_insert ();
740 /* On Teleray, make sure to erase the SO marker. */
741 if (TF_teleray)
743 cmgoto (curY - 1, FRAME_WIDTH (XFRAME (selected_frame)) - 4);
744 OUTPUT ("\033S");
745 curY++; /* ESC S moves to next line where the TS_standout_mode was */
746 curX = 0;
748 else
749 cmgoto (curY, 0); /* reposition to kill standout marker */
751 clear_end_of_line_raw (first_unused_hpos);
752 reassert_line_highlight (new_highlight, curY);
756 /* Move cursor to row/column position VPOS/HPOS. HPOS/VPOS are
757 frame-relative coordinates. */
759 void
760 cursor_to (vpos, hpos)
761 int vpos, hpos;
763 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
765 if (! FRAME_TERMCAP_P (f) && cursor_to_hook)
767 (*cursor_to_hook) (vpos, hpos);
768 return;
771 /* Detect the case where we are called from reset_sys_modes
772 and the costs have never been calculated. Do nothing. */
773 if (chars_wasted == 0)
774 return;
776 hpos += chars_wasted[vpos] & 077;
777 if (curY == vpos && curX == hpos)
778 return;
779 if (!TF_standout_motion)
780 background_highlight ();
781 if (!TF_insmode_motion)
782 turn_off_insert ();
783 cmgoto (vpos, hpos);
786 /* Similar but don't take any account of the wasted characters. */
788 void
789 raw_cursor_to (row, col)
790 int row, col;
792 struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
793 if (! FRAME_TERMCAP_P (f))
795 (*raw_cursor_to_hook) (row, col);
796 return;
798 if (curY == row && curX == col)
799 return;
800 if (!TF_standout_motion)
801 background_highlight ();
802 if (!TF_insmode_motion)
803 turn_off_insert ();
804 cmgoto (row, col);
807 /* Erase operations */
809 /* clear from cursor to end of frame */
810 void
811 clear_to_end ()
813 register int i;
815 if (clear_to_end_hook && ! FRAME_TERMCAP_P (updating_frame))
817 (*clear_to_end_hook) ();
818 return;
820 if (TS_clr_to_bottom)
822 background_highlight ();
823 OUTPUT (TS_clr_to_bottom);
824 bzero (chars_wasted + curY,
825 FRAME_HEIGHT (XFRAME (selected_frame)) - curY);
827 else
829 for (i = curY; i < FRAME_HEIGHT (XFRAME (selected_frame)); i++)
831 cursor_to (i, 0);
832 clear_end_of_line_raw (FRAME_WIDTH (XFRAME (selected_frame)));
837 /* Clear entire frame */
839 void
840 clear_frame ()
842 struct frame *sf = XFRAME (selected_frame);
844 if (clear_frame_hook
845 && ! FRAME_TERMCAP_P ((updating_frame ? updating_frame : sf)))
847 (*clear_frame_hook) ();
848 return;
850 if (TS_clr_frame)
852 background_highlight ();
853 OUTPUT (TS_clr_frame);
854 bzero (chars_wasted, FRAME_HEIGHT (sf));
855 cmat (0, 0);
857 else
859 cursor_to (0, 0);
860 clear_to_end ();
864 /* Clear to end of line, but do not clear any standout marker.
865 Assumes that the cursor is positioned at a character of real text,
866 which implies it cannot be before a standout marker
867 unless the marker has zero width.
869 Note that the cursor may be moved. */
871 void
872 clear_end_of_line (first_unused_hpos)
873 int first_unused_hpos;
875 if (FRAME_TERMCAP_P (XFRAME (selected_frame))
876 && chars_wasted != 0
877 && TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
878 write_glyphs (&space_glyph, 1);
879 clear_end_of_line_raw (first_unused_hpos);
882 /* Clear from cursor to end of line.
883 Assume that the line is already clear starting at column first_unused_hpos.
884 If the cursor is at a standout marker, erase the marker.
886 Note that the cursor may be moved, on terminals lacking a `ce' string. */
888 void
889 clear_end_of_line_raw (first_unused_hpos)
890 int first_unused_hpos;
892 register int i;
894 if (clear_end_of_line_hook
895 && ! FRAME_TERMCAP_P ((updating_frame
896 ? updating_frame
897 : XFRAME (selected_frame))))
899 (*clear_end_of_line_hook) (first_unused_hpos);
900 return;
903 /* Detect the case where we are called from reset_sys_modes
904 and the costs have never been calculated. Do nothing. */
905 if (chars_wasted == 0)
906 return;
908 first_unused_hpos += chars_wasted[curY] & 077;
909 if (curX >= first_unused_hpos)
910 return;
911 /* Notice if we are erasing a magic cookie */
912 if (curX == 0)
913 chars_wasted[curY] = 0;
914 background_highlight ();
915 if (TS_clr_line)
917 OUTPUT1 (TS_clr_line);
919 else
920 { /* have to do it the hard way */
921 struct frame *sf = XFRAME (selected_frame);
922 turn_off_insert ();
924 /* Do not write in last row last col with Auto-wrap on. */
925 if (AutoWrap && curY == FRAME_HEIGHT (sf) - 1
926 && first_unused_hpos == FRAME_WIDTH (sf))
927 first_unused_hpos--;
929 for (i = curX; i < first_unused_hpos; i++)
931 if (termscript)
932 fputc (' ', termscript);
933 putchar (' ');
935 cmplus (first_unused_hpos - curX);
939 /* Encode SRC_LEN glyphs starting at SRC to terminal output codes and
940 store them at DST. Do not write more than DST_LEN bytes. That may
941 require stopping before all SRC_LEN input glyphs have been
942 converted.
944 We store the number of glyphs actually converted in *CONSUMED. The
945 return value is the number of bytes store in DST. */
948 encode_terminal_code (src, dst, src_len, dst_len, consumed)
949 struct glyph *src;
950 int src_len;
951 unsigned char *dst;
952 int dst_len, *consumed;
954 struct glyph *src_start = src, *src_end = src + src_len;
955 unsigned char *dst_start = dst, *dst_end = dst + dst_len;
956 register GLYPH g;
957 unsigned int c;
958 unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *buf;
959 int len;
960 register int tlen = GLYPH_TABLE_LENGTH;
961 register Lisp_Object *tbase = GLYPH_TABLE_BASE;
962 int result;
963 struct coding_system *coding;
965 /* If terminal_coding does any conversion, use it, otherwise use
966 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
967 because it always return 1 if the member src_multibyte is 1. */
968 coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
969 ? &terminal_coding
970 : &safe_terminal_coding);
972 while (src < src_end)
974 /* We must skip glyphs to be padded for a wide character. */
975 if (! CHAR_GLYPH_PADDING_P (*src))
977 g = GLYPH_FROM_CHAR_GLYPH (src[0]);
979 if (g < 0 || g >= tlen)
981 /* This glyph doesn't has an entry in Vglyph_table. */
982 if (! CHAR_VALID_P (src->u.ch, 0))
984 len = 1;
985 buf = " ";
986 coding->src_multibyte = 0;
988 else
990 len = CHAR_STRING (src->u.ch, workbuf);
991 buf = workbuf;
992 coding->src_multibyte = 1;
995 else
997 /* This glyph has an entry in Vglyph_table,
998 so process any alias before testing for simpleness. */
999 GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
1001 if (GLYPH_SIMPLE_P (tbase, tlen, g))
1003 /* We set the multi-byte form of a character in G
1004 (that should be an ASCII character) at
1005 WORKBUF. */
1006 workbuf[0] = FAST_GLYPH_CHAR (g);
1007 len = 1;
1008 buf = workbuf;
1009 coding->src_multibyte = 0;
1011 else
1013 /* We have a string in Vglyph_table. */
1014 len = GLYPH_LENGTH (tbase, g);
1015 buf = GLYPH_STRING (tbase, g);
1016 coding->src_multibyte = STRING_MULTIBYTE (tbase[g]);
1020 result = encode_coding (coding, buf, dst, len, dst_end - dst);
1021 len -= coding->consumed;
1022 dst += coding->produced;
1023 if (result == CODING_FINISH_INSUFFICIENT_DST
1024 || (result == CODING_FINISH_INSUFFICIENT_SRC
1025 && len > dst_end - dst))
1026 /* The remaining output buffer is too short. We must
1027 break the loop here without increasing SRC so that the
1028 next call of this function starts from the same glyph. */
1029 break;
1031 if (len > 0)
1033 /* This is the case that a code of the range 0200..0237
1034 exists in buf. We must just write out such a code. */
1035 buf += coding->consumed;
1036 while (len--)
1037 *dst++ = *buf++;
1040 src++;
1043 *consumed = src - src_start;
1044 return (dst - dst_start);
1048 void
1049 write_glyphs (string, len)
1050 register struct glyph *string;
1051 register int len;
1053 int produced, consumed;
1054 struct frame *sf = XFRAME (selected_frame);
1055 struct frame *f = updating_frame ? updating_frame : sf;
1056 unsigned char conversion_buffer[1024];
1057 int conversion_buffer_size = sizeof conversion_buffer;
1059 if (write_glyphs_hook
1060 && ! FRAME_TERMCAP_P (f))
1062 (*write_glyphs_hook) (string, len);
1063 return;
1066 turn_off_insert ();
1068 /* Don't dare write in last column of bottom line, if Auto-Wrap,
1069 since that would scroll the whole frame on some terminals. */
1071 if (AutoWrap
1072 && curY + 1 == FRAME_HEIGHT (sf)
1073 && (curX + len - (chars_wasted[curY] & 077) == FRAME_WIDTH (sf)))
1074 len --;
1075 if (len <= 0)
1076 return;
1078 cmplus (len);
1080 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
1081 the tail. */
1082 terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
1084 while (len > 0)
1086 /* Identify a run of glyphs with the same face. */
1087 int face_id = string->face_id;
1088 int n;
1090 for (n = 1; n < len; ++n)
1091 if (string[n].face_id != face_id)
1092 break;
1094 /* Turn appearance modes of the face of the run on. */
1095 highlight_if_desired ();
1096 turn_on_face (f, face_id);
1098 while (n > 0)
1100 /* We use a fixed size (1024 bytes) of conversion buffer.
1101 Usually it is sufficient, but if not, we just repeat the
1102 loop. */
1103 produced = encode_terminal_code (string, conversion_buffer,
1104 n, conversion_buffer_size,
1105 &consumed);
1106 if (produced > 0)
1108 fwrite (conversion_buffer, 1, produced, stdout);
1109 if (ferror (stdout))
1110 clearerr (stdout);
1111 if (termscript)
1112 fwrite (conversion_buffer, 1, produced, termscript);
1114 len -= consumed;
1115 n -= consumed;
1116 string += consumed;
1119 /* Turn appearance modes off. */
1120 turn_off_face (f, face_id);
1121 turn_off_highlight ();
1124 /* We may have to output some codes to terminate the writing. */
1125 if (CODING_REQUIRE_FLUSHING (&terminal_coding))
1127 terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
1128 encode_coding (&terminal_coding, "", conversion_buffer,
1129 0, conversion_buffer_size);
1130 if (terminal_coding.produced > 0)
1132 fwrite (conversion_buffer, 1, terminal_coding.produced, stdout);
1133 if (ferror (stdout))
1134 clearerr (stdout);
1135 if (termscript)
1136 fwrite (conversion_buffer, 1, terminal_coding.produced,
1137 termscript);
1141 cmcheckmagic ();
1144 /* If start is zero, insert blanks instead of a string at start */
1146 void
1147 insert_glyphs (start, len)
1148 register struct glyph *start;
1149 register int len;
1151 char *buf;
1152 struct glyph *glyph = NULL;
1153 struct frame *f, *sf;
1155 if (len <= 0)
1156 return;
1158 if (insert_glyphs_hook)
1160 (*insert_glyphs_hook) (start, len);
1161 return;
1164 sf = XFRAME (selected_frame);
1165 f = updating_frame ? updating_frame : sf;
1167 if (TS_ins_multi_chars)
1169 buf = tparam (TS_ins_multi_chars, 0, 0, len);
1170 OUTPUT1 (buf);
1171 xfree (buf);
1172 if (start)
1173 write_glyphs (start, len);
1174 return;
1177 turn_on_insert ();
1178 cmplus (len);
1179 /* The bit CODING_MODE_LAST_BLOCK should be set to 1 only at the tail. */
1180 terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
1181 while (len-- > 0)
1183 int produced, consumed;
1184 unsigned char conversion_buffer[1024];
1185 int conversion_buffer_size = sizeof conversion_buffer;
1187 OUTPUT1_IF (TS_ins_char);
1188 if (!start)
1190 conversion_buffer[0] = SPACEGLYPH;
1191 produced = 1;
1193 else
1195 highlight_if_desired ();
1196 turn_on_face (f, start->face_id);
1197 glyph = start;
1198 ++start;
1199 /* We must open sufficient space for a character which
1200 occupies more than one column. */
1201 while (len && CHAR_GLYPH_PADDING_P (*start))
1203 OUTPUT1_IF (TS_ins_char);
1204 start++, len--;
1207 if (len <= 0)
1208 /* This is the last glyph. */
1209 terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
1211 /* The size of conversion buffer (1024 bytes) is surely
1212 sufficient for just one glyph. */
1213 produced = encode_terminal_code (glyph, conversion_buffer, 1,
1214 conversion_buffer_size, &consumed);
1217 if (produced > 0)
1219 fwrite (conversion_buffer, 1, produced, stdout);
1220 if (ferror (stdout))
1221 clearerr (stdout);
1222 if (termscript)
1223 fwrite (conversion_buffer, 1, produced, termscript);
1226 OUTPUT1_IF (TS_pad_inserted_char);
1227 if (start)
1229 turn_off_face (f, glyph->face_id);
1230 turn_off_highlight ();
1234 cmcheckmagic ();
1237 void
1238 delete_glyphs (n)
1239 register int n;
1241 char *buf;
1242 register int i;
1244 if (delete_glyphs_hook && ! FRAME_TERMCAP_P (updating_frame))
1246 (*delete_glyphs_hook) (n);
1247 return;
1250 if (delete_in_insert_mode)
1252 turn_on_insert ();
1254 else
1256 turn_off_insert ();
1257 OUTPUT_IF (TS_delete_mode);
1260 if (TS_del_multi_chars)
1262 buf = tparam (TS_del_multi_chars, 0, 0, n);
1263 OUTPUT1 (buf);
1264 xfree (buf);
1266 else
1267 for (i = 0; i < n; i++)
1268 OUTPUT1 (TS_del_char);
1269 if (!delete_in_insert_mode)
1270 OUTPUT_IF (TS_end_delete_mode);
1273 /* Insert N lines at vpos VPOS. If N is negative, delete -N lines. */
1275 void
1276 ins_del_lines (vpos, n)
1277 int vpos, n;
1279 char *multi = n > 0 ? TS_ins_multi_lines : TS_del_multi_lines;
1280 char *single = n > 0 ? TS_ins_line : TS_del_line;
1281 char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;
1282 struct frame *sf;
1284 register int i = n > 0 ? n : -n;
1285 register char *buf;
1287 if (ins_del_lines_hook && ! FRAME_TERMCAP_P (updating_frame))
1289 (*ins_del_lines_hook) (vpos, n);
1290 return;
1293 sf = XFRAME (selected_frame);
1295 /* If the lines below the insertion are being pushed
1296 into the end of the window, this is the same as clearing;
1297 and we know the lines are already clear, since the matching
1298 deletion has already been done. So can ignore this. */
1299 /* If the lines below the deletion are blank lines coming
1300 out of the end of the window, don't bother,
1301 as there will be a matching inslines later that will flush them. */
1302 if (scroll_region_ok && vpos + i >= specified_window)
1303 return;
1304 if (!memory_below_frame && vpos + i >= FRAME_HEIGHT (sf))
1305 return;
1307 if (multi)
1309 raw_cursor_to (vpos, 0);
1310 background_highlight ();
1311 buf = tparam (multi, 0, 0, i);
1312 OUTPUT (buf);
1313 xfree (buf);
1315 else if (single)
1317 raw_cursor_to (vpos, 0);
1318 background_highlight ();
1319 while (--i >= 0)
1320 OUTPUT (single);
1321 if (TF_teleray)
1322 curX = 0;
1324 else
1326 set_scroll_region (vpos, specified_window);
1327 if (n < 0)
1328 raw_cursor_to (specified_window - 1, 0);
1329 else
1330 raw_cursor_to (vpos, 0);
1331 background_highlight ();
1332 while (--i >= 0)
1333 OUTPUTL (scroll, specified_window - vpos);
1334 set_scroll_region (0, specified_window);
1337 if (TN_standout_width >= 0)
1339 register int lower_limit
1340 = (scroll_region_ok
1341 ? specified_window
1342 : FRAME_HEIGHT (sf));
1344 if (n < 0)
1346 bcopy (&chars_wasted[vpos - n], &chars_wasted[vpos],
1347 lower_limit - vpos + n);
1348 bzero (&chars_wasted[lower_limit + n], - n);
1350 else
1352 bcopy (&chars_wasted[vpos], &copybuf[vpos], lower_limit - vpos - n);
1353 bcopy (&copybuf[vpos], &chars_wasted[vpos + n],
1354 lower_limit - vpos - n);
1355 bzero (&chars_wasted[vpos], n);
1358 if (!scroll_region_ok && memory_below_frame && n < 0)
1360 cursor_to (FRAME_HEIGHT (sf) + n, 0);
1361 clear_to_end ();
1365 /* Compute cost of sending "str", in characters,
1366 not counting any line-dependent padding. */
1369 string_cost (str)
1370 char *str;
1372 cost = 0;
1373 if (str)
1374 tputs (str, 0, evalcost);
1375 return cost;
1378 /* Compute cost of sending "str", in characters,
1379 counting any line-dependent padding at one line. */
1381 static int
1382 string_cost_one_line (str)
1383 char *str;
1385 cost = 0;
1386 if (str)
1387 tputs (str, 1, evalcost);
1388 return cost;
1391 /* Compute per line amount of line-dependent padding,
1392 in tenths of characters. */
1395 per_line_cost (str)
1396 register char *str;
1398 cost = 0;
1399 if (str)
1400 tputs (str, 0, evalcost);
1401 cost = - cost;
1402 if (str)
1403 tputs (str, 10, evalcost);
1404 return cost;
1407 #ifndef old
1408 /* char_ins_del_cost[n] is cost of inserting N characters.
1409 char_ins_del_cost[-n] is cost of deleting N characters.
1410 The length of this vector is based on max_frame_width. */
1412 int *char_ins_del_vector;
1414 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_WIDTH ((f))])
1415 #endif
1417 /* ARGSUSED */
1418 static void
1419 calculate_ins_del_char_costs (frame)
1420 FRAME_PTR frame;
1422 int ins_startup_cost, del_startup_cost;
1423 int ins_cost_per_char, del_cost_per_char;
1424 register int i;
1425 register int *p;
1427 if (TS_ins_multi_chars)
1429 ins_cost_per_char = 0;
1430 ins_startup_cost = string_cost_one_line (TS_ins_multi_chars);
1432 else if (TS_ins_char || TS_pad_inserted_char
1433 || (TS_insert_mode && TS_end_insert_mode))
1435 ins_startup_cost = (30 * (string_cost (TS_insert_mode)
1436 + string_cost (TS_end_insert_mode))) / 100;
1437 ins_cost_per_char = (string_cost_one_line (TS_ins_char)
1438 + string_cost_one_line (TS_pad_inserted_char));
1440 else
1442 ins_startup_cost = 9999;
1443 ins_cost_per_char = 0;
1446 if (TS_del_multi_chars)
1448 del_cost_per_char = 0;
1449 del_startup_cost = string_cost_one_line (TS_del_multi_chars);
1451 else if (TS_del_char)
1453 del_startup_cost = (string_cost (TS_delete_mode)
1454 + string_cost (TS_end_delete_mode));
1455 if (delete_in_insert_mode)
1456 del_startup_cost /= 2;
1457 del_cost_per_char = string_cost_one_line (TS_del_char);
1459 else
1461 del_startup_cost = 9999;
1462 del_cost_per_char = 0;
1465 /* Delete costs are at negative offsets */
1466 p = &char_ins_del_cost (frame)[0];
1467 for (i = FRAME_WIDTH (frame); --i >= 0;)
1468 *--p = (del_startup_cost += del_cost_per_char);
1470 /* Doing nothing is free */
1471 p = &char_ins_del_cost (frame)[0];
1472 *p++ = 0;
1474 /* Insert costs are at positive offsets */
1475 for (i = FRAME_WIDTH (frame); --i >= 0;)
1476 *p++ = (ins_startup_cost += ins_cost_per_char);
1479 void
1480 calculate_costs (frame)
1481 FRAME_PTR frame;
1483 register char *f = (TS_set_scroll_region
1484 ? TS_set_scroll_region
1485 : TS_set_scroll_region_1);
1487 FRAME_COST_BAUD_RATE (frame) = baud_rate;
1489 scroll_region_cost = string_cost (f);
1491 /* These variables are only used for terminal stuff. They are allocated
1492 once for the terminal frame of X-windows emacs, but not used afterwards.
1494 char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
1495 X turns off char_ins_del_ok.
1497 chars_wasted and copybuf are only used here in term.c in cases where
1498 the term hook isn't called. */
1500 max_frame_height = max (max_frame_height, FRAME_HEIGHT (frame));
1501 max_frame_width = max (max_frame_width, FRAME_WIDTH (frame));
1503 if (chars_wasted != 0)
1504 chars_wasted = (char *) xrealloc (chars_wasted, max_frame_height);
1505 else
1506 chars_wasted = (char *) xmalloc (max_frame_height);
1508 if (copybuf != 0)
1509 copybuf = (char *) xrealloc (copybuf, max_frame_height);
1510 else
1511 copybuf = (char *) xmalloc (max_frame_height);
1513 if (char_ins_del_vector != 0)
1514 char_ins_del_vector
1515 = (int *) xrealloc (char_ins_del_vector,
1516 (sizeof (int)
1517 + 2 * max_frame_width * sizeof (int)));
1518 else
1519 char_ins_del_vector
1520 = (int *) xmalloc (sizeof (int)
1521 + 2 * max_frame_width * sizeof (int));
1523 bzero (chars_wasted, max_frame_height);
1524 bzero (copybuf, max_frame_height);
1525 bzero (char_ins_del_vector, (sizeof (int)
1526 + 2 * max_frame_width * sizeof (int)));
1528 if (f && (!TS_ins_line && !TS_del_line))
1529 do_line_insertion_deletion_costs (frame,
1530 TS_rev_scroll, TS_ins_multi_lines,
1531 TS_fwd_scroll, TS_del_multi_lines,
1532 f, f, 1);
1533 else
1534 do_line_insertion_deletion_costs (frame,
1535 TS_ins_line, TS_ins_multi_lines,
1536 TS_del_line, TS_del_multi_lines,
1537 0, 0, 1);
1539 calculate_ins_del_char_costs (frame);
1541 /* Don't use TS_repeat if its padding is worse than sending the chars */
1542 if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
1543 RPov = string_cost (TS_repeat);
1544 else
1545 RPov = FRAME_WIDTH (frame) * 2;
1547 cmcostinit (); /* set up cursor motion costs */
1550 struct fkey_table {
1551 char *cap, *name;
1554 /* Termcap capability names that correspond directly to X keysyms.
1555 Some of these (marked "terminfo") aren't supplied by old-style
1556 (Berkeley) termcap entries. They're listed in X keysym order;
1557 except we put the keypad keys first, so that if they clash with
1558 other keys (as on the IBM PC keyboard) they get overridden.
1561 static struct fkey_table keys[] =
1563 "kh", "home", /* termcap */
1564 "kl", "left", /* termcap */
1565 "ku", "up", /* termcap */
1566 "kr", "right", /* termcap */
1567 "kd", "down", /* termcap */
1568 "%8", "prior", /* terminfo */
1569 "%5", "next", /* terminfo */
1570 "@7", "end", /* terminfo */
1571 "@1", "begin", /* terminfo */
1572 "*6", "select", /* terminfo */
1573 "%9", "print", /* terminfo */
1574 "@4", "execute", /* terminfo --- actually the `command' key */
1576 * "insert" --- see below
1578 "&8", "undo", /* terminfo */
1579 "%0", "redo", /* terminfo */
1580 "%7", "menu", /* terminfo --- actually the `options' key */
1581 "@0", "find", /* terminfo */
1582 "@2", "cancel", /* terminfo */
1583 "%1", "help", /* terminfo */
1585 * "break" goes here, but can't be reliably intercepted with termcap
1587 "&4", "reset", /* terminfo --- actually `restart' */
1589 * "system" and "user" --- no termcaps
1591 "kE", "clearline", /* terminfo */
1592 "kA", "insertline", /* terminfo */
1593 "kL", "deleteline", /* terminfo */
1594 "kI", "insertchar", /* terminfo */
1595 "kD", "deletechar", /* terminfo */
1596 "kB", "backtab", /* terminfo */
1598 * "kp_backtab", "kp-space", "kp-tab" --- no termcaps
1600 "@8", "kp-enter", /* terminfo */
1602 * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1603 * "kp-multiply", "kp-add", "kp-separator",
1604 * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1605 * --- no termcaps for any of these.
1607 "K4", "kp-1", /* terminfo */
1609 * "kp-2" --- no termcap
1611 "K5", "kp-3", /* terminfo */
1613 * "kp-4" --- no termcap
1615 "K2", "kp-5", /* terminfo */
1617 * "kp-6" --- no termcap
1619 "K1", "kp-7", /* terminfo */
1621 * "kp-8" --- no termcap
1623 "K3", "kp-9", /* terminfo */
1625 * "kp-equal" --- no termcap
1627 "k1", "f1",
1628 "k2", "f2",
1629 "k3", "f3",
1630 "k4", "f4",
1631 "k5", "f5",
1632 "k6", "f6",
1633 "k7", "f7",
1634 "k8", "f8",
1635 "k9", "f9",
1638 static char **term_get_fkeys_arg;
1639 static Lisp_Object term_get_fkeys_1 ();
1641 /* Find the escape codes sent by the function keys for Vfunction_key_map.
1642 This function scans the termcap function key sequence entries, and
1643 adds entries to Vfunction_key_map for each function key it finds. */
1645 void
1646 term_get_fkeys (address)
1647 char **address;
1649 /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1650 errors during the call. The only errors should be from Fdefine_key
1651 when given a key sequence containing an invalid prefix key. If the
1652 termcap defines function keys which use a prefix that is already bound
1653 to a command by the default bindings, we should silently ignore that
1654 function key specification, rather than giving the user an error and
1655 refusing to run at all on such a terminal. */
1657 extern Lisp_Object Fidentity ();
1658 term_get_fkeys_arg = address;
1659 internal_condition_case (term_get_fkeys_1, Qerror, Fidentity);
1662 static Lisp_Object
1663 term_get_fkeys_1 ()
1665 int i;
1667 char **address = term_get_fkeys_arg;
1669 /* This can happen if CANNOT_DUMP or with strange options. */
1670 if (!initialized)
1671 Vfunction_key_map = Fmake_sparse_keymap (Qnil);
1673 for (i = 0; i < (sizeof (keys)/sizeof (keys[0])); i++)
1675 char *sequence = tgetstr (keys[i].cap, address);
1676 if (sequence)
1677 Fdefine_key (Vfunction_key_map, build_string (sequence),
1678 Fmake_vector (make_number (1),
1679 intern (keys[i].name)));
1682 /* The uses of the "k0" capability are inconsistent; sometimes it
1683 describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1684 We will attempt to politely accommodate both systems by testing for
1685 "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1688 char *k_semi = tgetstr ("k;", address);
1689 char *k0 = tgetstr ("k0", address);
1690 char *k0_name = "f10";
1692 if (k_semi)
1694 Fdefine_key (Vfunction_key_map, build_string (k_semi),
1695 Fmake_vector (make_number (1), intern ("f10")));
1696 k0_name = "f0";
1699 if (k0)
1700 Fdefine_key (Vfunction_key_map, build_string (k0),
1701 Fmake_vector (make_number (1), intern (k0_name)));
1704 /* Set up cookies for numbered function keys above f10. */
1706 char fcap[3], fkey[4];
1708 fcap[0] = 'F'; fcap[2] = '\0';
1709 for (i = 11; i < 64; i++)
1711 if (i <= 19)
1712 fcap[1] = '1' + i - 11;
1713 else if (i <= 45)
1714 fcap[1] = 'A' + i - 20;
1715 else
1716 fcap[1] = 'a' + i - 46;
1719 char *sequence = tgetstr (fcap, address);
1720 if (sequence)
1722 sprintf (fkey, "f%d", i);
1723 Fdefine_key (Vfunction_key_map, build_string (sequence),
1724 Fmake_vector (make_number (1),
1725 intern (fkey)));
1732 * Various mappings to try and get a better fit.
1735 #define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
1736 if (!tgetstr (cap1, address)) \
1738 char *sequence = tgetstr (cap2, address); \
1739 if (sequence) \
1740 Fdefine_key (Vfunction_key_map, build_string (sequence), \
1741 Fmake_vector (make_number (1), \
1742 intern (sym))); \
1745 /* if there's no key_next keycap, map key_npage to `next' keysym */
1746 CONDITIONAL_REASSIGN ("%5", "kN", "next");
1747 /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1748 CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1749 /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1750 CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1751 /* if there's no key_end keycap, map key_ll to 'end' keysym */
1752 CONDITIONAL_REASSIGN ("@7", "kH", "end");
1754 /* IBM has their own non-standard dialect of terminfo.
1755 If the standard name isn't found, try the IBM name. */
1756 CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
1757 CONDITIONAL_REASSIGN ("@4", "kJ", "execute"); /* actually "action" */
1758 CONDITIONAL_REASSIGN ("@4", "kc", "execute"); /* actually "command" */
1759 CONDITIONAL_REASSIGN ("%7", "ki", "menu");
1760 CONDITIONAL_REASSIGN ("@7", "kw", "end");
1761 CONDITIONAL_REASSIGN ("F1", "k<", "f11");
1762 CONDITIONAL_REASSIGN ("F2", "k>", "f12");
1763 CONDITIONAL_REASSIGN ("%1", "kq", "help");
1764 CONDITIONAL_REASSIGN ("*6", "kU", "select");
1765 #undef CONDITIONAL_REASSIGN
1768 return Qnil;
1772 /***********************************************************************
1773 Character Display Information
1774 ***********************************************************************/
1776 static void append_glyph P_ ((struct it *));
1779 /* Append glyphs to IT's glyph_row. Called from produce_glyphs for
1780 terminal frames if IT->glyph_row != NULL. IT->c is the character
1781 for which to produce glyphs; IT->face_id contains the character's
1782 face. Padding glyphs are appended if IT->c has a IT->pixel_width >
1783 1. */
1785 static void
1786 append_glyph (it)
1787 struct it *it;
1789 struct glyph *glyph, *end;
1790 int i;
1792 xassert (it->glyph_row);
1793 glyph = (it->glyph_row->glyphs[it->area]
1794 + it->glyph_row->used[it->area]);
1795 end = it->glyph_row->glyphs[1 + it->area];
1797 for (i = 0;
1798 i < it->pixel_width && glyph < end;
1799 ++i)
1801 glyph->type = CHAR_GLYPH;
1802 glyph->pixel_width = 1;
1803 glyph->u.ch = it->c;
1804 glyph->face_id = it->face_id;
1805 glyph->padding_p = i > 0;
1806 glyph->charpos = CHARPOS (it->position);
1807 glyph->object = it->object;
1809 ++it->glyph_row->used[it->area];
1810 ++glyph;
1815 /* Produce glyphs for the display element described by IT. The
1816 function fills output fields of IT with pixel information like the
1817 pixel width and height of a character, and maybe produces glyphs at
1818 the same time if IT->glyph_row is non-null. See the explanation of
1819 struct display_iterator in dispextern.h for an overview. */
1821 void
1822 produce_glyphs (it)
1823 struct it *it;
1825 /* If a hook is installed, let it do the work. */
1826 xassert (it->what == IT_CHARACTER
1827 || it->what == IT_COMPOSITION
1828 || it->what == IT_IMAGE
1829 || it->what == IT_STRETCH);
1831 /* Nothing but characters are supported on terminal frames. For a
1832 composition sequence, it->c is the first character of the
1833 sequence. */
1834 xassert (it->what == IT_CHARACTER
1835 || it->what == IT_COMPOSITION);
1837 if (it->c >= 040 && it->c < 0177)
1839 it->pixel_width = it->nglyphs = 1;
1840 if (it->glyph_row)
1841 append_glyph (it);
1843 else if (it->c == '\n')
1844 it->pixel_width = it->nglyphs = 0;
1845 else if (it->c == '\t')
1847 int absolute_x = (it->current_x
1848 + it->continuation_lines_width);
1849 int next_tab_x
1850 = (((1 + absolute_x + it->tab_width - 1)
1851 / it->tab_width)
1852 * it->tab_width);
1853 int nspaces;
1855 /* If part of the TAB has been displayed on the previous line
1856 which is continued now, continuation_lines_width will have
1857 been incremented already by the part that fitted on the
1858 continued line. So, we will get the right number of spaces
1859 here. */
1860 nspaces = next_tab_x - absolute_x;
1862 if (it->glyph_row)
1864 int n = nspaces;
1866 it->c = ' ';
1867 it->pixel_width = it->len = 1;
1869 while (n--)
1870 append_glyph (it);
1872 it->c = '\t';
1875 it->pixel_width = nspaces;
1876 it->nglyphs = nspaces;
1878 else if (SINGLE_BYTE_CHAR_P (it->c))
1880 /* Coming here means that it->c is from display table, thus we
1881 must send the code as is to the terminal. Although there's
1882 no way to know how many columns it occupies on a screen, it
1883 is a good assumption that a single byte code has 1-column
1884 width. */
1885 it->pixel_width = it->nglyphs = 1;
1886 if (it->glyph_row)
1887 append_glyph (it);
1889 else
1891 /* A multi-byte character. The display width is fixed for all
1892 characters of the set. Some of the glyphs may have to be
1893 ignored because they are already displayed in a continued
1894 line. */
1895 int charset = CHAR_CHARSET (it->c);
1897 it->pixel_width = CHARSET_WIDTH (charset);
1898 it->nglyphs = it->pixel_width;
1900 if (it->glyph_row)
1901 append_glyph (it);
1904 /* Advance current_x by the pixel width as a convenience for
1905 the caller. */
1906 if (it->area == TEXT_AREA)
1907 it->current_x += it->pixel_width;
1908 it->ascent = it->max_ascent = it->phys_ascent = it->max_phys_ascent = 0;
1909 it->descent = it->max_descent = it->phys_descent = it->max_phys_descent = 1;
1913 /* Get information about special display element WHAT in an
1914 environment described by IT. WHAT is one of IT_TRUNCATION or
1915 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
1916 non-null glyph_row member. This function ensures that fields like
1917 face_id, c, len of IT are left untouched. */
1919 void
1920 produce_special_glyphs (it, what)
1921 struct it *it;
1922 enum display_element_type what;
1924 struct it temp_it;
1926 temp_it = *it;
1927 temp_it.dp = NULL;
1928 temp_it.what = IT_CHARACTER;
1929 temp_it.len = 1;
1930 temp_it.object = make_number (0);
1931 bzero (&temp_it.current, sizeof temp_it.current);
1933 if (what == IT_CONTINUATION)
1935 /* Continuation glyph. */
1936 if (it->dp
1937 && INTEGERP (DISP_CONTINUE_GLYPH (it->dp))
1938 && GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (it->dp))))
1940 temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_CONTINUE_GLYPH (it->dp)));
1941 temp_it.len = CHAR_BYTES (temp_it.c);
1943 else
1944 temp_it.c = '\\';
1946 produce_glyphs (&temp_it);
1947 it->pixel_width = temp_it.pixel_width;
1948 it->nglyphs = temp_it.pixel_width;
1950 else if (what == IT_TRUNCATION)
1952 /* Truncation glyph. */
1953 if (it->dp
1954 && INTEGERP (DISP_TRUNC_GLYPH (it->dp))
1955 && GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (it->dp))))
1957 temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_TRUNC_GLYPH (it->dp)));
1958 temp_it.len = CHAR_BYTES (temp_it.c);
1960 else
1961 temp_it.c = '$';
1963 produce_glyphs (&temp_it);
1964 it->pixel_width = temp_it.pixel_width;
1965 it->nglyphs = temp_it.pixel_width;
1967 else
1968 abort ();
1972 /* Return an estimation of the pixel height of mode or top lines on
1973 frame F. FACE_ID specifies what line's height to estimate. */
1976 estimate_mode_line_height (f, face_id)
1977 struct frame *f;
1978 enum face_id face_id;
1980 if (estimate_mode_line_height_hook)
1981 return estimate_mode_line_height_hook (f, face_id);
1982 else
1983 return 1;
1988 /***********************************************************************
1989 Faces
1990 ***********************************************************************/
1992 /* Value is non-zero if attribute ATTR may be used. ATTR should be
1993 one of the enumerators from enum no_color_bit, or a bit set built
1994 from them. Some display attributes may not be used together with
1995 color; the termcap capability `NC' specifies which ones. */
1997 #define MAY_USE_WITH_COLORS_P(ATTR) \
1998 (TN_max_colors > 0 \
1999 ? (TN_no_color_video & (ATTR)) == 0 \
2000 : 1)
2002 /* Turn appearances of face FACE_ID on tty frame F on. */
2004 static void
2005 turn_on_face (f, face_id)
2006 struct frame *f;
2007 int face_id;
2009 struct face *face = FACE_FROM_ID (f, face_id);
2011 xassert (face != NULL);
2013 if (face->tty_bold_p)
2015 if (MAY_USE_WITH_COLORS_P (NC_BOLD))
2016 OUTPUT1_IF (TS_enter_bold_mode);
2018 else if (face->tty_dim_p)
2019 if (MAY_USE_WITH_COLORS_P (NC_DIM))
2020 OUTPUT1_IF (TS_enter_dim_mode);
2022 /* Alternate charset and blinking not yet used. */
2023 if (face->tty_alt_charset_p
2024 && MAY_USE_WITH_COLORS_P (NC_ALT_CHARSET))
2025 OUTPUT1_IF (TS_enter_alt_charset_mode);
2027 if (face->tty_blinking_p
2028 && MAY_USE_WITH_COLORS_P (NC_BLINK))
2029 OUTPUT1_IF (TS_enter_blink_mode);
2031 if (face->tty_underline_p
2032 /* Don't underline if that's difficult. */
2033 && TN_magic_cookie_glitch_ul <= 0
2034 && MAY_USE_WITH_COLORS_P (NC_UNDERLINE))
2035 OUTPUT1_IF (TS_enter_underline_mode);
2037 if (MAY_USE_WITH_COLORS_P (NC_REVERSE))
2038 if (face->tty_reverse_p
2039 || face->foreground == FACE_TTY_DEFAULT_BG_COLOR
2040 || face->background == FACE_TTY_DEFAULT_FG_COLOR)
2041 OUTPUT1_IF (TS_enter_reverse_mode);
2043 if (TN_max_colors > 0)
2045 char *p;
2047 if (face->foreground != FACE_TTY_DEFAULT_COLOR
2048 && face->foreground != FACE_TTY_DEFAULT_FG_COLOR
2049 && face->foreground != FACE_TTY_DEFAULT_BG_COLOR
2050 && TS_set_foreground)
2052 p = tparam (TS_set_foreground, NULL, 0, (int) face->foreground);
2053 OUTPUT (p);
2054 xfree (p);
2057 if (face->background != FACE_TTY_DEFAULT_COLOR
2058 && face->background != FACE_TTY_DEFAULT_BG_COLOR
2059 && face->background != FACE_TTY_DEFAULT_FG_COLOR
2060 && TS_set_background)
2062 p = tparam (TS_set_background, NULL, 0, (int) face->background);
2063 OUTPUT (p);
2064 xfree (p);
2070 /* Turn off appearances of face FACE_ID on tty frame F. */
2072 static void
2073 turn_off_face (f, face_id)
2074 struct frame *f;
2075 int face_id;
2077 struct face *face = FACE_FROM_ID (f, face_id);
2079 xassert (face != NULL);
2081 if (TS_exit_attribute_mode)
2083 /* Capability "me" will turn off appearance modes double-bright,
2084 half-bright, reverse-video, standout, underline. It may or
2085 may not turn off alt-char-mode. */
2086 if (face->tty_bold_p
2087 || face->tty_dim_p
2088 || face->tty_reverse_p
2089 || face->tty_alt_charset_p
2090 || face->tty_blinking_p
2091 || face->tty_underline_p)
2093 OUTPUT1_IF (TS_exit_attribute_mode);
2094 if (strcmp (TS_exit_attribute_mode, TS_end_standout_mode) == 0)
2095 standout_mode = 0;
2098 if (face->tty_alt_charset_p)
2099 OUTPUT_IF (TS_exit_alt_charset_mode);
2101 else
2103 /* If we don't have "me" we can only have those appearances
2104 that have exit sequences defined. */
2105 if (face->tty_alt_charset_p)
2106 OUTPUT_IF (TS_exit_alt_charset_mode);
2108 if (face->tty_underline_p
2109 /* We don't underline if that's difficult. */
2110 && TN_magic_cookie_glitch_ul <= 0)
2111 OUTPUT_IF (TS_exit_underline_mode);
2114 /* Switch back to default colors. */
2115 if (TN_max_colors > 0
2116 && ((face->foreground != FACE_TTY_DEFAULT_COLOR
2117 && face->foreground != FACE_TTY_DEFAULT_FG_COLOR)
2118 || (face->background != FACE_TTY_DEFAULT_COLOR
2119 && face->background != FACE_TTY_DEFAULT_BG_COLOR)))
2120 OUTPUT1_IF (TS_orig_pair);
2124 /* Return non-zero if the terminal is capable to display colors. */
2126 DEFUN ("tty-display-color-p", Ftty_display_color_p, Stty_display_color_p,
2127 0, 1, 0,
2128 "Return non-nil if TTY can display colors on FRAME.")
2129 (frame)
2130 Lisp_Object frame;
2132 return TN_max_colors > 0 ? Qt : Qnil;
2138 /***********************************************************************
2139 Initialization
2140 ***********************************************************************/
2142 void
2143 term_init (terminal_type)
2144 char *terminal_type;
2146 char *area;
2147 char **address = &area;
2148 char buffer[2044];
2149 register char *p;
2150 int status;
2151 struct frame *sf = XFRAME (selected_frame);
2153 #ifdef WINDOWSNT
2154 initialize_w32_display ();
2156 Wcm_clear ();
2158 area = (char *) xmalloc (2044);
2160 if (area == 0)
2161 abort ();
2163 FrameRows = FRAME_HEIGHT (sf);
2164 FrameCols = FRAME_WIDTH (sf);
2165 specified_window = FRAME_HEIGHT (sf);
2167 delete_in_insert_mode = 1;
2169 UseTabs = 0;
2170 scroll_region_ok = 0;
2172 /* Seems to insert lines when it's not supposed to, messing
2173 up the display. In doing a trace, it didn't seem to be
2174 called much, so I don't think we're losing anything by
2175 turning it off. */
2177 line_ins_del_ok = 0;
2178 char_ins_del_ok = 1;
2180 baud_rate = 19200;
2182 FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
2183 FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
2184 TN_max_colors = 16; /* Required to be non-zero for tty-display-color-p */
2186 return;
2187 #else /* not WINDOWSNT */
2189 Wcm_clear ();
2191 status = tgetent (buffer, terminal_type);
2192 if (status < 0)
2194 #ifdef TERMINFO
2195 fatal ("Cannot open terminfo database file");
2196 #else
2197 fatal ("Cannot open termcap database file");
2198 #endif
2200 if (status == 0)
2202 #ifdef TERMINFO
2203 fatal ("Terminal type %s is not defined.\n\
2204 If that is not the actual type of terminal you have,\n\
2205 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2206 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2207 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
2208 terminal_type);
2209 #else
2210 fatal ("Terminal type %s is not defined.\n\
2211 If that is not the actual type of terminal you have,\n\
2212 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2213 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2214 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
2215 terminal_type);
2216 #endif
2218 #ifdef TERMINFO
2219 area = (char *) xmalloc (2044);
2220 #else
2221 area = (char *) xmalloc (strlen (buffer));
2222 #endif /* not TERMINFO */
2223 if (area == 0)
2224 abort ();
2226 TS_ins_line = tgetstr ("al", address);
2227 TS_ins_multi_lines = tgetstr ("AL", address);
2228 TS_bell = tgetstr ("bl", address);
2229 BackTab = tgetstr ("bt", address);
2230 TS_clr_to_bottom = tgetstr ("cd", address);
2231 TS_clr_line = tgetstr ("ce", address);
2232 TS_clr_frame = tgetstr ("cl", address);
2233 ColPosition = NULL; /* tgetstr ("ch", address); */
2234 AbsPosition = tgetstr ("cm", address);
2235 CR = tgetstr ("cr", address);
2236 TS_set_scroll_region = tgetstr ("cs", address);
2237 TS_set_scroll_region_1 = tgetstr ("cS", address);
2238 RowPosition = tgetstr ("cv", address);
2239 TS_del_char = tgetstr ("dc", address);
2240 TS_del_multi_chars = tgetstr ("DC", address);
2241 TS_del_line = tgetstr ("dl", address);
2242 TS_del_multi_lines = tgetstr ("DL", address);
2243 TS_delete_mode = tgetstr ("dm", address);
2244 TS_end_delete_mode = tgetstr ("ed", address);
2245 TS_end_insert_mode = tgetstr ("ei", address);
2246 Home = tgetstr ("ho", address);
2247 TS_ins_char = tgetstr ("ic", address);
2248 TS_ins_multi_chars = tgetstr ("IC", address);
2249 TS_insert_mode = tgetstr ("im", address);
2250 TS_pad_inserted_char = tgetstr ("ip", address);
2251 TS_end_keypad_mode = tgetstr ("ke", address);
2252 TS_keypad_mode = tgetstr ("ks", address);
2253 LastLine = tgetstr ("ll", address);
2254 Right = tgetstr ("nd", address);
2255 Down = tgetstr ("do", address);
2256 if (!Down)
2257 Down = tgetstr ("nl", address); /* Obsolete name for "do" */
2258 #ifdef VMS
2259 /* VMS puts a carriage return before each linefeed,
2260 so it is not safe to use linefeeds. */
2261 if (Down && Down[0] == '\n' && Down[1] == '\0')
2262 Down = 0;
2263 #endif /* VMS */
2264 if (tgetflag ("bs"))
2265 Left = "\b"; /* can't possibly be longer! */
2266 else /* (Actually, "bs" is obsolete...) */
2267 Left = tgetstr ("le", address);
2268 if (!Left)
2269 Left = tgetstr ("bc", address); /* Obsolete name for "le" */
2270 TS_pad_char = tgetstr ("pc", address);
2271 TS_repeat = tgetstr ("rp", address);
2272 TS_end_standout_mode = tgetstr ("se", address);
2273 TS_fwd_scroll = tgetstr ("sf", address);
2274 TS_standout_mode = tgetstr ("so", address);
2275 TS_rev_scroll = tgetstr ("sr", address);
2276 Wcm.cm_tab = tgetstr ("ta", address);
2277 TS_end_termcap_modes = tgetstr ("te", address);
2278 TS_termcap_modes = tgetstr ("ti", address);
2279 Up = tgetstr ("up", address);
2280 TS_visible_bell = tgetstr ("vb", address);
2281 TS_cursor_normal = tgetstr ("ve", address);
2282 TS_cursor_visible = tgetstr ("vs", address);
2283 TS_cursor_invisible = tgetstr ("vi", address);
2284 TS_set_window = tgetstr ("wi", address);
2286 TS_enter_underline_mode = tgetstr ("us", address);
2287 TS_exit_underline_mode = tgetstr ("ue", address);
2288 TN_magic_cookie_glitch_ul = tgetnum ("ug");
2289 TS_enter_bold_mode = tgetstr ("md", address);
2290 TS_enter_dim_mode = tgetstr ("mh", address);
2291 TS_enter_blink_mode = tgetstr ("mb", address);
2292 TS_enter_reverse_mode = tgetstr ("mr", address);
2293 TS_enter_alt_charset_mode = tgetstr ("as", address);
2294 TS_exit_alt_charset_mode = tgetstr ("ae", address);
2295 TS_exit_attribute_mode = tgetstr ("me", address);
2297 MultiUp = tgetstr ("UP", address);
2298 MultiDown = tgetstr ("DO", address);
2299 MultiLeft = tgetstr ("LE", address);
2300 MultiRight = tgetstr ("RI", address);
2302 /* SVr4/ANSI color suppert. If "op" isn't available, don't support
2303 color because we can't switch back to the default foreground and
2304 background. */
2305 TS_orig_pair = tgetstr ("op", address);
2306 if (TS_orig_pair)
2308 TS_set_foreground = tgetstr ("AF", address);
2309 TS_set_background = tgetstr ("AB", address);
2310 if (!TS_set_foreground)
2312 /* SVr4. */
2313 TS_set_foreground = tgetstr ("Sf", address);
2314 TS_set_background = tgetstr ("Sb", address);
2317 TN_max_colors = tgetnum ("Co");
2318 TN_max_pairs = tgetnum ("pa");
2320 TN_no_color_video = tgetnum ("NC");
2321 if (TN_no_color_video == -1)
2322 TN_no_color_video = 0;
2325 MagicWrap = tgetflag ("xn");
2326 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
2327 the former flag imply the latter. */
2328 AutoWrap = MagicWrap || tgetflag ("am");
2329 memory_below_frame = tgetflag ("db");
2330 TF_hazeltine = tgetflag ("hz");
2331 must_write_spaces = tgetflag ("in");
2332 meta_key = tgetflag ("km") || tgetflag ("MT");
2333 TF_insmode_motion = tgetflag ("mi");
2334 TF_standout_motion = tgetflag ("ms");
2335 TF_underscore = tgetflag ("ul");
2336 TF_xs = tgetflag ("xs");
2337 TF_teleray = tgetflag ("xt");
2339 term_get_fkeys (address);
2341 /* Get frame size from system, or else from termcap. */
2343 int height, width;
2344 get_frame_size (&width, &height);
2345 FRAME_WIDTH (sf) = width;
2346 FRAME_HEIGHT (sf) = height;
2349 if (FRAME_WIDTH (sf) <= 0)
2350 SET_FRAME_WIDTH (sf, tgetnum ("co"));
2351 else
2352 /* Keep width and external_width consistent */
2353 SET_FRAME_WIDTH (sf, FRAME_WIDTH (sf));
2354 if (FRAME_HEIGHT (sf) <= 0)
2355 FRAME_HEIGHT (sf) = tgetnum ("li");
2357 if (FRAME_HEIGHT (sf) < 3 || FRAME_WIDTH (sf) < 3)
2358 fatal ("Screen size %dx%d is too small",
2359 FRAME_HEIGHT (sf), FRAME_WIDTH (sf));
2361 min_padding_speed = tgetnum ("pb");
2362 TN_standout_width = tgetnum ("sg");
2363 TabWidth = tgetnum ("tw");
2365 #ifdef VMS
2366 /* These capabilities commonly use ^J.
2367 I don't know why, but sending them on VMS does not work;
2368 it causes following spaces to be lost, sometimes.
2369 For now, the simplest fix is to avoid using these capabilities ever. */
2370 if (Down && Down[0] == '\n')
2371 Down = 0;
2372 #endif /* VMS */
2374 if (!TS_bell)
2375 TS_bell = "\07";
2377 if (!TS_fwd_scroll)
2378 TS_fwd_scroll = Down;
2380 PC = TS_pad_char ? *TS_pad_char : 0;
2382 if (TabWidth < 0)
2383 TabWidth = 8;
2385 /* Turned off since /etc/termcap seems to have :ta= for most terminals
2386 and newer termcap doc does not seem to say there is a default.
2387 if (!Wcm.cm_tab)
2388 Wcm.cm_tab = "\t";
2391 if (TS_standout_mode == 0)
2393 TN_standout_width = tgetnum ("ug");
2394 TS_end_standout_mode = tgetstr ("ue", address);
2395 TS_standout_mode = tgetstr ("us", address);
2398 /* If no `se' string, try using a `me' string instead.
2399 If that fails, we can't use standout mode at all. */
2400 if (TS_end_standout_mode == 0)
2402 char *s = tgetstr ("me", address);
2403 if (s != 0)
2404 TS_end_standout_mode = s;
2405 else
2406 TS_standout_mode = 0;
2409 if (TF_teleray)
2411 Wcm.cm_tab = 0;
2412 /* Teleray: most programs want a space in front of TS_standout_mode,
2413 but Emacs can do without it (and give one extra column). */
2414 TS_standout_mode = "\033RD";
2415 TN_standout_width = 1;
2416 /* But that means we cannot rely on ^M to go to column zero! */
2417 CR = 0;
2418 /* LF can't be trusted either -- can alter hpos */
2419 /* if move at column 0 thru a line with TS_standout_mode */
2420 Down = 0;
2423 /* Special handling for certain terminal types known to need it */
2425 if (!strcmp (terminal_type, "supdup"))
2427 memory_below_frame = 1;
2428 Wcm.cm_losewrap = 1;
2430 if (!strncmp (terminal_type, "c10", 3)
2431 || !strcmp (terminal_type, "perq"))
2433 /* Supply a makeshift :wi string.
2434 This string is not valid in general since it works only
2435 for windows starting at the upper left corner;
2436 but that is all Emacs uses.
2438 This string works only if the frame is using
2439 the top of the video memory, because addressing is memory-relative.
2440 So first check the :ti string to see if that is true.
2442 It would be simpler if the :wi string could go in the termcap
2443 entry, but it can't because it is not fully valid.
2444 If it were in the termcap entry, it would confuse other programs. */
2445 if (!TS_set_window)
2447 p = TS_termcap_modes;
2448 while (*p && strcmp (p, "\033v "))
2449 p++;
2450 if (*p)
2451 TS_set_window = "\033v%C %C %C %C ";
2453 /* Termcap entry often fails to have :in: flag */
2454 must_write_spaces = 1;
2455 /* :ti string typically fails to have \E^G! in it */
2456 /* This limits scope of insert-char to one line. */
2457 strcpy (area, TS_termcap_modes);
2458 strcat (area, "\033\007!");
2459 TS_termcap_modes = area;
2460 area += strlen (area) + 1;
2461 p = AbsPosition;
2462 /* Change all %+ parameters to %C, to handle
2463 values above 96 correctly for the C100. */
2464 while (*p)
2466 if (p[0] == '%' && p[1] == '+')
2467 p[1] = 'C';
2468 p++;
2472 FrameRows = FRAME_HEIGHT (sf);
2473 FrameCols = FRAME_WIDTH (sf);
2474 specified_window = FRAME_HEIGHT (sf);
2476 if (Wcm_init () == -1) /* can't do cursor motion */
2477 #ifdef VMS
2478 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2479 It lacks the ability to position the cursor.\n\
2480 If that is not the actual type of terminal you have, use either the\n\
2481 DCL command `SET TERMINAL/DEVICE= ...' for DEC-compatible terminals,\n\
2482 or `define EMACS_TERM \"terminal type\"' for non-DEC terminals.",
2483 terminal_type);
2484 #else /* not VMS */
2485 # ifdef TERMINFO
2486 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2487 It lacks the ability to position the cursor.\n\
2488 If that is not the actual type of terminal you have,\n\
2489 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2490 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2491 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
2492 terminal_type);
2493 # else /* TERMCAP */
2494 fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
2495 It lacks the ability to position the cursor.\n\
2496 If that is not the actual type of terminal you have,\n\
2497 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
2498 `setenv TERM ...') to specify the correct type. It may be necessary\n\
2499 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
2500 terminal_type);
2501 # endif /* TERMINFO */
2502 #endif /*VMS */
2503 if (FRAME_HEIGHT (sf) <= 0
2504 || FRAME_WIDTH (sf) <= 0)
2505 fatal ("The frame size has not been specified");
2507 delete_in_insert_mode
2508 = TS_delete_mode && TS_insert_mode
2509 && !strcmp (TS_delete_mode, TS_insert_mode);
2511 se_is_so = (TS_standout_mode
2512 && TS_end_standout_mode
2513 && !strcmp (TS_standout_mode, TS_end_standout_mode));
2515 /* Remove width of standout marker from usable width of line */
2516 if (TN_standout_width > 0)
2517 SET_FRAME_WIDTH (sf, FRAME_WIDTH (sf) - TN_standout_width);
2519 UseTabs = tabs_safe_p () && TabWidth == 8;
2521 scroll_region_ok
2522 = (Wcm.cm_abs
2523 && (TS_set_window || TS_set_scroll_region || TS_set_scroll_region_1));
2525 line_ins_del_ok = (((TS_ins_line || TS_ins_multi_lines)
2526 && (TS_del_line || TS_del_multi_lines))
2527 || (scroll_region_ok && TS_fwd_scroll && TS_rev_scroll));
2529 char_ins_del_ok = ((TS_ins_char || TS_insert_mode
2530 || TS_pad_inserted_char || TS_ins_multi_chars)
2531 && (TS_del_char || TS_del_multi_chars));
2533 fast_clear_end_of_line = TS_clr_line != 0;
2535 init_baud_rate ();
2536 if (read_socket_hook) /* Baudrate is somewhat */
2537 /* meaningless in this case */
2538 baud_rate = 9600;
2540 FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
2541 FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
2542 #endif /* WINDOWSNT */
2545 /* VARARGS 1 */
2546 void
2547 fatal (str, arg1, arg2)
2548 char *str, *arg1, *arg2;
2550 fprintf (stderr, "emacs: ");
2551 fprintf (stderr, str, arg1, arg2);
2552 fprintf (stderr, "\n");
2553 fflush (stderr);
2554 exit (1);
2557 void
2558 syms_of_term ()
2560 DEFVAR_BOOL ("system-uses-terminfo", &system_uses_terminfo,
2561 "Non-nil means the system uses terminfo rather than termcap.\n\
2562 This variable can be used by terminal emulator packages.");
2563 #ifdef TERMINFO
2564 system_uses_terminfo = 1;
2565 #else
2566 system_uses_terminfo = 0;
2567 #endif
2569 DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
2570 "Non-nil means call this function to ring the bell.\n\
2571 The function should accept no arguments.");
2572 Vring_bell_function = Qnil;
2574 defsubr (&Stty_display_color_p);