/* Display generation from window structure and buffer text.
Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995,
1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
#include <limits.h>
+#include <setjmp.h>
#include "lisp.h"
#include "keyboard.h"
static int display_echo_area_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
static int resize_mini_window_1 P_ ((EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT));
static Lisp_Object unwind_redisplay P_ ((Lisp_Object));
-static int string_char_and_length P_ ((const unsigned char *, int, int *));
+static int string_char_and_length P_ ((const unsigned char *, int *));
static struct text_pos display_prop_end P_ ((struct it *, Lisp_Object,
struct text_pos));
static int compute_window_start_on_continuation_line P_ ((struct window *));
static int display_mode_line P_ ((struct window *, enum face_id, Lisp_Object));
static int display_mode_element P_ ((struct it *, int, int, int, Lisp_Object, Lisp_Object, int));
static int store_mode_line_string P_ ((char *, Lisp_Object, int, int, int, Lisp_Object));
-static char *decode_mode_spec P_ ((struct window *, int, int, int, int *));
+static char *decode_mode_spec P_ ((struct window *, int, int, int,
+ Lisp_Object *));
static void display_menu_bar P_ ((struct window *));
static int display_count_lines P_ ((int, int, int, int, int *));
static int display_string P_ ((unsigned char *, Lisp_Object, Lisp_Object,
int top_x = it.current_x;
int top_y = it.current_y;
enum it_method it_method = it.method;
- /* Calling line_bottom_y may change it.method. */
+ /* Calling line_bottom_y may change it.method, it.position, etc. */
int bottom_y = (last_height = 0, line_bottom_y (&it));
int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
Lisp_Object window, prop;
XSETWINDOW (window, w);
- prop = Fget_char_property (make_number (it.position.charpos),
+ prop = Fget_char_property (make_number (charpos),
Qinvisible, window);
/* If charpos coincides with invisible text covered with an
character. */
static INLINE int
-string_char_and_length (str, maxlen, len)
+string_char_and_length (str, len)
const unsigned char *str;
- int maxlen, *len;
+ int *len;
{
int c;
- c = STRING_CHAR_AND_LENGTH (str, maxlen, *len);
+ c = STRING_CHAR_AND_LENGTH (str, *len);
if (!CHAR_VALID_P (c, 1))
/* We may not change the length here because other places in Emacs
don't use this function, i.e. they silently accept invalid
while (nchars--)
{
- string_char_and_length (p, rest, &len);
+ string_char_and_length (p, &len);
p += len, rest -= len;
xassert (rest >= 0);
CHARPOS (pos) += 1;
SET_TEXT_POS (pos, 0, 0);
while (charpos--)
{
- string_char_and_length (s, rest, &len);
+ string_char_and_length (s, &len);
s += len, rest -= len;
xassert (rest >= 0);
CHARPOS (pos) += 1;
for (nchars = 0; rest > 0; ++nchars)
{
- string_char_and_length (p, rest, &len);
+ string_char_and_length (p, &len);
rest -= len, p += len;
}
}
}
/* EXPORT:
- Return an estimation of the pixel height of mode or top lines on
+ Return an estimation of the pixel height of mode or header lines on
frame F. FACE_ID specifies what line's height to estimate. */
int
r.y = WINDOW_HEADER_LINE_HEIGHT (s->w);
else
r.y = max (0, s->row->y);
-
- /* If drawing a tool-bar window, draw it over the internal border
- at the top of the window. */
- if (WINDOWP (s->f->tool_bar_window)
- && s->w == XWINDOW (s->f->tool_bar_window))
- r.y -= FRAME_INTERNAL_BORDER_WIDTH (s->f);
}
r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
it->current_x = it->hpos = 0;
}
}
-
-#if 0 /* Don't assert the following because start_display is sometimes
- called intentionally with a window start that is not at a
- line start. Please leave this code in as a comment. */
-
- /* Window start should be on a line start, now. */
- xassert (it->continuation_lines_width
- || IT_CHARPOS (it) == BEGV
- || FETCH_BYTE (IT_BYTEPOS (it) - 1) == '\n');
-#endif /* 0 */
}
&next_stop,
base_face_id, 0);
-#if 0 /* This shouldn't be neccessary. Let's check it. */
- /* If IT is used to display a mode line we would really like to
- use the mode line face instead of the frame's default face. */
- if (it->glyph_row == MATRIX_MODE_LINE_ROW (it->w->desired_matrix)
- && new_face_id == DEFAULT_FACE_ID)
- new_face_id = CURRENT_MODE_LINE_FACE_ID (it->w);
-#endif
-
/* Is this a start of a run of characters with box? Caveat:
this can be called for a freshly allocated iterator; face_id
is -1 is this case. We know that the new face will not
int c, len;
struct face *face = FACE_FROM_ID (it->f, face_id);
- c = string_char_and_length (p, rest, &len);
+ c = string_char_and_length (p, &len);
face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), it->string);
}
}
}
-/* Determine from which buffer position in W's buffer STRING comes
- from. AROUND_CHARPOS is an approximate position where it could
- be from. Value is the buffer position or 0 if it couldn't be
- determined.
+/* Determine which buffer position in W's buffer STRING comes from.
+ AROUND_CHARPOS is an approximate position where it could come from.
+ Value is the buffer position or 0 if it couldn't be determined.
W's buffer must be current.
pos_byte = IT_STRING_BYTEPOS (*it);
string = it->string;
s = SDATA (string) + pos_byte;
- it->c = STRING_CHAR (s, 0);
+ it->c = STRING_CHAR (s);
}
else
{
case GET_FROM_STRING:
it->object = it->string;
break;
+ case GET_FROM_DISPLAY_VECTOR:
+ if (it->s)
+ it->method = GET_FROM_C_STRING;
+ else if (STRINGP (it->string))
+ it->method = GET_FROM_STRING;
+ else
+ {
+ it->method = GET_FROM_BUFFER;
+ it->object = it->w->buffer;
+ }
}
it->end_charpos = p->end_charpos;
it->string_nchars = p->string_nchars;
it->dp = XCHAR_TABLE (Vstandard_display_table);
it->stop_charpos = charpos;
+ if (s == NULL && it->multibyte_p)
+ composition_compute_stop_pos (&it->cmp_it, charpos, -1, it->end_charpos,
+ it->string);
CHECK_IT (it);
}
/* Return 1 iff a character at CHARPOS (and BYTEPOS) is composed
(possibly with the following characters). */
-#define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS) \
+#define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS) \
((IT)->cmp_it.id >= 0 \
|| ((IT)->cmp_it.stop_pos == (CHARPOS) \
&& composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS, \
- (IT)->end_charpos, (IT)->w, \
+ END_CHARPOS, (IT)->w, \
FACE_FROM_ID ((IT)->f, (IT)->face_id), \
(IT)->string)))
if (success_p && it->dpvec == NULL)
{
Lisp_Object dv;
+ struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
+ enum { char_is_other = 0, char_is_nbsp, char_is_soft_hyphen }
+ nbsp_or_shy = char_is_other;
+ int decoded = it->c;
if (it->dp
&& (dv = DISP_CHAR_VECTOR (it->dp, it->c),
goto get_next;
}
+ if (unibyte_display_via_language_environment
+ && !ASCII_CHAR_P (it->c))
+ decoded = DECODE_CHAR (unibyte, it->c);
+
+ if (it->c >= 0x80 && ! NILP (Vnobreak_char_display))
+ {
+ if (it->multibyte_p)
+ nbsp_or_shy = (it->c == 0xA0 ? char_is_nbsp
+ : it->c == 0xAD ? char_is_soft_hyphen
+ : char_is_other);
+ else if (unibyte_display_via_language_environment)
+ nbsp_or_shy = (decoded == 0xA0 ? char_is_nbsp
+ : decoded == 0xAD ? char_is_soft_hyphen
+ : char_is_other);
+ }
+
/* Translate control characters into `\003' or `^C' form.
Control characters coming from a display table entry are
currently not translated because we use IT->dpvec to hold
If it->multibyte_p is zero, eight-bit characters that
don't have corresponding multibyte char code are also
translated to octal form. */
- else if ((it->c < ' '
- ? (it->area != TEXT_AREA
- /* In mode line, treat \n, \t like other crl chars. */
- || (it->c != '\t'
- && it->glyph_row
- && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
- || (it->c != '\n' && it->c != '\t'))
- : (it->multibyte_p
- ? (!CHAR_PRINTABLE_P (it->c)
- || (!NILP (Vnobreak_char_display)
- && (it->c == 0xA0 /* NO-BREAK SPACE */
- || it->c == 0xAD /* SOFT HYPHEN */)))
- : (it->c >= 127
- && (! unibyte_display_via_language_environment
- || (UNIBYTE_CHAR_HAS_MULTIBYTE_P (it->c)))))))
+ if ((it->c < ' '
+ ? (it->area != TEXT_AREA
+ /* In mode line, treat \n, \t like other crl chars. */
+ || (it->c != '\t'
+ && it->glyph_row
+ && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
+ || (it->c != '\n' && it->c != '\t'))
+ : (nbsp_or_shy
+ || (it->multibyte_p
+ ? ! CHAR_PRINTABLE_P (it->c)
+ : (! unibyte_display_via_language_environment
+ ? it->c >= 0x80
+ : (decoded >= 0x80 && decoded < 0xA0))))))
{
/* IT->c is a control character which must be displayed
either as '\003' or as `^C' where the '\\' and '^'
highlighting. */
if (EQ (Vnobreak_char_display, Qt)
- && it->c == 0xA0)
+ && nbsp_or_shy == char_is_nbsp)
{
/* Merge the no-break-space face into the current face. */
face_id = merge_faces (it->f, Qnobreak_space, 0,
highlighting. */
if (EQ (Vnobreak_char_display, Qt)
- && it->c == 0xAD)
+ && nbsp_or_shy == char_is_soft_hyphen)
{
it->c = '-';
XSETINT (it->ctl_chars[0], '-');
/* Handle non-break space and soft hyphen
with the escape glyph. */
- if (it->c == 0xA0 || it->c == 0xAD)
+ if (nbsp_or_shy)
{
XSETINT (it->ctl_chars[0], escape_glyph);
- it->c = (it->c == 0xA0 ? ' ' : '-');
+ it->c = (nbsp_or_shy == char_is_nbsp ? ' ' : '-');
XSETINT (it->ctl_chars[1], it->c);
ctl_len = 2;
goto display_control;
or `\003'.
IT->dpvec holds the glyphs to return as characters.
- IT->saved_face_id holds the face id before the display vector--
- it is restored into IT->face_idin set_iterator_to_next. */
+ IT->saved_face_id holds the face id before the display vector--it
+ is restored into IT->face_id in set_iterator_to_next. */
static int
next_element_from_display_vector (it)
return 0;
}
else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
- IT_STRING_BYTEPOS (*it))
+ IT_STRING_BYTEPOS (*it), SCHARS (it->string))
&& next_element_from_composition (it))
{
return 1;
int remaining = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
const unsigned char *s = (SDATA (it->string)
+ IT_STRING_BYTEPOS (*it));
- it->c = string_char_and_length (s, remaining, &it->len);
+ it->c = string_char_and_length (s, &it->len);
}
else
{
CHARPOS (position) = BYTEPOS (position) = -1;
}
else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
- IT_STRING_BYTEPOS (*it))
+ IT_STRING_BYTEPOS (*it), it->string_nchars)
&& next_element_from_composition (it))
{
return 1;
int maxlen = SBYTES (it->string) - IT_STRING_BYTEPOS (*it);
const unsigned char *s = (SDATA (it->string)
+ IT_STRING_BYTEPOS (*it));
- it->c = string_char_and_length (s, maxlen, &it->len);
+ it->c = string_char_and_length (s, &it->len);
}
else
{
performance problem because there is no noticeable performance
difference between Emacs running in unibyte or multibyte mode. */
int maxlen = strlen (it->s) - IT_BYTEPOS (*it);
- it->c = string_char_and_length (it->s + IT_BYTEPOS (*it),
- maxlen, &it->len);
+ it->c = string_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
}
else
it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
/* Set up IT to return characters from an ellipsis, if appropriate.
The definition of the ellipsis glyphs may come from a display table
- entry. This function Fills IT with the first glyph from the
+ entry. This function fills IT with the first glyph from the
ellipsis if an ellipsis is to be displayed. */
static int
&& IT_CHARPOS (*it) >= it->redisplay_end_trigger_charpos)
run_redisplay_end_trigger_hook (it);
- if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it))
+ if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
+ it->end_charpos)
&& next_element_from_composition (it))
{
return 1;
/* Get the next character, maybe multibyte. */
p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
if (it->multibyte_p && !ASCII_BYTE_P (*p))
- it->c = STRING_CHAR_AND_LENGTH (p, 0, it->len);
+ it->c = STRING_CHAR_AND_LENGTH (p, it->len);
else
it->c = *p, it->len = 1;
/* The number of glyphs we get back in IT->nglyphs will normally
be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
character on a terminal frame, or (iii) a line end. For the
- second case, IT->nglyphs - 1 padding glyphs will be present
- (on X frames, there is only one glyph produced for a
- composite character.
+ second case, IT->nglyphs - 1 padding glyphs will be present.
+ (On X frames, there is only one glyph produced for a
+ composite character.)
The behavior implemented below means, for continuation lines,
that as many spaces of a TAB as fit on the current line are
}
set_iterator_to_next (it, 1);
- /* One graphical terminals, newlines may
+ /* On graphical terminals, newlines may
"overflow" into the fringe if
overflow-newline-into-fringe is non-nil.
On text-only terminals, newlines may
int op;
{
enum move_it_result skip, skip2 = MOVE_X_REACHED;
- int line_height;
- int reached = 0;
+ int line_height, line_start_x = 0, reached = 0;
for (;;)
{
if (it->current_x != it->last_visible_x
&& (op & MOVE_TO_VPOS)
&& !(op & (MOVE_TO_X | MOVE_TO_POS)))
- set_iterator_to_next (it, 0);
+ {
+ line_start_x = it->current_x + it->pixel_width
+ - it->last_visible_x;
+ set_iterator_to_next (it, 0);
+ }
}
else
it->continuation_lines_width += it->current_x;
/* Reset/increment for the next run. */
recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
- it->current_x = it->hpos = 0;
+ it->current_x = line_start_x;
+ line_start_x = 0;
+ it->hpos = 0;
it->current_y += it->max_ascent + it->max_descent;
++it->vpos;
last_height = it->max_ascent + it->max_descent;
value of nlines is > 0 if continuation lines were involved. */
if (nlines > 0)
move_it_by_lines (it, nlines, 1);
-#if 0
- /* I think this assert is bogus if buffer contains
- invisible text or images. KFS. */
- xassert (IT_CHARPOS (*it) <= start_pos);
-#endif
}
else
{
}
while (target_y >= line_bottom_y (it) && IT_CHARPOS (*it) < ZV);
}
-
-#if 0
- /* I think this assert is bogus if buffer contains
- invisible text or images. KFS. */
- xassert (IT_CHARPOS (*it) >= BEGV);
-#endif
}
}
}
for the *Message* buffer. */
for (i = 0; i < nbytes; i += char_bytes)
{
- c = string_char_and_length (m + i, nbytes - i, &char_bytes);
+ c = string_char_and_length (m + i, &char_bytes);
work[0] = (ASCII_CHAR_P (c)
? c
: multibyte_char_to_unibyte (c, Qnil));
for (i = 0; i < nbytes; i++)
{
c = msg[i];
- c = unibyte_char_to_multibyte (c);
+ MAKE_CHAR_MULTIBYTE (c);
char_bytes = CHAR_STRING (c, str);
insert_1_both (str, 1, char_bytes, 1, 0, 0);
}
/* Convert a multibyte string to single-byte. */
for (i = 0; i < nbytes; i += n)
{
- c = string_char_and_length (s + i, nbytes - i, &n);
+ c = string_char_and_length (s + i, &n);
work[0] = (ASCII_CHAR_P (c)
? c
: multibyte_char_to_unibyte (c, Qnil));
for (i = 0; i < nbytes; i++)
{
c = msg[i];
- c = unibyte_char_to_multibyte (c);
+ MAKE_CHAR_MULTIBYTE (c);
n = CHAR_STRING (c, str);
insert_1_both (str, 1, n, 1, 0, 0);
}
}
}
-
/* Notice any pending interrupt request to change frame size. */
do_pending_window_change (1);
&& PT >= CHARPOS (tlbufpos)
&& PT <= Z - CHARPOS (tlendpos)
/* All text outside that line, including its final newline,
- must be unchanged */
+ must be unchanged. */
&& text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
CHARPOS (tlendpos)))
{
&& FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
&& (CHARPOS (tlbufpos) == ZV
|| FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
- /* Former continuation line has disappeared by becoming empty */
+ /* Former continuation line has disappeared by becoming empty. */
goto cancel;
else if (XFASTINT (w->last_modified) < MODIFF
|| XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
|| MINI_WINDOW_P (w))
{
/* We have to handle the case of continuation around a
- wide-column character (See the comment in indent.c around
- line 885).
+ wide-column character (see the comment in indent.c around
+ line 1340).
For instance, in the following case:
^^ ^^
-------- --------
- As we have to redraw the line above, we should goto cancel. */
+ As we have to redraw the line above, we cannot use this
+ optimization. */
struct it it;
int line_height_before = this_line_pixel_height;
/* Note that start_display will handle the case that the
- line starting at tlbufpos is a continuation lines. */
+ line starting at tlbufpos is a continuation line. */
start_display (&it, w, tlbufpos);
/* Implementation note: It this still necessary? */
display_line (&it);
/* If line contains point, is not continued,
- and ends at same distance from eob as before, we win */
+ and ends at same distance from eob as before, we win. */
if (w->cursor.vpos >= 0
/* Line is not continued, otherwise this_line_start_pos
would have been set to 0 in display_line. */
= MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
int delta, delta_bytes;
- if (Z - CHARPOS (tlendpos) == ZV)
- {
- /* This line ends at end of (accessible part of)
- buffer. There is no newline to count. */
- delta = (Z
- - CHARPOS (tlendpos)
- - MATRIX_ROW_START_CHARPOS (row));
- delta_bytes = (Z_BYTE
- - BYTEPOS (tlendpos)
- - MATRIX_ROW_START_BYTEPOS (row));
- }
- else
- {
- /* This line ends in a newline. Must take
- account of the newline and the rest of the
- text that follows. */
- delta = (Z
- - CHARPOS (tlendpos)
- - MATRIX_ROW_START_CHARPOS (row));
- delta_bytes = (Z_BYTE
- - BYTEPOS (tlendpos)
- - MATRIX_ROW_START_BYTEPOS (row));
- }
+ /* We used to distinguish between two cases here,
+ conditioned by Z - CHARPOS (tlendpos) == ZV, for
+ when the line ends in a newline or the end of the
+ buffer's accessible portion. But both cases did
+ the same, so they were collapsed. */
+ delta = (Z
+ - CHARPOS (tlendpos)
+ - MATRIX_ROW_START_CHARPOS (row));
+ delta_bytes = (Z_BYTE
+ - BYTEPOS (tlendpos)
+ - MATRIX_ROW_START_BYTEPOS (row));
increment_matrix_positions (w->current_matrix,
this_line_vpos + 1,
/* Set cursor position of W. PT is assumed to be displayed in ROW.
- DELTA is the number of bytes by which positions recorded in ROW
- differ from current buffer positions.
+ DELTA and DELTA_BYTES are the numbers of characters and bytes by
+ which positions recorded in ROW differ from current buffer
+ positions.
- Return 0 if cursor is not on this row. 1 otherwise. */
+ Return 0 if cursor is not on this row, 1 otherwise. */
int
set_cursor_from_row (w, row, matrix, delta, delta_bytes, dy, dvpos)
struct glyph *glyph = row->glyphs[TEXT_AREA];
struct glyph *end = glyph + row->used[TEXT_AREA];
struct glyph *cursor = NULL;
- /* The first glyph that starts a sequence of glyphs from string. */
+ /* The first glyph that starts a sequence of glyphs from a string
+ that is a value of a display property. */
struct glyph *string_start;
/* The X coordinate of string_start. */
int string_start_x;
- /* The last known character position. */
+ /* The last known character position in row. */
int last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
/* The last known character position before string_start. */
int string_before_pos;
int x = row->x;
int cursor_x = x;
+ /* Last buffer position covered by an overlay. */
int cursor_from_overlay_pos = 0;
int pt_old = PT - delta;
string_start = NULL;
x += glyph->pixel_width;
++glyph;
+ /* If we are beyond the cursor position computed from the
+ last overlay seen, that overlay is not in effect for
+ current cursor position. Reset the cursor information
+ computed from that overlay. */
if (cursor_from_overlay_pos
&& last_pos >= cursor_from_overlay_pos)
{
cursor_from_overlay_pos = 0;
- cursor = 0;
+ cursor = NULL;
}
}
else
string_start = glyph;
string_start_x = x;
}
- /* Skip all glyphs from string. */
+ /* Skip all glyphs from a string. */
do
{
Lisp_Object cprop;
!NILP (cprop))
&& (pos = string_buffer_position (w, glyph->object,
string_before_pos),
- (pos == 0 /* From overlay */
+ (pos == 0 /* from overlay */
|| pos == pt_old)))
{
- /* Estimate overlay buffer position from the buffer
- positions of the glyphs before and after the overlay.
- Add 1 to last_pos so that if point corresponds to the
- glyph right after the overlay, we still use a 'cursor'
- property found in that overlay. */
+ /* Compute the first buffer position after the overlay.
+ If the `cursor' property tells us how many positions
+ are associated with the overlay, use that. Otherwise,
+ estimate from the buffer positions of the glyphs
+ before and after the overlay. */
cursor_from_overlay_pos = (pos ? 0 : last_pos
+ (INTEGERP (cprop) ? XINT (cprop) : 0));
cursor = glyph;
while (glyph > row->glyphs[TEXT_AREA]
&& (glyph - 1)->charpos == last_pos)
glyph--, x -= glyph->pixel_width;
- /* That loop always goes one position too far,
- including the glyph before the ellipsis.
- So scan forward over that one. */
+ /* That loop always goes one position too far, including the
+ glyph before the ellipsis. So scan forward over that one. */
x += glyph->pixel_width;
glyph++;
}
x = string_start_x;
string = glyph->object;
pos = string_buffer_position (w, string, string_before_pos);
- /* If STRING is from overlay, LAST_POS == 0. We skip such glyphs
- because we always put cursor after overlay strings. */
+ /* If POS == 0, STRING is from overlay. We skip such glyphs
+ because we always put the cursor after overlay strings. */
while (pos == 0 && glyph < stop)
{
string = glyph->object;
}
}
- /* If we reached the end of the line, and end was from a string,
- cursor is not on this line. */
+ /* If we reached the end of the line, and END was from a string,
+ the cursor is not on this line. */
if (glyph == end && row->continued_p)
return 0;
}
return 1;
}
return 0;
-
-#if 0
- /* This code used to try to scroll the window just enough to make
- the line visible. It returned 0 to say that the caller should
- allocate larger glyph matrices. */
-
- if (MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (w, row))
- {
- int dy = row->height - row->visible_height;
- w->vscroll = 0;
- w->cursor.y += dy;
- shift_glyph_matrix (w, matrix, 0, matrix->nrows, dy);
- }
- else /* MATRIX_ROW_PARTIALLY_VISIBLE_AT_BOTTOM_P (w, row)) */
- {
- int dy = - (row->height - row->visible_height);
- w->vscroll = dy;
- w->cursor.y += dy;
- shift_glyph_matrix (w, matrix, 0, matrix->nrows, dy);
- }
-
- /* When we change the cursor y-position of the selected window,
- change this_line_y as well so that the display optimization for
- the cursor line of the selected window in redisplay_internal uses
- the correct y-position. */
- if (w == XWINDOW (selected_window))
- this_line_y = w->cursor.y;
-
- /* If vscrolling requires a larger glyph matrix, arrange for a fresh
- redisplay with larger matrices. */
- if (matrix->nrows < required_matrix_height (w))
- {
- fonts_changed_p = 1;
- return 0;
- }
-
- return 1;
-#endif /* 0 */
}
used_current_matrix_p = 1;
goto done;
-#if 0 /* try_cursor_movement never returns this value. */
- case CURSOR_MOVEMENT_NEED_LARGER_MATRICES:
- goto need_larger_matrices;
-#endif
-
case CURSOR_MOVEMENT_MUST_SCROLL:
goto try_to_scroll;
= DESIRED_MODE_LINE_HEIGHT (w);
}
- /* If top line height has changed, arrange for a thorough
- immediate redisplay using the correct mode line height. */
+ /* If header line height has changed, arrange for a thorough
+ immediate redisplay using the correct header line height. */
if (WINDOW_WANTS_HEADER_LINE_P (w)
&& CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
{
|| !WINDOW_FULL_WIDTH_P (w)))
GIVE_UP (4);
- /* Give up if point is not known NOT to appear in W. */
+ /* Give up if point is known NOT to appear in W. */
if (PT < CHARPOS (start))
GIVE_UP (5);
if (!NILP (w->region_showing))
GIVE_UP (10);
- /* Can use this if overlay arrow position and or string have changed. */
+ /* Can't use this if overlay arrow position and/or string have
+ changed. */
if (overlay_arrows_changed_p ())
GIVE_UP (12);
else
abort ();
-#if 0 /* This leads to problems, for instance when the cursor is
- at ZV, and the cursor line displays no text. */
- /* Disable rows below what's displayed in the window. This makes
- debugging easier. */
- enable_glyph_matrix_rows (current_matrix,
- XFASTINT (w->window_end_vpos) + 1,
- bottom_vpos, 0);
-#endif
-
IF_DEBUG (debug_end_pos = XFASTINT (w->window_end_pos);
debug_end_vpos = XFASTINT (w->window_end_vpos));
/* Get the next character. */
if (multibyte_p)
- it.c = string_char_and_length (p, arrow_len, &it.len);
+ it.c = string_char_and_length (p, &it.len);
else
it.c = *p, it.len = 1;
p += it.len;
it->glyph_row->fill_line_p = 1;
/* If current character of IT is not ASCII, make sure we have the
- ASCII face. This will be automatically undone the next time
- get_next_display_element returns a multibyte character. Note
- that the character will always be single byte in unibyte text. */
+ ASCII face. This will be automatically undone the next time
+ get_next_display_element returns a multibyte character. Note
+ that the character will always be single byte in unibyte
+ text. */
if (!ASCII_CHAR_P (it->c))
{
it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
\f
/* Push the display property PROP so that it will be rendered at the
- current position in IT. */
+ current position in IT. Return 1 if PROP was successfully pushed,
+ 0 otherwise. */
-static void
+static int
push_display_prop (struct it *it, Lisp_Object prop)
{
push_it (it);
- /* Never display a cursor on the prefix. */
- it->avoid_cursor_p = 1;
-
if (STRINGP (prop))
{
if (SCHARS (prop) == 0)
{
pop_it (it);
- return;
+ return 0;
}
it->string = prop;
else
{
pop_it (it); /* bogus display property, give up */
- return;
+ return 0;
}
+
+ return 1;
}
/* Return the character-property PROP at the current position in IT. */
if (NILP (prefix))
prefix = Vline_prefix;
}
- if (! NILP (prefix))
+ if (! NILP (prefix) && push_display_prop (it, prefix))
{
- push_display_prop (it, prefix);
/* If the prefix is wider than the window, and we try to wrap
it, it would acquire its own wrap prefix, and so on till the
iterator stack overflows. So, don't wrap the prefix. */
it->line_wrap = TRUNCATE;
+ it->avoid_cursor_p = 1;
}
}
}
-/* Display the mode and/or top line of window W. Value is the number
- of mode lines displayed. */
+/* Display the mode and/or header line of window W. Value is the
+ sum number of mode lines and header lines displayed. */
static int
display_mode_lines (w)
}
-/* Display mode or top line of window W. FACE_ID specifies which line
- to display; it is either MODE_LINE_FACE_ID or HEADER_LINE_FACE_ID.
- FORMAT is the mode line format to display. Value is the pixel
- height of the mode line displayed. */
+/* Display mode or header line of window W. FACE_ID specifies which
+ line to display; it is either MODE_LINE_FACE_ID or
+ HEADER_LINE_FACE_ID. FORMAT is the mode/header line format to
+ display. Value is the pixel height of the mode/header line
+ displayed. */
static int
display_mode_line (w, face_id, format)
int multibyte;
int bytepos, charpos;
unsigned char *spec;
+ Lisp_Object string;
bytepos = percent_position;
charpos = (STRING_MULTIBYTE (elt)
? string_byte_to_char (elt, bytepos)
: bytepos);
- spec
- = decode_mode_spec (it->w, c, field, prec, &multibyte);
+ spec = decode_mode_spec (it->w, c, field, prec, &string);
+ multibyte = STRINGP (string) && STRING_MULTIBYTE (string);
switch (mode_line_target)
{
int nglyphs_before, nwritten;
nglyphs_before = it->glyph_row->used[TEXT_AREA];
- nwritten = display_string (spec, Qnil, elt,
+ nwritten = display_string (spec, string, elt,
charpos, 0, it,
field, prec, 0,
multibyte);
}
else if (STRINGP (car) || CONSP (car))
{
- register int limit = 50;
- /* Limit is to protect against circular lists. */
+ Lisp_Object halftail = elt;
+ int len = 0;
+
while (CONSP (elt)
- && --limit > 0
&& (precision <= 0 || n < precision))
{
n += display_mode_element (it, depth,
precision - n, XCAR (elt),
props, risky);
elt = XCDR (elt);
+ len++;
+ if ((len & 1) == 0)
+ halftail = XCDR (halftail);
+ /* Check for cycle. */
+ if (EQ (halftail, elt))
+ break;
}
}
}
/* Return a string for the output of a mode line %-spec for window W,
generated by character C. PRECISION >= 0 means don't return a
string longer than that value. FIELD_WIDTH > 0 means pad the
- string returned with spaces to that value. Return 1 in *MULTIBYTE
- if the result is multibyte text.
+ string returned with spaces to that value. Return a Lisp string in
+ *STRING if the resulting string is taken from that Lisp string.
Note we operate on the current buffer for most purposes,
the exception being w->base_line_pos. */
static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
static char *
-decode_mode_spec (w, c, field_width, precision, multibyte)
+decode_mode_spec (w, c, field_width, precision, string)
struct window *w;
register int c;
int field_width, precision;
- int *multibyte;
+ Lisp_Object *string;
{
Lisp_Object obj;
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct buffer *b = current_buffer;
obj = Qnil;
- *multibyte = 0;
+ *string = Qnil;
switch (c)
{
case '@':
{
- Lisp_Object val;
- val = call1 (intern ("file-remote-p"), current_buffer->directory);
+ int count = inhibit_garbage_collection ();
+ Lisp_Object val = call1 (intern ("file-remote-p"),
+ current_buffer->directory);
+ unbind_to (count, Qnil);
+
if (NILP (val))
return "-";
else
if (STRINGP (obj))
{
- *multibyte = STRING_MULTIBYTE (obj);
+ *string = obj;
return (char *) SDATA (obj);
}
else
/* Display a NUL-terminated string, starting with index START.
If STRING is non-null, display that C string. Otherwise, the Lisp
- string LISP_STRING is displayed.
+ string LISP_STRING is displayed. There's a case that STRING is
+ non-null and LISP_STRING is not nil. It means STRING is a string
+ data of LISP_STRING. In that case, we display LISP_STRING while
+ ignoring its text properties.
If FACE_STRING is not nil, FACE_STRING_POS is a position in
FACE_STRING. Display STRING or LISP_STRING with the face at
/* Initialize the iterator IT for iteration over STRING beginning
with index START. */
- reseat_to_string (it, string, lisp_string, start,
+ reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string, start,
precision, field_width, multibyte);
+ if (string && STRINGP (lisp_string))
+ /* LISP_STRING is the one returned by decode_mode_spec. We should
+ ignore its text properties. */
+ it->stop_charpos = -1;
/* If displaying STRING, set up the face of the iterator
from LISP_STRING, if that's given. */
s->first_glyph = row->glyphs[area] + start;
s->height = row->height;
s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
-
- /* Display the internal border below the tool-bar window. */
- if (WINDOWP (s->f->tool_bar_window)
- && s->w == XWINDOW (s->f->tool_bar_window))
- s->y -= FRAME_INTERNAL_BORDER_WIDTH (s->f);
-
s->ybase = s->y + row->ascent;
}
j = i;
BUILD_GLYPH_STRINGS (j, start, h, t,
overlap_hl, dummy_x, last_x);
+ start = i;
compute_overhangs_and_x (t, head->x, 1);
prepend_glyph_string_lists (&head, &tail, h, t);
clip_head = head;
BUILD_GLYPH_STRINGS (end, i, h, t,
overlap_hl, x, last_x);
+ /* Because BUILD_GLYPH_STRINGS updates the first argument,
+ we don't have `end = i;' here. */
compute_overhangs_and_x (h, tail->x + tail->width, 0);
append_glyph_string_lists (&head, &tail, h, t);
clip_tail = tail;
if (it->descent < 0)
it->descent = 0;
-#if 0 /* this breaks image tiling */
- /* If this glyph is alone on the last line, adjust it.ascent to minimum row ascent. */
- int face_ascent = face->font ? FONT_BASE (face->font) : FRAME_BASELINE_OFFSET (it->f);
- if (face_ascent > it->ascent)
- it->ascent = it->phys_ascent = face_ascent;
-#endif
-
it->nglyphs = 1;
if (face->box != FACE_NO_BOX)
{
int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
- IT_BYTEPOS (*it));
- it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
+ it2.c = STRING_CHAR_AND_LENGTH (p, it2.len);
}
else
it2.c = *p, it2.len = 1;
later.
Note: It seems that we don't have to record multibyte_p in
- struct glyph because the character code itself tells if or
- not the character is multibyte. Thus, in the future, we must
- consider eliminating the field `multibyte_p' in the struct
- glyph. */
+ struct glyph because the character code itself tells whether
+ or not the character is multibyte. Thus, in the future, we
+ must consider eliminating the field `multibyte_p' in the
+ struct glyph. */
int saved_multibyte_p = it->multibyte_p;
/* Maybe translate single-byte characters to multibyte, or the
{
if (SINGLE_BYTE_CHAR_P (it->c)
&& unibyte_display_via_language_environment)
- it->char_to_display = unibyte_char_to_multibyte (it->c);
- if (! SINGLE_BYTE_CHAR_P (it->char_to_display))
{
+ struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
+
+ /* get_next_display_element assures that this decoding
+ never fails. */
+ it->char_to_display = DECODE_CHAR (unibyte, it->c);
it->multibyte_p = 1;
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display,
-1, Qnil);
&char2b, it->multibyte_p, 0);
font = face->font;
- /* When no suitable font found, use the default font. */
font_not_found_p = font == NULL;
if (font_not_found_p)
{
- font = FRAME_FONT (it->f);
- boff = FRAME_BASELINE_OFFSET (it->f);
+ /* When no suitable font found, display an empty box based
+ on the metrics of the font of the default face (or what
+ remapped). */
+ struct face *no_font_face
+ = FACE_FROM_ID (it->f,
+ NILP (Vface_remapping_alist) ? DEFAULT_FACE_ID
+ : lookup_basic_face (it->f, DEFAULT_FACE_ID));
+ font = no_font_face->font;
+ boff = font->baseline_offset;
}
else
{
}
else if (it->char_to_display == '\n')
{
- /* A newline has no width but we need the height of the line.
- But if previous part of the line set a height, don't
- increase that height */
+ /* A newline has no width, but we need the height of the
+ line. But if previous part of the line sets a height,
+ don't increase that height */
Lisp_Object height;
Lisp_Object total_height = Qnil;
at least one column. */
char_width = 1;
it->glyph_not_available_p = 1;
- it->pixel_width = FRAME_COLUMN_WIDTH (it->f) * char_width;
+ it->pixel_width = font->space_width * char_width;
it->phys_ascent = FONT_BASE (font) + boff;
it->phys_descent = FONT_DESCENT (font) - boff;
}
}
else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
{
- /* A static compositoin.
+ /* A static composition.
Note: A composition is represented as one glyph in the
glyph matrix. There are no padding glyphs.
- Important is that pixel_width, ascent, and descent are the
+ Important note: pixel_width, ascent, and descent are the
values of what is drawn by draw_glyphs (i.e. the values of
the overall glyphs composed). */
struct face *face = FACE_FROM_ID (it->f, it->face_id);
the composition for the current face font, calculate them
now. Theoretically, we have to check all fonts for the
glyphs, but that requires much time and memory space. So,
- here we check only the font of the first glyph. This leads
- to incorrect display, but it's very rare, and C-l (recenter)
- can correct the display anyway. */
+ here we check only the font of the first glyph. This may
+ lead to incorrect display, but it's very rare, and C-l
+ (recenter-top-bottom) can correct the display anyway. */
if (! cmp->font || cmp->font != font)
{
/* Ascent and descent of the font of the first character
of this composition (adjusted by baseline offset).
Ascent and descent of overall glyphs should not be less
- than them respectively. */
+ than these, respectively. */
int font_ascent, font_descent, font_height;
/* Bounding box of the overall glyphs. */
int leftmost, rightmost, lowest, highest;
pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
: IT_CHARPOS (*it));
- /* When no suitable font found, use the default font. */
+ /* If no suitable font is found, use the default font. */
font_not_found_p = font == NULL;
if (font_not_found_p)
{
/* EXPORT:
Clear the cursor of window W to background color, and mark the
cursor as not shown. This is used when the text where the cursor
- is is about to be rewritten. */
+ is about to be rewritten. */
void
x_clear_cursor (w)
/* Skip truncation glyphs at the start of the glyph row. */
if (row->displays_text_p)
- for (; glyph < end && INTEGERP (glyph->object); ++glyph)
+ for (; glyph < end
+ && INTEGERP (glyph->object)
+ && glyph->charpos < 0;
+ ++glyph)
x += glyph->pixel_width;
/* Scan the glyph row, stopping before BEFORE_STRING or
/* Skip truncation glyphs at the start of the row. */
if (row->displays_text_p)
- for (; glyph < end && INTEGERP (glyph->object); ++glyph)
+ for (; glyph < end
+ && INTEGERP (glyph->object)
+ && glyph->charpos < 0;
+ ++glyph)
x += glyph->pixel_width;
/* Scan the glyph row, stopping at END_CHARPOS or when we encounter
Vmessage_stack = Qnil;
staticpro (&Vmessage_stack);
- Qinhibit_redisplay = intern ("inhibit-redisplay");
+ Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
staticpro (&Qinhibit_redisplay);
message_dolog_marker1 = Fmake_marker ();
defsubr (&Sinvisible_p);
staticpro (&Qmenu_bar_update_hook);
- Qmenu_bar_update_hook = intern ("menu-bar-update-hook");
+ Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
staticpro (&Qoverriding_terminal_local_map);
- Qoverriding_terminal_local_map = intern ("overriding-terminal-local-map");
+ Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
staticpro (&Qoverriding_local_map);
- Qoverriding_local_map = intern ("overriding-local-map");
+ Qoverriding_local_map = intern_c_string ("overriding-local-map");
staticpro (&Qwindow_scroll_functions);
- Qwindow_scroll_functions = intern ("window-scroll-functions");
+ Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
staticpro (&Qwindow_text_change_functions);
- Qwindow_text_change_functions = intern ("window-text-change-functions");
+ Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
staticpro (&Qredisplay_end_trigger_functions);
- Qredisplay_end_trigger_functions = intern ("redisplay-end-trigger-functions");
+ Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
staticpro (&Qinhibit_point_motion_hooks);
- Qinhibit_point_motion_hooks = intern ("inhibit-point-motion-hooks");
+ Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
- Qeval = intern ("eval");
+ Qeval = intern_c_string ("eval");
staticpro (&Qeval);
- QCdata = intern (":data");
+ QCdata = intern_c_string (":data");
staticpro (&QCdata);
- Qdisplay = intern ("display");
+ Qdisplay = intern_c_string ("display");
staticpro (&Qdisplay);
- Qspace_width = intern ("space-width");
+ Qspace_width = intern_c_string ("space-width");
staticpro (&Qspace_width);
- Qraise = intern ("raise");
+ Qraise = intern_c_string ("raise");
staticpro (&Qraise);
- Qslice = intern ("slice");
+ Qslice = intern_c_string ("slice");
staticpro (&Qslice);
- Qspace = intern ("space");
+ Qspace = intern_c_string ("space");
staticpro (&Qspace);
- Qmargin = intern ("margin");
+ Qmargin = intern_c_string ("margin");
staticpro (&Qmargin);
- Qpointer = intern ("pointer");
+ Qpointer = intern_c_string ("pointer");
staticpro (&Qpointer);
- Qleft_margin = intern ("left-margin");
+ Qleft_margin = intern_c_string ("left-margin");
staticpro (&Qleft_margin);
- Qright_margin = intern ("right-margin");
+ Qright_margin = intern_c_string ("right-margin");
staticpro (&Qright_margin);
- Qcenter = intern ("center");
+ Qcenter = intern_c_string ("center");
staticpro (&Qcenter);
- Qline_height = intern ("line-height");
+ Qline_height = intern_c_string ("line-height");
staticpro (&Qline_height);
- QCalign_to = intern (":align-to");
+ QCalign_to = intern_c_string (":align-to");
staticpro (&QCalign_to);
- QCrelative_width = intern (":relative-width");
+ QCrelative_width = intern_c_string (":relative-width");
staticpro (&QCrelative_width);
- QCrelative_height = intern (":relative-height");
+ QCrelative_height = intern_c_string (":relative-height");
staticpro (&QCrelative_height);
- QCeval = intern (":eval");
+ QCeval = intern_c_string (":eval");
staticpro (&QCeval);
- QCpropertize = intern (":propertize");
+ QCpropertize = intern_c_string (":propertize");
staticpro (&QCpropertize);
- QCfile = intern (":file");
+ QCfile = intern_c_string (":file");
staticpro (&QCfile);
- Qfontified = intern ("fontified");
+ Qfontified = intern_c_string ("fontified");
staticpro (&Qfontified);
- Qfontification_functions = intern ("fontification-functions");
+ Qfontification_functions = intern_c_string ("fontification-functions");
staticpro (&Qfontification_functions);
- Qtrailing_whitespace = intern ("trailing-whitespace");
+ Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
staticpro (&Qtrailing_whitespace);
- Qescape_glyph = intern ("escape-glyph");
+ Qescape_glyph = intern_c_string ("escape-glyph");
staticpro (&Qescape_glyph);
- Qnobreak_space = intern ("nobreak-space");
+ Qnobreak_space = intern_c_string ("nobreak-space");
staticpro (&Qnobreak_space);
- Qimage = intern ("image");
+ Qimage = intern_c_string ("image");
staticpro (&Qimage);
- QCmap = intern (":map");
+ QCmap = intern_c_string (":map");
staticpro (&QCmap);
- QCpointer = intern (":pointer");
+ QCpointer = intern_c_string (":pointer");
staticpro (&QCpointer);
- Qrect = intern ("rect");
+ Qrect = intern_c_string ("rect");
staticpro (&Qrect);
- Qcircle = intern ("circle");
+ Qcircle = intern_c_string ("circle");
staticpro (&Qcircle);
- Qpoly = intern ("poly");
+ Qpoly = intern_c_string ("poly");
staticpro (&Qpoly);
- Qmessage_truncate_lines = intern ("message-truncate-lines");
+ Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
staticpro (&Qmessage_truncate_lines);
- Qgrow_only = intern ("grow-only");
+ Qgrow_only = intern_c_string ("grow-only");
staticpro (&Qgrow_only);
- Qinhibit_menubar_update = intern ("inhibit-menubar-update");
+ Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
staticpro (&Qinhibit_menubar_update);
- Qinhibit_eval_during_redisplay = intern ("inhibit-eval-during-redisplay");
+ Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
staticpro (&Qinhibit_eval_during_redisplay);
- Qposition = intern ("position");
+ Qposition = intern_c_string ("position");
staticpro (&Qposition);
- Qbuffer_position = intern ("buffer-position");
+ Qbuffer_position = intern_c_string ("buffer-position");
staticpro (&Qbuffer_position);
- Qobject = intern ("object");
+ Qobject = intern_c_string ("object");
staticpro (&Qobject);
- Qbar = intern ("bar");
+ Qbar = intern_c_string ("bar");
staticpro (&Qbar);
- Qhbar = intern ("hbar");
+ Qhbar = intern_c_string ("hbar");
staticpro (&Qhbar);
- Qbox = intern ("box");
+ Qbox = intern_c_string ("box");
staticpro (&Qbox);
- Qhollow = intern ("hollow");
+ Qhollow = intern_c_string ("hollow");
staticpro (&Qhollow);
- Qhand = intern ("hand");
+ Qhand = intern_c_string ("hand");
staticpro (&Qhand);
- Qarrow = intern ("arrow");
+ Qarrow = intern_c_string ("arrow");
staticpro (&Qarrow);
- Qtext = intern ("text");
+ Qtext = intern_c_string ("text");
staticpro (&Qtext);
- Qrisky_local_variable = intern ("risky-local-variable");
+ Qrisky_local_variable = intern_c_string ("risky-local-variable");
staticpro (&Qrisky_local_variable);
- Qinhibit_free_realized_faces = intern ("inhibit-free-realized-faces");
+ Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
staticpro (&Qinhibit_free_realized_faces);
- list_of_error = Fcons (Fcons (intern ("error"),
- Fcons (intern ("void-variable"), Qnil)),
+ list_of_error = Fcons (Fcons (intern_c_string ("error"),
+ Fcons (intern_c_string ("void-variable"), Qnil)),
Qnil);
staticpro (&list_of_error);
- Qlast_arrow_position = intern ("last-arrow-position");
+ Qlast_arrow_position = intern_c_string ("last-arrow-position");
staticpro (&Qlast_arrow_position);
- Qlast_arrow_string = intern ("last-arrow-string");
+ Qlast_arrow_string = intern_c_string ("last-arrow-string");
staticpro (&Qlast_arrow_string);
- Qoverlay_arrow_string = intern ("overlay-arrow-string");
+ Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
staticpro (&Qoverlay_arrow_string);
- Qoverlay_arrow_bitmap = intern ("overlay-arrow-bitmap");
+ Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
staticpro (&Qoverlay_arrow_bitmap);
echo_buffer[0] = echo_buffer[1] = Qnil;
staticpro (&echo_area_buffer[0]);
staticpro (&echo_area_buffer[1]);
- Vmessages_buffer_name = build_string ("*Messages*");
+ Vmessages_buffer_name = make_pure_c_string ("*Messages*");
staticpro (&Vmessages_buffer_name);
mode_line_proptrans_alist = Qnil;
DEFVAR_LISP ("overlay-arrow-string", &Voverlay_arrow_string,
doc: /* String to display as an arrow in non-window frames.
See also `overlay-arrow-position'. */);
- Voverlay_arrow_string = build_string ("=>");
+ Voverlay_arrow_string = make_pure_c_string ("=>");
DEFVAR_LISP ("overlay-arrow-variable-list", &Voverlay_arrow_variable_list,
doc: /* List of variables (symbols) which hold markers for overlay arrows.
The symbols on this list are examined during redisplay to determine
where to display overlay arrows. */);
Voverlay_arrow_variable_list
- = Fcons (intern ("overlay-arrow-position"), Qnil);
+ = Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
DEFVAR_INT ("scroll-step", &scroll_step,
doc: /* *The number of lines to try scrolling a window by when point moves out.
DEFVAR_LISP ("truncate-partial-width-windows",
&Vtruncate_partial_width_windows,
- doc: /* Non-nil means truncate lines in windows with less than the frame width.
-For an integer value, truncate lines in each window with less than the
+ doc: /* Non-nil means truncate lines in windows narrower than the frame.
+For an integer value, truncate lines in each window narrower than the
full frame width, provided the window width is less than that integer;
otherwise, respect the value of `truncate-lines'.
-For any other non-nil value, truncate lines in all windows with
-less than the full frame width.
+For any other non-nil value, truncate lines in all windows that do
+not span the full frame width.
A value of nil means to respect the value of `truncate-lines'.
\(see `modify-frame-parameters'). */);
Vicon_title_format
= Vframe_title_format
- = Fcons (intern ("multiple-frames"),
- Fcons (build_string ("%b"),
- Fcons (Fcons (empty_unibyte_string,
- Fcons (intern ("invocation-name"),
- Fcons (build_string ("@"),
- Fcons (intern ("system-name"),
- Qnil)))),
- Qnil)));
+ = pure_cons (intern_c_string ("multiple-frames"),
+ pure_cons (make_pure_c_string ("%b"),
+ pure_cons (pure_cons (empty_unibyte_string,
+ pure_cons (intern_c_string ("invocation-name"),
+ pure_cons (make_pure_c_string ("@"),
+ pure_cons (intern_c_string ("system-name"),
+ Qnil)))),
+ Qnil)));
DEFVAR_LISP ("message-log-max", &Vmessage_log_max,
doc: /* Maximum number of lines to keep in the message log buffer.
DEFVAR_BOOL ("unibyte-display-via-language-environment",
&unibyte_display_via_language_environment,
doc: /* *Non-nil means display unibyte text according to language environment.
-Specifically this means that unibyte non-ASCII characters
+Specifically, this means that raw bytes in the range 160-255 decimal
are displayed by converting them to the equivalent multibyte characters
according to the current language environment. As a result, they are
-displayed according to the current fontset. */);
+displayed according to the current fontset.
+
+Note that this variable affects only how these bytes are displayed,
+but does not change the fact they are interpreted as raw bytes. */);
unibyte_display_via_language_environment = 0;
DEFVAR_LISP ("max-mini-window-height", &Vmax_mini_window_height,
DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p,
doc: /* *Non-nil means scroll the display automatically to make point visible. */);
automatic_hscrolling_p = 1;
- Qauto_hscroll_mode = intern ("auto-hscroll-mode");
+ Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
staticpro (&Qauto_hscroll_mode);
DEFVAR_INT ("hscroll-margin", &hscroll_margin,
To add a prefix to non-continuation lines, use `line-prefix'. */);
Vwrap_prefix = Qnil;
staticpro (&Qwrap_prefix);
- Qwrap_prefix = intern ("wrap-prefix");
+ Qwrap_prefix = intern_c_string ("wrap-prefix");
Fmake_variable_buffer_local (Qwrap_prefix);
DEFVAR_LISP ("line-prefix", &Vline_prefix,
To add a prefix to continuation lines, use `wrap-prefix'. */);
Vline_prefix = Qnil;
staticpro (&Qline_prefix);
- Qline_prefix = intern ("line-prefix");
+ Qline_prefix = intern_c_string ("line-prefix");
Fmake_variable_buffer_local (Qline_prefix);
DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay,