X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/eceeb5fca618f3bc0743c2388148dd758229c7c9..e5560ff7d28c684003ed598a9390e17f9fb92d34:/src/xdisp.c diff --git a/src/xdisp.c b/src/xdisp.c index da44281a55..cd5f03d34a 100644 --- a/src/xdisp.c +++ b/src/xdisp.c @@ -1,6 +1,6 @@ /* Display generation from window structure and buffer text. -Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc. +Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -281,8 +281,8 @@ along with GNU Emacs. If not, see . */ #include "window.h" #include "termchar.h" #include "dispextern.h" -#include "buffer.h" #include "character.h" +#include "buffer.h" #include "charset.h" #include "indent.h" #include "commands.h" @@ -751,6 +751,7 @@ static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 }; int redisplaying_p; static Lisp_Object Qinhibit_free_realized_faces; +static Lisp_Object Qmode_line_default_help_echo; /* If a string, XTread_socket generates an event to display that string. (The display is done in read_char.) */ @@ -758,7 +759,7 @@ static Lisp_Object Qinhibit_free_realized_faces; Lisp_Object help_echo_string; Lisp_Object help_echo_window; Lisp_Object help_echo_object; -EMACS_INT help_echo_pos; +ptrdiff_t help_echo_pos; /* Temporary variable for XTread_socket. */ @@ -805,33 +806,33 @@ static Lisp_Object get_it_property (struct it *it, Lisp_Object prop); static void handle_line_prefix (struct it *); -static void pint2str (char *, int, EMACS_INT); -static void pint2hrstr (char *, int, EMACS_INT); +static void pint2str (char *, int, ptrdiff_t); +static void pint2hrstr (char *, int, ptrdiff_t); static struct text_pos run_window_scroll_functions (Lisp_Object, struct text_pos); static void reconsider_clip_changes (struct window *, struct buffer *); static int text_outside_line_unchanged_p (struct window *, - EMACS_INT, EMACS_INT); + ptrdiff_t, ptrdiff_t); static void store_mode_line_noprop_char (char); static int store_mode_line_noprop (const char *, int, int); static void handle_stop (struct it *); -static void handle_stop_backwards (struct it *, EMACS_INT); +static void handle_stop_backwards (struct it *, ptrdiff_t); static void vmessage (const char *, va_list) ATTRIBUTE_FORMAT_PRINTF (1, 0); static void ensure_echo_area_buffers (void); static Lisp_Object unwind_with_echo_area_buffer (Lisp_Object); static Lisp_Object with_echo_area_buffer_unwind_data (struct window *); static int with_echo_area_buffer (struct window *, int, - int (*) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT), - EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); + int (*) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t), + ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); static void clear_garbaged_frames (void); -static int current_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); +static int current_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); static void pop_message (void); -static int truncate_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); -static void set_message (const char *, Lisp_Object, EMACS_INT, int); -static int set_message_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); +static int truncate_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); +static void set_message (const char *, Lisp_Object, ptrdiff_t, int); +static int set_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); static int display_echo_area (struct window *); -static int display_echo_area_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); -static int resize_mini_window_1 (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT); +static int display_echo_area_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); +static int resize_mini_window_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t); static Lisp_Object unwind_redisplay (Lisp_Object); static int string_char_and_length (const unsigned char *, int *); static struct text_pos display_prop_end (struct it *, Lisp_Object, @@ -844,11 +845,12 @@ static struct glyph_row *get_overlay_arrow_glyph_row (struct window *, static void extend_face_to_end_of_line (struct it *); static int append_space_for_newline (struct it *, int); static int cursor_row_fully_visible_p (struct window *, int, int); -static int try_scrolling (Lisp_Object, int, EMACS_INT, EMACS_INT, int, int); +static int try_scrolling (Lisp_Object, int, ptrdiff_t, ptrdiff_t, int, int); static int try_cursor_movement (Lisp_Object, struct text_pos, int *); -static int trailing_whitespace_p (EMACS_INT); -static intmax_t message_log_check_duplicate (EMACS_INT, EMACS_INT); +static int trailing_whitespace_p (ptrdiff_t); +static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t); static void push_it (struct it *, struct text_pos *); +static void iterate_out_of_display_property (struct it *); static void pop_it (struct it *); static void sync_frame_with_window_matrix_rows (struct window *); static void select_frame_for_redisplay (Lisp_Object); @@ -860,7 +862,7 @@ static Lisp_Object redisplay_window_error (Lisp_Object); static Lisp_Object redisplay_window_0 (Lisp_Object); static Lisp_Object redisplay_window_1 (Lisp_Object); static int set_cursor_from_row (struct window *, struct glyph_row *, - struct glyph_matrix *, EMACS_INT, EMACS_INT, + struct glyph_matrix *, ptrdiff_t, ptrdiff_t, int, int); static int update_menu_bar (struct frame *, int, int); static int try_window_reusing_current_matrix (struct window *); @@ -872,14 +874,14 @@ static int display_mode_element (struct it *, int, int, int, Lisp_Object, Lisp_O static int store_mode_line_string (const char *, Lisp_Object, int, int, int, Lisp_Object); static const char *decode_mode_spec (struct window *, int, int, Lisp_Object *); static void display_menu_bar (struct window *); -static EMACS_INT display_count_lines (EMACS_INT, EMACS_INT, EMACS_INT, - EMACS_INT *); +static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t, + ptrdiff_t *); static int display_string (const char *, Lisp_Object, Lisp_Object, - EMACS_INT, EMACS_INT, struct it *, int, int, int, int); + ptrdiff_t, ptrdiff_t, struct it *, int, int, int, int); static void compute_line_metrics (struct it *); static void run_redisplay_end_trigger_hook (struct it *); -static int get_overlay_strings (struct it *, EMACS_INT); -static int get_overlay_strings_1 (struct it *, EMACS_INT, int); +static int get_overlay_strings (struct it *, ptrdiff_t); +static int get_overlay_strings_1 (struct it *, ptrdiff_t, int); static void next_overlay_string (struct it *); static void reseat (struct it *, struct text_pos, int); static void reseat_1 (struct it *, struct text_pos, int); @@ -894,14 +896,14 @@ static int next_element_from_buffer (struct it *); static int next_element_from_composition (struct it *); static int next_element_from_image (struct it *); static int next_element_from_stretch (struct it *); -static void load_overlay_strings (struct it *, EMACS_INT); +static void load_overlay_strings (struct it *, ptrdiff_t); static int init_from_display_pos (struct it *, struct window *, struct display_pos *); static void reseat_to_string (struct it *, const char *, - Lisp_Object, EMACS_INT, EMACS_INT, int, int); + Lisp_Object, ptrdiff_t, ptrdiff_t, int, int); static int get_next_display_element (struct it *); static enum move_it_result - move_it_in_display_line_to (struct it *, EMACS_INT, int, + move_it_in_display_line_to (struct it *, ptrdiff_t, int, enum move_operation_enum); void move_it_vertically_backward (struct it *, int); static void init_to_row_start (struct it *, struct window *, @@ -911,20 +913,20 @@ static int init_to_row_end (struct it *, struct window *, static void back_to_previous_line_start (struct it *); static int forward_to_next_line_start (struct it *, int *, struct bidi_it *); static struct text_pos string_pos_nchars_ahead (struct text_pos, - Lisp_Object, EMACS_INT); -static struct text_pos string_pos (EMACS_INT, Lisp_Object); -static struct text_pos c_string_pos (EMACS_INT, const char *, int); -static EMACS_INT number_of_chars (const char *, int); + Lisp_Object, ptrdiff_t); +static struct text_pos string_pos (ptrdiff_t, Lisp_Object); +static struct text_pos c_string_pos (ptrdiff_t, const char *, int); +static ptrdiff_t number_of_chars (const char *, int); static void compute_stop_pos (struct it *); static void compute_string_pos (struct text_pos *, struct text_pos, Lisp_Object); static int face_before_or_after_it_pos (struct it *, int); -static EMACS_INT next_overlay_change (EMACS_INT); +static ptrdiff_t next_overlay_change (ptrdiff_t); static int handle_display_spec (struct it *, Lisp_Object, Lisp_Object, - Lisp_Object, struct text_pos *, EMACS_INT, int); + Lisp_Object, struct text_pos *, ptrdiff_t, int); static int handle_single_display_spec (struct it *, Lisp_Object, Lisp_Object, Lisp_Object, - struct text_pos *, EMACS_INT, int, int); + struct text_pos *, ptrdiff_t, int, int); static int underlying_face_id (struct it *); static int in_ellipses_for_invisible_text_p (struct display_pos *, struct window *); @@ -1256,7 +1258,7 @@ string_from_display_spec (Lisp_Object spec) Set *ROWH and *VPOS to row's visible height and VPOS (row number). */ int -pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y, +pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y, int *rtop, int *rbot, int *rowh, int *vpos) { struct it it; @@ -1313,8 +1315,8 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y, glyph. */ 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, it.position, etc. */ + enum it_method it_method = it.method; int bottom_y = (last_height = 0, line_bottom_y (&it)); int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w); @@ -1322,6 +1324,31 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y, visible_p = bottom_y > window_top_y; else if (top_y < it.last_visible_y) visible_p = 1; + if (bottom_y >= it.last_visible_y + && it.bidi_p && it.bidi_it.scan_dir == -1 + && IT_CHARPOS (it) < charpos) + { + /* When the last line of the window is scanned backwards + under bidi iteration, we could be duped into thinking + that we have passed CHARPOS, when in fact move_it_to + simply stopped short of CHARPOS because it reached + last_visible_y. To see if that's what happened, we call + move_it_to again with a slightly larger vertical limit, + and see if it actually moved vertically; if it did, we + didn't really reach CHARPOS, which is beyond window end. */ + struct it save_it = it; + /* Why 10? because we don't know how many canonical lines + will the height of the next line(s) be. So we guess. */ + int ten_more_lines = + 10 * FRAME_LINE_HEIGHT (XFRAME (WINDOW_FRAME (w))); + + move_it_to (&it, charpos, -1, bottom_y + ten_more_lines, -1, + MOVE_TO_POS | MOVE_TO_Y); + if (it.current_y > top_y) + visible_p = 0; + + it = save_it; + } if (visible_p) { if (it_method == GET_FROM_DISPLAY_VECTOR) @@ -1577,7 +1604,7 @@ string_char_and_length (const unsigned char *str, int *len) in STRING, return the position NCHARS ahead (NCHARS >= 0). */ static struct text_pos -string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, EMACS_INT nchars) +string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, ptrdiff_t nchars) { xassert (STRINGP (string) && nchars >= 0); @@ -1605,7 +1632,7 @@ string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, EMACS_INT ncha for character position CHARPOS in STRING. */ static inline struct text_pos -string_pos (EMACS_INT charpos, Lisp_Object string) +string_pos (ptrdiff_t charpos, Lisp_Object string) { struct text_pos pos; xassert (STRINGP (string)); @@ -1620,7 +1647,7 @@ string_pos (EMACS_INT charpos, Lisp_Object string) means recognize multibyte characters. */ static struct text_pos -c_string_pos (EMACS_INT charpos, const char *s, int multibyte_p) +c_string_pos (ptrdiff_t charpos, const char *s, int multibyte_p) { struct text_pos pos; @@ -1650,14 +1677,14 @@ c_string_pos (EMACS_INT charpos, const char *s, int multibyte_p) /* Value is the number of characters in C string S. MULTIBYTE_P non-zero means recognize multibyte characters. */ -static EMACS_INT +static ptrdiff_t number_of_chars (const char *s, int multibyte_p) { - EMACS_INT nchars; + ptrdiff_t nchars; if (multibyte_p) { - EMACS_INT rest = strlen (s); + ptrdiff_t rest = strlen (s); int len; const unsigned char *p = (const unsigned char *) s; @@ -2373,7 +2400,7 @@ safe_call (ptrdiff_t nargs, Lisp_Object *args) val = Qnil; else { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); struct gcpro gcpro1; GCPRO1 (args[0]); @@ -2523,7 +2550,7 @@ check_window_end (struct window *w) void init_iterator (struct it *it, struct window *w, - EMACS_INT charpos, EMACS_INT bytepos, + ptrdiff_t charpos, ptrdiff_t bytepos, struct glyph_row *row, enum face_id base_face_id) { int highlight_region_p; @@ -2614,7 +2641,9 @@ init_iterator (struct it *it, struct window *w, is invisible. >0 means lines indented more than this value are invisible. */ it->selective = (INTEGERP (BVAR (current_buffer, selective_display)) - ? XINT (BVAR (current_buffer, selective_display)) + ? clip_to_bounds (-1, XINT (BVAR (current_buffer, + selective_display)), + PTRDIFF_MAX) : (!NILP (BVAR (current_buffer, selective_display)) ? -1 : 0)); it->selective_display_ellipsis_p @@ -2647,7 +2676,7 @@ init_iterator (struct it *it, struct window *w, && WINDOWP (minibuf_selected_window) && w == XWINDOW (minibuf_selected_window)))) { - EMACS_INT markpos = marker_position (BVAR (current_buffer, mark)); + ptrdiff_t markpos = marker_position (BVAR (current_buffer, mark)); it->region_beg_charpos = min (PT, markpos); it->region_end_charpos = max (PT, markpos); } @@ -2661,7 +2690,8 @@ init_iterator (struct it *it, struct window *w, it->redisplay_end_trigger_charpos = marker_position (w->redisplay_end_trigger); else if (INTEGERP (w->redisplay_end_trigger)) - it->redisplay_end_trigger_charpos = XINT (w->redisplay_end_trigger); + it->redisplay_end_trigger_charpos = + clip_to_bounds (PTRDIFF_MIN, XINT (w->redisplay_end_trigger), PTRDIFF_MAX); it->tab_width = SANE_TAB_WIDTH (current_buffer); @@ -2921,7 +2951,7 @@ in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w) { Lisp_Object prop, window; int ellipses_p = 0; - EMACS_INT charpos = CHARPOS (pos->pos); + ptrdiff_t charpos = CHARPOS (pos->pos); /* If POS specifies a position in a display vector, this might be for an ellipsis displayed for invisible text. We won't @@ -2953,7 +2983,7 @@ in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w) static int init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos) { - EMACS_INT charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos); + ptrdiff_t charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos); int i, overlay_strings_with_newlines = 0; /* If POS specifies a position in a display vector, this might @@ -3013,7 +3043,7 @@ init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos) pos->overlay_string_index is in IT->overlay_strings. */ if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE) { - int n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE; + ptrdiff_t n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE; it->current.overlay_string_index = 0; while (n--) { @@ -3135,7 +3165,15 @@ handle_stop (struct it *it) overlays even if the actual buffer text is replaced. */ if (!handle_overlay_change_p || it->sp > 1 - || !get_overlay_strings_1 (it, 0, 0)) + /* Don't call get_overlay_strings_1 if we already + have overlay strings loaded, because doing so + will load them again and push the iterator state + onto the stack one more time, which is not + expected by the rest of the code that processes + overlay strings. */ + || (it->current.overlay_string_index < 0 + ? !get_overlay_strings_1 (it, 0, 0) + : 0)) { if (it->ellipsis_p) setup_for_ellipsis (it, 0); @@ -3200,7 +3238,7 @@ compute_stop_pos (struct it *it) { register INTERVAL iv, next_iv; Lisp_Object object, limit, position; - EMACS_INT charpos, bytepos; + ptrdiff_t charpos, bytepos; if (STRINGP (it->string)) { @@ -3214,7 +3252,7 @@ compute_stop_pos (struct it *it) } else { - EMACS_INT pos; + ptrdiff_t pos; /* If end_charpos is out of range for some reason, such as a misbehaving display function, rationalize it (Bug#5984). */ @@ -3296,7 +3334,7 @@ compute_stop_pos (struct it *it) if (it->cmp_it.id < 0) { - EMACS_INT stoppos = it->end_charpos; + ptrdiff_t stoppos = it->end_charpos; if (it->bidi_p && it->bidi_it.scan_dir < 0) stoppos = -1; @@ -3315,11 +3353,11 @@ compute_stop_pos (struct it *it) follows. This is like `next-overlay-change' but doesn't use xmalloc. */ -static EMACS_INT -next_overlay_change (EMACS_INT pos) +static ptrdiff_t +next_overlay_change (ptrdiff_t pos) { ptrdiff_t i, noverlays; - EMACS_INT endpos; + ptrdiff_t endpos; Lisp_Object *overlays; /* Get all overlays at the given position. */ @@ -3330,7 +3368,7 @@ next_overlay_change (EMACS_INT pos) for (i = 0; i < noverlays; ++i) { Lisp_Object oend; - EMACS_INT oendpos; + ptrdiff_t oendpos; oend = OVERLAY_END (overlays[i]); oendpos = OVERLAY_POSITION (oend); @@ -3357,7 +3395,7 @@ next_overlay_change (EMACS_INT pos) strings, non-zero otherwise. It is set to 2 if the display string uses any kind of `(space ...)' spec that will produce a stretch of white space in the text area. */ -EMACS_INT +ptrdiff_t compute_display_string_pos (struct text_pos *position, struct bidi_string_data *string, int frame_window_p, int *disp_prop) @@ -3367,10 +3405,10 @@ compute_display_string_pos (struct text_pos *position, (string && STRINGP (string->lstring)) ? string->lstring : Qnil; Lisp_Object pos, spec, limpos; int string_p = (string && (STRINGP (string->lstring) || string->s)); - EMACS_INT eob = string_p ? string->schars : ZV; - EMACS_INT begb = string_p ? 0 : BEGV; - EMACS_INT bufpos, charpos = CHARPOS (*position); - EMACS_INT lim = + ptrdiff_t eob = string_p ? string->schars : ZV; + ptrdiff_t begb = string_p ? 0 : BEGV; + ptrdiff_t bufpos, charpos = CHARPOS (*position); + ptrdiff_t lim = (charpos < eob - MAX_DISP_SCAN) ? charpos + MAX_DISP_SCAN : eob; struct text_pos tpos; int rv = 0; @@ -3441,14 +3479,14 @@ compute_display_string_pos (struct text_pos *position, return -1. A display string is either an overlay with `display' property whose value is a string or a `display' text property whose value is a string. */ -EMACS_INT -compute_display_string_end (EMACS_INT charpos, struct bidi_string_data *string) +ptrdiff_t +compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string) { /* OBJECT = nil means current buffer. */ Lisp_Object object = (string && STRINGP (string->lstring)) ? string->lstring : Qnil; Lisp_Object pos = make_number (charpos); - EMACS_INT eob = + ptrdiff_t eob = (STRINGP (object) || (string && string->s)) ? string->schars : ZV; if (charpos >= eob || (string->s && !STRINGP (object))) @@ -3511,7 +3549,7 @@ handle_fontified_prop (struct it *it) no amount of fontifying will be able to change it. */ NILP (prop) && IT_CHARPOS (*it) < Z)) { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); Lisp_Object val; struct buffer *obuf = current_buffer; int begv = BEGV, zv = ZV; @@ -3608,7 +3646,7 @@ static enum prop_handled handle_face_prop (struct it *it) { int new_face_id; - EMACS_INT next_stop; + ptrdiff_t next_stop; if (!STRINGP (it->string)) { @@ -3649,11 +3687,12 @@ handle_face_prop (struct it *it) else { int base_face_id; - EMACS_INT bufpos; + ptrdiff_t bufpos; int i; Lisp_Object from_overlay = (it->current.overlay_string_index >= 0 - ? it->string_overlays[it->current.overlay_string_index] + ? it->string_overlays[it->current.overlay_string_index + % OVERLAY_STRING_CHUNK_SIZE] : Qnil); /* See if we got to this string directly or indirectly from @@ -3667,7 +3706,8 @@ handle_face_prop (struct it *it) { if (it->stack[i].current.overlay_string_index >= 0) from_overlay - = it->string_overlays[it->stack[i].current.overlay_string_index]; + = it->string_overlays[it->stack[i].current.overlay_string_index + % OVERLAY_STRING_CHUNK_SIZE]; else if (! NILP (it->stack[i].from_overlay)) from_overlay = it->stack[i].from_overlay; @@ -3769,7 +3809,7 @@ static int face_before_or_after_it_pos (struct it *it, int before_p) { int face_id, limit; - EMACS_INT next_check_charpos; + ptrdiff_t next_check_charpos; struct it it_copy; void *it_copy_data = NULL; @@ -3777,7 +3817,7 @@ face_before_or_after_it_pos (struct it *it, int before_p) if (STRINGP (it->string)) { - EMACS_INT bufpos, charpos; + ptrdiff_t bufpos, charpos; int base_face_id; /* No face change past the end of the string (for the case @@ -3990,7 +4030,7 @@ handle_invisible_prop (struct it *it) if (!NILP (prop) && IT_STRING_CHARPOS (*it) < it->end_charpos) { - EMACS_INT endpos; + ptrdiff_t endpos; handled = HANDLED_RECOMPUTE_PROPS; @@ -4009,7 +4049,7 @@ handle_invisible_prop (struct it *it) && (endpos = XFASTINT (end_charpos)) < XFASTINT (limit)) { struct text_pos old; - EMACS_INT oldpos; + ptrdiff_t oldpos; old = it->current.string_pos; oldpos = CHARPOS (old); @@ -4061,7 +4101,7 @@ handle_invisible_prop (struct it *it) else { int invis_p; - EMACS_INT newpos, next_stop, start_charpos, tem; + ptrdiff_t newpos, next_stop, start_charpos, tem; Lisp_Object pos, prop, overlay; /* First of all, is there invisible text at this position? */ @@ -4124,7 +4164,7 @@ handle_invisible_prop (struct it *it) /* The position newpos is now either ZV or on visible text. */ if (it->bidi_p) { - EMACS_INT bpos = CHAR_TO_BYTE (newpos); + ptrdiff_t bpos = CHAR_TO_BYTE (newpos); int on_newline = bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n'; int after_newline = @@ -4300,7 +4340,7 @@ handle_display_prop (struct it *it) { Lisp_Object propval, object, overlay; struct text_pos *position; - EMACS_INT bufpos; + ptrdiff_t bufpos; /* Nonzero if some property replaces the display of the text itself. */ int display_replaced_p = 0; @@ -4365,7 +4405,7 @@ handle_display_prop (struct it *it) static int handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, Lisp_Object overlay, struct text_pos *position, - EMACS_INT bufpos, int frame_window_p) + ptrdiff_t bufpos, int frame_window_p) { int replacing_p = 0; int rv; @@ -4401,7 +4441,7 @@ handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, } else if (VECTORP (spec)) { - int i; + ptrdiff_t i; for (i = 0; i < ASIZE (spec); ++i) if ((rv = handle_single_display_spec (it, AREF (spec, i), object, overlay, position, bufpos, @@ -4472,7 +4512,7 @@ display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos) static int handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, Lisp_Object overlay, struct text_pos *position, - EMACS_INT bufpos, int display_replaced_p, + ptrdiff_t bufpos, int display_replaced_p, int frame_window_p) { Lisp_Object form; @@ -4494,7 +4534,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, if (!NILP (form) && !EQ (form, Qt)) { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); struct gcpro gcpro1; /* Bind `object' to the object having the `display' property, a @@ -4536,7 +4576,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, && (EQ (XCAR (it->font_height), Qplus) || EQ (XCAR (it->font_height), Qminus)) && CONSP (XCDR (it->font_height)) - && INTEGERP (XCAR (XCDR (it->font_height)))) + && RANGED_INTEGERP (0, XCAR (XCDR (it->font_height)), INT_MAX)) { /* `(+ N)' or `(- N)' where N is an integer. */ int steps = XINT (XCAR (XCDR (it->font_height))); @@ -4568,7 +4608,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, { /* Evaluate IT->font_height with `height' bound to the current specified height to get the new height. */ - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]); value = safe_eval (it->font_height); @@ -4691,10 +4731,22 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, if (!FRAME_WINDOW_P (it->f)) /* If we return here, POSITION has been advanced across the text with this property. */ - return 0; + { + /* Synchronize the bidi iterator with POSITION. This is + needed because we are not going to push the iterator + on behalf of this display property, so there will be + no pop_it call to do this synchronization for us. */ + if (it->bidi_p) + { + it->position = *position; + iterate_out_of_display_property (it); + *position = it->position; + } + return 1; + } } else if (!frame_window_p) - return 0; + return 1; #ifdef HAVE_WINDOW_SYSTEM value = XCAR (XCDR (spec)); @@ -4702,7 +4754,15 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, || !(fringe_bitmap = lookup_fringe_bitmap (value))) /* If we return here, POSITION has been advanced across the text with this property. */ - return 0; + { + if (it && it->bidi_p) + { + it->position = *position; + iterate_out_of_display_property (it); + *position = it->position; + } + return 1; + } if (it) { @@ -4897,7 +4957,7 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object, int display_prop_intangible_p (Lisp_Object prop, Lisp_Object overlay, - EMACS_INT charpos, EMACS_INT bytepos) + ptrdiff_t charpos, ptrdiff_t bytepos) { int frame_window_p = FRAME_WINDOW_P (XFRAME (selected_frame)); struct text_pos position; @@ -4978,7 +5038,7 @@ display_prop_string_p (Lisp_Object prop, Lisp_Object string) else if (VECTORP (prop)) { /* A vector of sub-properties. */ - int i; + ptrdiff_t i; for (i = 0; i < ASIZE (prop); ++i) if (single_display_spec_string_p (AREF (prop, i), string)) return 1; @@ -4999,9 +5059,9 @@ display_prop_string_p (Lisp_Object prop, Lisp_Object string) This function may only use code that doesn't eval because it is called asynchronously from note_mouse_highlight. */ -static EMACS_INT +static ptrdiff_t string_buffer_position_lim (Lisp_Object string, - EMACS_INT from, EMACS_INT to, int back_p) + ptrdiff_t from, ptrdiff_t to, int back_p) { Lisp_Object limit, prop, pos; int found = 0; @@ -5047,11 +5107,11 @@ string_buffer_position_lim (Lisp_Object string, This function may only use code that doesn't eval because it is called asynchronously from note_mouse_highlight. */ -static EMACS_INT -string_buffer_position (Lisp_Object string, EMACS_INT around_charpos) +static ptrdiff_t +string_buffer_position (Lisp_Object string, ptrdiff_t around_charpos) { const int MAX_DISTANCE = 1000; - EMACS_INT found = string_buffer_position_lim (string, around_charpos, + ptrdiff_t found = string_buffer_position_lim (string, around_charpos, around_charpos + MAX_DISTANCE, 0); @@ -5074,7 +5134,7 @@ static enum prop_handled handle_composition_prop (struct it *it) { Lisp_Object prop, string; - EMACS_INT pos, pos_byte, start, end; + ptrdiff_t pos, pos_byte, start, end; if (STRINGP (it->string)) { @@ -5140,7 +5200,7 @@ struct overlay_entry { Lisp_Object overlay; Lisp_Object string; - int priority; + EMACS_INT priority; int after_string_p; }; @@ -5272,12 +5332,17 @@ compare_overlay_entries (const void *e1, const void *e2) else result = entry1->after_string_p ? -1 : 1; } - else if (entry1->after_string_p) - /* After-strings sorted in order of decreasing priority. */ - result = entry2->priority - entry1->priority; + else if (entry1->priority != entry2->priority) + { + if (entry1->after_string_p) + /* After-strings sorted in order of decreasing priority. */ + result = entry2->priority < entry1->priority ? -1 : 1; + else + /* Before-strings sorted in order of increasing priority. */ + result = entry1->priority < entry2->priority ? -1 : 1; + } else - /* Before-strings sorted in order of increasing priority. */ - result = entry1->priority - entry2->priority; + result = 0; return result; } @@ -5308,15 +5373,17 @@ compare_overlay_entries (const void *e1, const void *e2) compare_overlay_entries. */ static void -load_overlay_strings (struct it *it, EMACS_INT charpos) +load_overlay_strings (struct it *it, ptrdiff_t charpos) { Lisp_Object overlay, window, str, invisible; struct Lisp_Overlay *ov; - EMACS_INT start, end; - int size = 20; - int n = 0, i, j, invis_p; + ptrdiff_t start, end; + ptrdiff_t size = 20; + ptrdiff_t n = 0, i, j; + int invis_p; struct overlay_entry *entries = (struct overlay_entry *) alloca (size * sizeof *entries); + USE_SAFE_ALLOCA; if (charpos <= 0) charpos = IT_CHARPOS (*it); @@ -5332,13 +5399,10 @@ load_overlay_strings (struct it *it, EMACS_INT charpos) \ if (n == size) \ { \ - int new_size = 2 * size; \ struct overlay_entry *old = entries; \ - entries = \ - (struct overlay_entry *) alloca (new_size \ - * sizeof *entries); \ + SAFE_NALLOCA (entries, 2, size); \ memcpy (entries, old, size * sizeof *entries); \ - size = new_size; \ + size *= 2; \ } \ \ entries[n].string = (STRING); \ @@ -5451,6 +5515,7 @@ load_overlay_strings (struct it *it, EMACS_INT charpos) } CHECK_IT (it); + SAFE_FREE (); } @@ -5459,7 +5524,7 @@ load_overlay_strings (struct it *it, EMACS_INT charpos) least one overlay string was found. */ static int -get_overlay_strings_1 (struct it *it, EMACS_INT charpos, int compute_stop_p) +get_overlay_strings_1 (struct it *it, ptrdiff_t charpos, int compute_stop_p) { /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to process. This fills IT->overlay_strings with strings, and sets @@ -5523,7 +5588,7 @@ get_overlay_strings_1 (struct it *it, EMACS_INT charpos, int compute_stop_p) /* Set up the bidi iterator for this overlay string. */ if (it->bidi_p) { - EMACS_INT pos = (charpos > 0 ? charpos : IT_CHARPOS (*it)); + ptrdiff_t pos = (charpos > 0 ? charpos : IT_CHARPOS (*it)); it->bidi_it.string.lstring = it->string; it->bidi_it.string.s = NULL; @@ -5541,7 +5606,7 @@ get_overlay_strings_1 (struct it *it, EMACS_INT charpos, int compute_stop_p) } static int -get_overlay_strings (struct it *it, EMACS_INT charpos) +get_overlay_strings (struct it *it, ptrdiff_t charpos) { it->string = Qnil; it->method = GET_FROM_BUFFER; @@ -5621,9 +5686,9 @@ push_it (struct it *it, struct text_pos *position) static void iterate_out_of_display_property (struct it *it) { - int buffer_p = BUFFERP (it->object); - EMACS_INT eob = (buffer_p ? ZV : it->end_charpos); - EMACS_INT bob = (buffer_p ? BEGV : 0); + int buffer_p = !STRINGP (it->string); + ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos); + ptrdiff_t bob = (buffer_p ? BEGV : 0); xassert (eob >= CHARPOS (it->position) && CHARPOS (it->position) >= bob); @@ -5785,7 +5850,7 @@ static int forward_to_next_line_start (struct it *it, int *skipped_p, struct bidi_it *bidi_it_prev) { - EMACS_INT old_selective; + ptrdiff_t old_selective; int newline_found_p, n; const int MAX_NEWLINE_DISTANCE = 500; @@ -5827,8 +5892,8 @@ forward_to_next_line_start (struct it *it, int *skipped_p, short-cut. */ if (!newline_found_p) { - EMACS_INT start = IT_CHARPOS (*it); - EMACS_INT limit = find_next_newline_no_quit (start, 1); + ptrdiff_t start = IT_CHARPOS (*it); + ptrdiff_t limit = find_next_newline_no_quit (start, 1); Lisp_Object pos; xassert (!STRINGP (it->string)); @@ -5926,8 +5991,8 @@ back_to_previous_visible_line_start (struct it *it) { struct it it2; void *it2data = NULL; - EMACS_INT pos; - EMACS_INT beg, end; + ptrdiff_t pos; + ptrdiff_t beg, end; Lisp_Object val, overlay; SAVE_IT (it2, *it, it2data); @@ -6080,7 +6145,7 @@ reseat_at_next_visible_line_start (struct it *it, int on_newline_p) static void reseat (struct it *it, struct text_pos pos, int force_p) { - EMACS_INT original_pos = IT_CHARPOS (*it); + ptrdiff_t original_pos = IT_CHARPOS (*it); reseat_1 (it, pos, 0); @@ -6190,7 +6255,7 @@ reseat_1 (struct it *it, struct text_pos pos, int set_stop_p) static void reseat_to_string (struct it *it, const char *s, Lisp_Object string, - EMACS_INT charpos, EMACS_INT precision, int field_width, + ptrdiff_t charpos, ptrdiff_t precision, int field_width, int multibyte) { /* No region in strings. */ @@ -6308,7 +6373,7 @@ reseat_to_string (struct it *it, const char *s, Lisp_Object string, } if (s == NULL && it->multibyte_p) { - EMACS_INT endpos = SCHARS (it->string); + ptrdiff_t endpos = SCHARS (it->string); if (endpos > it->end_charpos) endpos = it->end_charpos; composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos, @@ -6416,11 +6481,11 @@ lookup_glyphless_char_display (int c, struct it *it) end of buffer (or C string) is reached. */ static struct frame *last_escape_glyph_frame = NULL; -static unsigned last_escape_glyph_face_id = (1 << FACE_ID_BITS); +static int last_escape_glyph_face_id = (1 << FACE_ID_BITS); static int last_escape_glyph_merged_face_id = 0; struct frame *last_glyphless_glyph_frame = NULL; -unsigned last_glyphless_glyph_face_id = (1 << FACE_ID_BITS); +int last_glyphless_glyph_face_id = (1 << FACE_ID_BITS); int last_glyphless_glyph_merged_face_id = 0; static int @@ -6552,7 +6617,7 @@ get_next_display_element (struct it *it) Lisp_Object gc; int ctl_len; int face_id; - EMACS_INT lface_id = 0; + int lface_id = 0; int escape_glyph; /* Handle control characters with ^. */ @@ -6564,8 +6629,7 @@ get_next_display_element (struct it *it) g = '^'; /* default glyph for Control */ /* Set IT->ctl_chars[0] to the glyph for `^'. */ if (it->dp - && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc)) - && GLYPH_CODE_CHAR_VALID_P (gc)) + && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc))) { g = GLYPH_CODE_CHAR (gc); lface_id = GLYPH_CODE_FACE (gc); @@ -6614,8 +6678,7 @@ get_next_display_element (struct it *it) escape_glyph = '\\'; if (it->dp - && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc)) - && GLYPH_CODE_CHAR_VALID_P (gc)) + && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc))) { escape_glyph = GLYPH_CODE_CHAR (gc); lface_id = GLYPH_CODE_FACE (gc); @@ -6714,7 +6777,7 @@ get_next_display_element (struct it *it) } else { - EMACS_INT pos = (it->s ? -1 + ptrdiff_t pos = (it->s ? -1 : STRINGP (it->string) ? IT_STRING_CHARPOS (*it) : IT_CHARPOS (*it)); int c; @@ -6766,7 +6829,7 @@ get_next_display_element (struct it *it) && (it->current.overlay_string_index == it->n_overlay_strings - 1)) { - EMACS_INT ignore; + ptrdiff_t ignore; int next_face_id; struct text_pos pos = it->current.pos; INC_TEXT_POS (pos, it->multibyte_p); @@ -6790,6 +6853,16 @@ get_next_display_element (struct it *it) && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX); } } + /* If we reached the end of the object we've been iterating (e.g., a + display string or an overlay string), and there's something on + IT->stack, proceed with what's on the stack. It doesn't make + sense to return zero if there's unprocessed stuff on the stack, + because otherwise that stuff will never be displayed. */ + if (!success_p && it->sp > 0) + { + set_iterator_to_next (it, 0); + success_p = get_next_display_element (it); + } /* Value is 0 if end of buffer or string reached. */ return success_p; @@ -6868,7 +6941,7 @@ set_iterator_to_next (struct it *it, int reseat_p) { /* No more grapheme clusters in this composition. Find the next stop position. */ - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) /* Now we are scanning backward and don't know where to stop. */ @@ -6896,7 +6969,7 @@ set_iterator_to_next (struct it *it, int reseat_p) { /* No more grapheme clusters in this composition. Find the next stop position. */ - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) /* Now we are scanning backward and don't know where to stop. */ @@ -6929,7 +7002,7 @@ set_iterator_to_next (struct it *it, int reseat_p) { /* As the scan direction was changed, we must re-compute the stop position for composition. */ - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) stop = -1; composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it), @@ -6971,7 +7044,7 @@ set_iterator_to_next (struct it *it, int reseat_p) display vector entry (these entries may contain faces). */ it->face_id = it->saved_face_id; - if (it->dpvec + it->current.dpvec_index == it->dpend) + if (it->dpvec + it->current.dpvec_index >= it->dpend) { int recheck_faces = it->ellipsis_p; @@ -7009,6 +7082,26 @@ set_iterator_to_next (struct it *it, int reseat_p) case GET_FROM_STRING: /* Current display element is a character from a Lisp string. */ xassert (it->s == NULL && STRINGP (it->string)); + /* Don't advance past string end. These conditions are true + when set_iterator_to_next is called at the end of + get_next_display_element, in which case the Lisp string is + already exhausted, and all we want is pop the iterator + stack. */ + if (it->current.overlay_string_index >= 0) + { + /* This is an overlay string, so there's no padding with + spaces, and the number of characters in the string is + where the string ends. */ + if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)) + goto consider_string_end; + } + else + { + /* Not an overlay string. There could be padding, so test + against it->end_charpos . */ + if (IT_STRING_CHARPOS (*it) >= it->end_charpos) + goto consider_string_end; + } if (it->cmp_it.id >= 0) { int i; @@ -7039,7 +7132,7 @@ set_iterator_to_next (struct it *it, int reseat_p) it->cmp_it.from = it->cmp_it.to; else { - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) stop = -1; composition_compute_stop_pos (&it->cmp_it, @@ -7058,7 +7151,7 @@ set_iterator_to_next (struct it *it, int reseat_p) it->cmp_it.to = it->cmp_it.from; else { - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) stop = -1; composition_compute_stop_pos (&it->cmp_it, @@ -7090,7 +7183,7 @@ set_iterator_to_next (struct it *it, int reseat_p) IT_STRING_CHARPOS (*it) = it->bidi_it.charpos; if (prev_scan_dir != it->bidi_it.scan_dir) { - EMACS_INT stop = it->end_charpos; + ptrdiff_t stop = it->end_charpos; if (it->bidi_it.scan_dir < 0) stop = -1; @@ -7176,7 +7269,7 @@ next_element_from_display_vector (struct it *it) That seemed totally bogus - so I changed it... */ gc = it->dpvec[it->current.dpvec_index]; - if (GLYPH_CODE_P (gc) && GLYPH_CODE_CHAR_VALID_P (gc)) + if (GLYPH_CODE_P (gc)) { it->c = GLYPH_CODE_CHAR (gc); it->len = CHAR_BYTES (it->c); @@ -7188,7 +7281,7 @@ next_element_from_display_vector (struct it *it) it->face_id = it->dpvec_face_id; else { - EMACS_INT lface_id = GLYPH_CODE_FACE (gc); + int lface_id = GLYPH_CODE_FACE (gc); if (lface_id > 0) it->face_id = merge_faces (it->f, Qt, lface_id, it->saved_face_id); @@ -7211,8 +7304,8 @@ static void get_visually_first_element (struct it *it) { int string_p = STRINGP (it->string) || it->s; - EMACS_INT eob = (string_p ? it->bidi_it.string.schars : ZV); - EMACS_INT bob = (string_p ? 0 : BEGV); + ptrdiff_t eob = (string_p ? it->bidi_it.string.schars : ZV); + ptrdiff_t bob = (string_p ? 0 : BEGV); if (STRINGP (it->string)) { @@ -7244,7 +7337,7 @@ get_visually_first_element (struct it *it) } else { - EMACS_INT orig_bytepos = it->bidi_it.bytepos; + ptrdiff_t orig_bytepos = it->bidi_it.bytepos; /* We need to prime the bidi iterator starting at the line's or string's beginning, before we will be able to produce the @@ -7282,7 +7375,7 @@ get_visually_first_element (struct it *it) if (STRINGP (it->string) || !it->s) { - EMACS_INT stop, charpos, bytepos; + ptrdiff_t stop, charpos, bytepos; if (STRINGP (it->string)) { @@ -7583,10 +7676,10 @@ compute_stop_pos_backwards (struct it *it) struct text_pos pos; struct display_pos save_current = it->current; struct text_pos save_position = it->position; - EMACS_INT charpos = IT_CHARPOS (*it); - EMACS_INT where_we_are = charpos; - EMACS_INT save_stop_pos = it->stop_charpos; - EMACS_INT save_end_pos = it->end_charpos; + ptrdiff_t charpos = IT_CHARPOS (*it); + ptrdiff_t where_we_are = charpos; + ptrdiff_t save_stop_pos = it->stop_charpos; + ptrdiff_t save_end_pos = it->end_charpos; xassert (NILP (it->string) && !it->s); xassert (it->bidi_p); @@ -7624,14 +7717,14 @@ compute_stop_pos_backwards (struct it *it) position. */ static void -handle_stop_backwards (struct it *it, EMACS_INT charpos) +handle_stop_backwards (struct it *it, ptrdiff_t charpos) { int bufp = !STRINGP (it->string); - EMACS_INT where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it)); + ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it)); struct display_pos save_current = it->current; struct text_pos save_position = it->position; struct text_pos pos1; - EMACS_INT next_stop; + ptrdiff_t next_stop; /* Scan in strict logical order. */ xassert (it->bidi_p); @@ -7775,7 +7868,7 @@ next_element_from_buffer (struct it *it) /* No face changes, overlays etc. in sight, so just return a character from current_buffer. */ unsigned char *p; - EMACS_INT stop; + ptrdiff_t stop; /* Maybe run the redisplay end trigger hook. Performance note: This doesn't seem to cost measurable time. */ @@ -7964,7 +8057,7 @@ next_element_from_composition (struct it *it) static enum move_it_result move_it_in_display_line_to (struct it *it, - EMACS_INT to_charpos, int to_x, + ptrdiff_t to_charpos, int to_x, enum move_operation_enum op) { enum move_it_result result = MOVE_UNDEFINED; @@ -7974,7 +8067,7 @@ move_it_in_display_line_to (struct it *it, void *ppos_data = NULL; int may_wrap = 0; enum it_method prev_method = it->method; - EMACS_INT prev_pos = IT_CHARPOS (*it); + ptrdiff_t prev_pos = IT_CHARPOS (*it); int saw_smaller_pos = prev_pos < to_charpos; /* Don't produce glyphs in produce_glyphs. */ @@ -8468,7 +8561,7 @@ move_it_in_display_line_to (struct it *it, /* For external use. */ void move_it_in_display_line (struct it *it, - EMACS_INT to_charpos, int to_x, + ptrdiff_t to_charpos, int to_x, enum move_operation_enum op) { if (it->line_wrap == WORD_WRAP @@ -8511,7 +8604,7 @@ move_it_in_display_line (struct it *it, displayed to the right of TO_CHARPOS on the screen. */ void -move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos, int op) +move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op) { enum move_it_result skip, skip2 = MOVE_X_REACHED; int line_height, line_start_x = 0, reached = 0; @@ -8615,8 +8708,18 @@ move_it_to (struct it *it, EMACS_INT to_charpos, int to_x, int to_y, int to_vpos { /* If TO_Y is in this line and TO_X was reached above, we scanned too far. We have to restore - IT's settings to the ones before skipping. */ + IT's settings to the ones before skipping. But + keep the more accurate values of max_ascent and + max_descent we've found while skipping the rest + of the line, for the sake of callers, such as + pos_visible_p, that need to know the line + height. */ + int max_ascent = it->max_ascent; + int max_descent = it->max_descent; + RESTORE_IT (it, &it_backup, backup_data); + it->max_ascent = max_ascent; + it->max_descent = max_descent; reached = 6; } else @@ -8778,7 +8881,7 @@ move_it_vertically_backward (struct it *it, int dy) int nlines, h; struct it it2, it3; void *it2data = NULL, *it3data = NULL; - EMACS_INT start_pos; + ptrdiff_t start_pos; move_further_back: xassert (dy >= 0); @@ -8860,7 +8963,7 @@ move_it_vertically_backward (struct it *it, int dy) && IT_CHARPOS (*it) > BEGV && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n') { - EMACS_INT nl_pos = + ptrdiff_t nl_pos = find_next_newline_no_quit (IT_CHARPOS (*it) - 1, -1); move_it_to (it, nl_pos, -1, -1, -1, MOVE_TO_POS); @@ -8970,7 +9073,7 @@ move_it_past_eol (struct it *it) truncate-lines nil. */ void -move_it_by_lines (struct it *it, int dvpos) +move_it_by_lines (struct it *it, ptrdiff_t dvpos) { /* The commented-out optimization uses vmotion on terminals. This @@ -9019,7 +9122,7 @@ move_it_by_lines (struct it *it, int dvpos) { struct it it2; void *it2data = NULL; - EMACS_INT start_charpos, i; + ptrdiff_t start_charpos, i; /* Start at the beginning of the screen line containing IT's position. This may actually move vertically backwards, @@ -9105,7 +9208,7 @@ add_to_log (const char *format, Lisp_Object arg1, Lisp_Object arg2) Lisp_Object args[3]; Lisp_Object msg, fmt; char *buffer; - EMACS_INT len; + ptrdiff_t len; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; USE_SAFE_ALLOCA; @@ -9154,7 +9257,7 @@ message_log_maybe_newline (void) so the buffer M must NOT point to a Lisp string. */ void -message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) +message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte) { const unsigned char *msg = (const unsigned char *) m; @@ -9166,8 +9269,8 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) struct buffer *oldbuf; Lisp_Object oldpoint, oldbegv, oldzv; int old_windows_or_buffers_changed = windows_or_buffers_changed; - EMACS_INT point_at_end = 0; - EMACS_INT zv_at_end = 0; + ptrdiff_t point_at_end = 0; + ptrdiff_t zv_at_end = 0; Lisp_Object old_deactivate_mark, tem; struct gcpro gcpro1; @@ -9200,7 +9303,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) if (multibyte && NILP (BVAR (current_buffer, enable_multibyte_characters))) { - EMACS_INT i; + ptrdiff_t i; int c, char_bytes; char work[1]; @@ -9218,7 +9321,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) else if (! multibyte && ! NILP (BVAR (current_buffer, enable_multibyte_characters))) { - EMACS_INT i; + ptrdiff_t i; int c, char_bytes; unsigned char str[MAX_MULTIBYTE_LENGTH]; /* Convert a single-byte string to multibyte @@ -9236,7 +9339,7 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) if (nlflag) { - EMACS_INT this_bol, this_bol_byte, prev_bol, prev_bol_byte; + ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte; printmax_t dups; insert_1 ("\n", 1, 1, 0, 0); @@ -9329,10 +9432,10 @@ message_dolog (const char *m, EMACS_INT nbytes, int nlflag, int multibyte) value N > 1 if we should also append " [N times]". */ static intmax_t -message_log_check_duplicate (EMACS_INT prev_bol_byte, EMACS_INT this_bol_byte) +message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte) { - EMACS_INT i; - EMACS_INT len = Z_BYTE - 1 - this_bol_byte; + ptrdiff_t i; + ptrdiff_t len = Z_BYTE - 1 - this_bol_byte; int seen_dots = 0; unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte); unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte); @@ -9366,7 +9469,7 @@ message_log_check_duplicate (EMACS_INT prev_bol_byte, EMACS_INT this_bol_byte) This may GC, so the buffer M must NOT point to a Lisp string. */ void -message2 (const char *m, EMACS_INT nbytes, int multibyte) +message2 (const char *m, ptrdiff_t nbytes, int multibyte) { /* First flush out any partial line written with print. */ message_log_maybe_newline (); @@ -9379,7 +9482,7 @@ message2 (const char *m, EMACS_INT nbytes, int multibyte) /* The non-logging counterpart of message2. */ void -message2_nolog (const char *m, EMACS_INT nbytes, int multibyte) +message2_nolog (const char *m, ptrdiff_t nbytes, int multibyte) { struct frame *sf = SELECTED_FRAME (); message_enable_multibyte = multibyte; @@ -9441,7 +9544,7 @@ message2_nolog (const char *m, EMACS_INT nbytes, int multibyte) This function cancels echoing. */ void -message3 (Lisp_Object m, EMACS_INT nbytes, int multibyte) +message3 (Lisp_Object m, ptrdiff_t nbytes, int multibyte) { struct gcpro gcpro1; @@ -9473,7 +9576,7 @@ message3 (Lisp_Object m, EMACS_INT nbytes, int multibyte) and make this cancel echoing. */ void -message3_nolog (Lisp_Object m, EMACS_INT nbytes, int multibyte) +message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte) { struct frame *sf = SELECTED_FRAME (); message_enable_multibyte = multibyte; @@ -9664,7 +9767,7 @@ vmessage (const char *m, va_list ap) len = doprnt (FRAME_MESSAGE_BUF (f), FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, ap); - message2 (FRAME_MESSAGE_BUF (f), len, 0); + message2 (FRAME_MESSAGE_BUF (f), len, 1); } else message1 (0); @@ -9770,12 +9873,12 @@ ensure_echo_area_buffers (void) static int with_echo_area_buffer (struct window *w, int which, - int (*fn) (EMACS_INT, Lisp_Object, EMACS_INT, EMACS_INT), - EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4) + int (*fn) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t), + ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4) { Lisp_Object buffer; int this_one, the_other, clear_buffer_p, rc; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); /* If buffers aren't live, make new ones. */ ensure_echo_area_buffers (); @@ -9951,7 +10054,7 @@ setup_echo_area_for_printing (int multibyte_p) if (Z > BEG) { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); specbind (Qinhibit_read_only, Qt); /* Note that undo recording is always disabled. */ del_range (BEG, Z); @@ -10004,14 +10107,14 @@ setup_echo_area_for_printing (int multibyte_p) static int display_echo_area (struct window *w) { - int i, no_message_p, window_height_changed_p, count; + int i, no_message_p, window_height_changed_p; /* Temporarily disable garbage collections while displaying the echo area. This is done because a GC can print a message itself. That message would modify the echo area buffer's contents while a redisplay of the buffer is going on, and seriously confuse redisplay. */ - count = inhibit_garbage_collection (); + ptrdiff_t count = inhibit_garbage_collection (); /* If there is no message, we must call display_echo_area_1 nevertheless because it resizes the window. But we will have to @@ -10040,7 +10143,7 @@ display_echo_area (struct window *w) Value is non-zero if height of W was changed. */ static int -display_echo_area_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4) +display_echo_area_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4) { intptr_t i1 = a1; struct window *w = (struct window *) i1; @@ -10104,7 +10207,7 @@ resize_echo_area_exactly (void) resize_mini_window returns. */ static int -resize_mini_window_1 (EMACS_INT a1, Lisp_Object exactly, EMACS_INT a3, EMACS_INT a4) +resize_mini_window_1 (ptrdiff_t a1, Lisp_Object exactly, ptrdiff_t a3, ptrdiff_t a4) { intptr_t i1 = a1; return resize_mini_window ((struct window *) i1, !NILP (exactly)); @@ -10154,7 +10257,8 @@ resize_mini_window (struct window *w, int exact_p) struct it it; struct window *root = XWINDOW (FRAME_ROOT_WINDOW (f)); int total_height = WINDOW_TOTAL_LINES (root) + WINDOW_TOTAL_LINES (w); - int height, max_height; + int height; + EMACS_INT max_height; int unit = FRAME_LINE_HEIGHT (f); struct text_pos start; struct buffer *old_current_buffer = NULL; @@ -10283,7 +10387,7 @@ current_message (void) static int -current_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4) +current_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4) { intptr_t i1 = a1; Lisp_Object *msg = (Lisp_Object *) i1; @@ -10362,7 +10466,7 @@ check_message_stack (void) time we display it---but don't redisplay it now. */ void -truncate_echo_area (EMACS_INT nchars) +truncate_echo_area (ptrdiff_t nchars) { if (nchars == 0) echo_area_buffer[0] = Qnil; @@ -10384,7 +10488,7 @@ truncate_echo_area (EMACS_INT nchars) message to at most NCHARS characters. */ static int -truncate_message_1 (EMACS_INT nchars, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4) +truncate_message_1 (ptrdiff_t nchars, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4) { if (BEG + nchars < Z) del_range (BEG + nchars, Z); @@ -10410,7 +10514,7 @@ truncate_message_1 (EMACS_INT nchars, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4 static void set_message (const char *s, Lisp_Object string, - EMACS_INT nbytes, int multibyte_p) + ptrdiff_t nbytes, int multibyte_p) { message_enable_multibyte = ((s && multibyte_p) @@ -10429,7 +10533,7 @@ set_message (const char *s, Lisp_Object string, current. */ static int -set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multibyte_p) +set_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t nbytes, ptrdiff_t multibyte_p) { intptr_t i1 = a1; const char *s = (const char *) i1; @@ -10450,7 +10554,7 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby if (STRINGP (string)) { - EMACS_INT nchars; + ptrdiff_t nchars; if (nbytes == 0) nbytes = SBYTES (string); @@ -10469,7 +10573,7 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby if (multibyte_p && NILP (BVAR (current_buffer, enable_multibyte_characters))) { /* Convert from multi-byte to single-byte. */ - EMACS_INT i; + ptrdiff_t i; int c, n; char work[1]; @@ -10487,7 +10591,7 @@ set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multiby && !NILP (BVAR (current_buffer, enable_multibyte_characters))) { /* Convert from single-byte to multi-byte. */ - EMACS_INT i; + ptrdiff_t i; int c, n; unsigned char str[MAX_MULTIBYTE_LENGTH]; @@ -10632,7 +10736,7 @@ echo_area_display (int update_frame_p) /* Must update other windows. Likewise as in other cases, don't let this update be interrupted by pending input. */ - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); specbind (Qredisplay_dont_pause, Qt); windows_or_buffers_changed = 1; redisplay_internal (); @@ -10809,7 +10913,7 @@ store_mode_line_noprop (const char *string, int field_width, int precision) { const unsigned char *str = (const unsigned char *) string; int n = 0; - EMACS_INT dummy, nbytes; + ptrdiff_t dummy, nbytes; /* Copy at most PRECISION chars from STR. */ nbytes = strlen (string); @@ -10854,7 +10958,7 @@ x_consider_frame_title (Lisp_Object frame) char *title; ptrdiff_t len; struct it it; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail)) { @@ -10957,7 +11061,7 @@ prepare_menu_bars (void) if (all_windows) { Lisp_Object tail, frame; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); /* 1 means that update_menu_bar has run its hooks so any further calls to update_menu_bar shouldn't do so again. */ int menu_bar_hooks_run = 0; @@ -11068,13 +11172,13 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run) || update_mode_lines || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer)) < BUF_MODIFF (XBUFFER (w->buffer))) - != !NILP (w->last_had_star)) + != w->last_had_star) || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (XBUFFER (w->buffer), mark_active))) != !NILP (w->region_showing))) { struct buffer *prev = current_buffer; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); specbind (Qinhibit_menubar_update, Qt); @@ -11120,11 +11224,11 @@ update_menu_bar (struct frame *f, int save_match_data, int hooks_run) else /* On a terminal screen, the menu bar is an ordinary screen line, and this makes it get updated. */ - w->update_mode_line = Qt; + w->update_mode_line = 1; #else /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */ /* In the non-toolkit version, the menu bar is an ordinary screen line, and this makes it get updated. */ - w->update_mode_line = Qt; + w->update_mode_line = 1; #endif /* ! (USE_X_TOOLKIT || HAVE_NTGUI || HAVE_NS || USE_GTK) */ unbind_to (count, Qnil); @@ -11262,17 +11366,17 @@ update_tool_bar (struct frame *f, int save_match_data) the rest of the redisplay algorithm is about the same as windows_or_buffers_changed anyway. */ if (windows_or_buffers_changed - || !NILP (w->update_mode_line) + || w->update_mode_line || update_mode_lines || ((BUF_SAVE_MODIFF (XBUFFER (w->buffer)) < BUF_MODIFF (XBUFFER (w->buffer))) - != !NILP (w->last_had_star)) + != w->last_had_star) || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (XBUFFER (w->buffer), mark_active))) != !NILP (w->region_showing))) { struct buffer *prev = current_buffer; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); Lisp_Object frame, new_tool_bar; int new_n_tool_bar; struct gcpro gcpro1; @@ -11317,7 +11421,7 @@ update_tool_bar (struct frame *f, int save_match_data) BLOCK_INPUT; f->tool_bar_items = new_tool_bar; f->n_tool_bar_items = new_n_tool_bar; - w->update_mode_line = Qt; + w->update_mode_line = 1; UNBLOCK_INPUT; } @@ -11410,20 +11514,20 @@ build_desired_tool_bar_string (struct frame *f) : DEFAULT_TOOL_BAR_BUTTON_RELIEF); hmargin = vmargin = relief; - if (INTEGERP (Vtool_bar_button_margin) - && XINT (Vtool_bar_button_margin) > 0) + if (RANGED_INTEGERP (1, Vtool_bar_button_margin, + INT_MAX - max (hmargin, vmargin))) { hmargin += XFASTINT (Vtool_bar_button_margin); vmargin += XFASTINT (Vtool_bar_button_margin); } else if (CONSP (Vtool_bar_button_margin)) { - if (INTEGERP (XCAR (Vtool_bar_button_margin)) - && XINT (XCAR (Vtool_bar_button_margin)) > 0) + if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin), + INT_MAX - hmargin)) hmargin += XFASTINT (XCAR (Vtool_bar_button_margin)); - if (INTEGERP (XCDR (Vtool_bar_button_margin)) - && XINT (XCDR (Vtool_bar_button_margin)) > 0) + if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), + INT_MAX - vmargin)) vmargin += XFASTINT (XCDR (Vtool_bar_button_margin)); } @@ -11769,7 +11873,7 @@ redisplay_tool_bar (struct frame *f) { int border, rows, height, extra; - if (INTEGERP (Vtool_bar_border)) + if (TYPE_RANGED_INTEGERP (int, Vtool_bar_border)) border = XINT (Vtool_bar_border); else if (EQ (Vtool_bar_border, Qinternal_border_width)) border = FRAME_INTERNAL_BORDER_WIDTH (f); @@ -11957,7 +12061,7 @@ get_tool_bar_item (struct frame *f, int x, int y, struct glyph **glyph, void handle_tool_bar_click (struct frame *f, int x, int y, int down_p, - unsigned int modifiers) + int modifiers) { Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f); struct window *w = XWINDOW (f->tool_bar_window); @@ -12136,7 +12240,7 @@ hscroll_window_tree (Lisp_Object window) hscroll_step_abs = 0; } } - else if (INTEGERP (Vhscroll_step)) + else if (TYPE_RANGED_INTEGERP (int, Vhscroll_step)) { hscroll_step_abs = XINT (Vhscroll_step); if (hscroll_step_abs < 0) @@ -12200,9 +12304,9 @@ hscroll_window_tree (Lisp_Object window) && (w->cursor.x >= text_area_width - h_margin)))))) { struct it it; - int hscroll; + ptrdiff_t hscroll; struct buffer *saved_current_buffer; - EMACS_INT pt; + ptrdiff_t pt; int wanted_x; /* Find point in a display of infinite width. */ @@ -12317,12 +12421,12 @@ static int debug_dvpos, debug_dy; /* Delta in characters and bytes for try_window_id. */ -static EMACS_INT debug_delta, debug_delta_bytes; +static ptrdiff_t debug_delta, debug_delta_bytes; /* Values of window_end_pos and window_end_vpos at the end of try_window_id. */ -static EMACS_INT debug_end_vpos; +static ptrdiff_t debug_end_vpos; /* Append a string to W->desired_matrix->method. FMT is a printf format string. If trace_redisplay_p is non-zero also printf the @@ -12372,7 +12476,7 @@ debug_method_add (struct window *w, char const *fmt, ...) static inline int text_outside_line_unchanged_p (struct window *w, - EMACS_INT start, EMACS_INT end) + ptrdiff_t start, ptrdiff_t end) { int unchanged_p = 1; @@ -12595,10 +12699,10 @@ overlay_arrow_at_row (struct it *it, struct glyph_row *row) position. BUF and PT are the current point buffer and position. */ static int -check_point_in_composition (struct buffer *prev_buf, EMACS_INT prev_pt, - struct buffer *buf, EMACS_INT pt) +check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt, + struct buffer *buf, ptrdiff_t pt) { - EMACS_INT start, end; + ptrdiff_t start, end; Lisp_Object prop; Lisp_Object buffer; @@ -12649,7 +12753,7 @@ reconsider_clip_changes (struct window *w, struct buffer *b) if (!b->clip_changed && BUFFERP (w->buffer) && !NILP (w->window_end_valid)) { - EMACS_INT pt; + ptrdiff_t pt; if (w == XWINDOW (selected_window)) pt = PT; @@ -12718,7 +12822,7 @@ redisplay_internal (void) int must_finish = 0; struct text_pos tlbufpos, tlendpos; int number_of_visible_frames; - int count, count1; + ptrdiff_t count, count1; struct frame *sf; int polling_stopped_here = 0; Lisp_Object old_frame = selected_frame; @@ -12727,6 +12831,9 @@ redisplay_internal (void) frames. Zero means, only selected_window is considered. */ int consider_all_windows_p; + /* Non-zero means redisplay has to redisplay the miniwindow */ + int update_miniwindow_p = 0; + TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p)); /* No redisplay if running in batch mode or frame is not yet fully @@ -12863,9 +12970,9 @@ redisplay_internal (void) update_mode_lines++; /* Detect case that we need to write or remove a star in the mode line. */ - if ((SAVE_MODIFF < MODIFF) != !NILP (w->last_had_star)) + if ((SAVE_MODIFF < MODIFF) != w->last_had_star) { - w->update_mode_line = Qt; + w->update_mode_line = 1; if (buffer_shared > 1) update_mode_lines++; } @@ -12882,7 +12989,7 @@ redisplay_internal (void) && XFASTINT (w->last_modified) >= MODIFF && XFASTINT (w->last_overlay_modified) >= OVERLAY_MODIFF) && (XFASTINT (w->column_number_displayed) != current_column ())) - w->update_mode_line = Qt; + w->update_mode_line = 1; unbind_to (count1, Qnil); @@ -12913,6 +13020,10 @@ redisplay_internal (void) && !MINI_WINDOW_P (XWINDOW (selected_window)))) { int window_height_changed_p = echo_area_display (0); + + if (message_cleared_p) + update_miniwindow_p = 1; + must_finish = 1; /* If we don't display the current message, don't clear the @@ -12949,7 +13060,7 @@ redisplay_internal (void) /* FIXME: this causes all frames to be updated, which seems unnecessary since only the current frame needs to be considered. This function needs to be rewritten with two variables, consider_all_windows and - consider_all_frames. */ + consider_all_frames. */ consider_all_windows_p = 1; ++windows_or_buffers_changed; ++update_mode_lines; @@ -12981,7 +13092,7 @@ redisplay_internal (void) tlendpos = this_line_end_pos; if (!consider_all_windows_p && CHARPOS (tlbufpos) > 0 - && NILP (w->update_mode_line) + && !w->update_mode_line && !current_buffer->clip_changed && !current_buffer->prevent_redisplay_optimizations_p && FRAME_VISIBLE_P (XFRAME (w->frame)) @@ -12989,8 +13100,8 @@ redisplay_internal (void) /* Make sure recorded data applies to current buffer, etc. */ && this_line_buffer == current_buffer && current_buffer == XBUFFER (w->buffer) - && NILP (w->force_start) - && NILP (w->optional_new_start) + && !w->force_start + && !w->optional_new_start /* Point must be on the line that we have info recorded about. */ && PT >= CHARPOS (tlbufpos) && PT <= Z - CHARPOS (tlendpos) @@ -13061,7 +13172,7 @@ redisplay_internal (void) { struct glyph_row *row = MATRIX_ROW (w->current_matrix, this_line_vpos + 1); - EMACS_INT delta, delta_bytes; + ptrdiff_t delta, delta_bytes; /* We used to distinguish between two cases here, conditioned by Z - CHARPOS (tlendpos) == ZV, for @@ -13135,7 +13246,8 @@ redisplay_internal (void) then we can't just move the cursor. */ else if (! (!NILP (Vtransient_mark_mode) && !NILP (BVAR (current_buffer, mark_active))) - && (EQ (selected_window, BVAR (current_buffer, last_selected_window)) + && (EQ (selected_window, + BVAR (current_buffer, last_selected_window)) || highlight_nonselected_windows) && NILP (w->region_showing) && NILP (Vshow_trailing_whitespace) @@ -13288,7 +13400,7 @@ redisplay_internal (void) } else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf)) { - Lisp_Object mini_window; + Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf); struct frame *mini_frame; displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer); @@ -13297,6 +13409,10 @@ redisplay_internal (void) internal_condition_case_1 (redisplay_window_1, selected_window, list_of_error, redisplay_window_error); + if (update_miniwindow_p) + internal_condition_case_1 (redisplay_window_1, mini_window, + list_of_error, + redisplay_window_error); /* Compare desired and current matrices, perform output. */ @@ -13520,7 +13636,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p) w->last_overlay_modified = make_number (accurate_p ? BUF_OVERLAY_MODIFF (b) : 0); w->last_had_star - = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b) ? Qt : Qnil; + = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b); if (accurate_p) { @@ -13549,7 +13665,7 @@ mark_window_display_accurate_1 (struct window *w, int accurate_p) if (accurate_p) { w->window_end_valid = w->buffer; - w->update_mode_line = Qnil; + w->update_mode_line = 0; } } @@ -13684,18 +13800,18 @@ redisplay_window_1 (Lisp_Object window) static int set_cursor_from_row (struct window *w, struct glyph_row *row, struct glyph_matrix *matrix, - EMACS_INT delta, EMACS_INT delta_bytes, + ptrdiff_t delta, ptrdiff_t delta_bytes, int dy, int dvpos) { struct glyph *glyph = row->glyphs[TEXT_AREA]; struct glyph *end = glyph + row->used[TEXT_AREA]; struct glyph *cursor = NULL; /* The last known character position in row. */ - EMACS_INT last_pos = MATRIX_ROW_START_CHARPOS (row) + delta; + ptrdiff_t last_pos = MATRIX_ROW_START_CHARPOS (row) + delta; int x = row->x; - EMACS_INT pt_old = PT - delta; - EMACS_INT pos_before = MATRIX_ROW_START_CHARPOS (row) + delta; - EMACS_INT pos_after = MATRIX_ROW_END_CHARPOS (row) + delta; + ptrdiff_t pt_old = PT - delta; + ptrdiff_t pos_before = MATRIX_ROW_START_CHARPOS (row) + delta; + ptrdiff_t pos_after = MATRIX_ROW_END_CHARPOS (row) + delta; struct glyph *glyph_before = glyph - 1, *glyph_after = end; /* A glyph beyond the edge of TEXT_AREA which we should never touch. */ @@ -13708,11 +13824,11 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, int string_seen = 0; /* Largest and smallest buffer positions seen so far during scan of glyph row. */ - EMACS_INT bpos_max = pos_before; - EMACS_INT bpos_min = pos_after; + ptrdiff_t bpos_max = pos_before; + ptrdiff_t bpos_min = pos_after; /* Last buffer position covered by an overlay string with an integer `cursor' property. */ - EMACS_INT bpos_covered = 0; + ptrdiff_t bpos_covered = 0; /* Non-zero means the display string on which to display the cursor comes from a text property, not from an overlay. */ int string_from_text_prop = 0; @@ -13805,7 +13921,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, { if (BUFFERP (glyph->object)) { - EMACS_INT dpos = glyph->charpos - pt_old; + ptrdiff_t dpos = glyph->charpos - pt_old; if (glyph->charpos > bpos_max) bpos_max = glyph->charpos; @@ -13821,16 +13937,13 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, break; } /* See if we've found a better approximation to - POS_BEFORE or to POS_AFTER. Note that we want the - first (leftmost) glyph of all those that are the - closest from below, and the last (rightmost) of all - those from above. */ + POS_BEFORE or to POS_AFTER. */ if (0 > dpos && dpos > pos_before - pt_old) { pos_before = glyph->charpos; glyph_before = glyph; } - else if (0 < dpos && dpos <= pos_after - pt_old) + else if (0 < dpos && dpos < pos_after - pt_old) { pos_after = glyph->charpos; glyph_after = glyph; @@ -13842,7 +13955,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, else if (STRINGP (glyph->object)) { Lisp_Object chprop; - EMACS_INT glyph_pos = glyph->charpos; + ptrdiff_t glyph_pos = glyph->charpos; chprop = Fget_char_property (make_number (glyph_pos), Qcursor, glyph->object); @@ -13858,7 +13971,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, text is completely covered by display properties, so that no glyph with valid buffer positions is ever seen in the row. */ - EMACS_INT prop_pos = + ptrdiff_t prop_pos = string_buffer_position_lim (glyph->object, pos_before, pos_after, 0); @@ -13896,7 +14009,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, { if (BUFFERP (glyph->object)) { - EMACS_INT dpos = glyph->charpos - pt_old; + ptrdiff_t dpos = glyph->charpos - pt_old; if (glyph->charpos > bpos_max) bpos_max = glyph->charpos; @@ -13914,7 +14027,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, pos_before = glyph->charpos; glyph_before = glyph; } - else if (0 < dpos && dpos <= pos_after - pt_old) + else if (0 < dpos && dpos < pos_after - pt_old) { pos_after = glyph->charpos; glyph_after = glyph; @@ -13926,13 +14039,13 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, else if (STRINGP (glyph->object)) { Lisp_Object chprop; - EMACS_INT glyph_pos = glyph->charpos; + ptrdiff_t glyph_pos = glyph->charpos; chprop = Fget_char_property (make_number (glyph_pos), Qcursor, glyph->object); if (!NILP (chprop)) { - EMACS_INT prop_pos = + ptrdiff_t prop_pos = string_buffer_position_lim (glyph->object, pos_before, pos_after, 0); @@ -13980,7 +14093,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, if (row->ends_in_ellipsis_p && pos_after == last_pos) { - EMACS_INT ellipsis_pos; + ptrdiff_t ellipsis_pos; /* Scan back over the ellipsis glyphs. */ if (!row->reversed_p) @@ -14020,7 +14133,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, positioned between POS_BEFORE and POS_AFTER in the buffer. */ struct glyph *start, *stop; - EMACS_INT pos = pos_before; + ptrdiff_t pos = pos_before; x = -1; @@ -14063,10 +14176,10 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, if (STRINGP (glyph->object)) { Lisp_Object str; - EMACS_INT tem; + ptrdiff_t tem; /* If the display property covers the newline, we need to search for it one position farther. */ - EMACS_INT lim = pos_after + ptrdiff_t lim = pos_after + (pos_after == MATRIX_ROW_END_CHARPOS (row) + delta); string_from_text_prop = 0; @@ -14095,7 +14208,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, be a character in the string with the `cursor' property, which means display cursor on that character's glyph. */ - EMACS_INT strpos = glyph->charpos; + ptrdiff_t strpos = glyph->charpos; if (tem) { @@ -14108,7 +14221,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, glyph += incr) { Lisp_Object cprop; - EMACS_INT gpos = glyph->charpos; + ptrdiff_t gpos = glyph->charpos; cprop = Fget_char_property (make_number (gpos), Qcursor, @@ -14146,6 +14259,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, the cursor is not on this line. */ if (cursor == NULL && (row->reversed_p ? glyph <= end : glyph >= end) + && (row->reversed_p ? end > glyphs_end : end < glyphs_end) && STRINGP (end->object) && row->continued_p) return 0; @@ -14175,6 +14289,21 @@ set_cursor_from_row (struct window *w, struct glyph_row *row, compute_x: if (cursor != NULL) glyph = cursor; + else if (glyph == glyphs_end + && pos_before == pos_after + && STRINGP ((row->reversed_p + ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1 + : row->glyphs[TEXT_AREA])->object)) + { + /* If all the glyphs of this row came from strings, put the + cursor on the first glyph of the row. This avoids having the + cursor outside of the text area in this very rare and hard + use case. */ + glyph = + row->reversed_p + ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1 + : row->glyphs[TEXT_AREA]; + } if (x < 0) { struct glyph *g; @@ -14399,7 +14528,7 @@ enum static int try_scrolling (Lisp_Object window, int just_this_one_p, - EMACS_INT arg_scroll_conservatively, EMACS_INT scroll_step, + ptrdiff_t arg_scroll_conservatively, ptrdiff_t scroll_step, int temp_scroll_step, int last_line_misfit) { struct window *w = XWINDOW (window); @@ -15039,7 +15168,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste MATRIX_ROW (w->current_matrix, w->cursor.vpos); struct glyph *g = candidate->glyphs[TEXT_AREA] + w->cursor.hpos; - EMACS_INT endpos = MATRIX_ROW_END_CHARPOS (candidate); + ptrdiff_t endpos = MATRIX_ROW_END_CHARPOS (candidate); exact_match_p = (BUFFERP (g->object) && g->charpos == PT) @@ -15099,7 +15228,7 @@ static void set_vertical_scroll_bar (struct window *w) { - EMACS_INT start, end, whole; + ptrdiff_t start, end, whole; /* Calculate the start and end positions for the current window. At some point, it would be nice to choose between scrollbars @@ -15159,11 +15288,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p) It indicates that the buffer contents and narrowing are unchanged. */ int buffer_unchanged_p = 0; int temp_scroll_step = 0; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); int rc; int centering_position = -1; int last_line_misfit = 0; - EMACS_INT beg_unchanged, end_unchanged; + ptrdiff_t beg_unchanged, end_unchanged; SET_TEXT_POS (lpoint, PT, PT_BYTE); opoint = lpoint; @@ -15178,7 +15307,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) reconsider_clip_changes (w, buffer); /* Has the mode line to be updated? */ - update_mode_line = (!NILP (w->update_mode_line) + update_mode_line = (w->update_mode_line || update_mode_lines || buffer->clip_changed || buffer->prevent_redisplay_optimizations_p); @@ -15304,8 +15433,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p) window, set up appropriate value. */ if (!EQ (window, selected_window)) { - EMACS_INT new_pt = XMARKER (w->pointm)->charpos; - EMACS_INT new_pt_byte = marker_byte_position (w->pointm); + ptrdiff_t new_pt = XMARKER (w->pointm)->charpos; + ptrdiff_t new_pt_byte = marker_byte_position (w->pointm); if (new_pt < BEGV) { new_pt = BEGV; @@ -15350,32 +15479,31 @@ redisplay_window (Lisp_Object window, int just_this_one_p) /* If someone specified a new starting point but did not insist, check whether it can be used. */ - if (!NILP (w->optional_new_start) + if (w->optional_new_start && CHARPOS (startp) >= BEGV && CHARPOS (startp) <= ZV) { - w->optional_new_start = Qnil; + w->optional_new_start = 0; start_display (&it, w, startp); move_it_to (&it, PT, 0, it.last_visible_y, -1, MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y); if (IT_CHARPOS (it) == PT) - w->force_start = Qt; + w->force_start = 1; /* IT may overshoot PT if text at PT is invisible. */ else if (IT_CHARPOS (it) > PT && CHARPOS (startp) <= PT) - w->force_start = Qt; + w->force_start = 1; } force_start: /* Handle case where place to start displaying has been specified, unless the specified location is outside the accessible range. */ - if (!NILP (w->force_start) - || w->frozen_window_start_p) + if (w->force_start || w->frozen_window_start_p) { /* We set this later on if we have to adjust point. */ int new_vpos = -1; - w->force_start = Qnil; + w->force_start = 0; w->vscroll = 0; w->window_end_valid = Qnil; @@ -15394,7 +15522,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) || ! NILP (Vwindow_scroll_functions)) { update_mode_line = 1; - w->update_mode_line = Qt; + w->update_mode_line = 1; startp = run_window_scroll_functions (window, startp); } @@ -15412,7 +15540,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) the scroll margin (bug#148) -- cyd */ if (!try_window (window, startp, 0)) { - w->force_start = Qt; + w->force_start = 1; clear_glyph_matrix (w->desired_matrix); goto need_larger_matrices; } @@ -15491,7 +15619,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) } /* If current starting point was originally the beginning of a line but no longer is, find a new starting point. */ - else if (!NILP (w->start_at_line_beg) + else if (w->start_at_line_beg && !(CHARPOS (startp) <= BEGV || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n')) { @@ -15538,7 +15666,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) new window start, since that would change the position under the mouse, resulting in an unwanted mouse-movement rather than a simple mouse-click. */ - if (NILP (w->start_at_line_beg) + if (!w->start_at_line_beg && NILP (do_mouse_tracking) && CHARPOS (startp) > BEGV && CHARPOS (startp) > BEG + beg_unchanged @@ -15558,7 +15686,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) See bug#9324. */ && pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &d6)) { - w->force_start = Qt; + w->force_start = 1; SET_TEXT_POS_FROM_MARKER (startp, w->start); goto force_start; } @@ -15619,7 +15747,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) if (!update_mode_line) { update_mode_line = 1; - w->update_mode_line = Qt; + w->update_mode_line = 1; } /* Try to scroll by specified few lines. */ @@ -15677,7 +15805,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p) scroll_margin > 0 ? min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4) : 0; - EMACS_INT margin_pos = CHARPOS (startp); + ptrdiff_t margin_pos = CHARPOS (startp); Lisp_Object aggressive; int scrolling_up; @@ -15874,9 +16002,8 @@ redisplay_window (Lisp_Object window, int just_this_one_p) done: SET_TEXT_POS_FROM_MARKER (startp, w->start); - w->start_at_line_beg = ((CHARPOS (startp) == BEGV - || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n') - ? Qt : Qnil); + w->start_at_line_beg = (CHARPOS (startp) == BEGV + || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n'); /* Display the mode line, if we must. */ if ((update_mode_line @@ -16093,7 +16220,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags) /* If bottom moved off end of frame, change mode line percentage. */ if (XFASTINT (w->window_end_pos) <= 0 && Z != IT_CHARPOS (it)) - w->update_mode_line = Qt; + w->update_mode_line = 1; /* Set window_end_pos to the offset of the last character displayed on the window from the end of current_buffer. Set @@ -16576,7 +16703,7 @@ try_window_reusing_current_matrix (struct window *w) static struct glyph_row *find_last_unchanged_at_beg_row (struct window *); static struct glyph_row *find_first_unchanged_at_end_row (struct window *, - EMACS_INT *, EMACS_INT *); + ptrdiff_t *, ptrdiff_t *); static struct glyph_row * find_last_row_displaying_text (struct glyph_matrix *, struct it *, struct glyph_row *); @@ -16624,7 +16751,7 @@ find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it, static struct glyph_row * find_last_unchanged_at_beg_row (struct window *w) { - EMACS_INT first_changed_pos = BEG + BEG_UNCHANGED; + ptrdiff_t first_changed_pos = BEG + BEG_UNCHANGED; struct glyph_row *row; struct glyph_row *row_found = NULL; int yb = window_text_bottom_y (w); @@ -16680,7 +16807,7 @@ find_last_unchanged_at_beg_row (struct window *w) static struct glyph_row * find_first_unchanged_at_end_row (struct window *w, - EMACS_INT *delta, EMACS_INT *delta_bytes) + ptrdiff_t *delta, ptrdiff_t *delta_bytes) { struct glyph_row *row; struct glyph_row *row_found = NULL; @@ -16708,11 +16835,11 @@ find_first_unchanged_at_end_row (struct window *w, corresponds to window_end_pos. This allows us to translate buffer positions in the current matrix to current buffer positions for characters not in changed text. */ - EMACS_INT Z_old = + ptrdiff_t Z_old = MATRIX_ROW_END_CHARPOS (row) + XFASTINT (w->window_end_pos); - EMACS_INT Z_BYTE_old = + ptrdiff_t Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos; - EMACS_INT last_unchanged_pos, last_unchanged_pos_old; + ptrdiff_t last_unchanged_pos, last_unchanged_pos_old; struct glyph_row *first_text_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix); @@ -16799,12 +16926,12 @@ sync_frame_with_window_matrix_rows (struct window *w) containing CHARPOS or null. */ struct glyph_row * -row_containing_pos (struct window *w, EMACS_INT charpos, +row_containing_pos (struct window *w, ptrdiff_t charpos, struct glyph_row *start, struct glyph_row *end, int dy) { struct glyph_row *row = start; struct glyph_row *best_row = NULL; - EMACS_INT mindif = BUF_ZV (XBUFFER (w->buffer)) + 1; + ptrdiff_t mindif = BUF_ZV (XBUFFER (w->buffer)) + 1; int last_y; /* If we happen to start on a header-line, skip that. */ @@ -16918,14 +17045,14 @@ try_window_id (struct window *w) struct glyph_row *bottom_row; int bottom_vpos; struct it it; - EMACS_INT delta = 0, delta_bytes = 0, stop_pos; + ptrdiff_t delta = 0, delta_bytes = 0, stop_pos; int dvpos, dy; struct text_pos start_pos; struct run run; int first_unchanged_at_end_vpos = 0; struct glyph_row *last_text_row, *last_text_row_at_end; struct text_pos start; - EMACS_INT first_changed_charpos, last_changed_charpos; + ptrdiff_t first_changed_charpos, last_changed_charpos; #if GLYPH_DEBUG if (inhibit_try_window_id) @@ -17052,7 +17179,7 @@ try_window_id (struct window *w) || (last_changed_charpos < CHARPOS (start) - 1 && FETCH_BYTE (BYTEPOS (start) - 1) == '\n'))) { - EMACS_INT Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes; + ptrdiff_t Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes; struct glyph_row *r0; /* Compute how many chars/bytes have been added to or removed @@ -17796,7 +17923,7 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs) row->visible_height, row->ascent, row->phys_ascent); - fprintf (stderr, "%9d %5d\t%5d\n", row->start.overlay_string_index, + fprintf (stderr, "%9"pD"d %5"pD"d\t%5d\n", row->start.overlay_string_index, row->end.overlay_string_index, row->continuation_lines_width); fprintf (stderr, "%9"pI"d %5"pI"d\n", @@ -17870,7 +17997,7 @@ glyphs in short form, otherwise show glyphs in long form. */) w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos); fprintf (stderr, "=============================================\n"); dump_glyph_matrix (w->current_matrix, - NILP (glyphs) ? 0 : XINT (glyphs)); + TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 0); return Qnil; } @@ -17893,7 +18020,7 @@ GLYPH > 1 or omitted means dump glyphs in long form. */) (Lisp_Object row, Lisp_Object glyphs) { struct glyph_matrix *matrix; - int vpos; + EMACS_INT vpos; CHECK_NUMBER (row); matrix = XWINDOW (selected_window)->current_matrix; @@ -17901,7 +18028,7 @@ GLYPH > 1 or omitted means dump glyphs in long form. */) if (vpos >= 0 && vpos < matrix->nrows) dump_glyph_row (MATRIX_ROW (matrix, vpos), vpos, - INTEGERP (glyphs) ? XINT (glyphs) : 2); + TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 2); return Qnil; } @@ -17915,13 +18042,13 @@ GLYPH > 1 or omitted means dump glyphs in long form. */) { struct frame *sf = SELECTED_FRAME (); struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix; - int vpos; + EMACS_INT vpos; CHECK_NUMBER (row); vpos = XINT (row); if (vpos >= 0 && vpos < m->nrows) dump_glyph_row (MATRIX_ROW (m, vpos), vpos, - INTEGERP (glyphs) ? XINT (glyphs) : 2); + TYPE_RANGED_INTEGERP (int, glyphs) ? XINT (glyphs) : 2); return Qnil; } @@ -18446,9 +18573,9 @@ extend_face_to_end_of_line (struct it *it) trailing whitespace. */ static int -trailing_whitespace_p (EMACS_INT charpos) +trailing_whitespace_p (ptrdiff_t charpos) { - EMACS_INT bytepos = CHAR_TO_BYTE (charpos); + ptrdiff_t bytepos = CHAR_TO_BYTE (charpos); int c = 0; while (bytepos < ZV_BYTE @@ -18590,7 +18717,7 @@ cursor_row_p (struct glyph_row *row) for ( ; glyph >= beg && EQ (glyph->object, s); --glyph) { - EMACS_INT gpos = glyph->charpos; + ptrdiff_t gpos = glyph->charpos; if (!NILP (Fget_char_property (make_number (gpos), Qcursor, s))) @@ -18787,8 +18914,8 @@ unproduce_glyphs (struct it *it, int n) and ROW->maxpos. */ static void find_row_edges (struct it *it, struct glyph_row *row, - EMACS_INT min_pos, EMACS_INT min_bpos, - EMACS_INT max_pos, EMACS_INT max_bpos) + ptrdiff_t min_pos, ptrdiff_t min_bpos, + ptrdiff_t max_pos, ptrdiff_t max_bpos) { /* FIXME: Revisit this when glyph ``spilling'' in continuation lines' rows is implemented for bidi-reordered rows. */ @@ -18955,11 +19082,11 @@ display_line (struct it *it) int wrap_row_ascent IF_LINT (= 0), wrap_row_height IF_LINT (= 0); int wrap_row_phys_ascent IF_LINT (= 0), wrap_row_phys_height IF_LINT (= 0); int wrap_row_extra_line_spacing IF_LINT (= 0); - EMACS_INT wrap_row_min_pos IF_LINT (= 0), wrap_row_min_bpos IF_LINT (= 0); - EMACS_INT wrap_row_max_pos IF_LINT (= 0), wrap_row_max_bpos IF_LINT (= 0); + ptrdiff_t wrap_row_min_pos IF_LINT (= 0), wrap_row_min_bpos IF_LINT (= 0); + ptrdiff_t wrap_row_max_pos IF_LINT (= 0), wrap_row_max_bpos IF_LINT (= 0); int cvpos; - EMACS_INT min_pos = ZV + 1, max_pos = 0; - EMACS_INT min_bpos IF_LINT (= 0), max_bpos IF_LINT (= 0); + ptrdiff_t min_pos = ZV + 1, max_pos = 0; + ptrdiff_t min_bpos IF_LINT (= 0), max_bpos IF_LINT (= 0); /* We always start displaying at hpos zero even if hscrolled. */ xassert (it->hpos == 0 && it->current_x == 0); @@ -19032,10 +19159,10 @@ display_line (struct it *it) { \ int composition_p = !STRINGP ((IT)->string) \ && ((IT)->what == IT_COMPOSITION); \ - EMACS_INT current_pos = \ + ptrdiff_t current_pos = \ composition_p ? (IT)->cmp_it.charpos \ : IT_CHARPOS (*(IT)); \ - EMACS_INT current_bpos = \ + ptrdiff_t current_bpos = \ composition_p ? CHAR_TO_BYTE (current_pos) \ : IT_BYTEPOS (*(IT)); \ if (current_pos < min_pos) \ @@ -19683,8 +19810,8 @@ See also `bidi-paragraph-direction'. */) use current_matrix if it is up to date, but this seems fast enough as it is. */ struct bidi_it itb; - EMACS_INT pos = BUF_PT (buf); - EMACS_INT bytepos = BUF_PT_BYTE (buf); + ptrdiff_t pos = BUF_PT (buf); + ptrdiff_t bytepos = BUF_PT_BYTE (buf); int c; void *itb_data = bidi_shelve_cache (); @@ -19972,7 +20099,7 @@ display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format) { struct it it; struct face *face; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); init_iterator (&it, w, -1, -1, NULL, face_id); /* Don't extend on a previously drawn mode-line. @@ -20108,7 +20235,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, { /* A string: output it and check for %-constructs within it. */ unsigned char c; - EMACS_INT offset = 0; + ptrdiff_t offset = 0; if (SCHARS (elt) > 0 && (!NILP (props) || risky)) @@ -20205,7 +20332,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, && (mode_line_target != MODE_LINE_DISPLAY || it->current_x < it->last_visible_x)) { - EMACS_INT last_offset = offset; + ptrdiff_t last_offset = offset; /* Advance to end of string or next format specifier. */ while ((c = SREF (elt, offset++)) != '\0' && c != '%') @@ -20213,7 +20340,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, if (offset - 1 != last_offset) { - EMACS_INT nchars, nbytes; + ptrdiff_t nchars, nbytes; /* Output to end of string or up to '%'. Field width is length of string. Don't output more than @@ -20232,9 +20359,9 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, break; case MODE_LINE_STRING: { - EMACS_INT bytepos = last_offset; - EMACS_INT charpos = string_byte_to_char (elt, bytepos); - EMACS_INT endpos = (precision <= 0 + ptrdiff_t bytepos = last_offset; + ptrdiff_t charpos = string_byte_to_char (elt, bytepos); + ptrdiff_t endpos = (precision <= 0 ? string_byte_to_char (elt, offset) : charpos + nchars); @@ -20246,8 +20373,8 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, break; case MODE_LINE_DISPLAY: { - EMACS_INT bytepos = last_offset; - EMACS_INT charpos = string_byte_to_char (elt, bytepos); + ptrdiff_t bytepos = last_offset; + ptrdiff_t charpos = string_byte_to_char (elt, bytepos); if (precision <= 0) nchars = string_byte_to_char (elt, offset) - charpos; @@ -20260,7 +20387,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, } else /* c == '%' */ { - EMACS_INT percent_position = offset; + ptrdiff_t percent_position = offset; /* Get the specified minimum width. Zero means don't pad. */ @@ -20282,7 +20409,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision, else if (c != 0) { int multibyte; - EMACS_INT bytepos, charpos; + ptrdiff_t bytepos, charpos; const char *spec; Lisp_Object string; @@ -20555,7 +20682,7 @@ static int store_mode_line_string (const char *string, Lisp_Object lisp_string, int copy_string, int field_width, int precision, Lisp_Object props) { - EMACS_INT len; + ptrdiff_t len; int n = 0; if (string != NULL) @@ -20656,7 +20783,7 @@ are the selected window and the WINDOW's buffer). */) struct buffer *old_buffer = NULL; int face_id; int no_props = INTEGERP (face); - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); Lisp_Object str; int string_start = 0; @@ -20742,7 +20869,7 @@ are the selected window and the WINDOW's buffer). */) the positive integer D to BUF using a minimal field width WIDTH. */ static void -pint2str (register char *buf, register int width, register EMACS_INT d) +pint2str (register char *buf, register int width, register ptrdiff_t d) { register char *p = buf; @@ -20786,11 +20913,11 @@ static const char power_letter[] = }; static void -pint2hrstr (char *buf, int width, EMACS_INT d) +pint2hrstr (char *buf, int width, ptrdiff_t d) { /* We aim to represent the nonnegative integer D as QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */ - EMACS_INT quotient = d; + ptrdiff_t quotient = d; int remainder = 0; /* -1 means: do not use TENTHS. */ int tenths = -1; @@ -20900,8 +21027,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_ if (!VECTORP (val)) /* Not yet decided. */ { - if (multibyte) - *buf++ = '-'; + *buf++ = multibyte ? '-' : ' '; if (eol_flag) eoltype = eol_mnemonic_undecided; /* Don't mention EOL conversion if it isn't decided. */ @@ -20914,8 +21040,9 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_ attrs = AREF (val, 0); eolvalue = AREF (val, 2); - if (multibyte) - *buf++ = XFASTINT (CODING_ATTR_MNEMONIC (attrs)); + *buf++ = multibyte + ? XFASTINT (CODING_ATTR_MNEMONIC (attrs)) + : ' '; if (eol_flag) { @@ -21070,7 +21197,7 @@ decode_mode_spec (struct window *w, register int c, int field_width, return ""; else { - EMACS_INT col = current_column (); + ptrdiff_t col = current_column (); w->column_number_displayed = make_number (col); pint2str (decode_mode_spec_buf, field_width, col); return decode_mode_spec_buf; @@ -21102,23 +21229,23 @@ decode_mode_spec (struct window *w, register int c, int field_width, case 'i': { - EMACS_INT size = ZV - BEGV; + ptrdiff_t size = ZV - BEGV; pint2str (decode_mode_spec_buf, field_width, size); return decode_mode_spec_buf; } case 'I': { - EMACS_INT size = ZV - BEGV; + ptrdiff_t size = ZV - BEGV; pint2hrstr (decode_mode_spec_buf, field_width, size); return decode_mode_spec_buf; } case 'l': { - EMACS_INT startpos, startpos_byte, line, linepos, linepos_byte; - EMACS_INT topline, nlines, height; - EMACS_INT junk; + ptrdiff_t startpos, startpos_byte, line, linepos, linepos_byte; + ptrdiff_t topline, nlines, height; + ptrdiff_t junk; /* %c and %l are ignored in `frame-title-format'. */ if (mode_line_target == MODE_LINE_TITLE) @@ -21179,10 +21306,10 @@ decode_mode_spec (struct window *w, register int c, int field_width, else if (nlines < height + 25 || nlines > height * 3 + 50 || linepos == BUF_BEGV (b)) { - EMACS_INT limit = BUF_BEGV (b); - EMACS_INT limit_byte = BUF_BEGV_BYTE (b); - EMACS_INT position; - EMACS_INT distance = + ptrdiff_t limit = BUF_BEGV (b); + ptrdiff_t limit_byte = BUF_BEGV_BYTE (b); + ptrdiff_t position; + ptrdiff_t distance = (height * 2 + 30) * line_number_display_limit_width; if (startpos - distance > limit) @@ -21244,8 +21371,8 @@ decode_mode_spec (struct window *w, register int c, int field_width, case 'p': { - EMACS_INT pos = marker_position (w->start); - EMACS_INT total = BUF_ZV (b) - BUF_BEGV (b); + ptrdiff_t pos = marker_position (w->start); + ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b); if (XFASTINT (w->window_end_pos) <= BUF_Z (b) - BUF_ZV (b)) { @@ -21267,7 +21394,7 @@ decode_mode_spec (struct window *w, register int c, int field_width, so get us a 2-digit number that is close. */ if (total == 100) total = 99; - sprintf (decode_mode_spec_buf, "%2"pI"d%%", total); + sprintf (decode_mode_spec_buf, "%2"pD"d%%", total); return decode_mode_spec_buf; } } @@ -21275,9 +21402,9 @@ decode_mode_spec (struct window *w, register int c, int field_width, /* Display percentage of size above the bottom of the screen. */ case 'P': { - EMACS_INT toppos = marker_position (w->start); - EMACS_INT botpos = BUF_Z (b) - XFASTINT (w->window_end_pos); - EMACS_INT total = BUF_ZV (b) - BUF_BEGV (b); + ptrdiff_t toppos = marker_position (w->start); + ptrdiff_t botpos = BUF_Z (b) - XFASTINT (w->window_end_pos); + ptrdiff_t total = BUF_ZV (b) - BUF_BEGV (b); if (botpos >= BUF_ZV (b)) { @@ -21298,9 +21425,9 @@ decode_mode_spec (struct window *w, register int c, int field_width, if (total == 100) total = 99; if (toppos <= BUF_BEGV (b)) - sprintf (decode_mode_spec_buf, "Top%2"pI"d%%", total); + sprintf (decode_mode_spec_buf, "Top%2"pD"d%%", total); else - sprintf (decode_mode_spec_buf, "%2"pI"d%%", total); + sprintf (decode_mode_spec_buf, "%2"pD"d%%", total); return decode_mode_spec_buf; } } @@ -21317,7 +21444,7 @@ decode_mode_spec (struct window *w, register int c, int field_width, case '@': { - int count = inhibit_garbage_collection (); + ptrdiff_t count = inhibit_garbage_collection (); Lisp_Object val = call1 (intern ("file-remote-p"), BVAR (current_buffer, directory)); unbind_to (count, Qnil); @@ -21386,17 +21513,17 @@ decode_mode_spec (struct window *w, register int c, int field_width, Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT. */ -static EMACS_INT -display_count_lines (EMACS_INT start_byte, - EMACS_INT limit_byte, EMACS_INT count, - EMACS_INT *byte_pos_ptr) +static ptrdiff_t +display_count_lines (ptrdiff_t start_byte, + ptrdiff_t limit_byte, ptrdiff_t count, + ptrdiff_t *byte_pos_ptr) { register unsigned char *cursor; unsigned char *base; - register EMACS_INT ceiling; + register ptrdiff_t ceiling; register unsigned char *ceiling_addr; - EMACS_INT orig_count = count; + ptrdiff_t orig_count = count; /* If we are not in selective display mode, check only for newlines. */ @@ -21530,13 +21657,13 @@ display_count_lines (EMACS_INT start_byte, static int display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_string, - EMACS_INT face_string_pos, EMACS_INT start, struct it *it, + ptrdiff_t face_string_pos, ptrdiff_t start, struct it *it, int field_width, int precision, int max_x, int multibyte) { int hpos_at_start = it->hpos; int saved_face_id = it->face_id; struct glyph_row *row = it->glyph_row; - EMACS_INT it_charpos; + ptrdiff_t it_charpos; /* Initialize the iterator IT for iteration over STRING beginning with index START. */ @@ -21551,7 +21678,7 @@ display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_st FACE_STRING, if that's given. */ if (STRINGP (face_string)) { - EMACS_INT endptr; + ptrdiff_t endptr; struct face *face; it->face_id @@ -21980,7 +22107,9 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop, return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w)); } - prop = Fbuffer_local_value (prop, it->w->buffer); + prop = buffer_local_value_1 (prop, it->w->buffer); + if (EQ (prop, Qunbound)) + prop = Qnil; } if (INTEGERP (prop) || FLOATP (prop)) @@ -22030,7 +22159,9 @@ calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop, return OK_PIXELS (pixels); } - car = Fbuffer_local_value (car, it->w->buffer); + car = buffer_local_value_1 (car, it->w->buffer); + if (EQ (car, Qunbound)) + car = Qnil; } if (INTEGERP (car) || FLOATP (car)) @@ -23038,7 +23169,7 @@ compute_overhangs_and_x (struct glyph_string *s, int x, int backward_p) static int draw_glyphs (struct window *w, int x, struct glyph_row *row, - enum glyph_row_area area, EMACS_INT start, EMACS_INT end, + enum glyph_row_area area, ptrdiff_t start, ptrdiff_t end, enum draw_glyphs_face hl, int overlaps) { struct glyph_string *head, *tail; @@ -24502,7 +24633,7 @@ x_produce_glyphs (struct it *it) XChar2b char2b; struct font_metrics *pcm; int font_not_found_p; - EMACS_INT pos; + ptrdiff_t pos; for (glyph_len = cmp->glyph_len; glyph_len > 0; glyph_len--) if ((c = COMPOSITION_GLYPH (cmp, glyph_len - 1)) != '\t') @@ -24910,7 +25041,7 @@ x_insert_glyphs (struct glyph *start, int len) struct glyph_row *row; struct glyph *glyph; int frame_x, frame_y; - EMACS_INT hpos; + ptrdiff_t hpos; xassert (updated_window && updated_row); BLOCK_INPUT; @@ -25057,8 +25188,7 @@ get_specified_cursor_type (Lisp_Object arg, int *width) if (CONSP (arg) && EQ (XCAR (arg), Qbar) - && INTEGERP (XCDR (arg)) - && XINT (XCDR (arg)) >= 0) + && RANGED_INTEGERP (0, XCDR (arg), INT_MAX)) { *width = XINT (XCDR (arg)); return BAR_CURSOR; @@ -25072,8 +25202,7 @@ get_specified_cursor_type (Lisp_Object arg, int *width) if (CONSP (arg) && EQ (XCAR (arg), Qhbar) - && INTEGERP (XCDR (arg)) - && XINT (XCDR (arg)) >= 0) + && RANGED_INTEGERP (0, XCDR (arg), INT_MAX)) { *width = XINT (XCDR (arg)); return HBAR_CURSOR; @@ -25731,7 +25860,7 @@ draw_row_with_mouse_face (struct window *w, int start_x, struct glyph_row *row, return; } #endif -#if defined (HAVE_GPM) || defined (MSDOS) +#if defined (HAVE_GPM) || defined (MSDOS) || defined (WINDOWSNT) tty_draw_row_with_mouse_face (w, row, start_hpos, end_hpos, draw); #endif } @@ -25970,7 +26099,7 @@ cursor_in_mouse_face_p (struct window *w) buffer positions change non-linearly with glyph rows. */ static void rows_from_pos_range (struct window *w, - EMACS_INT start_charpos, EMACS_INT end_charpos, + ptrdiff_t start_charpos, ptrdiff_t end_charpos, Lisp_Object disp_string, struct glyph_row **start, struct glyph_row **end) { @@ -26046,7 +26175,7 @@ rows_from_pos_range (struct window *w, for ( ; row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y; row++) { struct glyph_row *next = row + 1; - EMACS_INT next_start = MATRIX_ROW_START_CHARPOS (next); + ptrdiff_t next_start = MATRIX_ROW_START_CHARPOS (next); if (!next->enabled_p || next >= MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w) @@ -26127,9 +26256,9 @@ rows_from_pos_range (struct window *w, static void mouse_face_from_buffer_pos (Lisp_Object window, Mouse_HLInfo *hlinfo, - EMACS_INT mouse_charpos, - EMACS_INT start_charpos, - EMACS_INT end_charpos, + ptrdiff_t mouse_charpos, + ptrdiff_t start_charpos, + ptrdiff_t end_charpos, Lisp_Object before_string, Lisp_Object after_string, Lisp_Object disp_string) @@ -26138,7 +26267,7 @@ mouse_face_from_buffer_pos (Lisp_Object window, struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix); struct glyph_row *r1, *r2; struct glyph *glyph, *end; - EMACS_INT ignore, pos; + ptrdiff_t ignore, pos; int x; xassert (NILP (disp_string) || STRINGP (disp_string)); @@ -26471,7 +26600,7 @@ mouse_face_from_buffer_pos (Lisp_Object window, Value is non-zero if a glyph was found. */ static int -fast_find_string_pos (struct window *w, EMACS_INT pos, Lisp_Object object, +fast_find_string_pos (struct window *w, ptrdiff_t pos, Lisp_Object object, int *hpos, int *vpos, int *x, int *y, int right_p) { int yb = window_text_bottom_y (w); @@ -26541,7 +26670,7 @@ fast_find_string_pos (struct window *w, EMACS_INT pos, Lisp_Object object, static void mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo, Lisp_Object object, - EMACS_INT startpos, EMACS_INT endpos) + ptrdiff_t startpos, ptrdiff_t endpos) { int yb = window_text_bottom_y (w); struct glyph_row *r; @@ -26711,8 +26840,8 @@ on_hot_spot_p (Lisp_Object hot_spot, int x, int y) { struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot)); Lisp_Object *poly = v->contents; - int n = v->header.size; - int i; + ptrdiff_t n = v->header.size; + ptrdiff_t i; int inside = 0; Lisp_Object lx, ly; int x0, y0; @@ -26790,7 +26919,9 @@ Returns the alist element for the first matching AREA in MAP. */) CHECK_NUMBER (x); CHECK_NUMBER (y); - return find_hot_spot (map, XINT (x), XINT (y)); + return find_hot_spot (map, + clip_to_bounds (INT_MIN, XINT (x), INT_MAX), + clip_to_bounds (INT_MIN, XINT (y), INT_MAX)); } @@ -26849,14 +26980,14 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y, Cursor cursor = No_Cursor; Lisp_Object pointer = Qnil; int dx, dy, width, height; - EMACS_INT charpos; + ptrdiff_t charpos; Lisp_Object string, object = Qnil; - Lisp_Object pos, help; + Lisp_Object pos IF_LINT (= Qnil), help; Lisp_Object mouse_face; int original_x_pixel = x; struct glyph * glyph = NULL, * row_start_glyph = NULL; - struct glyph_row *row; + struct glyph_row *row IF_LINT (= 0); if (area == ON_MODE_LINE || area == ON_HEADER_LINE) { @@ -26924,7 +27055,6 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y, if (!NILP (help)) { help_echo_string = help; - /* Is this correct? ++kfs */ XSETWINDOW (help_echo_window, w); help_echo_object = w->buffer; help_echo_pos = charpos; @@ -26937,14 +27067,20 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y, #endif /* HAVE_WINDOW_SYSTEM */ if (STRINGP (string)) + pos = make_number (charpos); + + /* Set the help text and mouse pointer. If the mouse is on a part + of the mode line without any text (e.g. past the right edge of + the mode line text), use the default help text and pointer. */ + if (STRINGP (string) || area == ON_MODE_LINE) { - pos = make_number (charpos); - /* If we're on a string with `help-echo' text property, arrange - for the help to be displayed. This is done by setting the - global variable help_echo_string to the help string. */ + /* Arrange to display the help by setting the global variables + help_echo_string, help_echo_object, and help_echo_pos. */ if (NILP (help)) { - help = Fget_text_property (pos, Qhelp_echo, string); + if (STRINGP (string)) + help = Fget_text_property (pos, Qhelp_echo, string); + if (!NILP (help)) { help_echo_string = help; @@ -26952,31 +27088,56 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y, help_echo_object = string; help_echo_pos = charpos; } + else if (area == ON_MODE_LINE) + { + Lisp_Object default_help + = buffer_local_value_1 (Qmode_line_default_help_echo, + w->buffer); + + if (STRINGP (default_help)) + { + help_echo_string = default_help; + XSETWINDOW (help_echo_window, w); + help_echo_object = Qnil; + help_echo_pos = -1; + } + } } #ifdef HAVE_WINDOW_SYSTEM + /* Change the mouse pointer according to what is under it. */ if (FRAME_WINDOW_P (f)) { dpyinfo = FRAME_X_DISPLAY_INFO (f); - cursor = FRAME_X_OUTPUT (f)->nontext_cursor; - if (NILP (pointer)) - pointer = Fget_text_property (pos, Qpointer, string); - - /* Change the mouse pointer according to what is under X/Y. */ - if (NILP (pointer) - && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))) + if (STRINGP (string)) { - Lisp_Object map; - map = Fget_text_property (pos, Qlocal_map, string); - if (!KEYMAPP (map)) - map = Fget_text_property (pos, Qkeymap, string); - if (!KEYMAPP (map)) - cursor = dpyinfo->vertical_scroll_bar_cursor; + cursor = FRAME_X_OUTPUT (f)->nontext_cursor; + + if (NILP (pointer)) + pointer = Fget_text_property (pos, Qpointer, string); + + /* Change the mouse pointer according to what is under X/Y. */ + if (NILP (pointer) + && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))) + { + Lisp_Object map; + map = Fget_text_property (pos, Qlocal_map, string); + if (!KEYMAPP (map)) + map = Fget_text_property (pos, Qkeymap, string); + if (!KEYMAPP (map)) + cursor = dpyinfo->vertical_scroll_bar_cursor; + } } + else + /* Default mode-line pointer. */ + cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor; } #endif + } - /* Change the mouse face according to what is under X/Y. */ + /* Change the mouse face according to what is under X/Y. */ + if (STRINGP (string)) + { mouse_face = Fget_text_property (pos, Qmouse_face, string); if (!NILP (mouse_face) && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)) @@ -26989,7 +27150,7 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y, int gpos; int gseq_length; int total_pixel_width; - EMACS_INT begpos, endpos, ignore; + ptrdiff_t begpos, endpos, ignore; int vpos, hpos; @@ -27219,14 +27380,14 @@ note_mouse_highlight (struct frame *f, int x, int y) && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b)) { int hpos, vpos, dx, dy, area = LAST_AREA; - EMACS_INT pos; + ptrdiff_t pos; struct glyph *glyph; Lisp_Object object; Lisp_Object mouse_face = Qnil, position; Lisp_Object *overlay_vec = NULL; ptrdiff_t i, noverlays; struct buffer *obuf; - EMACS_INT obegv, ozv; + ptrdiff_t obegv, ozv; int same_region; /* Find the glyph under X/Y. */ @@ -27384,7 +27545,7 @@ note_mouse_highlight (struct frame *f, int x, int y) /* The mouse-highlighting comes from a display string with a mouse-face. */ Lisp_Object s, e; - EMACS_INT ignore; + ptrdiff_t ignore; s = Fprevious_single_property_change (make_number (pos + 1), Qmouse_face, object, Qnil); @@ -27416,7 +27577,7 @@ note_mouse_highlight (struct frame *f, int x, int y) /* If we are on a display string with no mouse-face, check if the text under it has one. */ struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos); - EMACS_INT start = MATRIX_ROW_START_CHARPOS (r); + ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r); pos = string_buffer_position (object, start); if (pos > 0) { @@ -27515,7 +27676,7 @@ note_mouse_highlight (struct frame *f, int x, int y) else { Lisp_Object obj = glyph->object; - EMACS_INT charpos = glyph->charpos; + ptrdiff_t charpos = glyph->charpos; /* Try text properties. */ if (STRINGP (obj) @@ -27530,8 +27691,8 @@ note_mouse_highlight (struct frame *f, int x, int y) see if the buffer text ``under'' it does. */ struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos); - EMACS_INT start = MATRIX_ROW_START_CHARPOS (r); - EMACS_INT p = string_buffer_position (obj, start); + ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r); + ptrdiff_t p = string_buffer_position (obj, start); if (p > 0) { help = Fget_char_property (make_number (p), @@ -27571,7 +27732,7 @@ note_mouse_highlight (struct frame *f, int x, int y) if (NILP (pointer)) { Lisp_Object obj = glyph->object; - EMACS_INT charpos = glyph->charpos; + ptrdiff_t charpos = glyph->charpos; /* Try text properties. */ if (STRINGP (obj) @@ -27586,8 +27747,8 @@ note_mouse_highlight (struct frame *f, int x, int y) see if the buffer text ``under'' it does. */ struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos); - EMACS_INT start = MATRIX_ROW_START_CHARPOS (r); - EMACS_INT p = string_buffer_position (obj, start); + ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r); + ptrdiff_t p = string_buffer_position (obj, start); if (p > 0) pointer = Fget_char_property (make_number (p), Qpointer, w->buffer); @@ -28317,6 +28478,8 @@ syms_of_xdisp (void) Vmode_line_unwind_vector = Qnil; staticpro (&Vmode_line_unwind_vector); + DEFSYM (Qmode_line_default_help_echo, "mode-line-default-help-echo"); + help_echo_string = Qnil; staticpro (&help_echo_string); help_echo_object = Qnil; @@ -28597,7 +28760,9 @@ It can be one of both - show both, text below image both-horiz - show text to the right of the image text-image-horiz - show text to the left of the image - any other - use system default or image if no system default. */); + any other - use system default or image if no system default. + +This variable only affects the GTK+ toolkit version of Emacs. */); Vtool_bar_style = Qnil; DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size, @@ -28870,37 +29035,22 @@ init_xdisp (void) /* Platform-independent portion of hourglass implementation. */ -/* Return non-zero if hourglass timer has been started or hourglass is - shown. */ -int -hourglass_started (void) -{ - return hourglass_shown_p || hourglass_atimer != NULL; -} - /* Cancel a currently active hourglass timer, and start a new one. */ void start_hourglass (void) { #if defined (HAVE_WINDOW_SYSTEM) EMACS_TIME delay; - int secs, usecs = 0; + int secs = DEFAULT_HOURGLASS_DELAY, usecs = 0; cancel_hourglass (); - if (INTEGERP (Vhourglass_delay) - && XINT (Vhourglass_delay) > 0) - secs = XFASTINT (Vhourglass_delay); - else if (FLOATP (Vhourglass_delay) - && XFLOAT_DATA (Vhourglass_delay) > 0) + if (NUMBERP (Vhourglass_delay)) { - Lisp_Object tem; - tem = Ftruncate (Vhourglass_delay, Qnil); - secs = XFASTINT (tem); - usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000; + double duration = extract_float (Vhourglass_delay); + if (0 < duration) + duration_to_sec_usec (duration, &secs, &usecs); } - else - secs = DEFAULT_HOURGLASS_DELAY; EMACS_SET_SECS_USECS (delay, secs, usecs); hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,