static void tty_hide_cursor P_ ((void));
#define OUTPUT(a) \
- tputs (a, (int) (FRAME_HEIGHT (XFRAME (selected_frame)) - curY), cmputc)
+ 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_HEIGHT (XFRAME (selected_frame)) \
+ 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)
+/* Display space properties */
+
+extern Lisp_Object Qspace, QCalign_to, QCwidth;
+
/* Function to use to ring the bell. */
Lisp_Object Vring_bell_function;
void (*write_glyphs_hook) P_ ((struct glyph *, int));
void (*delete_glyphs_hook) P_ ((int));
-int (*read_socket_hook) P_ ((int, struct input_event *, int, int));
+int (*read_socket_hook) P_ ((int, int, struct input_event *));
void (*frame_up_to_date_hook) P_ ((struct frame *));
void (*judge_scroll_bars_hook) P_ ((FRAME_PTR FRAME));
-/* Hook to call in estimate_mode_line_height, if any. */
-
-int (* estimate_mode_line_height_hook) P_ ((struct frame *f, enum face_id));
-
-
/* Strings, numbers and flags taken from the termcap entry. */
char *TS_ins_line; /* "al" */
/* The largest frame width in any call to calculate_costs. */
-int max_frame_width;
+int max_frame_cols;
/* The largest frame height in any call to calculate_costs. */
-int max_frame_height;
+int max_frame_lines;
static int costs_set; /* Nonzero if costs have been calculated. */
This is the number of lines, from the top of frame downwards,
which can participate in insert-line/delete-line operations.
- Effectively it excludes the bottom frame_height - specified_window_size
+ Effectively it excludes the bottom frame_lines - specified_window_size
lines from those operations. */
int specified_window;
{
if (FRAME_TERMCAP_P (updating_frame))
{
- specified_window = size ? size : FRAME_HEIGHT (updating_frame);
+ specified_window = size ? size : FRAME_LINES (updating_frame);
if (scroll_region_ok)
set_scroll_region (0, specified_window);
}
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_HEIGHT (sf), start,
- FRAME_HEIGHT (sf) - stop,
- FRAME_HEIGHT (sf));
+ FRAME_LINES (sf), start,
+ FRAME_LINES (sf) - stop,
+ FRAME_LINES (sf));
else
- buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_WIDTH (sf));
+ buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_COLS (sf));
OUTPUT (buf);
xfree (buf);
}
else
{
- for (i = curY; i < FRAME_HEIGHT (XFRAME (selected_frame)); i++)
+ for (i = curY; i < FRAME_LINES (XFRAME (selected_frame)); i++)
{
cursor_to (i, 0);
- clear_end_of_line (FRAME_WIDTH (XFRAME (selected_frame)));
+ clear_end_of_line (FRAME_COLS (XFRAME (selected_frame)));
}
}
}
turn_off_insert ();
/* Do not write in last row last col with Auto-wrap on. */
- if (AutoWrap && curY == FRAME_HEIGHT (sf) - 1
- && first_unused_hpos == FRAME_WIDTH (sf))
+ if (AutoWrap && curY == FRAME_LINES (sf) - 1
+ && first_unused_hpos == FRAME_COLS (sf))
first_unused_hpos--;
for (i = curX; i < first_unused_hpos; i++)
}
}
\f
-/* Encode SRC_LEN glyphs starting at SRC to terminal output codes and
- store them at DST. Do not write more than DST_LEN bytes. That may
- require stopping before all SRC_LEN input glyphs have been
- converted.
+/* Buffer to store the source and result of code conversion for terminal. */
+static unsigned char *encode_terminal_buf;
+/* Allocated size of the above buffer. */
+static int encode_terminal_bufsize;
- We store the number of glyphs actually converted in *CONSUMED. The
- return value is the number of bytes store in DST. */
+/* 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. */
-int
-encode_terminal_code (src, dst, src_len, dst_len, consumed)
+unsigned char *
+encode_terminal_code (src, src_len, coding)
struct glyph *src;
int src_len;
- unsigned char *dst;
- int dst_len, *consumed;
+ struct coding_system *coding;
{
struct glyph *src_start = src, *src_end = src + src_len;
- unsigned char *dst_start = dst, *dst_end = dst + dst_len;
register GLYPH g;
- unsigned char workbuf[MAX_MULTIBYTE_LENGTH];
- const unsigned char *buf;
- int len;
+ unsigned char *buf;
+ int nchars, nbytes, required;
register int tlen = GLYPH_TABLE_LENGTH;
register Lisp_Object *tbase = GLYPH_TABLE_BASE;
- int result;
- struct coding_system *coding;
- /* If terminal_coding does any conversion, use it, otherwise use
- safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
- because it always return 1 if the member src_multibyte is 1. */
- coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
- ? &terminal_coding
- : &safe_terminal_coding);
+ /* Allocate sufficient size of buffer to store all characters in
+ multibyte-form. But, it may be enlarged on demand if
+ Vglyph_table contains a string. */
+ 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)
{
/* We must skip glyphs to be padded for a wide character. */
if (g < 0 || g >= tlen)
{
/* This glyph doesn't has an entry in Vglyph_table. */
- if (! CHAR_VALID_P (src->u.ch, 0))
- {
- len = 1;
- buf = " ";
- coding->src_multibyte = 0;
- }
+ if (CHAR_VALID_P (src->u.ch, 0))
+ buf += CHAR_STRING (src->u.ch, buf);
else
- {
- len = CHAR_STRING (src->u.ch, workbuf);
- buf = workbuf;
- coding->src_multibyte = 1;
- }
+ *buf++ = SPACEGLYPH;
+ nchars++;
}
else
{
if (GLYPH_SIMPLE_P (tbase, tlen, g))
{
- /* We set the multi-byte form of a character in G
- (that should be an ASCII character) at
- WORKBUF. */
- workbuf[0] = FAST_GLYPH_CHAR (g);
- len = 1;
- buf = workbuf;
- coding->src_multibyte = 0;
+ int c = FAST_GLYPH_CHAR (g);
+
+ if (CHAR_VALID_P (c, 0))
+ buf += CHAR_STRING (c, buf);
+ else
+ *buf++ = SPACEGLYPH;
+ nchars++;
}
else
{
/* We have a string in Vglyph_table. */
- len = GLYPH_LENGTH (tbase, g);
- buf = GLYPH_STRING (tbase, g);
- coding->src_multibyte = STRING_MULTIBYTE (tbase[g]);
+ Lisp_Object string;
+
+ string = tbase[g];
+ if (! STRING_MULTIBYTE (string))
+ string = string_to_multibyte (string);
+ nbytes = buf - encode_terminal_buf;
+ if (nbytes + SBYTES (string) < encode_terminal_bufsize)
+ {
+ 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);
}
}
-
- result = encode_coding (coding, buf, dst, len, dst_end - dst);
- len -= coding->consumed;
- dst += coding->produced;
- if (result == CODING_FINISH_INSUFFICIENT_DST
- || (result == CODING_FINISH_INSUFFICIENT_SRC
- && len > dst_end - dst))
- /* The remaining output buffer is too short. We must
- break the loop here without increasing SRC so that the
- next call of this function starts from the same glyph. */
- break;
-
- if (len > 0)
- {
- /* This is the case that a code of the range 0200..0237
- exists in buf. We must just write out such a code. */
- buf += coding->consumed;
- while (len--)
- *dst++ = *buf++;
- }
}
src++;
}
- *consumed = src - src_start;
- return (dst - dst_start);
-}
+ 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;
{
- int produced, consumed;
struct frame *sf = XFRAME (selected_frame);
struct frame *f = updating_frame ? updating_frame : sf;
- unsigned char conversion_buffer[1024];
- int conversion_buffer_size = sizeof conversion_buffer;
+ unsigned char *conversion_buffer;
+ struct coding_system *coding;
if (write_glyphs_hook
&& ! FRAME_TERMCAP_P (f))
since that would scroll the whole frame on some terminals. */
if (AutoWrap
- && curY + 1 == FRAME_HEIGHT (sf)
- && (curX + len) == FRAME_WIDTH (sf))
+ && curY + 1 == FRAME_LINES (sf)
+ && (curX + len) == FRAME_COLS (sf))
len --;
if (len <= 0)
return;
cmplus (len);
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always return 1 if the member src_multibyte is 1. */
+ coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+ ? &terminal_coding : &safe_terminal_coding);
/* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
the tail. */
- terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
while (len > 0)
{
highlight_if_desired ();
turn_on_face (f, face_id);
- while (n > 0)
+ if (n == len)
+ /* This is the last run. */
+ coding->mode |= CODING_MODE_LAST_BLOCK;
+ conversion_buffer = encode_terminal_code (string, n, coding);
+ if (coding->produced > 0)
{
- /* We use a fixed size (1024 bytes) of conversion buffer.
- Usually it is sufficient, but if not, we just repeat the
- loop. */
- produced = encode_terminal_code (string, conversion_buffer,
- n, conversion_buffer_size,
- &consumed);
- if (produced > 0)
- {
- fwrite (conversion_buffer, 1, produced, stdout);
- if (ferror (stdout))
- clearerr (stdout);
- if (termscript)
- fwrite (conversion_buffer, 1, produced, termscript);
- }
- len -= consumed;
- n -= consumed;
- string += consumed;
+ fwrite (conversion_buffer, 1, coding->produced, stdout);
+ if (ferror (stdout))
+ clearerr (stdout);
+ if (termscript)
+ fwrite (conversion_buffer, 1, coding->produced, termscript);
}
+ len -= n;
+ string += n;
/* Turn appearance modes off. */
turn_off_face (f, face_id);
turn_off_highlight ();
}
- /* We may have to output some codes to terminate the writing. */
- if (CODING_REQUIRE_FLUSHING (&terminal_coding))
- {
- terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
- encode_coding (&terminal_coding, "", conversion_buffer,
- 0, conversion_buffer_size);
- if (terminal_coding.produced > 0)
- {
- fwrite (conversion_buffer, 1, terminal_coding.produced, stdout);
- if (ferror (stdout))
- clearerr (stdout);
- if (termscript)
- fwrite (conversion_buffer, 1, terminal_coding.produced,
- termscript);
- }
- }
-
cmcheckmagic ();
}
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;
turn_on_insert ();
cmplus (len);
- /* The bit CODING_MODE_LAST_BLOCK should be set to 1 only at the tail. */
- terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+
+ if (! start)
+ space[0] = SPACEGLYPH;
+
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always return 1 if the member src_multibyte is 1. */
+ coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+ ? &terminal_coding : &safe_terminal_coding);
+ /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
+ the tail. */
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
+
while (len-- > 0)
{
- int produced, consumed;
- unsigned char conversion_buffer[1024];
- int conversion_buffer_size = sizeof conversion_buffer;
-
OUTPUT1_IF (TS_ins_char);
if (!start)
{
- conversion_buffer[0] = SPACEGLYPH;
- produced = 1;
+ conversion_buffer = space;
+ coding->produced = 1;
}
else
{
if (len <= 0)
/* This is the last glyph. */
- terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
+ coding->mode |= CODING_MODE_LAST_BLOCK;
- /* The size of conversion buffer (1024 bytes) is surely
- sufficient for just one glyph. */
- produced = encode_terminal_code (glyph, conversion_buffer, 1,
- conversion_buffer_size, &consumed);
+ conversion_buffer = encode_terminal_code (glyph, 1, coding);
}
- if (produced > 0)
+ if (coding->produced > 0)
{
- fwrite (conversion_buffer, 1, produced, stdout);
+ fwrite (conversion_buffer, 1, coding->produced, stdout);
if (ferror (stdout))
clearerr (stdout);
if (termscript)
- fwrite (conversion_buffer, 1, produced, termscript);
+ fwrite (conversion_buffer, 1, coding->produced, termscript);
}
OUTPUT1_IF (TS_pad_inserted_char);
as there will be a matching inslines later that will flush them. */
if (scroll_region_ok && vpos + i >= specified_window)
return;
- if (!memory_below_frame && vpos + i >= FRAME_HEIGHT (sf))
+ if (!memory_below_frame && vpos + i >= FRAME_LINES (sf))
return;
if (multi)
if (!scroll_region_ok && memory_below_frame && n < 0)
{
- cursor_to (FRAME_HEIGHT (sf) + n, 0);
+ cursor_to (FRAME_LINES (sf) + n, 0);
clear_to_end ();
}
}
#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_width. */
+ 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_WIDTH ((f))])
+#define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_COLS ((f))])
#endif
/* ARGSUSED */
/* Delete costs are at negative offsets */
p = &char_ins_del_cost (frame)[0];
- for (i = FRAME_WIDTH (frame); --i >= 0;)
+ for (i = FRAME_COLS (frame); --i >= 0;)
*--p = (del_startup_cost += del_cost_per_char);
/* Doing nothing is free */
*p++ = 0;
/* Insert costs are at positive offsets */
- for (i = FRAME_WIDTH (frame); --i >= 0;)
+ for (i = FRAME_COLS (frame); --i >= 0;)
*p++ = (ins_startup_cost += ins_cost_per_char);
}
char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
X turns off char_ins_del_ok. */
- max_frame_height = max (max_frame_height, FRAME_HEIGHT (frame));
- max_frame_width = max (max_frame_width, FRAME_WIDTH (frame));
+ max_frame_lines = max (max_frame_lines, FRAME_LINES (frame));
+ max_frame_cols = max (max_frame_cols, FRAME_COLS (frame));
costs_set = 1;
char_ins_del_vector
= (int *) xrealloc (char_ins_del_vector,
(sizeof (int)
- + 2 * max_frame_width * sizeof (int)));
+ + 2 * max_frame_cols * sizeof (int)));
else
char_ins_del_vector
= (int *) xmalloc (sizeof (int)
- + 2 * max_frame_width * sizeof (int));
+ + 2 * max_frame_cols * sizeof (int));
bzero (char_ins_del_vector, (sizeof (int)
- + 2 * max_frame_width * sizeof (int)));
+ + 2 * max_frame_cols * sizeof (int)));
if (f && (!TS_ins_line && !TS_del_line))
do_line_insertion_deletion_costs (frame,
if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
RPov = string_cost (TS_repeat);
else
- RPov = FRAME_WIDTH (frame) * 2;
+ RPov = FRAME_COLS (frame) * 2;
cmcostinit (); /* set up cursor motion costs */
}
***********************************************************************/
static void append_glyph P_ ((struct it *));
+static void produce_stretch_glyph P_ ((struct it *));
/* Append glyphs to IT's glyph_row. Called from produce_glyphs for
/* If a hook is installed, let it do the work. */
xassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION
- || it->what == IT_IMAGE
|| it->what == IT_STRETCH);
+ if (it->what == IT_STRETCH)
+ {
+ produce_stretch_glyph (it);
+ goto done;
+ }
+
/* Nothing but characters are supported on terminal frames. For a
composition sequence, it->c is the first character of the
sequence. */
append_glyph (it);
}
+ done:
/* Advance current_x by the pixel width as a convenience for
the caller. */
if (it->area == TEXT_AREA)
}
+/* 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->glyph_row)
+ {
+ Lisp_Object o_object = it->object;
+ Lisp_Object object = it->stack[it->sp - 1].string;
+ int n = width;
+ int c = it->c;
+
+ if (!STRINGP (object))
+ object = it->w->buffer;
+ it->object = object;
+ it->c = ' ';
+ it->pixel_width = it->len = 1;
+ while (n--)
+ append_glyph (it);
+ it->object = o_object;
+ it->c = c;
+ }
+ it->pixel_width = width;
+ it->nglyphs = width;
+}
+
+
/* 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
}
-/* Return an estimation of the pixel height of mode or top lines on
- frame F. FACE_ID specifies what line's height to estimate. */
-
-int
-estimate_mode_line_height (f, face_id)
- struct frame *f;
- enum face_id face_id;
-{
- if (estimate_mode_line_height_hook)
- return estimate_mode_line_height_hook (f, face_id);
- else
- return 1;
-}
-
-
\f
/***********************************************************************
Faces
tty_setup_colors (mode)
int mode;
{
+ /* Canonicalize all negative values of MODE. */
+ if (mode < -1)
+ mode = -1;
+
switch (mode)
{
case -1: /* no colors at all */
tty_color_mode_alist = Fintern_soft (build_string ("tty-color-mode-alist"),
Qnil);
- if (NATNUMP (val))
+ if (INTEGERP (val))
color_mode = val;
else
{
color_mode_spec = Qnil;
else
color_mode_spec = Fassq (val, XSYMBOL (tty_color_mode_alist)->value);
- current_mode_spec = assq_no_quit (Qtty_color_mode, f->param_alist);
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 (NATNUMP (color_mode))
+ if (INTEGERP (color_mode))
mode = XINT (color_mode);
else
mode = 0; /* meaning default */
- if (NATNUMP (current_mode))
+ if (INTEGERP (current_mode))
old_mode = XINT (current_mode);
else
old_mode = 0;
{
char *area;
char **address = &area;
- char buffer[2044];
+ 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 ();
area = (char *) xmalloc (2044);
- if (area == 0)
- abort ();
-
- FrameRows = FRAME_HEIGHT (sf);
- FrameCols = FRAME_WIDTH (sf);
- specified_window = FRAME_HEIGHT (sf);
+ FrameRows = FRAME_LINES (sf);
+ FrameCols = FRAME_COLS (sf);
+ specified_window = FRAME_LINES (sf);
delete_in_insert_mode = 1;
Wcm_clear ();
+ buffer = (char *) xmalloc (buffer_size);
status = tgetent (buffer, terminal_type);
if (status < 0)
{
terminal_type);
#endif
}
-#ifdef TERMINFO
- area = (char *) xmalloc (2044);
-#else
- area = (char *) xmalloc (strlen (buffer));
-#endif /* not TERMINFO */
- if (area == 0)
+
+#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);
{
int height, width;
get_frame_size (&width, &height);
- FRAME_WIDTH (sf) = width;
- FRAME_HEIGHT (sf) = height;
+ FRAME_COLS (sf) = width;
+ FRAME_LINES (sf) = height;
}
- if (FRAME_WIDTH (sf) <= 0)
- SET_FRAME_WIDTH (sf, tgetnum ("co"));
+ if (FRAME_COLS (sf) <= 0)
+ SET_FRAME_COLS (sf, tgetnum ("co"));
else
/* Keep width and external_width consistent */
- SET_FRAME_WIDTH (sf, FRAME_WIDTH (sf));
- if (FRAME_HEIGHT (sf) <= 0)
- FRAME_HEIGHT (sf) = tgetnum ("li");
+ SET_FRAME_COLS (sf, FRAME_COLS (sf));
+ if (FRAME_LINES (sf) <= 0)
+ FRAME_LINES (sf) = tgetnum ("li");
- if (FRAME_HEIGHT (sf) < 3 || FRAME_WIDTH (sf) < 3)
+ if (FRAME_LINES (sf) < 3 || FRAME_COLS (sf) < 3)
fatal ("Screen size %dx%d is too small",
- FRAME_HEIGHT (sf), FRAME_WIDTH (sf));
+ FRAME_LINES (sf), FRAME_COLS (sf));
min_padding_speed = tgetnum ("pb");
TabWidth = tgetnum ("tw");
}
}
- FrameRows = FRAME_HEIGHT (sf);
- FrameCols = FRAME_WIDTH (sf);
- specified_window = FRAME_HEIGHT (sf);
+ FrameRows = FRAME_LINES (sf);
+ FrameCols = FRAME_COLS (sf);
+ specified_window = FRAME_LINES (sf);
if (Wcm_init () == -1) /* can't do cursor motion */
#ifdef VMS
terminal_type);
# endif /* TERMINFO */
#endif /*VMS */
- if (FRAME_HEIGHT (sf) <= 0
- || FRAME_WIDTH (sf) <= 0)
+ if (FRAME_LINES (sf) <= 0
+ || FRAME_COLS (sf) <= 0)
fatal ("The frame size has not been specified");
delete_in_insert_mode
FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
#endif /* WINDOWSNT */
+
+ xfree (buffer);
}
/* VARARGS 1 */
defsubr (&Stty_display_color_cells);
}
+/* arch-tag: 498e7449-6f2e-45e2-91dd-b7d4ca488193
+ (do not change this comment) */