/* Terminal control module for terminals described by TERMCAP
- Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1998, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+ Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2012
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
-#include <ctype.h>
-#include <string.h>
#include <errno.h>
#include <sys/file.h>
-
-#ifdef HAVE_UNISTD_H
+#include <sys/time.h>
#include <unistd.h>
-#endif
-
-#if HAVE_TERMIOS_H
-#include <termios.h> /* For TIOCNOTTY. */
-#endif
-
-#include <signal.h>
-#include <stdarg.h>
-#include <setjmp.h>
#include "lisp.h"
#include "termchar.h"
-#include "termopts.h"
-#include "buffer.h"
+#include "tparam.h"
#include "character.h"
+#include "buffer.h"
#include "charset.h"
#include "coding.h"
#include "composite.h"
static int been_here = -1;
#endif
-/* For now, don't try to include termcap.h. On some systems,
- configure finds a non-standard termcap.h that the main build
- won't find. */
-
-#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"
/* The name of the default console device. */
#ifdef WINDOWSNT
#define DEV_TTY "CONOUT$"
+#include "w32term.h"
#else
#define DEV_TTY "/dev/tty"
#endif
-static void tty_set_scroll_region P_ ((struct frame *f, int start, int stop));
-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_ ((struct tty_display_info *));
-static void tty_hide_cursor P_ ((struct tty_display_info *));
-static void tty_background_highlight P_ ((struct tty_display_info *tty));
-static void clear_tty_hooks P_ ((struct terminal *terminal));
-static void set_tty_hooks P_ ((struct terminal *terminal));
-static void dissociate_if_controlling_tty P_ ((int fd));
-static void delete_tty P_ ((struct terminal *));
+static void tty_set_scroll_region (struct frame *f, int start, int stop);
+static void turn_on_face (struct frame *, int face_id);
+static void turn_off_face (struct frame *, int face_id);
+static void tty_turn_off_highlight (struct tty_display_info *);
+static void tty_show_cursor (struct tty_display_info *);
+static void tty_hide_cursor (struct tty_display_info *);
+static void tty_background_highlight (struct tty_display_info *tty);
+static struct terminal *get_tty_terminal (Lisp_Object, int);
+static void clear_tty_hooks (struct terminal *terminal);
+static void set_tty_hooks (struct terminal *terminal);
+static void dissociate_if_controlling_tty (int fd);
+static void delete_tty (struct terminal *);
+static _Noreturn void maybe_fatal (int must_succeed, struct terminal *terminal,
+ const char *str1, const char *str2, ...)
+ ATTRIBUTE_FORMAT_PRINTF (3, 5) ATTRIBUTE_FORMAT_PRINTF (4, 5);
+static _Noreturn void vfatal (const char *str, va_list ap)
+ ATTRIBUTE_FORMAT_PRINTF (1, 0);
+
#define OUTPUT(tty, a) \
emacs_tputs ((tty), a, \
#define OUTPUT_IF(tty, a) \
do { \
if (a) \
- emacs_tputs ((tty), a, \
- (int) (FRAME_LINES (XFRAME (selected_frame)) \
- - curY (tty) ), \
- cmputc); \
+ OUTPUT (tty, a); \
} while (0)
#define OUTPUT1_IF(tty, a) do { if (a) emacs_tputs ((tty), a, 1, cmputc); } while (0)
-/* If true, use "vs", otherwise use "ve" to make the cursor visible. */
-
-static int visible_cursor;
-
/* Display space properties */
-extern Lisp_Object Qspace, QCalign_to, QCwidth;
-
-/* Functions to call after suspending a tty. */
-Lisp_Object Vsuspend_tty_functions;
-
-/* Functions to call after resuming a tty. */
-Lisp_Object Vresume_tty_functions;
-
/* Chain of all tty device parameters. */
struct tty_display_info *tty_list;
-/* Nonzero means no need to redraw the entire frame on resuming a
- suspended Emacs. This is useful on terminals with multiple
- pages, where one page is used for Emacs and another for all
- else. */
-int no_redraw_on_reenter;
-
/* Meaning of bits in no_color_video. Each bit set means that the
corresponding attribute cannot be combined with colors. */
NC_STANDOUT = 1 << 0,
NC_UNDERLINE = 1 << 1,
NC_REVERSE = 1 << 2,
- NC_BLINK = 1 << 3,
+ NC_ITALIC = 1 << 3,
NC_DIM = 1 << 4,
NC_BOLD = 1 << 5,
NC_INVIS = 1 << 6,
- NC_PROTECT = 1 << 7,
- NC_ALT_CHARSET = 1 << 8
+ NC_PROTECT = 1 << 7
};
/* internal state */
/* The largest frame width in any call to calculate_costs. */
-int max_frame_cols;
-
-/* The largest frame height in any call to calculate_costs. */
-
-int max_frame_lines;
+static int max_frame_cols;
/* Non-zero if we have dropped our controlling tty and therefore
should not open a frame on stdout. */
static int no_controlling_tty;
-/* Provided for lisp packages. */
-
-static int system_uses_terminfo;
-
-char *tparam ();
-
-extern char *tgetstr ();
\f
#ifdef HAVE_GPM
#include <sys/fcntl.h>
-static void term_clear_mouse_face ();
-static void term_mouse_highlight (struct frame *f, int x, int y);
-
/* The device for which we have enabled gpm support (or NULL). */
struct tty_display_info *gpm_tty = NULL;
-/* These variables describe the range of text currently shown in its
- mouse-face, together with the window they apply to. As long as
- the mouse stays within this range, we need not redraw anything on
- its account. Rows and columns are glyph matrix positions in
- MOUSE_FACE_WINDOW. */
-static int mouse_face_beg_row, mouse_face_beg_col;
-static int mouse_face_end_row, mouse_face_end_col;
-static int mouse_face_past_end;
-static Lisp_Object mouse_face_window;
-static int mouse_face_face_id;
-
-static int pos_x, pos_y;
+/* Last recorded mouse coordinates. */
static int last_mouse_x, last_mouse_y;
#endif /* HAVE_GPM */
/* Set up termcap modes for Emacs. */
-void
+static void
tty_set_terminal_modes (struct terminal *terminal)
{
struct tty_display_info *tty = terminal->display_info.tty;
/* Reset termcap modes before exiting Emacs. */
-void
+static void
tty_reset_terminal_modes (struct terminal *terminal)
{
struct tty_display_info *tty = terminal->display_info.tty;
struct tty_display_info *tty = FRAME_TTY (f);
if (tty->TS_set_scroll_region)
- buf = tparam (tty->TS_set_scroll_region, 0, 0, start, stop - 1);
+ buf = tparam (tty->TS_set_scroll_region, 0, 0, start, stop - 1, 0, 0);
else if (tty->TS_set_scroll_region_1)
buf = tparam (tty->TS_set_scroll_region_1, 0, 0,
FRAME_LINES (f), start,
\f
/* Handle highlighting. */
-void
+static void
tty_turn_off_highlight (struct tty_display_info *tty)
{
if (tty->standout_mode)
static unsigned char *encode_terminal_src;
static unsigned char *encode_terminal_dst;
/* Allocated sizes of the above buffers. */
-static int encode_terminal_src_size;
-static int encode_terminal_dst_size;
+static ptrdiff_t encode_terminal_src_size;
+static ptrdiff_t encode_terminal_dst_size;
/* Encode SRC_LEN glyphs starting at SRC to terminal output codes.
Set CODING->produced to the byte-length of the resulting byte
sequence, and return a pointer to that byte sequence. */
unsigned char *
-encode_terminal_code (src, src_len, coding)
- struct glyph *src;
- int src_len;
- struct coding_system *coding;
+encode_terminal_code (struct glyph *src, int src_len, struct coding_system *coding)
{
struct glyph *src_end = src + src_len;
unsigned char *buf;
- int nchars, nbytes, required;
- register int tlen = GLYPH_TABLE_LENGTH;
+ ptrdiff_t nchars, nbytes, required;
+ ptrdiff_t tlen = GLYPH_TABLE_LENGTH;
register Lisp_Object *tbase = GLYPH_TABLE_BASE;
Lisp_Object charset_list;
multibyte-form. But, it may be enlarged on demand if
Vglyph_table contains a string or a composite glyph is
encountered. */
- required = MAX_MULTIBYTE_LENGTH * src_len;
+ if (min (PTRDIFF_MAX, SIZE_MAX) / MAX_MULTIBYTE_LENGTH < src_len)
+ memory_full (SIZE_MAX);
+ required = src_len;
+ required *= MAX_MULTIBYTE_LENGTH;
if (encode_terminal_src_size < required)
{
- if (encode_terminal_src)
- encode_terminal_src = xrealloc (encode_terminal_src, required);
- else
- encode_terminal_src = xmalloc (required);
+ encode_terminal_src = xrealloc (encode_terminal_src, required);
encode_terminal_src_size = required;
}
{
if (src->type == COMPOSITE_GLYPH)
{
- struct composition *cmp;
- Lisp_Object gstring;
+ struct composition *cmp IF_LINT (= NULL);
+ Lisp_Object gstring IF_LINT (= Qnil);
int i;
nbytes = buf - encode_terminal_src;
if (src->u.cmp.automatic)
{
gstring = composition_gstring_from_id (src->u.cmp.id);
- required = src->u.cmp.to + 1 - src->u.cmp.from;
+ required = src->slice.cmp.to - src->slice.cmp.from + 1;
}
else
{
cmp = composition_table[src->u.cmp.id];
- required = MAX_MULTIBYTE_LENGTH * cmp->glyph_len;
+ required = cmp->glyph_len;
+ required *= MAX_MULTIBYTE_LENGTH;
}
- if (encode_terminal_src_size < nbytes + required)
+ if (encode_terminal_src_size - nbytes < required)
{
- encode_terminal_src_size = nbytes + required;
- encode_terminal_src = xrealloc (encode_terminal_src,
- encode_terminal_src_size);
+ encode_terminal_src =
+ xpalloc (encode_terminal_src, &encode_terminal_src_size,
+ required - (encode_terminal_src_size - nbytes),
+ -1, 1);
buf = encode_terminal_src + nbytes;
}
if (src->u.cmp.automatic)
- for (i = src->u.cmp.from; i <= src->u.cmp.to; i++)
+ for (i = src->slice.cmp.from; i <= src->slice.cmp.to; i++)
{
Lisp_Object g = LGSTRING_GLYPH (gstring, i);
int c = LGLYPH_CHAR (g);
{
int c = COMPOSITION_GLYPH (cmp, i);
+ /* TAB in a composition means display glyphs with
+ padding space on the left or right. */
if (c == '\t')
continue;
if (char_charset (c, charset_list, NULL))
else if (! CHAR_GLYPH_PADDING_P (*src))
{
GLYPH g;
- int c;
+ int c IF_LINT (= 0);
Lisp_Object string;
string = Qnil;
if (NILP (string))
{
nbytes = buf - encode_terminal_src;
- if (encode_terminal_src_size < nbytes + MAX_MULTIBYTE_LENGTH)
+ if (encode_terminal_src_size - nbytes < MAX_MULTIBYTE_LENGTH)
{
- encode_terminal_src_size = nbytes + MAX_MULTIBYTE_LENGTH;
- encode_terminal_src = xrealloc (encode_terminal_src,
- encode_terminal_src_size);
+ encode_terminal_src =
+ xpalloc (encode_terminal_src, &encode_terminal_src_size,
+ MAX_MULTIBYTE_LENGTH, -1, 1);
buf = encode_terminal_src + nbytes;
}
if (CHAR_BYTE8_P (c)
}
else
{
- unsigned char *p = SDATA (string), *pend = p + SBYTES (string);
-
if (! STRING_MULTIBYTE (string))
string = string_to_multibyte (string);
nbytes = buf - encode_terminal_src;
- if (encode_terminal_src_size < nbytes + SBYTES (string))
+ if (encode_terminal_src_size - nbytes < SBYTES (string))
{
- encode_terminal_src_size = nbytes + SBYTES (string);
- encode_terminal_src = xrealloc (encode_terminal_src,
- encode_terminal_src_size);
+ encode_terminal_src =
+ xpalloc (encode_terminal_src, &encode_terminal_src_size,
+ (SBYTES (string)
+ - (encode_terminal_src_size - nbytes)),
+ -1, 1);
buf = encode_terminal_src + nbytes;
}
- bcopy (SDATA (string), buf, SBYTES (string));
+ memcpy (buf, SDATA (string), SBYTES (string));
buf += SBYTES (string);
nchars += SCHARS (string);
}
coding->source = encode_terminal_src;
if (encode_terminal_dst_size == 0)
{
+ encode_terminal_dst = xrealloc (encode_terminal_dst,
+ encode_terminal_src_size);
encode_terminal_dst_size = encode_terminal_src_size;
- if (encode_terminal_dst)
- encode_terminal_dst = xrealloc (encode_terminal_dst,
- encode_terminal_dst_size);
- else
- encode_terminal_dst = xmalloc (encode_terminal_dst_size);
}
coding->destination = encode_terminal_dst;
coding->dst_bytes = encode_terminal_dst_size;
{
unsigned char *conversion_buffer;
struct coding_system *coding;
+ size_t n, stringlen;
struct tty_display_info *tty = FRAME_TTY (f);
the tail. */
coding->mode &= ~CODING_MODE_LAST_BLOCK;
- while (len > 0)
+ for (stringlen = len; stringlen != 0; stringlen -= n)
{
/* Identify a run of glyphs with the same face. */
int face_id = string->face_id;
- int n;
- for (n = 1; n < len; ++n)
+ for (n = 1; n < stringlen; ++n)
if (string[n].face_id != face_id)
break;
tty_highlight_if_desired (tty);
turn_on_face (f, face_id);
- if (n == len)
+ if (n == stringlen)
/* This is the last run. */
coding->mode |= CODING_MODE_LAST_BLOCK;
conversion_buffer = encode_terminal_code (string, n, coding);
if (coding->produced > 0)
{
- BLOCK_INPUT;
+ block_input ();
fwrite (conversion_buffer, 1, coding->produced, tty->output);
if (ferror (tty->output))
clearerr (tty->output);
if (tty->termscript)
fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
- UNBLOCK_INPUT;
+ unblock_input ();
}
- len -= n;
string += n;
/* Turn appearance modes off. */
#ifdef HAVE_GPM /* Only used by GPM code. */
static void
-tty_write_glyphs_with_face (f, string, len, face_id)
- register struct frame *f;
- register struct glyph *string;
- register int len, face_id;
+tty_write_glyphs_with_face (register struct frame *f, register struct glyph *string,
+ register int len, register int face_id)
{
unsigned char *conversion_buffer;
struct coding_system *coding;
conversion_buffer = encode_terminal_code (string, len, coding);
if (coding->produced > 0)
{
- BLOCK_INPUT;
+ block_input ();
fwrite (conversion_buffer, 1, coding->produced, tty->output);
if (ferror (tty->output))
clearerr (tty->output);
if (tty->termscript)
fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
- UNBLOCK_INPUT;
+ unblock_input ();
}
/* Turn appearance modes off. */
if (tty->TS_ins_multi_chars)
{
- buf = tparam (tty->TS_ins_multi_chars, 0, 0, len);
+ buf = tparam (tty->TS_ins_multi_chars, 0, 0, len, 0, 0, 0);
OUTPUT1 (tty, buf);
xfree (buf);
if (start)
if (coding->produced > 0)
{
- BLOCK_INPUT;
+ block_input ();
fwrite (conversion_buffer, 1, coding->produced, tty->output);
if (ferror (tty->output))
clearerr (tty->output);
if (tty->termscript)
fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
- UNBLOCK_INPUT;
+ unblock_input ();
}
OUTPUT1_IF (tty, tty->TS_pad_inserted_char);
if (tty->TS_del_multi_chars)
{
- buf = tparam (tty->TS_del_multi_chars, 0, 0, n);
+ buf = tparam (tty->TS_del_multi_chars, 0, 0, n, 0, 0, 0);
OUTPUT1 (tty, buf);
xfree (buf);
}
tty_ins_del_lines (struct frame *f, int vpos, int n)
{
struct tty_display_info *tty = FRAME_TTY (f);
- char *multi = n > 0 ? tty->TS_ins_multi_lines : tty->TS_del_multi_lines;
- char *single = n > 0 ? tty->TS_ins_line : tty->TS_del_line;
- char *scroll = n > 0 ? tty->TS_rev_scroll : tty->TS_fwd_scroll;
+ const char *multi =
+ n > 0 ? tty->TS_ins_multi_lines : tty->TS_del_multi_lines;
+ const char *single = n > 0 ? tty->TS_ins_line : tty->TS_del_line;
+ const char *scroll = n > 0 ? tty->TS_rev_scroll : tty->TS_fwd_scroll;
register int i = n > 0 ? n : -n;
register char *buf;
{
raw_cursor_to (f, vpos, 0);
tty_background_highlight (tty);
- buf = tparam (multi, 0, 0, i);
+ buf = tparam (multi, 0, 0, i, 0, 0, 0);
OUTPUT (tty, buf);
xfree (buf);
}
not counting any line-dependent padding. */
int
-string_cost (char *str)
+string_cost (const char *str)
{
cost = 0;
if (str)
counting any line-dependent padding at one line. */
static int
-string_cost_one_line (char *str)
+string_cost_one_line (const char *str)
{
cost = 0;
if (str)
in tenths of characters. */
int
-per_line_cost (char *str)
+per_line_cost (const char *str)
{
cost = 0;
if (str)
return cost;
}
-#ifndef old
/* char_ins_del_cost[n] is cost of inserting N characters.
char_ins_del_cost[-n] is cost of deleting N characters.
The length of this vector is based on max_frame_cols. */
int *char_ins_del_vector;
#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_COLS ((f))])
-#endif
/* ARGSUSED */
static void
if (FRAME_TERMCAP_P (frame))
{
struct tty_display_info *tty = FRAME_TTY (frame);
- register char *f = (tty->TS_set_scroll_region
- ? tty->TS_set_scroll_region
- : tty->TS_set_scroll_region_1);
+ register const char *f = (tty->TS_set_scroll_region
+ ? tty->TS_set_scroll_region
+ : tty->TS_set_scroll_region_1);
FRAME_SCROLL_REGION_COST (frame) = string_cost (f);
char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
X turns off char_ins_del_ok. */
- max_frame_lines = max (max_frame_lines, FRAME_LINES (frame));
max_frame_cols = max (max_frame_cols, FRAME_COLS (frame));
+ if ((min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) - 1) / 2
+ < max_frame_cols)
+ memory_full (SIZE_MAX);
- 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));
+ char_ins_del_vector =
+ xrealloc (char_ins_del_vector,
+ (sizeof (int) + 2 * sizeof (int) * max_frame_cols));
- bzero (char_ins_del_vector, (sizeof (int)
- + 2 * max_frame_cols * sizeof (int)));
+ memset (char_ins_del_vector, 0,
+ (sizeof (int) + 2 * sizeof (int) * max_frame_cols));
if (f && (!tty->TS_ins_line && !tty->TS_del_line))
}
\f
struct fkey_table {
- char *cap, *name;
+ const char *cap, *name;
};
/* Termcap capability names that correspond directly to X keysyms.
other keys (as on the IBM PC keyboard) they get overridden.
*/
-static struct fkey_table keys[] =
+static const struct fkey_table keys[] =
{
{"kh", "home"}, /* termcap */
{"kl", "left"}, /* termcap */
{"!3", "S-undo"} /*shifted undo key*/
};
+#ifndef DOS_NT
static char **term_get_fkeys_address;
static KBOARD *term_get_fkeys_kboard;
-static Lisp_Object term_get_fkeys_1 ();
+static Lisp_Object term_get_fkeys_1 (void);
/* Find the escape codes sent by the function keys for Vinput_decode_map.
This function scans the termcap function key sequence entries, and
adds entries to Vinput_decode_map for each function key it finds. */
static void
-term_get_fkeys (address, kboard)
- char **address;
- KBOARD *kboard;
+term_get_fkeys (char **address, KBOARD *kboard)
{
/* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
errors during the call. The only errors should be from Fdefine_key
function key specification, rather than giving the user an error and
refusing to run at all on such a terminal. */
- extern Lisp_Object Fidentity ();
term_get_fkeys_address = address;
term_get_fkeys_kboard = kboard;
internal_condition_case (term_get_fkeys_1, Qerror, Fidentity);
}
static Lisp_Object
-term_get_fkeys_1 ()
+term_get_fkeys_1 (void)
{
int i;
KBOARD *kboard = term_get_fkeys_kboard;
/* This can happen if CANNOT_DUMP or with strange options. */
- if (!KEYMAPP (kboard->Vinput_decode_map))
- kboard->Vinput_decode_map = Fmake_sparse_keymap (Qnil);
+ if (!KEYMAPP (KVAR (kboard, Vinput_decode_map)))
+ kset_input_decode_map (kboard, 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 (kboard->Vinput_decode_map, build_string (sequence),
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence),
Fmake_vector (make_number (1),
intern (keys[i].name)));
}
"k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
*/
{
- char *k_semi = tgetstr ("k;", address);
- char *k0 = tgetstr ("k0", address);
- char *k0_name = "f10";
+ const char *k_semi = tgetstr ("k;", address);
+ const char *k0 = tgetstr ("k0", address);
+ const char *k0_name = "f10";
if (k_semi)
{
if (k0)
/* Define f0 first, so that f10 takes precedence in case the
key sequences happens to be the same. */
- Fdefine_key (kboard->Vinput_decode_map, build_string (k0),
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k0),
Fmake_vector (make_number (1), intern ("f0")));
- Fdefine_key (kboard->Vinput_decode_map, build_string (k_semi),
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k_semi),
Fmake_vector (make_number (1), intern ("f10")));
}
else if (k0)
- Fdefine_key (kboard->Vinput_decode_map, build_string (k0),
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (k0),
Fmake_vector (make_number (1), intern (k0_name)));
}
if (sequence)
{
sprintf (fkey, "f%d", i);
- Fdefine_key (kboard->Vinput_decode_map, build_string (sequence),
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence),
Fmake_vector (make_number (1),
intern (fkey)));
}
{ \
char *sequence = tgetstr (cap2, address); \
if (sequence) \
- Fdefine_key (kboard->Vinput_decode_map, build_string (sequence), \
+ Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence), \
Fmake_vector (make_number (1), \
intern (sym))); \
}
return Qnil;
}
+#endif /* not DOS_NT */
\f
/***********************************************************************
Character Display Information
***********************************************************************/
-
-/* Avoid name clash with functions defined in xterm.c */
-#ifdef static
-#define append_glyph append_glyph_term
-#define produce_stretch_glyph produce_stretch_glyph_term
-#define append_composite_glyph append_composite_glyph_term
-#define produce_composite_glyph produce_composite_glyph_term
-#endif
-
-static void append_glyph P_ ((struct it *));
-static void produce_stretch_glyph P_ ((struct it *));
-static void append_composite_glyph P_ ((struct it *));
-static void produce_composite_glyph P_ ((struct it *));
+static void append_glyph (struct it *);
+static void append_composite_glyph (struct it *);
+static void produce_composite_glyph (struct it *);
+static void append_glyphless_glyph (struct it *, int, const char *);
+static void produce_glyphless_glyph (struct it *, int, Lisp_Object);
/* Append glyphs to IT's glyph_row. Called from produce_glyphs for
terminal frames if IT->glyph_row != NULL. IT->char_to_display is
IT->pixel_width > 1. */
static void
-append_glyph (it)
- struct it *it;
+append_glyph (struct it *it)
{
struct glyph *glyph, *end;
int i;
- xassert (it->glyph_row);
+ eassert (it->glyph_row);
glyph = (it->glyph_row->glyphs[it->area]
+ it->glyph_row->used[it->area]);
end = it->glyph_row->glyphs[1 + it->area];
+ /* If the glyph row is reversed, we need to prepend the glyph rather
+ than append it. */
+ if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
+ {
+ struct glyph *g;
+ int move_by = it->pixel_width;
+
+ /* Make room for the new glyphs. */
+ if (move_by > end - glyph) /* don't overstep end of this area */
+ move_by = end - glyph;
+ for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
+ g[move_by] = *g;
+ glyph = it->glyph_row->glyphs[it->area];
+ end = glyph + move_by;
+ }
+
+ /* BIDI Note: we put the glyphs of a "multi-pixel" character left to
+ right, even in the REVERSED_P case, since (a) all of its u.ch are
+ identical, and (b) the PADDING_P flag needs to be set for the
+ leftmost one, because we write to the terminal left-to-right. */
for (i = 0;
i < it->pixel_width && glyph < end;
++i)
glyph->padding_p = i > 0;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
+ if (it->bidi_p)
+ {
+ glyph->resolved_level = it->bidi_it.resolved_level;
+ if ((it->bidi_it.type & 7) != it->bidi_it.type)
+ emacs_abort ();
+ glyph->bidi_type = it->bidi_it.type;
+ }
+ else
+ {
+ glyph->resolved_level = 0;
+ glyph->bidi_type = UNKNOWN_BT;
+ }
++it->glyph_row->used[it->area];
++glyph;
}
}
+/* For external use. */
+void
+tty_append_glyph (struct it *it)
+{
+ append_glyph (it);
+}
+
/* Produce glyphs for the display element described by IT. *IT
specifies what we want to produce a glyph for (character, image, ...),
instead they use the macro PRODUCE_GLYPHS. */
void
-produce_glyphs (it)
- struct it *it;
+produce_glyphs (struct it *it)
{
/* If a hook is installed, let it do the work. */
/* Nothing but characters are supported on terminal frames. */
- xassert (it->what == IT_CHARACTER
+ eassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION
- || it->what == IT_STRETCH);
+ || it->what == IT_STRETCH
+ || it->what == IT_GLYPHLESS);
if (it->what == IT_STRETCH)
{
goto done;
}
+ if (it->what == IT_GLYPHLESS)
+ {
+ produce_glyphless_glyph (it, 0, Qnil);
+ goto done;
+ }
+
if (it->char_to_display >= 040 && it->char_to_display < 0177)
{
it->pixel_width = it->nglyphs = 1;
}
else
{
- it->pixel_width = CHAR_WIDTH (it->char_to_display);
- it->nglyphs = it->pixel_width;
+ Lisp_Object charset_list = FRAME_TERMINAL (it->f)->charset_list;
- if (it->glyph_row)
- append_glyph (it);
+ if (char_charset (it->char_to_display, charset_list, NULL))
+ {
+ it->pixel_width = CHAR_WIDTH (it->char_to_display);
+ it->nglyphs = it->pixel_width;
+ if (it->glyph_row)
+ append_glyph (it);
+ }
+ else
+ {
+ Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
+
+ eassert (it->what == IT_GLYPHLESS);
+ produce_glyphless_glyph (it, 1, acronym);
+ }
}
done:
it->descent = it->max_descent = it->phys_descent = it->max_phys_descent = 1;
}
-
-/* Produce a stretch glyph for iterator IT. IT->object is the value
- of the glyph property displayed. The value must be a list
- `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
- being recognized:
-
- 1. `:width WIDTH' specifies that the space should be WIDTH *
- canonical char width wide. WIDTH may be an integer or floating
- point number.
-
- 2. `:align-to HPOS' specifies that the space should be wide enough
- to reach HPOS, a value in canonical character units. */
-
-static void
-produce_stretch_glyph (it)
- struct it *it;
-{
- /* (space :width WIDTH ...) */
- Lisp_Object prop, plist;
- int width = 0, align_to = -1;
- int zero_width_ok_p = 0;
- double tem;
-
- /* List should start with `space'. */
- xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
- plist = XCDR (it->object);
-
- /* Compute the width of the stretch. */
- if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
- && calc_pixel_width_or_height (&tem, it, prop, 0, 1, 0))
- {
- /* Absolute width `:width WIDTH' specified and valid. */
- 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
- /* Nothing specified -> width defaults to canonical char width. */
- width = FRAME_COLUMN_WIDTH (it->f);
-
- if (width <= 0 && (width < 0 || !zero_width_ok_p))
- width = 1;
-
- if (width > 0 && it->line_wrap != TRUNCATE
- && it->current_x + width > it->last_visible_x)
- width = it->last_visible_x - it->current_x - 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;
-}
-
-
/* Append glyphs to IT's glyph_row for the composition IT->cmp_id.
Called from produce_composite_glyph for terminal frames if
IT->glyph_row != NULL. IT->face_id contains the character's
face. */
static void
-append_composite_glyph (it)
- struct it *it;
+append_composite_glyph (struct it *it)
{
struct glyph *glyph;
- xassert (it->glyph_row);
+ eassert (it->glyph_row);
glyph = it->glyph_row->glyphs[it->area] + it->glyph_row->used[it->area];
if (glyph < it->glyph_row->glyphs[1 + it->area])
{
+ /* If the glyph row is reversed, we need to prepend the glyph
+ rather than append it. */
+ if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
+ {
+ struct glyph *g;
+
+ /* Make room for the new glyph. */
+ for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
+ g[1] = *g;
+ glyph = it->glyph_row->glyphs[it->area];
+ }
glyph->type = COMPOSITE_GLYPH;
glyph->pixel_width = it->pixel_width;
glyph->u.cmp.id = it->cmp_it.id;
{
glyph->u.cmp.automatic = 1;
glyph->u.cmp.id = it->cmp_it.id;
- glyph->u.cmp.from = it->cmp_it.from;
- glyph->u.cmp.to = it->cmp_it.to - 1;
+ glyph->slice.cmp.from = it->cmp_it.from;
+ glyph->slice.cmp.to = it->cmp_it.to - 1;
}
glyph->face_id = it->face_id;
glyph->padding_p = 0;
glyph->charpos = CHARPOS (it->position);
glyph->object = it->object;
+ if (it->bidi_p)
+ {
+ glyph->resolved_level = it->bidi_it.resolved_level;
+ if ((it->bidi_it.type & 7) != it->bidi_it.type)
+ emacs_abort ();
+ glyph->bidi_type = it->bidi_it.type;
+ }
+ else
+ {
+ glyph->resolved_level = 0;
+ glyph->bidi_type = UNKNOWN_BT;
+ }
++it->glyph_row->used[it->area];
++glyph;
correctly. */
static void
-produce_composite_glyph (it)
- struct it *it;
+produce_composite_glyph (struct it *it)
{
- int c;
-
if (it->cmp_it.ch < 0)
{
struct composition *cmp = composition_table[it->cmp_it.id];
}
-/* Get information about special display element WHAT in an
- environment described by IT. WHAT is one of IT_TRUNCATION or
- IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
- non-null glyph_row member. This function ensures that fields like
- face_id, c, len of IT are left untouched. */
+/* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
+ is a face ID to be used for the glyph. What is actually appended
+ are glyphs of type CHAR_GLYPH whose characters are in STR (which
+ comes from it->nglyphs bytes). */
-void
-produce_special_glyphs (it, what)
- struct it *it;
- enum display_element_type what;
-{
- struct it temp_it;
- Lisp_Object gc;
- 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)
- {
- /* Continuation glyph. */
- SET_GLYPH_FROM_CHAR (glyph, '\\');
- if (it->dp
- && (gc = DISP_CONTINUE_GLYPH (it->dp), GLYPH_CODE_P (gc))
- && GLYPH_CODE_CHAR_VALID_P (gc))
- {
- SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
- spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
- }
+static void
+append_glyphless_glyph (struct it *it, int face_id, const char *str)
+{
+ struct glyph *glyph, *end;
+ int i;
+
+ eassert (it->glyph_row);
+ glyph = it->glyph_row->glyphs[it->area] + it->glyph_row->used[it->area];
+ end = it->glyph_row->glyphs[1 + it->area];
+
+ /* If the glyph row is reversed, we need to prepend the glyph rather
+ than append it. */
+ if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
+ {
+ struct glyph *g;
+ int move_by = it->pixel_width;
+
+ /* Make room for the new glyphs. */
+ if (move_by > end - glyph) /* don't overstep end of this area */
+ move_by = end - glyph;
+ for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
+ g[move_by] = *g;
+ glyph = it->glyph_row->glyphs[it->area];
+ end = glyph + move_by;
}
- else if (what == IT_TRUNCATION)
+
+ if (glyph >= end)
+ return;
+ glyph->type = CHAR_GLYPH;
+ glyph->pixel_width = 1;
+ glyph->face_id = face_id;
+ glyph->padding_p = 0;
+ glyph->charpos = CHARPOS (it->position);
+ glyph->object = it->object;
+ if (it->bidi_p)
+ {
+ glyph->resolved_level = it->bidi_it.resolved_level;
+ if ((it->bidi_it.type & 7) != it->bidi_it.type)
+ emacs_abort ();
+ glyph->bidi_type = it->bidi_it.type;
+ }
+ else
{
- /* Truncation glyph. */
- SET_GLYPH_FROM_CHAR (glyph, '$');
- if (it->dp
- && (gc = DISP_TRUNC_GLYPH (it->dp), GLYPH_CODE_P (gc))
- && GLYPH_CODE_CHAR_VALID_P (gc))
- {
- SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
- spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
- }
+ glyph->resolved_level = 0;
+ glyph->bidi_type = UNKNOWN_BT;
+ }
+
+ /* BIDI Note: we put the glyphs of characters left to right, even in
+ the REVERSED_P case because we write to the terminal
+ left-to-right. */
+ for (i = 0; i < it->nglyphs && glyph < end; ++i)
+ {
+ if (i > 0)
+ glyph[0] = glyph[-1];
+ glyph->u.ch = str[i];
+ ++it->glyph_row->used[it->area];
+ ++glyph;
+ }
+}
+
+/* Produce glyphs for a glyphless character for iterator IT.
+ IT->glyphless_method specifies which method to use for displaying
+ the character. See the description of enum
+ glyphless_display_method in dispextern.h for the details.
+
+ FOR_NO_FONT is nonzero if and only if this is for a character that
+ is not supported by the coding system of the terminal. ACRONYM, if
+ non-nil, is an acronym string for the character.
+
+ The glyphs actually produced are of type CHAR_GLYPH. */
+
+static void
+produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
+{
+ int face_id;
+ int len;
+ char buf[sizeof "\\x" + max (6, (sizeof it->c * CHAR_BIT + 3) / 4)];
+ char const *str = " ";
+
+ /* Get a face ID for the glyph by utilizing a cache (the same way as
+ done for `escape-glyph' in get_next_display_element). */
+ if (it->f == last_glyphless_glyph_frame
+ && it->face_id == last_glyphless_glyph_face_id)
+ {
+ face_id = last_glyphless_glyph_merged_face_id;
}
else
- abort ();
+ {
+ /* Merge the `glyphless-char' face into the current face. */
+ face_id = merge_faces (it->f, Qglyphless_char, 0, it->face_id);
+ last_glyphless_glyph_frame = it->f;
+ last_glyphless_glyph_face_id = it->face_id;
+ last_glyphless_glyph_merged_face_id = face_id;
+ }
- temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
- temp_it.face_id = GLYPH_FACE (glyph);
- temp_it.len = CHAR_BYTES (temp_it.c);
+ if (it->glyphless_method == GLYPHLESS_DISPLAY_THIN_SPACE)
+ {
+ /* As there's no way to produce a thin space, we produce a space
+ of canonical width. */
+ len = 1;
+ }
+ else if (it->glyphless_method == GLYPHLESS_DISPLAY_EMPTY_BOX)
+ {
+ len = CHAR_WIDTH (it->c);
+ if (len == 0)
+ len = 1;
+ else if (len > 4)
+ len = 4;
+ len = sprintf (buf, "[%.*s]", len, str);
+ str = buf;
+ }
+ else
+ {
+ if (it->glyphless_method == GLYPHLESS_DISPLAY_ACRONYM)
+ {
+ if (! STRINGP (acronym) && CHAR_TABLE_P (Vglyphless_char_display))
+ acronym = CHAR_TABLE_REF (Vglyphless_char_display, it->c);
+ if (CONSP (acronym))
+ acronym = XCDR (acronym);
+ buf[0] = '[';
+ str = STRINGP (acronym) ? SSDATA (acronym) : "";
+ for (len = 0; len < 6 && str[len] && ASCII_BYTE_P (str[len]); len++)
+ buf[1 + len] = str[len];
+ buf[1 + len] = ']';
+ len += 2;
+ }
+ else
+ {
+ eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
+ len = (it->c < 0x10000 ? sprintf (buf, "\\u%04X", it->c)
+ : it->c <= MAX_UNICODE_CHAR ? sprintf (buf, "\\U%06X", it->c)
+ : sprintf (buf, "\\x%06X", it->c));
+ }
+ str = buf;
+ }
- produce_glyphs (&temp_it);
- it->pixel_width = temp_it.pixel_width;
- it->nglyphs = temp_it.pixel_width;
+ it->pixel_width = len;
+ it->nglyphs = len;
+ if (it->glyph_row)
+ append_glyphless_glyph (it, face_id, str);
}
-
\f
/***********************************************************************
Faces
FACE_ID is a realized face ID number, in the face cache. */
static void
-turn_on_face (f, face_id)
- struct frame *f;
- int face_id;
+turn_on_face (struct frame *f, int face_id)
{
struct face *face = FACE_FROM_ID (f, face_id);
long fg = face->foreground;
if (face->tty_bold_p && MAY_USE_WITH_COLORS_P (tty, NC_BOLD))
OUTPUT1_IF (tty, tty->TS_enter_bold_mode);
- if (face->tty_dim_p && MAY_USE_WITH_COLORS_P (tty, NC_DIM))
- OUTPUT1_IF (tty, tty->TS_enter_dim_mode);
-
- /* Alternate charset and blinking not yet used. */
- if (face->tty_alt_charset_p
- && MAY_USE_WITH_COLORS_P (tty, NC_ALT_CHARSET))
- OUTPUT1_IF (tty, tty->TS_enter_alt_charset_mode);
-
- if (face->tty_blinking_p
- && MAY_USE_WITH_COLORS_P (tty, NC_BLINK))
- OUTPUT1_IF (tty, tty->TS_enter_blink_mode);
+ if (face->tty_italic_p && MAY_USE_WITH_COLORS_P (tty, NC_ITALIC))
+ {
+ if (tty->TS_enter_italic_mode)
+ OUTPUT1 (tty, tty->TS_enter_italic_mode);
+ else
+ /* Italics mode is unavailable on many terminals. In that
+ case, map slant to dimmed text; we want italic text to
+ appear different and dimming is not otherwise used. */
+ OUTPUT1 (tty, tty->TS_enter_dim_mode);
+ }
if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (tty, NC_UNDERLINE))
OUTPUT1_IF (tty, tty->TS_enter_underline_mode);
if (tty->TN_max_colors > 0)
{
- char *ts, *p;
+ const char *ts;
+ char *p;
ts = tty->standout_mode ? tty->TS_set_background : tty->TS_set_foreground;
if (fg >= 0 && ts)
{
- p = tparam (ts, NULL, 0, (int) fg);
+ p = tparam (ts, NULL, 0, (int) fg, 0, 0, 0);
OUTPUT (tty, p);
xfree (p);
}
ts = tty->standout_mode ? tty->TS_set_foreground : tty->TS_set_background;
if (bg >= 0 && ts)
{
- p = tparam (ts, NULL, 0, (int) bg);
+ p = tparam (ts, NULL, 0, (int) bg, 0, 0, 0);
OUTPUT (tty, p);
xfree (p);
}
/* Turn off appearances of face FACE_ID on tty frame F. */
static void
-turn_off_face (f, face_id)
- struct frame *f;
- int face_id;
+turn_off_face (struct frame *f, int face_id)
{
struct face *face = FACE_FROM_ID (f, face_id);
struct tty_display_info *tty = FRAME_TTY (f);
- xassert (face != NULL);
+ eassert (face != NULL);
if (tty->TS_exit_attribute_mode)
{
half-bright, reverse-video, standout, underline. It may or
may not turn off alt-char-mode. */
if (face->tty_bold_p
- || face->tty_dim_p
+ || face->tty_italic_p
|| face->tty_reverse_p
- || face->tty_alt_charset_p
- || face->tty_blinking_p
|| face->tty_underline_p)
{
OUTPUT1_IF (tty, tty->TS_exit_attribute_mode);
if (strcmp (tty->TS_exit_attribute_mode, tty->TS_end_standout_mode) == 0)
tty->standout_mode = 0;
}
-
- if (face->tty_alt_charset_p)
- OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);
}
else
{
/* If we don't have "me" we can only have those appearances
that have exit sequences defined. */
- if (face->tty_alt_charset_p)
- OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);
-
if (face->tty_underline_p)
OUTPUT_IF (tty, tty->TS_exit_underline_mode);
}
colors FG and BG. */
int
-tty_capable_p (tty, caps, fg, bg)
- struct tty_display_info *tty;
- unsigned caps;
- unsigned long fg, bg;
+tty_capable_p (struct tty_display_info *tty, unsigned int caps,
+ unsigned long fg, unsigned long bg)
{
#define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit) \
if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
TTY_CAPABLE_P_TRY (tty, TTY_CAP_UNDERLINE, tty->TS_enter_underline_mode, NC_UNDERLINE);
TTY_CAPABLE_P_TRY (tty, TTY_CAP_BOLD, tty->TS_enter_bold_mode, NC_BOLD);
TTY_CAPABLE_P_TRY (tty, TTY_CAP_DIM, tty->TS_enter_dim_mode, NC_DIM);
- TTY_CAPABLE_P_TRY (tty, TTY_CAP_BLINK, tty->TS_enter_blink_mode, NC_BLINK);
- TTY_CAPABLE_P_TRY (tty, TTY_CAP_ALT_CHARSET, tty->TS_enter_alt_charset_mode, NC_ALT_CHARSET);
+ TTY_CAPABLE_P_TRY (tty, TTY_CAP_ITALIC, tty->TS_enter_italic_mode, NC_ITALIC);
/* We can do it! */
return 1;
TERMINAL can be a terminal object, a frame, or nil (meaning the
selected frame's terminal). This function always returns nil if
-TERMINAL does not refer to a text-only terminal. */)
- (terminal)
- Lisp_Object terminal;
+TERMINAL does not refer to a text terminal. */)
+ (Lisp_Object terminal)
{
struct terminal *t = get_tty_terminal (terminal, 0);
if (!t)
TERMINAL can be a terminal object, a frame, or nil (meaning the
selected frame's terminal). This function always returns 0 if
-TERMINAL does not refer to a text-only terminal. */)
- (terminal)
- Lisp_Object terminal;
+TERMINAL does not refer to a text terminal. */)
+ (Lisp_Object terminal)
{
struct terminal *t = get_tty_terminal (terminal, 0);
if (!t)
}
void
-set_tty_color_mode (tty, f)
- struct tty_display_info *tty;
- struct frame *f;
+set_tty_color_mode (struct tty_display_info *tty, struct frame *f)
{
- Lisp_Object tem, val, color_mode_spec;
+ Lisp_Object tem, val;
Lisp_Object color_mode;
int mode;
- extern Lisp_Object Qtty_color_mode;
Lisp_Object tty_color_mode_alist
= Fintern_soft (build_string ("tty-color-mode-alist"), Qnil);
if (INTEGERP (val))
color_mode = val;
- else
+ else if (SYMBOLP (tty_color_mode_alist))
{
- tem = (NILP (tty_color_mode_alist) ? Qnil
- : Fassq (val, XSYMBOL (tty_color_mode_alist)->value));
+ tem = Fassq (val, Fsymbol_value (tty_color_mode_alist));
color_mode = CONSP (tem) ? XCDR (tem) : Qnil;
}
+ else
+ color_mode = Qnil;
- mode = INTEGERP (color_mode) ? XINT (color_mode) : 0;
+ mode = TYPE_RANGED_INTEGERP (int, color_mode) ? XINT (color_mode) : 0;
if (mode != tty->previous_color_mode)
{
- Lisp_Object funsym = intern ("tty-set-up-initial-frame-faces");
tty->previous_color_mode = mode;
tty_setup_colors (tty , mode);
/* This recomputes all the faces given the new color definitions. */
- safe_call (1, &funsym);
+ safe_call (1, intern ("tty-set-up-initial-frame-faces"));
}
}
/* Return the tty display object specified by TERMINAL. */
-struct terminal *
+static struct terminal *
get_tty_terminal (Lisp_Object terminal, int throw)
{
struct terminal *t = get_terminal (terminal, throw);
Returns NULL if the named terminal device is not opened. */
struct terminal *
-get_named_tty (name)
- char *name;
+get_named_tty (const char *name)
{
struct terminal *t;
if (!name)
- abort ();
+ emacs_abort ();
for (t = terminal_list; t; t = t->next_terminal)
{
TERMINAL can be a terminal object, a frame, or nil (meaning the
selected frame's terminal). */)
- (terminal)
- Lisp_Object terminal;
+ (Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
TERMINAL can be a terminal object, a frame, or nil (meaning the
selected frame's terminal). This function always returns nil if
TERMINAL is not on a tty device. */)
- (terminal)
- Lisp_Object terminal;
+ (Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
TERMINAL can be a terminal object, a frame or nil (meaning the
selected frame's terminal). This function always returns nil if
-TERMINAL does not refer to a text-only terminal. */)
- (terminal)
- Lisp_Object terminal;
+TERMINAL does not refer to a text terminal. */)
+ (Lisp_Object terminal)
{
struct terminal *t = get_terminal (terminal, 1);
return Qnil;
}
+DEFUN ("tty-top-frame", Ftty_top_frame, Stty_top_frame, 0, 1, 0,
+ doc: /* Return the topmost terminal frame on TERMINAL.
+TERMINAL can be a terminal object, a frame or nil (meaning the
+selected frame's terminal). This function returns nil if TERMINAL
+does not refer to a text terminal. Otherwise, it returns the
+top-most frame on the text terminal. */)
+ (Lisp_Object terminal)
+{
+ struct terminal *t = get_terminal (terminal, 1);
+
+ if (t->type == output_termcap)
+ return t->display_info.tty->top_frame;
+ return Qnil;
+}
+
\f
DEFUN ("suspend-tty", Fsuspend_tty, Ssuspend_tty, 0, 1, 0,
suspended.
A suspended tty may be resumed by calling `resume-tty' on it. */)
- (tty)
- Lisp_Object tty;
+ (Lisp_Object tty)
{
struct terminal *t = get_tty_terminal (tty, 1);
FILE *f;
/* First run `suspend-tty-functions' and then clean up the tty
state because `suspend-tty-functions' might need to change
the tty state. */
- if (!NILP (Vrun_hooks))
- {
- Lisp_Object args[2];
- args[0] = intern ("suspend-tty-functions");
- XSETTERMINAL (args[1], t);
- Frun_hook_with_args (2, args);
- }
+ Lisp_Object args[2];
+ args[0] = intern ("suspend-tty-functions");
+ XSETTERMINAL (args[1], t);
+ Frun_hook_with_args (2, args);
reset_sys_modes (t->display_info.tty);
-
-#ifdef subprocesses
delete_keyboard_wait_descriptor (fileno (f));
-#endif
#ifndef MSDOS
fclose (f);
TTY may be a terminal object, a frame, or nil (meaning the selected
frame's terminal). */)
- (tty)
- Lisp_Object tty;
+ (Lisp_Object tty)
{
struct terminal *t = get_tty_terminal (tty, 1);
int fd;
t->display_info.tty->input = t->display_info.tty->output;
#endif
-#ifdef subprocesses
add_keyboard_wait_descriptor (fd);
-#endif
if (FRAMEP (t->display_info.tty->top_frame))
{
FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
}
+ set_tty_hooks (t);
init_sys_modes (t->display_info.tty);
- /* Run `resume-tty-functions'. */
- if (!NILP (Vrun_hooks))
- {
- Lisp_Object args[2];
- args[0] = intern ("resume-tty-functions");
- XSETTERMINAL (args[1], t);
- Frun_hook_with_args (2, args);
- }
+ {
+ /* Run `resume-tty-functions'. */
+ Lisp_Object args[2];
+ args[0] = intern ("resume-tty-functions");
+ XSETTERMINAL (args[1], t);
+ Frun_hook_with_args (2, args);
+ }
}
set_tty_hooks (t);
***********************************************************************/
#ifdef HAVE_GPM
+
+#ifndef HAVE_WINDOW_SYSTEM
void
term_mouse_moveto (int x, int y)
{
last_mouse_x = x;
last_mouse_y = y; */
}
+#endif /* HAVE_WINDOW_SYSTEM */
-static void
-term_show_mouse_face (enum draw_glyphs_face draw)
+/* Implementation of draw_row_with_mouse_face for TTY/GPM. */
+void
+tty_draw_row_with_mouse_face (struct window *w, struct glyph_row *row,
+ int start_hpos, int end_hpos,
+ enum draw_glyphs_face draw)
{
- struct window *w = XWINDOW (mouse_face_window);
- int save_x, save_y;
- int i;
-
- struct frame *f = XFRAME (w->frame);
+ int nglyphs = end_hpos - start_hpos;
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
struct tty_display_info *tty = FRAME_TTY (f);
+ int face_id = tty->mouse_highlight.mouse_face_face_id;
+ int save_x, save_y, pos_x, pos_y;
- if (/* If window is in the process of being destroyed, don't bother
- to do anything. */
- w->current_matrix != NULL
- /* Recognize when we are called to operate on rows that don't exist
- anymore. This can happen when a window is split. */
- && mouse_face_end_row < w->current_matrix->nrows)
- {
- /* write_glyphs writes at cursor position, so we need to
- temporarily move cursor coordinates to the beginning of
- the highlight region. */
-
- /* Save current cursor co-ordinates */
- save_y = curY (tty);
- save_x = curX (tty);
-
- /* Note that mouse_face_beg_row etc. are window relative. */
- for (i = mouse_face_beg_row; i <= mouse_face_end_row; i++)
- {
- int start_hpos, end_hpos, nglyphs;
- struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
-
- /* Don't do anything if row doesn't have valid contents. */
- if (!row->enabled_p)
- continue;
-
- /* For all but the first row, the highlight starts at column 0. */
- if (i == mouse_face_beg_row)
- start_hpos = mouse_face_beg_col;
- else
- start_hpos = 0;
-
- if (i == mouse_face_end_row)
- end_hpos = mouse_face_end_col;
- else
- {
- end_hpos = row->used[TEXT_AREA];
- if (draw == DRAW_NORMAL_TEXT)
- row->fill_line_p = 1; /* Clear to end of line */
- }
-
- if (end_hpos <= start_hpos)
- continue;
- /* Record that some glyphs of this row are displayed in
- mouse-face. */
- row->mouse_face_p = draw > 0;
-
- nglyphs = end_hpos - start_hpos;
-
- if (end_hpos >= row->used[TEXT_AREA])
- nglyphs = row->used[TEXT_AREA] - start_hpos;
-
- pos_y = row->y + WINDOW_TOP_EDGE_Y (w);
- pos_x = row->used[LEFT_MARGIN_AREA] + start_hpos
- + WINDOW_LEFT_EDGE_X (w);
-
- cursor_to (f, pos_y, pos_x);
-
- if (draw == DRAW_MOUSE_FACE)
- {
- tty_write_glyphs_with_face (f, row->glyphs[TEXT_AREA] + start_hpos,
- nglyphs, mouse_face_face_id);
- }
- else /* draw == DRAW_NORMAL_TEXT */
- write_glyphs (f, row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
- }
- cursor_to (f, save_y, save_x);
- }
-}
-
-static void
-term_clear_mouse_face ()
-{
- if (!NILP (mouse_face_window))
- term_show_mouse_face (DRAW_NORMAL_TEXT);
-
- mouse_face_beg_row = mouse_face_beg_col = -1;
- mouse_face_end_row = mouse_face_end_col = -1;
- mouse_face_window = Qnil;
-}
-
-/* Find the glyph matrix position of buffer position POS in window W.
- *HPOS and *VPOS are set to the positions found. W's current glyphs
- must be up to date. If POS is above window start return (0, 0).
- If POS is after end of W, return end of last line in W.
- - taken from msdos.c */
-static int
-fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
-{
- int i, lastcol, line_start_position, maybe_next_line_p = 0;
- int yb = window_text_bottom_y (w);
- struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0), *best_row = row;
-
- while (row->y < yb)
- {
- if (row->used[TEXT_AREA])
- line_start_position = row->glyphs[TEXT_AREA]->charpos;
- else
- line_start_position = 0;
-
- if (line_start_position > pos)
- break;
- /* If the position sought is the end of the buffer,
- don't include the blank lines at the bottom of the window. */
- else if (line_start_position == pos
- && pos == BUF_ZV (XBUFFER (w->buffer)))
- {
- maybe_next_line_p = 1;
- break;
- }
- else if (line_start_position > 0)
- best_row = row;
-
- /* Don't overstep the last matrix row, lest we get into the
- never-never land... */
- if (row->y + 1 >= yb)
- break;
-
- ++row;
- }
-
- /* Find the right column within BEST_ROW. */
- lastcol = 0;
- row = best_row;
- for (i = 0; i < row->used[TEXT_AREA]; i++)
- {
- struct glyph *glyph = row->glyphs[TEXT_AREA] + i;
- int charpos;
-
- charpos = glyph->charpos;
- if (charpos == pos)
- {
- *hpos = i;
- *vpos = row->y;
- return 1;
- }
- else if (charpos > pos)
- break;
- else if (charpos > 0)
- lastcol = i;
- }
-
- /* If we're looking for the end of the buffer,
- and we didn't find it in the line we scanned,
- use the start of the following line. */
- if (maybe_next_line_p)
- {
- ++row;
- lastcol = 0;
- }
-
- *vpos = row->y;
- *hpos = lastcol + 1;
- return 0;
-}
-
-static void
-term_mouse_highlight (struct frame *f, int x, int y)
-{
- enum window_part part;
- Lisp_Object window;
- struct window *w;
- struct buffer *b;
-
- if (NILP (Vmouse_highlight)
- || !f->glyphs_initialized_p)
- return;
-
- /* Which window is that in? */
- window = window_from_coordinates (f, x, y, &part, &x, &y, 0);
-
- /* Not on a window -> return. */
- if (!WINDOWP (window))
- return;
-
- if (!EQ (window, mouse_face_window))
- term_clear_mouse_face ();
-
- w = XWINDOW (window);
-
- /* Are we in a window whose display is up to date?
- And verify the buffer's text has not changed. */
- b = XBUFFER (w->buffer);
- if (part == ON_TEXT
- && EQ (w->window_end_valid, w->buffer)
- && XFASTINT (w->last_modified) == BUF_MODIFF (b)
- && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
- {
- int pos, i, nrows = w->current_matrix->nrows;
- struct glyph_row *row;
- struct glyph *glyph;
-
- /* Find the glyph under X/Y. */
- glyph = NULL;
- if (y >= 0 && y < nrows)
- {
- row = MATRIX_ROW (w->current_matrix, y);
- /* Give up if some row before the one we are looking for is
- not enabled. */
- for (i = 0; i <= y; i++)
- if (!MATRIX_ROW (w->current_matrix, i)->enabled_p)
- break;
- if (i > y /* all rows upto and including the one at Y are enabled */
- && row->displays_text_p
- && x < window_box_width (w, TEXT_AREA))
- {
- glyph = row->glyphs[TEXT_AREA];
- if (x >= row->used[TEXT_AREA])
- glyph = NULL;
- else
- {
- glyph += x;
- if (!BUFFERP (glyph->object))
- glyph = NULL;
- }
- }
- }
+ if (end_hpos >= row->used[TEXT_AREA])
+ nglyphs = row->used[TEXT_AREA] - start_hpos;
- /* Clear mouse face if X/Y not over text. */
- if (glyph == NULL)
- {
- term_clear_mouse_face ();
- return;
- }
+ pos_y = row->y + WINDOW_TOP_EDGE_Y (w);
+ pos_x = row->used[LEFT_MARGIN_AREA] + start_hpos + WINDOW_LEFT_EDGE_X (w);
- if (!BUFFERP (glyph->object))
- abort ();
- pos = glyph->charpos;
+ /* Save current cursor co-ordinates. */
+ save_y = curY (tty);
+ save_x = curX (tty);
+ cursor_to (f, pos_y, pos_x);
- /* Check for mouse-face. */
- {
- extern Lisp_Object Qmouse_face;
- Lisp_Object mouse_face, overlay, position, *overlay_vec;
- int noverlays, obegv, ozv;
- struct buffer *obuf;
-
- /* If we get an out-of-range value, return now; avoid an error. */
- if (pos > BUF_Z (b))
- return;
-
- /* Make the window's buffer temporarily current for
- overlays_at and compute_char_face. */
- obuf = current_buffer;
- current_buffer = b;
- obegv = BEGV;
- ozv = ZV;
- BEGV = BEG;
- ZV = Z;
-
- /* Is this char mouse-active? */
- XSETINT (position, pos);
-
- /* Put all the overlays we want in a vector in overlay_vec. */
- GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL, 0);
- /* Sort overlays into increasing priority order. */
- noverlays = sort_overlays (overlay_vec, noverlays, w);
-
- /* Check mouse-face highlighting. */
- if (!(EQ (window, mouse_face_window)
- && y >= mouse_face_beg_row
- && y <= mouse_face_end_row
- && (y > mouse_face_beg_row
- || x >= mouse_face_beg_col)
- && (y < mouse_face_end_row
- || x < mouse_face_end_col
- || mouse_face_past_end)))
- {
- /* Clear the display of the old active region, if any. */
- term_clear_mouse_face ();
-
- /* Find the highest priority overlay that has a mouse-face
- property. */
- overlay = Qnil;
- for (i = noverlays - 1; i >= 0; --i)
- {
- mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
- if (!NILP (mouse_face))
- {
- overlay = overlay_vec[i];
- break;
- }
- }
+ if (draw == DRAW_MOUSE_FACE)
+ tty_write_glyphs_with_face (f, row->glyphs[TEXT_AREA] + start_hpos,
+ nglyphs, face_id);
+ else if (draw == DRAW_NORMAL_TEXT)
+ write_glyphs (f, row->glyphs[TEXT_AREA] + start_hpos, nglyphs);
- /* If no overlay applies, get a text property. */
- if (NILP (overlay))
- mouse_face = Fget_text_property (position, Qmouse_face,
- w->buffer);
-
- /* Handle the overlay case. */
- if (!NILP (overlay))
- {
- /* Find the range of text around this char that
- should be active. */
- Lisp_Object before, after;
- EMACS_INT ignore;
-
-
- before = Foverlay_start (overlay);
- after = Foverlay_end (overlay);
- /* Record this as the current active region. */
- fast_find_position (w, XFASTINT (before),
- &mouse_face_beg_col,
- &mouse_face_beg_row);
-
- mouse_face_past_end
- = !fast_find_position (w, XFASTINT (after),
- &mouse_face_end_col,
- &mouse_face_end_row);
- mouse_face_window = window;
-
- mouse_face_face_id
- = face_at_buffer_position (w, pos, 0, 0,
- &ignore, pos + 1, 1, -1);
-
- /* Display it as active. */
- term_show_mouse_face (DRAW_MOUSE_FACE);
- }
- /* Handle the text property case. */
- else if (!NILP (mouse_face))
- {
- /* Find the range of text around this char that
- should be active. */
- Lisp_Object before, after, beginning, end;
- EMACS_INT ignore;
-
- beginning = Fmarker_position (w->start);
- XSETINT (end, (BUF_Z (b) - XFASTINT (w->window_end_pos)));
- before
- = Fprevious_single_property_change (make_number (pos + 1),
- Qmouse_face,
- w->buffer, beginning);
- after
- = Fnext_single_property_change (position, Qmouse_face,
- w->buffer, end);
-
- /* Record this as the current active region. */
- fast_find_position (w, XFASTINT (before),
- &mouse_face_beg_col,
- &mouse_face_beg_row);
- mouse_face_past_end
- = !fast_find_position (w, XFASTINT (after),
- &mouse_face_end_col,
- &mouse_face_end_row);
- mouse_face_window = window;
-
- mouse_face_face_id
- = face_at_buffer_position (w, pos, 0, 0,
- &ignore, pos + 1, 1, -1);
-
- /* Display it as active. */
- term_show_mouse_face (DRAW_MOUSE_FACE);
- }
- }
-
- /* Look for a `help-echo' property. */
- {
- Lisp_Object help;
- extern Lisp_Object Qhelp_echo;
-
- /* Check overlays first. */
- help = Qnil;
- for (i = noverlays - 1; i >= 0 && NILP (help); --i)
- {
- overlay = overlay_vec[i];
- help = Foverlay_get (overlay, Qhelp_echo);
- }
-
- if (!NILP (help))
- {
- help_echo_string = help;
- help_echo_window = window;
- help_echo_object = overlay;
- help_echo_pos = pos;
- }
- /* Try text properties. */
- else if (NILP (help)
- && ((STRINGP (glyph->object)
- && glyph->charpos >= 0
- && glyph->charpos < SCHARS (glyph->object))
- || (BUFFERP (glyph->object)
- && glyph->charpos >= BEGV
- && glyph->charpos < ZV)))
- {
- help = Fget_text_property (make_number (glyph->charpos),
- Qhelp_echo, glyph->object);
- if (!NILP (help))
- {
- help_echo_string = help;
- help_echo_window = window;
- help_echo_object = glyph->object;
- help_echo_pos = glyph->charpos;
- }
- }
- }
-
- BEGV = obegv;
- ZV = ozv;
- current_buffer = obuf;
- }
- }
+ cursor_to (f, save_y, save_x);
}
static int
if (event->x != last_mouse_x || event->y != last_mouse_y)
{
frame->mouse_moved = 1;
- term_mouse_highlight (frame, event->x, event->y);
+ note_mouse_highlight (frame, event->x, event->y);
/* Remember which glyph we're now on. */
last_mouse_x = event->x;
last_mouse_y = event->y;
return 0;
}
+/* Return the Time that corresponds to T. Wrap around on overflow. */
+static Time
+timeval_to_Time (struct timeval const *t)
+{
+ Time s_1000, ms;
+
+ s_1000 = t->tv_sec;
+ s_1000 *= 1000;
+ ms = t->tv_usec / 1000;
+ return s_1000 + ms;
+}
+
/* Return the current position of the mouse.
Set *f to the frame the mouse is in, or zero if the mouse is in no
Set *bar_window to Qnil, and *x and *y to the column and
row of the character cell the mouse is over.
- Set *time to the time the mouse was at the returned position.
+ Set *timeptr to the time the mouse was at the returned position.
This clears mouse_moved until the next motion
event arrives. */
static void
term_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
enum scroll_bar_part *part, Lisp_Object *x,
- Lisp_Object *y, unsigned long *time)
+ Lisp_Object *y, Time *timeptr)
{
struct timeval now;
XSETINT (*x, last_mouse_x);
XSETINT (*y, last_mouse_y);
gettimeofday(&now, 0);
- *time = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+ *timeptr = timeval_to_Time (&now);
}
/* Prepare a mouse-event in *RESULT for placement in the input queue.
}
}
gettimeofday(&now, 0);
- result->timestamp = (now.tv_sec * 1000) + (now.tv_usec / 1000);
+ result->timestamp = timeval_to_Time (&now);
if (event->type & GPM_UP)
result->modifiers = up_modifier;
0, 0, 0,
doc: /* Open a connection to Gpm.
Gpm-mouse can only be activated for one tty at a time. */)
- ()
+ (void)
{
struct frame *f = SELECTED_FRAME ();
struct tty_display_info *tty
DEFUN ("gpm-mouse-stop", Fgpm_mouse_stop, Sgpm_mouse_stop,
0, 0, 0,
doc: /* Close a connection to Gpm. */)
- ()
+ (void)
{
struct frame *f = SELECTED_FRAME ();
struct tty_display_info *tty
void
create_tty_output (struct frame *f)
{
- struct tty_output *t;
+ struct tty_output *t = xzalloc (sizeof *t);
if (! FRAME_TERMCAP_P (f))
- abort ();
-
- t = xmalloc (sizeof (struct tty_output));
- bzero (t, sizeof (struct tty_output));
+ emacs_abort ();
t->display_info = FRAME_TERMINAL (f)->display_info.tty;
tty_free_frame_resources (struct frame *f)
{
if (! FRAME_TERMCAP_P (f))
- abort ();
+ emacs_abort ();
if (FRAME_FACE_CACHE (f))
free_frame_faces (f);
tty_free_frame_resources (struct frame *f)
{
if (! FRAME_TERMCAP_P (f) && ! FRAME_MSDOS_P (f))
- abort ();
+ emacs_abort ();
if (FRAME_FACE_CACHE (f))
free_frame_faces (f);
dissociate_if_controlling_tty (int fd)
{
#ifndef DOS_NT
- int pgid;
- EMACS_GET_TTY_PGRP (fd, &pgid); /* If tcgetpgrp succeeds, fd is the ctty. */
+ int pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
if (pgid != -1)
{
-#if defined (USG) && !defined (BSD_PGRPS)
+#if defined (USG5)
setpgrp ();
no_controlling_tty = 1;
#elif defined (CYGWIN)
no_controlling_tty = 1;
#else
#ifdef TIOCNOTTY /* Try BSD ioctls. */
- sigblock (sigmask (SIGTTOU));
+ sigset_t blocked;
+ sigemptyset (&blocked);
+ sigaddset (&blocked, SIGTTOU);
+ pthread_sigmask (SIG_BLOCK, &blocked, 0);
fd = emacs_open (DEV_TTY, O_RDWR, 0);
if (fd != -1 && ioctl (fd, TIOCNOTTY, 0) != -1)
{
}
if (fd != -1)
emacs_close (fd);
- sigunblock (sigmask (SIGTTOU));
+ pthread_sigmask (SIG_UNBLOCK, &blocked, 0);
#else
- /* Unknown system. */
- croak ();
+# error "Unknown system."
#endif /* ! TIOCNOTTY */
#endif /* ! USG */
}
#endif /* !DOS_NT */
}
-static void maybe_fatal();
-
/* Create a termcap display on the tty device with the given name and
type.
If MUST_SUCCEED is true, then all errors are fatal. */
struct terminal *
-init_tty (char *name, char *terminal_type, int must_succeed)
+init_tty (const char *name, const char *terminal_type, int must_succeed)
{
char *area = NULL;
char **address = &area;
int buffer_size = 4096;
- register char *p = NULL;
int status;
struct tty_display_info *tty = NULL;
struct terminal *terminal = NULL;
terminal = create_terminal ();
#ifdef MSDOS
if (been_here > 0)
- maybe_fatal (1, 0, "Attempt to create another terminal %s", "",
+ maybe_fatal (0, 0, "Attempt to create another terminal %s", "",
name, "");
been_here = 1;
tty = &the_only_display_info;
#else
- tty = (struct tty_display_info *) xmalloc (sizeof (struct tty_display_info));
+ tty = xzalloc (sizeof *tty);
#endif
- bzero (tty, sizeof (struct tty_display_info));
+ tty->top_frame = Qnil;
tty->next = tty_list;
tty_list = tty;
terminal->display_info.tty = tty;
tty->terminal = terminal;
- tty->Wcm = (struct cm *) xmalloc (sizeof (struct cm));
+ tty->Wcm = xmalloc (sizeof *tty->Wcm);
Wcm_clear (tty);
+ encode_terminal_src_size = 0;
+ encode_terminal_dst_size = 0;
+
+
#ifndef DOS_NT
set_tty_hooks (terminal);
int fd;
FILE *file;
-#ifdef O_IGNORE_CTTY
+#if O_IGNORE_CTTY
if (!ctty)
/* Open the terminal device. Don't recognize it as our
controlling terminal, and don't make it the controlling tty
name);
}
-#ifndef O_IGNORE_CTTY
+#if !O_IGNORE_CTTY
if (!ctty)
dissociate_if_controlling_tty (fd);
#endif
add_keyboard_wait_descriptor (fileno (tty->input));
-#endif /* !DOS_NT */
-
- encode_terminal_src_size = 0;
- encode_terminal_dst_size = 0;
-
-#ifdef HAVE_GPM
- terminal->mouse_position_hook = term_mouse_position;
- mouse_face_window = Qnil;
-#endif
-
-#ifdef DOS_NT
-#ifdef WINDOWSNT
- initialize_w32_display (terminal);
-#else /* MSDOS */
- if (strcmp (terminal_type, "internal") == 0)
- terminal->type = output_msdos_raw;
- initialize_msdos_display (terminal);
-#endif /* MSDOS */
- tty->output = stdout;
- tty->input = stdin;
- /* The following two are inaccessible from w32console.c. */
- terminal->delete_frame_hook = &tty_free_frame_resources;
- terminal->delete_terminal_hook = &delete_tty;
-
- tty->name = xstrdup (name);
- terminal->name = xstrdup (name);
- tty->type = xstrdup (terminal_type);
-
-#ifdef subprocesses
- add_keyboard_wait_descriptor (0);
-#endif
-
- Wcm_clear (tty);
-
-#ifdef WINDOWSNT
- {
- struct frame *f = XFRAME (selected_frame);
-
- FrameRows (tty) = FRAME_LINES (f);
- FrameCols (tty) = FRAME_COLS (f);
- tty->specified_window = FRAME_LINES (f);
-
- FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
- FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
- }
-#else /* MSDOS */
- {
- int height, width;
- get_tty_size (fileno (tty->input), &width, &height);
- FrameCols (tty) = width;
- FrameRows (tty) = height;
- }
-#endif /* MSDOS */
- tty->delete_in_insert_mode = 1;
-
- UseTabs (tty) = 0;
- terminal->scroll_region_ok = 0;
-
- /* Seems to insert lines when it's not supposed to, messing up the
- display. In doing a trace, it didn't seem to be called much, so I
- don't think we're losing anything by turning it off. */
- terminal->line_ins_del_ok = 0;
-#ifdef WINDOWSNT
- terminal->char_ins_del_ok = 1;
- baud_rate = 19200;
-#else /* MSDOS */
- terminal->char_ins_del_ok = 0;
- init_baud_rate (fileno (tty->input));
-#endif /* MSDOS */
-
- tty->TN_max_colors = 16; /* Required to be non-zero for tty-display-color-p */
-
-#else /* not DOS_NT */
-
Wcm_clear (tty);
- tty->termcap_term_buffer = (char *) xmalloc (buffer_size);
+ tty->termcap_term_buffer = xmalloc (buffer_size);
/* On some systems, tgetent tries to access the controlling
terminal. */
- sigblock (sigmask (SIGTTOU));
- status = tgetent (tty->termcap_term_buffer, terminal_type);
- sigunblock (sigmask (SIGTTOU));
+ {
+ sigset_t blocked;
+ sigemptyset (&blocked);
+ sigaddset (&blocked, SIGTTOU);
+ pthread_sigmask (SIG_BLOCK, &blocked, 0);
+ status = tgetent (tty->termcap_term_buffer, terminal_type);
+ pthread_sigmask (SIG_UNBLOCK, &blocked, 0);
+ }
if (status < 0)
{
}
if (status == 0)
{
-#ifdef TERMINFO
maybe_fatal (must_succeed, terminal,
"Terminal type %s is not defined",
"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);
+`setenv TERM ...') to specify the correct type. It may be necessary\n"
+#ifdef TERMINFO
+"to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
#else
- maybe_fatal (must_succeed, terminal,
- "Terminal type %s is not defined",
- "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);
+"to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
#endif
+ terminal_type);
}
#ifndef TERMINFO
if (strlen (tty->termcap_term_buffer) >= buffer_size)
- abort ();
+ emacs_abort ();
buffer_size = strlen (tty->termcap_term_buffer);
#endif
- tty->termcap_strings_buffer = area = (char *) xmalloc (buffer_size);
+ tty->termcap_strings_buffer = area = xmalloc (buffer_size);
tty->TS_ins_line = tgetstr ("al", address);
tty->TS_ins_multi_lines = tgetstr ("AL", address);
tty->TS_bell = tgetstr ("bl", address);
tty->TS_enter_underline_mode = tgetstr ("us", address);
tty->TS_exit_underline_mode = tgetstr ("ue", address);
tty->TS_enter_bold_mode = tgetstr ("md", address);
+ tty->TS_enter_italic_mode = tgetstr ("ZH", address);
tty->TS_enter_dim_mode = tgetstr ("mh", address);
- tty->TS_enter_blink_mode = tgetstr ("mb", address);
tty->TS_enter_reverse_mode = tgetstr ("mr", address);
tty->TS_enter_alt_charset_mode = tgetstr ("as", address);
tty->TS_exit_alt_charset_mode = tgetstr ("ae", address);
MultiLeft (tty) = tgetstr ("LE", address);
MultiRight (tty) = tgetstr ("RI", address);
- /* SVr4/ANSI color suppert. If "op" isn't available, don't support
+ /* SVr4/ANSI color support. If "op" isn't available, don't support
color because we can't switch back to the default foreground and
background. */
tty->TS_orig_pair = tgetstr ("op", address);
tty->TF_underscore = tgetflag ("ul");
tty->TF_teleray = tgetflag ("xt");
-#endif /* !DOS_NT */
- terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
+#else /* DOS_NT */
+#ifdef WINDOWSNT
+ {
+ struct frame *f = XFRAME (selected_frame);
+
+ initialize_w32_display (terminal);
+
+ FrameRows (tty) = FRAME_LINES (f);
+ FrameCols (tty) = FRAME_COLS (f);
+ tty->specified_window = FRAME_LINES (f);
+
+ FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
+ FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
+ terminal->char_ins_del_ok = 1;
+ baud_rate = 19200;
+ }
+#else /* MSDOS */
+ {
+ int height, width;
+ if (strcmp (terminal_type, "internal") == 0)
+ terminal->type = output_msdos_raw;
+ initialize_msdos_display (terminal);
+
+ get_tty_size (fileno (tty->input), &width, &height);
+ FrameCols (tty) = width;
+ FrameRows (tty) = height;
+ terminal->char_ins_del_ok = 0;
+ init_baud_rate (fileno (tty->input));
+ }
+#endif /* MSDOS */
+ tty->output = stdout;
+ tty->input = stdin;
+ /* The following two are inaccessible from w32console.c. */
+ terminal->delete_frame_hook = &tty_free_frame_resources;
+ terminal->delete_terminal_hook = &delete_tty;
+
+ tty->name = xstrdup (name);
+ terminal->name = xstrdup (name);
+ tty->type = xstrdup (terminal_type);
+
+ add_keyboard_wait_descriptor (0);
+
+ tty->delete_in_insert_mode = 1;
+
+ UseTabs (tty) = 0;
+ terminal->scroll_region_ok = 0;
+
+ /* Seems to insert lines when it's not supposed to, messing up the
+ display. In doing a trace, it didn't seem to be called much, so I
+ don't think we're losing anything by turning it off. */
+ terminal->line_ins_del_ok = 0;
+
+ tty->TN_max_colors = 16; /* Required to be non-zero for tty-display-color-p */
+#endif /* DOS_NT */
+
+#ifdef HAVE_GPM
+ terminal->mouse_position_hook = term_mouse_position;
+ tty->mouse_highlight.mouse_face_window = Qnil;
+#endif
+
+ terminal->kboard = xmalloc (sizeof *terminal->kboard);
init_kboard (terminal->kboard);
- terminal->kboard->Vwindow_system = Qnil;
+ kset_window_system (terminal->kboard, Qnil);
terminal->kboard->next_kboard = all_kboards;
all_kboards = terminal->kboard;
terminal->kboard->reference_count++;
if (FrameRows (tty) < 3 || FrameCols (tty) < 3)
maybe_fatal (must_succeed, terminal,
- "Screen size %dx%d is too small"
+ "Screen size %dx%d is too small",
"Screen size %dx%d is too small",
FrameCols (tty), FrameRows (tty));
Down (tty) = 0;
}
- /* Special handling for certain terminal types known to need it */
-
- if (!strcmp (terminal_type, "supdup"))
- {
- terminal->memory_below_frame = 1;
- tty->Wcm->cm_losewrap = 1;
- }
- if (!strncmp (terminal_type, "c10", 3)
- || !strcmp (terminal_type, "perq"))
- {
- /* Supply a makeshift :wi string.
- This string is not valid in general since it works only
- for windows starting at the upper left corner;
- but that is all Emacs uses.
-
- This string works only if the frame is using
- the top of the video memory, because addressing is memory-relative.
- So first check the :ti string to see if that is true.
-
- It would be simpler if the :wi string could go in the termcap
- entry, but it can't because it is not fully valid.
- If it were in the termcap entry, it would confuse other programs. */
- if (!tty->TS_set_window)
- {
- p = tty->TS_termcap_modes;
- while (*p && strcmp (p, "\033v "))
- p++;
- if (*p)
- tty->TS_set_window = "\033v%C %C %C %C ";
- }
- /* Termcap entry often fails to have :in: flag */
- terminal->must_write_spaces = 1;
- /* :ti string typically fails to have \E^G! in it */
- /* This limits scope of insert-char to one line. */
- strcpy (area, tty->TS_termcap_modes);
- strcat (area, "\033\007!");
- tty->TS_termcap_modes = area;
- area += strlen (area) + 1;
- p = AbsPosition (tty);
- /* Change all %+ parameters to %C, to handle
- values above 96 correctly for the C100. */
- while (*p)
- {
- if (p[0] == '%' && p[1] == '+')
- p[1] = 'C';
- p++;
- }
- }
-
tty->specified_window = FrameRows (tty);
if (Wcm_init (tty) == -1) /* can't do cursor motion */
{
maybe_fatal (must_succeed, terminal,
"Terminal type \"%s\" is not powerful enough to run Emacs",
-# ifdef TERMINFO
"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.",
+`setenv TERM ...') to specify the correct type. It may be necessary\n"
+# ifdef TERMINFO
+"to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
# else /* TERMCAP */
- "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.",
+"to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
# endif /* TERMINFO */
terminal_type);
}
return terminal;
}
+
+static void
+vfatal (const char *str, va_list ap)
+{
+ fprintf (stderr, "emacs: ");
+ vfprintf (stderr, str, ap);
+ if (!(strlen (str) > 0 && str[strlen (str) - 1] == '\n'))
+ fprintf (stderr, "\n");
+ fflush (stderr);
+ exit (1);
+}
+
+
/* Auxiliary error-handling function for init_tty.
Delete TERMINAL, then call error or fatal with str1 or str2,
- respectively, according to MUST_SUCCEED. */
+ respectively, according to whether MUST_SUCCEED is zero or not. */
static void
-maybe_fatal (must_succeed, terminal, str1, str2, arg1, arg2)
- int must_succeed;
- struct terminal *terminal;
- char *str1, *str2, *arg1, *arg2;
+maybe_fatal (int must_succeed, struct terminal *terminal,
+ const char *str1, const char *str2, ...)
{
+ va_list ap;
+ va_start (ap, str2);
if (terminal)
delete_tty (terminal);
if (must_succeed)
- fatal (str2, arg1, arg2);
+ vfatal (str2, ap);
else
- error (str1, arg1, arg2);
+ verror (str1, ap);
- abort ();
+ va_end (ap);
+ emacs_abort ();
}
void
{
va_list ap;
va_start (ap, str);
- fprintf (stderr, "emacs: ");
- vfprintf (stderr, str, ap);
- if (!(strlen (str) > 0 && str[strlen (str) - 1] == '\n'))
- fprintf (stderr, "\n");
+ vfatal (str, ap);
va_end (ap);
- fflush (stderr);
- exit (1);
}
\f
return;
if (terminal->type != output_termcap)
- abort ();
+ emacs_abort ();
tty = terminal->display_info.tty;
if (! p)
/* This should not happen. */
- abort ();
+ emacs_abort ();
p->next = tty->next;
tty->next = 0;
if (tty->input)
{
-#ifdef subprocesses
delete_keyboard_wait_descriptor (fileno (tty->input));
-#endif
if (tty->input != stdin)
fclose (tty->input);
}
xfree (tty->termcap_strings_buffer);
xfree (tty->termcap_term_buffer);
- bzero (tty, sizeof (struct tty_display_info));
xfree (tty);
}
-\f
-
-/* Mark the pointers in the tty_display_info objects.
- Called by the Fgarbage_collector. */
-
-void
-mark_ttys (void)
-{
- struct tty_display_info *tty;
-
- for (tty = tty_list; tty; tty = tty->next)
- mark_object (tty->top_frame);
-}
-
-\f
-
void
-syms_of_term ()
+syms_of_term (void)
{
- DEFVAR_BOOL ("system-uses-terminfo", &system_uses_terminfo,
+ DEFVAR_BOOL ("system-uses-terminfo", system_uses_terminfo,
doc: /* Non-nil means the system uses terminfo rather than termcap.
This variable can be used by terminal emulator packages. */);
#ifdef TERMINFO
system_uses_terminfo = 0;
#endif
- DEFVAR_LISP ("suspend-tty-functions", &Vsuspend_tty_functions,
- doc: /* Functions to be run after suspending a tty.
+ DEFVAR_LISP ("suspend-tty-functions", Vsuspend_tty_functions,
+ doc: /* Functions run after suspending a tty.
The functions are run with one argument, the terminal object to be suspended.
See `suspend-tty'. */);
Vsuspend_tty_functions = Qnil;
- DEFVAR_LISP ("resume-tty-functions", &Vresume_tty_functions,
- doc: /* Functions to be run after resuming a tty.
+ DEFVAR_LISP ("resume-tty-functions", Vresume_tty_functions,
+ doc: /* Functions run after resuming a tty.
The functions are run with one argument, the terminal object that was revived.
See `resume-tty'. */);
Vresume_tty_functions = Qnil;
- DEFVAR_BOOL ("visible-cursor", &visible_cursor,
+ DEFVAR_BOOL ("visible-cursor", visible_cursor,
doc: /* Non-nil means to make the cursor very visible.
This only has an effect when running in a text terminal.
What means \"very visible\" is up to your terminal. It may make the cursor
defsubr (&Stty_no_underline);
defsubr (&Stty_type);
defsubr (&Scontrolling_tty_p);
+ defsubr (&Stty_top_frame);
defsubr (&Ssuspend_tty);
defsubr (&Sresume_tty);
#ifdef HAVE_GPM
defsubr (&Sgpm_mouse_start);
defsubr (&Sgpm_mouse_stop);
-
- staticpro (&mouse_face_window);
#endif /* HAVE_GPM */
#ifndef DOS_NT
encode_terminal_src = NULL;
encode_terminal_dst = NULL;
}
-
-
-
-/* arch-tag: 498e7449-6f2e-45e2-91dd-b7d4ca488193
- (do not change this comment) */