#include <config.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "termchar.h"
#include "termopts.h"
#include "lisp.h"
#include "charset.h"
#include "coding.h"
#include "keyboard.h"
#include "frame.h"
#include "disptab.h"
#include "termhooks.h"
#include "dispextern.h"
#include "window.h"
#include "keymap.h"
#include "blockinput.h"
#if defined HAVE_TERMCAP_H && 0
#include <termcap.h>
#else
extern void tputs P_ ((const char *, int, int (*)(int)));
extern int tgetent P_ ((char *, const char *));
extern int tgetflag P_ ((char *id));
extern int tgetnum P_ ((char *id));
#endif
#include "cm.h"
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif
#ifdef MAC_OS
#include "macterm.h"
#endif
static void turn_on_face P_ ((struct frame *, int face_id));
static void turn_off_face P_ ((struct frame *, int face_id));
static void tty_show_cursor P_ ((void));
static void tty_hide_cursor P_ ((void));
#define OUTPUT(a) \
tputs (a, (int) (FRAME_LINES (XFRAME (selected_frame)) - curY), cmputc)
#define OUTPUT1(a) tputs (a, 1, cmputc)
#define OUTPUTL(a, lines) tputs (a, lines, cmputc)
#define OUTPUT_IF(a) \
do { \
if (a) \
tputs (a, (int) (FRAME_LINES (XFRAME (selected_frame)) \
- curY), cmputc); \
} while (0)
#define OUTPUT1_IF(a) do { if (a) tputs (a, 1, cmputc); } while (0)
extern Lisp_Object Qspace, QCalign_to, QCwidth;
Lisp_Object Vring_bell_function;
static int visible_cursor;
int must_write_spaces;
int min_padding_speed;
int line_ins_del_ok;
int char_ins_del_ok;
int scroll_region_ok;
int scroll_region_cost;
int memory_below_frame;
int fast_clear_end_of_line;
int no_redraw_on_reenter;
void (*cursor_to_hook) P_ ((int, int));
void (*raw_cursor_to_hook) P_ ((int, int));
void (*clear_to_end_hook) P_ ((void));
void (*clear_frame_hook) P_ ((void));
void (*clear_end_of_line_hook) P_ ((int));
void (*ins_del_lines_hook) P_ ((int, int));
void (*delete_glyphs_hook) P_ ((int));
void (*ring_bell_hook) P_ ((void));
void (*reset_terminal_modes_hook) P_ ((void));
void (*set_terminal_modes_hook) P_ ((void));
void (*update_begin_hook) P_ ((struct frame *));
void (*update_end_hook) P_ ((struct frame *));
void (*set_terminal_window_hook) P_ ((int));
void (*insert_glyphs_hook) P_ ((struct glyph *, int));
void (*write_glyphs_hook) P_ ((struct glyph *, int));
void (*delete_glyphs_hook) P_ ((int));
int (*read_socket_hook) P_ ((int, int, struct input_event *));
void (*frame_up_to_date_hook) P_ ((struct frame *));
void (*mouse_position_hook) P_ ((FRAME_PTR *f, int insist,
Lisp_Object *bar_window,
enum scroll_bar_part *part,
Lisp_Object *x,
Lisp_Object *y,
unsigned long *time));
void (*frame_rehighlight_hook) P_ ((FRAME_PTR f));
void (*frame_raise_lower_hook) P_ ((FRAME_PTR f, int raise));
void (*fullscreen_hook) P_ ((struct frame *f));
void (*set_vertical_scroll_bar_hook)
P_ ((struct window *window,
int portion, int whole, int position));
void (*condemn_scroll_bars_hook) P_ ((FRAME_PTR frame));
void (*redeem_scroll_bar_hook) P_ ((struct window *window));
void (*judge_scroll_bars_hook) P_ ((FRAME_PTR FRAME));
char *TS_ins_line;
char *TS_ins_multi_lines;
char *TS_bell;
char *TS_clr_to_bottom;
char *TS_clr_line;
char *TS_clr_frame;
char *TS_set_scroll_region;
char *TS_set_scroll_region_1;
char *TS_del_char;
char *TS_del_multi_chars;
char *TS_del_line;
char *TS_del_multi_lines;
char *TS_delete_mode;
char *TS_end_delete_mode;
char *TS_end_insert_mode;
char *TS_ins_char;
char *TS_ins_multi_chars;
char *TS_insert_mode;
char *TS_pad_inserted_char;
char *TS_end_keypad_mode;
char *TS_keypad_mode;
char *TS_pad_char;
char *TS_repeat;
char *TS_end_standout_mode;
char *TS_fwd_scroll;
char *TS_standout_mode;
char *TS_rev_scroll;
char *TS_end_termcap_modes;
char *TS_termcap_modes;
char *TS_visible_bell;
char *TS_cursor_normal;
char *TS_cursor_visible;
char *TS_cursor_invisible;
char *TS_set_window;
static int TN_no_color_video;
enum no_color_bit
{
NC_STANDOUT = 1 << 0,
NC_UNDERLINE = 1 << 1,
NC_REVERSE = 1 << 2,
NC_BLINK = 1 << 3,
NC_DIM = 1 << 4,
NC_BOLD = 1 << 5,
NC_INVIS = 1 << 6,
NC_PROTECT = 1 << 7,
NC_ALT_CHARSET = 1 << 8
};
char *TS_enter_bold_mode;
char *TS_enter_dim_mode;
char *TS_enter_blink_mode;
char *TS_enter_reverse_mode;
char *TS_exit_underline_mode, *TS_enter_underline_mode;
char *TS_enter_alt_charset_mode, *TS_exit_alt_charset_mode;
char *TS_exit_attribute_mode;
int TN_max_colors;
int TN_max_pairs;
char *TS_orig_pair;
char *TS_set_foreground, *TS_set_background;
int TF_hazeltine;
int TF_insmode_motion;
int TF_standout_motion;
int TF_underscore;
int TF_teleray;
static int RPov;
static int delete_in_insert_mode;
static int se_is_so;
int max_frame_cols;
int max_frame_lines;
static int costs_set;
int insert_mode;
int standout_mode;
int specified_window;
FRAME_PTR updating_frame;
static int system_uses_terminfo;
static int tty_cursor_hidden;
char *tparam ();
extern char *tgetstr ();
#ifdef WINDOWSNT
#undef FRAME_TERMCAP_P
#define FRAME_TERMCAP_P(_f_) 0
#endif
void
ring_bell ()
{
if (!NILP (Vring_bell_function))
{
Lisp_Object function;
function = Vring_bell_function;
Vring_bell_function = Qnil;
call0 (function);
Vring_bell_function = function;
}
else if (!FRAME_TERMCAP_P (XFRAME (selected_frame)))
(*ring_bell_hook) ();
else
OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
}
void
set_terminal_modes ()
{
if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
{
if (TS_termcap_modes)
OUTPUT (TS_termcap_modes);
else
{
int i;
for (i = 0; i < FRAME_LINES (XFRAME (selected_frame)); i++)
putchar ('\n');
}
OUTPUT_IF (visible_cursor ? TS_cursor_visible : TS_cursor_normal);
OUTPUT_IF (TS_keypad_mode);
losecursor ();
}
else
(*set_terminal_modes_hook) ();
}
void
reset_terminal_modes ()
{
if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
{
turn_off_highlight ();
turn_off_insert ();
OUTPUT_IF (TS_end_keypad_mode);
OUTPUT_IF (TS_cursor_normal);
OUTPUT_IF (TS_end_termcap_modes);
OUTPUT_IF (TS_orig_pair);
cmputc ('\r');
}
else if (reset_terminal_modes_hook)
(*reset_terminal_modes_hook) ();
}
void
update_begin (f)
struct frame *f;
{
updating_frame = f;
if (!FRAME_TERMCAP_P (f))
update_begin_hook (f);
}
void
update_end (f)
struct frame *f;
{
if (FRAME_TERMCAP_P (f))
{
if (!XWINDOW (selected_window)->cursor_off_p)
tty_show_cursor ();
turn_off_insert ();
background_highlight ();
}
else
update_end_hook (f);
updating_frame = NULL;
}
void
set_terminal_window (size)
int size;
{
if (FRAME_TERMCAP_P (updating_frame))
{
specified_window = size ? size : FRAME_LINES (updating_frame);
if (scroll_region_ok)
set_scroll_region (0, specified_window);
}
else
set_terminal_window_hook (size);
}
void
set_scroll_region (start, stop)
int start, stop;
{
char *buf;
struct frame *sf = XFRAME (selected_frame);
if (TS_set_scroll_region)
buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
else if (TS_set_scroll_region_1)
buf = tparam (TS_set_scroll_region_1, 0, 0,
FRAME_LINES (sf), start,
FRAME_LINES (sf) - stop,
FRAME_LINES (sf));
else
buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_COLS (sf));
OUTPUT (buf);
xfree (buf);
losecursor ();
}
static void
turn_on_insert ()
{
if (!insert_mode)
OUTPUT (TS_insert_mode);
insert_mode = 1;
}
void
turn_off_insert ()
{
if (insert_mode)
OUTPUT (TS_end_insert_mode);
insert_mode = 0;
}
void
turn_off_highlight ()
{
if (standout_mode)
OUTPUT_IF (TS_end_standout_mode);
standout_mode = 0;
}
static void
turn_on_highlight ()
{
if (!standout_mode)
OUTPUT_IF (TS_standout_mode);
standout_mode = 1;
}
static void
toggle_highlight ()
{
if (standout_mode)
turn_off_highlight ();
else
turn_on_highlight ();
}
static void
tty_hide_cursor ()
{
if (tty_cursor_hidden == 0)
{
tty_cursor_hidden = 1;
OUTPUT_IF (TS_cursor_invisible);
}
}
static void
tty_show_cursor ()
{
if (tty_cursor_hidden)
{
tty_cursor_hidden = 0;
OUTPUT_IF (TS_cursor_normal);
if (visible_cursor)
OUTPUT_IF (TS_cursor_visible);
}
}
void
background_highlight ()
{
if (inverse_video)
turn_on_highlight ();
else
turn_off_highlight ();
}
static void
highlight_if_desired ()
{
if (inverse_video)
turn_on_highlight ();
else
turn_off_highlight ();
}
void
cursor_to (vpos, hpos)
int vpos, hpos;
{
struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
if (! FRAME_TERMCAP_P (f) && cursor_to_hook)
{
(*cursor_to_hook) (vpos, hpos);
return;
}
if (! costs_set)
return;
if (curY == vpos && curX == hpos)
return;
if (!TF_standout_motion)
background_highlight ();
if (!TF_insmode_motion)
turn_off_insert ();
cmgoto (vpos, hpos);
}
void
raw_cursor_to (row, col)
int row, col;
{
struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
if (! FRAME_TERMCAP_P (f))
{
(*raw_cursor_to_hook) (row, col);
return;
}
if (curY == row && curX == col)
return;
if (!TF_standout_motion)
background_highlight ();
if (!TF_insmode_motion)
turn_off_insert ();
cmgoto (row, col);
}
void
clear_to_end ()
{
register int i;
if (clear_to_end_hook && ! FRAME_TERMCAP_P (updating_frame))
{
(*clear_to_end_hook) ();
return;
}
if (TS_clr_to_bottom)
{
background_highlight ();
OUTPUT (TS_clr_to_bottom);
}
else
{
for (i = curY; i < FRAME_LINES (XFRAME (selected_frame)); i++)
{
cursor_to (i, 0);
clear_end_of_line (FRAME_COLS (XFRAME (selected_frame)));
}
}
}
void
clear_frame ()
{
struct frame *sf = XFRAME (selected_frame);
if (clear_frame_hook
&& ! FRAME_TERMCAP_P ((updating_frame ? updating_frame : sf)))
{
(*clear_frame_hook) ();
return;
}
if (TS_clr_frame)
{
background_highlight ();
OUTPUT (TS_clr_frame);
cmat (0, 0);
}
else
{
cursor_to (0, 0);
clear_to_end ();
}
}
void
clear_end_of_line (first_unused_hpos)
int first_unused_hpos;
{
register int i;
if (clear_end_of_line_hook
&& ! FRAME_TERMCAP_P ((updating_frame
? updating_frame
: XFRAME (selected_frame))))
{
(*clear_end_of_line_hook) (first_unused_hpos);
return;
}
if (! costs_set)
return;
if (curX >= first_unused_hpos)
return;
background_highlight ();
if (TS_clr_line)
{
OUTPUT1 (TS_clr_line);
}
else
{
struct frame *sf = XFRAME (selected_frame);
turn_off_insert ();
if (AutoWrap && curY == FRAME_LINES (sf) - 1
&& first_unused_hpos == FRAME_COLS (sf))
first_unused_hpos--;
for (i = curX; i < first_unused_hpos; i++)
{
if (termscript)
fputc (' ', termscript);
putchar (' ');
}
cmplus (first_unused_hpos - curX);
}
}
static unsigned char *encode_terminal_buf;
static int encode_terminal_bufsize;
unsigned char *
encode_terminal_code (src, src_len, coding)
struct glyph *src;
int src_len;
struct coding_system *coding;
{
struct glyph *src_end = src + src_len;
register GLYPH g;
unsigned char *buf;
int nchars, nbytes, required;
register int tlen = GLYPH_TABLE_LENGTH;
register Lisp_Object *tbase = GLYPH_TABLE_BASE;
required = MAX_MULTIBYTE_LENGTH * src_len;
if (encode_terminal_bufsize < required)
{
if (encode_terminal_bufsize == 0)
encode_terminal_buf = xmalloc (required);
else
encode_terminal_buf = xrealloc (encode_terminal_buf, required);
encode_terminal_bufsize = required;
}
buf = encode_terminal_buf;
nchars = 0;
while (src < src_end)
{
if (! CHAR_GLYPH_PADDING_P (*src))
{
g = GLYPH_FROM_CHAR_GLYPH (src[0]);
if (g < 0 || g >= tlen)
{
if (CHAR_VALID_P (src->u.ch, 0))
buf += CHAR_STRING (src->u.ch, buf);
else
*buf++ = SPACEGLYPH;
nchars++;
}
else
{
GLYPH_FOLLOW_ALIASES (tbase, tlen, g);
if (GLYPH_SIMPLE_P (tbase, tlen, g))
{
int c = FAST_GLYPH_CHAR (g);
if (CHAR_VALID_P (c, 0))
buf += CHAR_STRING (c, buf);
else
*buf++ = SPACEGLYPH;
nchars++;
}
else
{
Lisp_Object string;
string = tbase[g];
if (! STRING_MULTIBYTE (string))
string = string_to_multibyte (string);
nbytes = buf - encode_terminal_buf;
if (encode_terminal_bufsize < nbytes + SBYTES (string))
{
encode_terminal_bufsize = nbytes + SBYTES (string);
encode_terminal_buf = xrealloc (encode_terminal_buf,
encode_terminal_bufsize);
buf = encode_terminal_buf + nbytes;
}
bcopy (SDATA (string), buf, SBYTES (string));
buf += SBYTES (string);
nchars += SCHARS (string);
}
}
}
src++;
}
nbytes = buf - encode_terminal_buf;
coding->src_multibyte = 1;
coding->dst_multibyte = 0;
if (SYMBOLP (coding->pre_write_conversion)
&& ! NILP (Ffboundp (coding->pre_write_conversion)))
{
run_pre_write_conversin_on_c_str (&encode_terminal_buf,
&encode_terminal_bufsize,
nchars, nbytes, coding);
nchars = coding->produced_char;
nbytes = coding->produced;
}
required = nbytes + encoding_buffer_size (coding, nbytes);
if (encode_terminal_bufsize < required)
{
encode_terminal_bufsize = required;
encode_terminal_buf = xrealloc (encode_terminal_buf, required);
}
encode_coding (coding, encode_terminal_buf, encode_terminal_buf + nbytes,
nbytes, encode_terminal_bufsize - nbytes);
return encode_terminal_buf + nbytes;
}
void
write_glyphs (string, len)
register struct glyph *string;
register int len;
{
struct frame *sf = XFRAME (selected_frame);
struct frame *f = updating_frame ? updating_frame : sf;
unsigned char *conversion_buffer;
struct coding_system *coding;
if (write_glyphs_hook
&& ! FRAME_TERMCAP_P (f))
{
(*write_glyphs_hook) (string, len);
return;
}
turn_off_insert ();
tty_hide_cursor ();
if (AutoWrap
&& curY + 1 == FRAME_LINES (sf)
&& (curX + len) == FRAME_COLS (sf))
len --;
if (len <= 0)
return;
cmplus (len);
coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
? &terminal_coding : &safe_terminal_coding);
coding->mode &= ~CODING_MODE_LAST_BLOCK;
while (len > 0)
{
int face_id = string->face_id;
int n;
for (n = 1; n < len; ++n)
if (string[n].face_id != face_id)
break;
highlight_if_desired ();
turn_on_face (f, face_id);
if (n == len)
coding->mode |= CODING_MODE_LAST_BLOCK;
conversion_buffer = encode_terminal_code (string, n, coding);
if (coding->produced > 0)
{
BLOCK_INPUT;
fwrite (conversion_buffer, 1, coding->produced, stdout);
if (ferror (stdout))
clearerr (stdout);
if (termscript)
fwrite (conversion_buffer, 1, coding->produced, termscript);
UNBLOCK_INPUT;
}
len -= n;
string += n;
turn_off_face (f, face_id);
turn_off_highlight ();
}
cmcheckmagic ();
}
void
insert_glyphs (start, len)
register struct glyph *start;
register int len;
{
char *buf;
struct glyph *glyph = NULL;
struct frame *f, *sf;
unsigned char *conversion_buffer;
unsigned char space[1];
struct coding_system *coding;
if (len <= 0)
return;
if (insert_glyphs_hook)
{
(*insert_glyphs_hook) (start, len);
return;
}
sf = XFRAME (selected_frame);
f = updating_frame ? updating_frame : sf;
if (TS_ins_multi_chars)
{
buf = tparam (TS_ins_multi_chars, 0, 0, len);
OUTPUT1 (buf);
xfree (buf);
if (start)
write_glyphs (start, len);
return;
}
turn_on_insert ();
cmplus (len);
if (! start)
space[0] = SPACEGLYPH;
coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
? &terminal_coding : &safe_terminal_coding);
coding->mode &= ~CODING_MODE_LAST_BLOCK;
while (len-- > 0)
{
OUTPUT1_IF (TS_ins_char);
if (!start)
{
conversion_buffer = space;
coding->produced = 1;
}
else
{
highlight_if_desired ();
turn_on_face (f, start->face_id);
glyph = start;
++start;
while (len && CHAR_GLYPH_PADDING_P (*start))
{
OUTPUT1_IF (TS_ins_char);
start++, len--;
}
if (len <= 0)
coding->mode |= CODING_MODE_LAST_BLOCK;
conversion_buffer = encode_terminal_code (glyph, 1, coding);
}
if (coding->produced > 0)
{
BLOCK_INPUT;
fwrite (conversion_buffer, 1, coding->produced, stdout);
if (ferror (stdout))
clearerr (stdout);
if (termscript)
fwrite (conversion_buffer, 1, coding->produced, termscript);
UNBLOCK_INPUT;
}
OUTPUT1_IF (TS_pad_inserted_char);
if (start)
{
turn_off_face (f, glyph->face_id);
turn_off_highlight ();
}
}
cmcheckmagic ();
}
void
delete_glyphs (n)
register int n;
{
char *buf;
register int i;
if (delete_glyphs_hook && ! FRAME_TERMCAP_P (updating_frame))
{
(*delete_glyphs_hook) (n);
return;
}
if (delete_in_insert_mode)
{
turn_on_insert ();
}
else
{
turn_off_insert ();
OUTPUT_IF (TS_delete_mode);
}
if (TS_del_multi_chars)
{
buf = tparam (TS_del_multi_chars, 0, 0, n);
OUTPUT1 (buf);
xfree (buf);
}
else
for (i = 0; i < n; i++)
OUTPUT1 (TS_del_char);
if (!delete_in_insert_mode)
OUTPUT_IF (TS_end_delete_mode);
}
void
ins_del_lines (vpos, n)
int vpos, n;
{
char *multi = n > 0 ? TS_ins_multi_lines : TS_del_multi_lines;
char *single = n > 0 ? TS_ins_line : TS_del_line;
char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;
struct frame *sf;
register int i = n > 0 ? n : -n;
register char *buf;
if (ins_del_lines_hook && ! FRAME_TERMCAP_P (updating_frame))
{
(*ins_del_lines_hook) (vpos, n);
return;
}
sf = XFRAME (selected_frame);
if (scroll_region_ok && vpos + i >= specified_window)
return;
if (!memory_below_frame && vpos + i >= FRAME_LINES (sf))
return;
if (multi)
{
raw_cursor_to (vpos, 0);
background_highlight ();
buf = tparam (multi, 0, 0, i);
OUTPUT (buf);
xfree (buf);
}
else if (single)
{
raw_cursor_to (vpos, 0);
background_highlight ();
while (--i >= 0)
OUTPUT (single);
if (TF_teleray)
curX = 0;
}
else
{
set_scroll_region (vpos, specified_window);
if (n < 0)
raw_cursor_to (specified_window - 1, 0);
else
raw_cursor_to (vpos, 0);
background_highlight ();
while (--i >= 0)
OUTPUTL (scroll, specified_window - vpos);
set_scroll_region (0, specified_window);
}
if (!scroll_region_ok && memory_below_frame && n < 0)
{
cursor_to (FRAME_LINES (sf) + n, 0);
clear_to_end ();
}
}
int
string_cost (str)
char *str;
{
cost = 0;
if (str)
tputs (str, 0, evalcost);
return cost;
}
static int
string_cost_one_line (str)
char *str;
{
cost = 0;
if (str)
tputs (str, 1, evalcost);
return cost;
}
int
per_line_cost (str)
register char *str;
{
cost = 0;
if (str)
tputs (str, 0, evalcost);
cost = - cost;
if (str)
tputs (str, 10, evalcost);
return cost;
}
#ifndef old
int *char_ins_del_vector;
#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_COLS ((f))])
#endif
static void
calculate_ins_del_char_costs (frame)
FRAME_PTR frame;
{
int ins_startup_cost, del_startup_cost;
int ins_cost_per_char, del_cost_per_char;
register int i;
register int *p;
if (TS_ins_multi_chars)
{
ins_cost_per_char = 0;
ins_startup_cost = string_cost_one_line (TS_ins_multi_chars);
}
else if (TS_ins_char || TS_pad_inserted_char
|| (TS_insert_mode && TS_end_insert_mode))
{
ins_startup_cost = (30 * (string_cost (TS_insert_mode)
+ string_cost (TS_end_insert_mode))) / 100;
ins_cost_per_char = (string_cost_one_line (TS_ins_char)
+ string_cost_one_line (TS_pad_inserted_char));
}
else
{
ins_startup_cost = 9999;
ins_cost_per_char = 0;
}
if (TS_del_multi_chars)
{
del_cost_per_char = 0;
del_startup_cost = string_cost_one_line (TS_del_multi_chars);
}
else if (TS_del_char)
{
del_startup_cost = (string_cost (TS_delete_mode)
+ string_cost (TS_end_delete_mode));
if (delete_in_insert_mode)
del_startup_cost /= 2;
del_cost_per_char = string_cost_one_line (TS_del_char);
}
else
{
del_startup_cost = 9999;
del_cost_per_char = 0;
}
p = &char_ins_del_cost (frame)[0];
for (i = FRAME_COLS (frame); --i >= 0;)
*--p = (del_startup_cost += del_cost_per_char);
p = &char_ins_del_cost (frame)[0];
*p++ = 0;
for (i = FRAME_COLS (frame); --i >= 0;)
*p++ = (ins_startup_cost += ins_cost_per_char);
}
void
calculate_costs (frame)
FRAME_PTR frame;
{
register char *f = (TS_set_scroll_region
? TS_set_scroll_region
: TS_set_scroll_region_1);
FRAME_COST_BAUD_RATE (frame) = baud_rate;
scroll_region_cost = string_cost (f);
max_frame_lines = max (max_frame_lines, FRAME_LINES (frame));
max_frame_cols = max (max_frame_cols, FRAME_COLS (frame));
costs_set = 1;
if (char_ins_del_vector != 0)
char_ins_del_vector
= (int *) xrealloc (char_ins_del_vector,
(sizeof (int)
+ 2 * max_frame_cols * sizeof (int)));
else
char_ins_del_vector
= (int *) xmalloc (sizeof (int)
+ 2 * max_frame_cols * sizeof (int));
bzero (char_ins_del_vector, (sizeof (int)
+ 2 * max_frame_cols * sizeof (int)));
if (f && (!TS_ins_line && !TS_del_line))
do_line_insertion_deletion_costs (frame,
TS_rev_scroll, TS_ins_multi_lines,
TS_fwd_scroll, TS_del_multi_lines,
f, f, 1);
else
do_line_insertion_deletion_costs (frame,
TS_ins_line, TS_ins_multi_lines,
TS_del_line, TS_del_multi_lines,
0, 0, 1);
calculate_ins_del_char_costs (frame);
if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
RPov = string_cost (TS_repeat);
else
RPov = FRAME_COLS (frame) * 2;
cmcostinit ();
}
struct fkey_table {
char *cap, *name;
};
static struct fkey_table keys[] =
{
{"kh", "home"},
{"kl", "left"},
{"ku", "up"},
{"kr", "right"},
{"kd", "down"},
{"%8", "prior"},
{"%5", "next"},
{"@7", "end"},
{"@1", "begin"},
{"*6", "select"},
{"%9", "print"},
{"@4", "execute"},
{"&8", "undo"},
{"%0", "redo"},
{"%7", "menu"},
{"@0", "find"},
{"@2", "cancel"},
{"%1", "help"},
{"&4", "reset"},
{"kE", "clearline"},
{"kA", "insertline"},
{"kL", "deleteline"},
{"kI", "insertchar"},
{"kD", "deletechar"},
{"kB", "backtab"},
{"@8", "kp-enter"},
{"K4", "kp-1"},
{"K5", "kp-3"},
{"K2", "kp-5"},
{"K1", "kp-7"},
{"K3", "kp-9"},
{"k1", "f1"},
{"k2", "f2"},
{"k3", "f3"},
{"k4", "f4"},
{"k5", "f5"},
{"k6", "f6"},
{"k7", "f7"},
{"k8", "f8"},
{"k9", "f9"},
{"&0", "S-cancel"},
{"&9", "S-begin"},
{"*0", "S-find"},
{"*1", "S-execute"},
{"*4", "S-delete"},
{"*7", "S-end"},
{"*8", "S-clearline"},
{"#1", "S-help"},
{"#2", "S-home"},
{"#3", "S-insert"},
{"#4", "S-left"},
{"%d", "S-menu"},
{"%c", "S-next"},
{"%e", "S-prior"},
{"%f", "S-print"},
{"%g", "S-redo"},
{"%i", "S-right"},
{"!3", "S-undo"}
};
static char **term_get_fkeys_arg;
static Lisp_Object term_get_fkeys_1 ();
void
term_get_fkeys (address)
char **address;
{
extern Lisp_Object Fidentity ();
term_get_fkeys_arg = address;
internal_condition_case (term_get_fkeys_1, Qerror, Fidentity);
}
static Lisp_Object
term_get_fkeys_1 ()
{
int i;
char **address = term_get_fkeys_arg;
if (!initialized)
Vfunction_key_map = Fmake_sparse_keymap (Qnil);
for (i = 0; i < (sizeof (keys)/sizeof (keys[0])); i++)
{
char *sequence = tgetstr (keys[i].cap, address);
if (sequence)
Fdefine_key (Vfunction_key_map, build_string (sequence),
Fmake_vector (make_number (1),
intern (keys[i].name)));
}
{
char *k_semi = tgetstr ("k;", address);
char *k0 = tgetstr ("k0", address);
char *k0_name = "f10";
if (k_semi)
{
if (k0)
Fdefine_key (Vfunction_key_map, build_string (k0),
Fmake_vector (make_number (1), intern ("f0")));
Fdefine_key (Vfunction_key_map, build_string (k_semi),
Fmake_vector (make_number (1), intern ("f10")));
}
else if (k0)
Fdefine_key (Vfunction_key_map, build_string (k0),
Fmake_vector (make_number (1), intern (k0_name)));
}
{
char fcap[3], fkey[4];
fcap[0] = 'F'; fcap[2] = '\0';
for (i = 11; i < 64; i++)
{
if (i <= 19)
fcap[1] = '1' + i - 11;
else if (i <= 45)
fcap[1] = 'A' + i - 20;
else
fcap[1] = 'a' + i - 46;
{
char *sequence = tgetstr (fcap, address);
if (sequence)
{
sprintf (fkey, "f%d", i);
Fdefine_key (Vfunction_key_map, build_string (sequence),
Fmake_vector (make_number (1),
intern (fkey)));
}
}
}
}
{
#define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
if (!tgetstr (cap1, address)) \
{ \
char *sequence = tgetstr (cap2, address); \
if (sequence) \
Fdefine_key (Vfunction_key_map, build_string (sequence), \
Fmake_vector (make_number (1), \
intern (sym))); \
}
CONDITIONAL_REASSIGN ("%5", "kN", "next");
CONDITIONAL_REASSIGN ("%8", "kP", "prior");
CONDITIONAL_REASSIGN ("kD", "kI", "insert");
CONDITIONAL_REASSIGN ("@7", "kH", "end");
CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
CONDITIONAL_REASSIGN ("@4", "kJ", "execute");
CONDITIONAL_REASSIGN ("@4", "kc", "execute");
CONDITIONAL_REASSIGN ("%7", "ki", "menu");
CONDITIONAL_REASSIGN ("@7", "kw", "end");
CONDITIONAL_REASSIGN ("F1", "k<", "f11");
CONDITIONAL_REASSIGN ("F2", "k>", "f12");
CONDITIONAL_REASSIGN ("%1", "kq", "help");
CONDITIONAL_REASSIGN ("*6", "kU", "select");
#undef CONDITIONAL_REASSIGN
}
return Qnil;
}
#ifdef static
#define append_glyph append_glyph_term
#define produce_stretch_glyph produce_stretch_glyph_term
#endif
static void append_glyph P_ ((struct it *));
static void produce_stretch_glyph P_ ((struct it *));
static void
append_glyph (it)
struct it *it;
{
struct glyph *glyph, *end;
int i;
xassert (it->glyph_row);
glyph = (it->glyph_row->glyphs[it->area]
+ it->glyph_row->used[it->area]);
end = it->glyph_row->glyphs[1 + it->area];
for (i = 0;
i < it->pixel_width && glyph < end;
++i)
{
glyph->type = CHAR_GLYPH;
glyph->pixel_width = 1;
glyph->u.ch = it->char_to_display;
glyph->face_id = it->face_id;
glyph->padding_p = i > 0;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
++it->glyph_row->used[it->area];
++glyph;
}
}
void
produce_glyphs (it)
struct it *it;
{
xassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION
|| it->what == IT_STRETCH);
if (it->what == IT_STRETCH)
{
produce_stretch_glyph (it);
goto done;
}
xassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION);
it->char_to_display = it->c;
if (it->c >= 040 && it->c < 0177)
{
it->pixel_width = it->nglyphs = 1;
if (it->glyph_row)
append_glyph (it);
}
else if (it->c == '\n')
it->pixel_width = it->nglyphs = 0;
else if (it->c == '\t')
{
int absolute_x = (it->current_x
+ it->continuation_lines_width);
int next_tab_x
= (((1 + absolute_x + it->tab_width - 1)
/ it->tab_width)
* it->tab_width);
int nspaces;
nspaces = next_tab_x - absolute_x;
if (it->glyph_row)
{
int n = nspaces;
it->char_to_display = ' ';
it->pixel_width = it->len = 1;
while (n--)
append_glyph (it);
}
it->pixel_width = nspaces;
it->nglyphs = nspaces;
}
else if (SINGLE_BYTE_CHAR_P (it->c))
{
if (unibyte_display_via_language_environment
&& (it->c >= 0240
|| !NILP (Vnonascii_translation_table)))
{
int charset;
it->char_to_display = unibyte_char_to_multibyte (it->c);
charset = CHAR_CHARSET (it->char_to_display);
it->pixel_width = CHARSET_WIDTH (charset);
it->nglyphs = it->pixel_width;
if (it->glyph_row)
append_glyph (it);
}
else
{
it->pixel_width = it->nglyphs = 1;
if (it->glyph_row)
append_glyph (it);
}
}
else
{
int charset = CHAR_CHARSET (it->c);
it->pixel_width = CHARSET_WIDTH (charset);
it->nglyphs = it->pixel_width;
if (it->glyph_row)
append_glyph (it);
}
done:
if (it->area == TEXT_AREA)
it->current_x += it->pixel_width;
it->ascent = it->max_ascent = it->phys_ascent = it->max_phys_ascent = 0;
it->descent = it->max_descent = it->phys_descent = it->max_phys_descent = 1;
}
static void
produce_stretch_glyph (it)
struct it *it;
{
Lisp_Object prop, plist;
int width = 0, align_to = -1;
int zero_width_ok_p = 0;
double tem;
xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
plist = XCDR (it->object);
if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
&& calc_pixel_width_or_height (&tem, it, prop, 0, 1, 0))
{
zero_width_ok_p = 1;
width = (int)(tem + 0.5);
}
else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
&& calc_pixel_width_or_height (&tem, it, prop, 0, 1, &align_to))
{
if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
align_to = (align_to < 0
? 0
: align_to - window_box_left_offset (it->w, TEXT_AREA));
else if (align_to < 0)
align_to = window_box_left_offset (it->w, TEXT_AREA);
width = max (0, (int)(tem + 0.5) + align_to - it->current_x);
zero_width_ok_p = 1;
}
else
width = FRAME_COLUMN_WIDTH (it->f);
if (width <= 0 && (width < 0 || !zero_width_ok_p))
width = 1;
if (width > 0 && it->glyph_row)
{
Lisp_Object o_object = it->object;
Lisp_Object object = it->stack[it->sp - 1].string;
int n = width;
if (!STRINGP (object))
object = it->w->buffer;
it->object = object;
it->char_to_display = ' ';
it->pixel_width = it->len = 1;
while (n--)
append_glyph (it);
it->object = o_object;
}
it->pixel_width = width;
it->nglyphs = width;
}
void
produce_special_glyphs (it, what)
struct it *it;
enum display_element_type what;
{
struct it temp_it;
GLYPH glyph;
temp_it = *it;
temp_it.dp = NULL;
temp_it.what = IT_CHARACTER;
temp_it.len = 1;
temp_it.object = make_number (0);
bzero (&temp_it.current, sizeof temp_it.current);
if (what == IT_CONTINUATION)
{
if (it->dp
&& INTEGERP (DISP_CONTINUE_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (it->dp))))
{
glyph = XINT (DISP_CONTINUE_GLYPH (it->dp));
glyph = spec_glyph_lookup_face (XWINDOW (it->window), glyph);
}
else
glyph = '\\';
}
else if (what == IT_TRUNCATION)
{
if (it->dp
&& INTEGERP (DISP_TRUNC_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (it->dp))))
{
glyph = XINT (DISP_TRUNC_GLYPH (it->dp));
glyph = spec_glyph_lookup_face (XWINDOW (it->window), glyph);
}
else
glyph = '$';
}
else
abort ();
temp_it.c = FAST_GLYPH_CHAR (glyph);
temp_it.face_id = FAST_GLYPH_FACE (glyph);
temp_it.len = CHAR_BYTES (temp_it.c);
produce_glyphs (&temp_it);
it->pixel_width = temp_it.pixel_width;
it->nglyphs = temp_it.pixel_width;
}
#define MAY_USE_WITH_COLORS_P(ATTR) \
(TN_max_colors > 0 \
? (TN_no_color_video & (ATTR)) == 0 \
: 1)
static void
turn_on_face (f, face_id)
struct frame *f;
int face_id;
{
struct face *face = FACE_FROM_ID (f, face_id);
long fg = face->foreground;
long bg = face->background;
if (MAY_USE_WITH_COLORS_P (NC_REVERSE))
{
if (TN_max_colors > 0)
{
if (fg >= 0 && bg >= 0)
{
}
else if (inverse_video)
{
if (fg == FACE_TTY_DEFAULT_FG_COLOR
|| bg == FACE_TTY_DEFAULT_BG_COLOR)
toggle_highlight ();
}
else
{
if (fg == FACE_TTY_DEFAULT_BG_COLOR
|| bg == FACE_TTY_DEFAULT_FG_COLOR)
toggle_highlight ();
}
}
else
{
if (inverse_video)
{
if (fg == FACE_TTY_DEFAULT_FG_COLOR
|| bg == FACE_TTY_DEFAULT_BG_COLOR)
toggle_highlight ();
}
else
{
if (fg == FACE_TTY_DEFAULT_BG_COLOR
|| bg == FACE_TTY_DEFAULT_FG_COLOR)
toggle_highlight ();
}
}
}
if (face->tty_bold_p)
{
if (MAY_USE_WITH_COLORS_P (NC_BOLD))
OUTPUT1_IF (TS_enter_bold_mode);
}
else if (face->tty_dim_p)
if (MAY_USE_WITH_COLORS_P (NC_DIM))
OUTPUT1_IF (TS_enter_dim_mode);
if (face->tty_alt_charset_p
&& MAY_USE_WITH_COLORS_P (NC_ALT_CHARSET))
OUTPUT1_IF (TS_enter_alt_charset_mode);
if (face->tty_blinking_p
&& MAY_USE_WITH_COLORS_P (NC_BLINK))
OUTPUT1_IF (TS_enter_blink_mode);
if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (NC_UNDERLINE))
OUTPUT1_IF (TS_enter_underline_mode);
if (TN_max_colors > 0)
{
char *ts, *p;
ts = standout_mode ? TS_set_background : TS_set_foreground;
if (fg >= 0 && ts)
{
p = tparam (ts, NULL, 0, (int) fg);
OUTPUT (p);
xfree (p);
}
ts = standout_mode ? TS_set_foreground : TS_set_background;
if (bg >= 0 && ts)
{
p = tparam (ts, NULL, 0, (int) bg);
OUTPUT (p);
xfree (p);
}
}
}
static void
turn_off_face (f, face_id)
struct frame *f;
int face_id;
{
struct face *face = FACE_FROM_ID (f, face_id);
xassert (face != NULL);
if (TS_exit_attribute_mode)
{
if (face->tty_bold_p
|| face->tty_dim_p
|| face->tty_reverse_p
|| face->tty_alt_charset_p
|| face->tty_blinking_p
|| face->tty_underline_p)
{
OUTPUT1_IF (TS_exit_attribute_mode);
if (strcmp (TS_exit_attribute_mode, TS_end_standout_mode) == 0)
standout_mode = 0;
}
if (face->tty_alt_charset_p)
OUTPUT_IF (TS_exit_alt_charset_mode);
}
else
{
if (face->tty_alt_charset_p)
OUTPUT_IF (TS_exit_alt_charset_mode);
if (face->tty_underline_p)
OUTPUT_IF (TS_exit_underline_mode);
}
if (TN_max_colors > 0
&& ((face->foreground != FACE_TTY_DEFAULT_COLOR
&& face->foreground != FACE_TTY_DEFAULT_FG_COLOR)
|| (face->background != FACE_TTY_DEFAULT_COLOR
&& face->background != FACE_TTY_DEFAULT_BG_COLOR)))
OUTPUT1_IF (TS_orig_pair);
}
int
tty_capable_p (f, caps, fg, bg)
struct frame *f;
unsigned caps;
unsigned long fg, bg;
{
#define TTY_CAPABLE_P_TRY(cap, TS, NC_bit) \
if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(NC_bit))) \
return 0;
TTY_CAPABLE_P_TRY (TTY_CAP_INVERSE, TS_standout_mode, NC_REVERSE);
TTY_CAPABLE_P_TRY (TTY_CAP_UNDERLINE, TS_enter_underline_mode, NC_UNDERLINE);
TTY_CAPABLE_P_TRY (TTY_CAP_BOLD, TS_enter_bold_mode, NC_BOLD);
TTY_CAPABLE_P_TRY (TTY_CAP_DIM, TS_enter_dim_mode, NC_DIM);
TTY_CAPABLE_P_TRY (TTY_CAP_BLINK, TS_enter_blink_mode, NC_BLINK);
TTY_CAPABLE_P_TRY (TTY_CAP_ALT_CHARSET, TS_enter_alt_charset_mode, NC_ALT_CHARSET);
return 1;
}
DEFUN ("tty-display-color-p", Ftty_display_color_p, Stty_display_color_p,
0, 1, 0,
doc: )
(display)
Lisp_Object display;
{
return TN_max_colors > 0 ? Qt : Qnil;
}
DEFUN ("tty-display-color-cells", Ftty_display_color_cells,
Stty_display_color_cells, 0, 1, 0,
doc: )
(display)
Lisp_Object display;
{
return make_number (TN_max_colors);
}
#ifndef WINDOWSNT
static void
tty_default_color_capabilities (save)
int save;
{
static char
*default_orig_pair, *default_set_foreground, *default_set_background;
static int default_max_colors, default_max_pairs, default_no_color_video;
if (save)
{
if (default_orig_pair)
xfree (default_orig_pair);
default_orig_pair = TS_orig_pair ? xstrdup (TS_orig_pair) : NULL;
if (default_set_foreground)
xfree (default_set_foreground);
default_set_foreground = TS_set_foreground ? xstrdup (TS_set_foreground)
: NULL;
if (default_set_background)
xfree (default_set_background);
default_set_background = TS_set_background ? xstrdup (TS_set_background)
: NULL;
default_max_colors = TN_max_colors;
default_max_pairs = TN_max_pairs;
default_no_color_video = TN_no_color_video;
}
else
{
TS_orig_pair = default_orig_pair;
TS_set_foreground = default_set_foreground;
TS_set_background = default_set_background;
TN_max_colors = default_max_colors;
TN_max_pairs = default_max_pairs;
TN_no_color_video = default_no_color_video;
}
}
void
tty_setup_colors (mode)
int mode;
{
if (mode < -1)
mode = -1;
switch (mode)
{
case -1:
TN_max_colors = 0;
TN_max_pairs = 0;
TN_no_color_video = 0;
TS_set_foreground = TS_set_background = TS_orig_pair = NULL;
break;
case 0:
default:
tty_default_color_capabilities (0);
break;
case 8:
TS_orig_pair = "\033[0m";
#ifdef TERMINFO
TS_set_foreground = "\033[3%p1%dm";
TS_set_background = "\033[4%p1%dm";
#else
TS_set_foreground = "\033[3%dm";
TS_set_background = "\033[4%dm";
#endif
TN_max_colors = 8;
TN_max_pairs = 64;
TN_no_color_video = 0;
break;
}
}
void
set_tty_color_mode (f, val)
struct frame *f;
Lisp_Object val;
{
Lisp_Object color_mode_spec, current_mode_spec;
Lisp_Object color_mode, current_mode;
int mode, old_mode;
extern Lisp_Object Qtty_color_mode;
Lisp_Object tty_color_mode_alist;
tty_color_mode_alist = Fintern_soft (build_string ("tty-color-mode-alist"),
Qnil);
if (INTEGERP (val))
color_mode = val;
else
{
if (NILP (tty_color_mode_alist))
color_mode_spec = Qnil;
else
color_mode_spec = Fassq (val, XSYMBOL (tty_color_mode_alist)->value);
if (CONSP (color_mode_spec))
color_mode = XCDR (color_mode_spec);
else
color_mode = Qnil;
}
current_mode_spec = assq_no_quit (Qtty_color_mode, f->param_alist);
if (CONSP (current_mode_spec))
current_mode = XCDR (current_mode_spec);
else
current_mode = Qnil;
if (INTEGERP (color_mode))
mode = XINT (color_mode);
else
mode = 0;
if (INTEGERP (current_mode))
old_mode = XINT (current_mode);
else
old_mode = 0;
if (mode != old_mode)
{
tty_setup_colors (mode);
call0 (intern ("tty-set-up-initial-frame-faces"));
redraw_frame (f);
}
}
#endif
void
term_init (terminal_type)
char *terminal_type;
{
char *area;
char **address = &area;
char *buffer = NULL;
int buffer_size = 4096;
register char *p;
int status;
struct frame *sf = XFRAME (selected_frame);
encode_terminal_bufsize = 0;
#ifdef WINDOWSNT
initialize_w32_display ();
Wcm_clear ();
area = (char *) xmalloc (2044);
FrameRows = FRAME_LINES (sf);
FrameCols = FRAME_COLS (sf);
specified_window = FRAME_LINES (sf);
delete_in_insert_mode = 1;
UseTabs = 0;
scroll_region_ok = 0;
line_ins_del_ok = 0;
char_ins_del_ok = 1;
baud_rate = 19200;
FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
TN_max_colors = 16;
return;
#else
Wcm_clear ();
buffer = (char *) xmalloc (buffer_size);
status = tgetent (buffer, terminal_type);
if (status < 0)
{
#ifdef TERMINFO
fatal ("Cannot open terminfo database file");
#else
fatal ("Cannot open termcap database file");
#endif
}
if (status == 0)
{
#ifdef TERMINFO
fatal ("Terminal type %s is not defined.\n\
If that is not the actual type of terminal you have,\n\
use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
`setenv TERM ...') to specify the correct type. It may be necessary\n\
to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
terminal_type);
#else
fatal ("Terminal type %s is not defined.\n\
If that is not the actual type of terminal you have,\n\
use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
`setenv TERM ...') to specify the correct type. It may be necessary\n\
to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
terminal_type);
#endif
}
#ifndef TERMINFO
if (strlen (buffer) >= buffer_size)
abort ();
buffer_size = strlen (buffer);
#endif
area = (char *) xmalloc (buffer_size);
TS_ins_line = tgetstr ("al", address);
TS_ins_multi_lines = tgetstr ("AL", address);
TS_bell = tgetstr ("bl", address);
BackTab = tgetstr ("bt", address);
TS_clr_to_bottom = tgetstr ("cd", address);
TS_clr_line = tgetstr ("ce", address);
TS_clr_frame = tgetstr ("cl", address);
ColPosition = NULL;
AbsPosition = tgetstr ("cm", address);
CR = tgetstr ("cr", address);
TS_set_scroll_region = tgetstr ("cs", address);
TS_set_scroll_region_1 = tgetstr ("cS", address);
RowPosition = tgetstr ("cv", address);
TS_del_char = tgetstr ("dc", address);
TS_del_multi_chars = tgetstr ("DC", address);
TS_del_line = tgetstr ("dl", address);
TS_del_multi_lines = tgetstr ("DL", address);
TS_delete_mode = tgetstr ("dm", address);
TS_end_delete_mode = tgetstr ("ed", address);
TS_end_insert_mode = tgetstr ("ei", address);
Home = tgetstr ("ho", address);
TS_ins_char = tgetstr ("ic", address);
TS_ins_multi_chars = tgetstr ("IC", address);
TS_insert_mode = tgetstr ("im", address);
TS_pad_inserted_char = tgetstr ("ip", address);
TS_end_keypad_mode = tgetstr ("ke", address);
TS_keypad_mode = tgetstr ("ks", address);
LastLine = tgetstr ("ll", address);
Right = tgetstr ("nd", address);
Down = tgetstr ("do", address);
if (!Down)
Down = tgetstr ("nl", address);
#ifdef VMS
if (Down && Down[0] == '\n' && Down[1] == '\0')
Down = 0;
#endif
if (tgetflag ("bs"))
Left = "\b";
else
Left = tgetstr ("le", address);
if (!Left)
Left = tgetstr ("bc", address);
TS_pad_char = tgetstr ("pc", address);
TS_repeat = tgetstr ("rp", address);
TS_end_standout_mode = tgetstr ("se", address);
TS_fwd_scroll = tgetstr ("sf", address);
TS_standout_mode = tgetstr ("so", address);
TS_rev_scroll = tgetstr ("sr", address);
Wcm.cm_tab = tgetstr ("ta", address);
TS_end_termcap_modes = tgetstr ("te", address);
TS_termcap_modes = tgetstr ("ti", address);
Up = tgetstr ("up", address);
TS_visible_bell = tgetstr ("vb", address);
TS_cursor_normal = tgetstr ("ve", address);
TS_cursor_visible = tgetstr ("vs", address);
TS_cursor_invisible = tgetstr ("vi", address);
TS_set_window = tgetstr ("wi", address);
TS_enter_underline_mode = tgetstr ("us", address);
TS_exit_underline_mode = tgetstr ("ue", address);
TS_enter_bold_mode = tgetstr ("md", address);
TS_enter_dim_mode = tgetstr ("mh", address);
TS_enter_blink_mode = tgetstr ("mb", address);
TS_enter_reverse_mode = tgetstr ("mr", address);
TS_enter_alt_charset_mode = tgetstr ("as", address);
TS_exit_alt_charset_mode = tgetstr ("ae", address);
TS_exit_attribute_mode = tgetstr ("me", address);
MultiUp = tgetstr ("UP", address);
MultiDown = tgetstr ("DO", address);
MultiLeft = tgetstr ("LE", address);
MultiRight = tgetstr ("RI", address);
TS_orig_pair = tgetstr ("op", address);
if (TS_orig_pair)
{
TS_set_foreground = tgetstr ("AF", address);
TS_set_background = tgetstr ("AB", address);
if (!TS_set_foreground)
{
TS_set_foreground = tgetstr ("Sf", address);
TS_set_background = tgetstr ("Sb", address);
}
TN_max_colors = tgetnum ("Co");
TN_max_pairs = tgetnum ("pa");
TN_no_color_video = tgetnum ("NC");
if (TN_no_color_video == -1)
TN_no_color_video = 0;
}
tty_default_color_capabilities (1);
MagicWrap = tgetflag ("xn");
AutoWrap = MagicWrap || tgetflag ("am");
memory_below_frame = tgetflag ("db");
TF_hazeltine = tgetflag ("hz");
must_write_spaces = tgetflag ("in");
meta_key = tgetflag ("km") || tgetflag ("MT");
TF_insmode_motion = tgetflag ("mi");
TF_standout_motion = tgetflag ("ms");
TF_underscore = tgetflag ("ul");
TF_teleray = tgetflag ("xt");
term_get_fkeys (address);
{
int height, width;
get_frame_size (&width, &height);
FRAME_COLS (sf) = width;
FRAME_LINES (sf) = height;
}
if (FRAME_COLS (sf) <= 0)
SET_FRAME_COLS (sf, tgetnum ("co"));
else
SET_FRAME_COLS (sf, FRAME_COLS (sf));
if (FRAME_LINES (sf) <= 0)
FRAME_LINES (sf) = tgetnum ("li");
if (FRAME_LINES (sf) < 3 || FRAME_COLS (sf) < 3)
fatal ("Screen size %dx%d is too small",
FRAME_LINES (sf), FRAME_COLS (sf));
min_padding_speed = tgetnum ("pb");
TabWidth = tgetnum ("tw");
#ifdef VMS
if (Down && Down[0] == '\n')
Down = 0;
#endif
if (!TS_bell)
TS_bell = "\07";
if (!TS_fwd_scroll)
TS_fwd_scroll = Down;
PC = TS_pad_char ? *TS_pad_char : 0;
if (TabWidth < 0)
TabWidth = 8;
if (TS_standout_mode && tgetnum ("sg") >= 0)
{
TS_standout_mode = 0;
TS_end_standout_mode = 0;
}
if (TS_enter_underline_mode && tgetnum ("ug") >= 0)
{
TS_enter_underline_mode = 0;
TS_exit_underline_mode = 0;
}
if (TS_standout_mode == 0)
{
TS_standout_mode = TS_enter_underline_mode;
TS_end_standout_mode = TS_exit_underline_mode;
}
if (TS_end_standout_mode == 0)
{
char *s = tgetstr ("me", address);
if (s != 0)
TS_end_standout_mode = s;
else
TS_standout_mode = 0;
}
if (TF_teleray)
{
Wcm.cm_tab = 0;
TS_standout_mode = 0;
CR = 0;
Down = 0;
}
if (!strcmp (terminal_type, "supdup"))
{
memory_below_frame = 1;
Wcm.cm_losewrap = 1;
}
if (!strncmp (terminal_type, "c10", 3)
|| !strcmp (terminal_type, "perq"))
{
if (!TS_set_window)
{
p = TS_termcap_modes;
while (*p && strcmp (p, "\033v "))
p++;
if (*p)
TS_set_window = "\033v%C %C %C %C ";
}
must_write_spaces = 1;
strcpy (area, TS_termcap_modes);
strcat (area, "\033\007!");
TS_termcap_modes = area;
area += strlen (area) + 1;
p = AbsPosition;
while (*p)
{
if (p[0] == '%' && p[1] == '+')
p[1] = 'C';
p++;
}
}
FrameRows = FRAME_LINES (sf);
FrameCols = FRAME_COLS (sf);
specified_window = FRAME_LINES (sf);
if (Wcm_init () == -1)
#ifdef VMS
fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
It lacks the ability to position the cursor.\n\
If that is not the actual type of terminal you have, use either the\n\
DCL command `SET TERMINAL/DEVICE= ...' for DEC-compatible terminals,\n\
or `define EMACS_TERM \"terminal type\"' for non-DEC terminals.",
terminal_type);
#else
# ifdef TERMINFO
fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
It lacks the ability to position the cursor.\n\
If that is not the actual type of terminal you have,\n\
use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
`setenv TERM ...') to specify the correct type. It may be necessary\n\
to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
terminal_type);
# else
fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
It lacks the ability to position the cursor.\n\
If that is not the actual type of terminal you have,\n\
use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
`setenv TERM ...') to specify the correct type. It may be necessary\n\
to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
terminal_type);
# endif
#endif
if (FRAME_LINES (sf) <= 0
|| FRAME_COLS (sf) <= 0)
fatal ("The frame size has not been specified");
delete_in_insert_mode
= TS_delete_mode && TS_insert_mode
&& !strcmp (TS_delete_mode, TS_insert_mode);
se_is_so = (TS_standout_mode
&& TS_end_standout_mode
&& !strcmp (TS_standout_mode, TS_end_standout_mode));
UseTabs = tabs_safe_p () && TabWidth == 8;
scroll_region_ok
= (Wcm.cm_abs
&& (TS_set_window || TS_set_scroll_region || TS_set_scroll_region_1));
line_ins_del_ok = (((TS_ins_line || TS_ins_multi_lines)
&& (TS_del_line || TS_del_multi_lines))
|| (scroll_region_ok && TS_fwd_scroll && TS_rev_scroll));
char_ins_del_ok = ((TS_ins_char || TS_insert_mode
|| TS_pad_inserted_char || TS_ins_multi_chars)
&& (TS_del_char || TS_del_multi_chars));
fast_clear_end_of_line = TS_clr_line != 0;
init_baud_rate ();
if (read_socket_hook)
baud_rate = 9600;
FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
#endif
xfree (buffer);
}
void
fatal (str, arg1, arg2)
char *str, *arg1, *arg2;
{
fprintf (stderr, "emacs: ");
fprintf (stderr, str, arg1, arg2);
fprintf (stderr, "\n");
fflush (stderr);
exit (1);
}
DEFUN ("tty-no-underline", Ftty_no_underline, Stty_no_underline, 0, 0, 0,
doc: )
()
{
TS_enter_underline_mode = 0;
return Qnil;
}
void
syms_of_term ()
{
DEFVAR_BOOL ("system-uses-terminfo", &system_uses_terminfo,
doc: );
#ifdef TERMINFO
system_uses_terminfo = 1;
#else
system_uses_terminfo = 0;
#endif
DEFVAR_LISP ("ring-bell-function", &Vring_bell_function,
doc: );
Vring_bell_function = Qnil;
DEFVAR_BOOL ("visible-cursor", &visible_cursor,
doc: );
visible_cursor = 1;
defsubr (&Stty_display_color_p);
defsubr (&Stty_display_color_cells);
defsubr (&Stty_no_underline);
fullscreen_hook = NULL;
}