X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/e9a9ae0350689d352c2bdfa3af0eb722f587b966..3a880af4a79688e90da45311a8d85bae2d59a811:/src/dispnew.c diff --git a/src/dispnew.c b/src/dispnew.c index c149baec50..555136d785 100644 --- a/src/dispnew.c +++ b/src/dispnew.c @@ -18,10 +18,10 @@ You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see . */ #include -#include + +#define DISPEXTERN_INLINE EXTERN_INLINE + #include -#include -#include #include #include "lisp.h" @@ -45,50 +45,19 @@ along with GNU Emacs. If not, see . */ #include "syssignal.h" -#ifdef HAVE_X_WINDOWS -#include "xterm.h" -#endif /* HAVE_X_WINDOWS */ - -#ifdef HAVE_NTGUI -#include "w32term.h" -#endif /* HAVE_NTGUI */ - -#ifdef HAVE_NS -#include "nsterm.h" -#endif +#ifdef HAVE_WINDOW_SYSTEM +#include TERM_HEADER +#endif /* HAVE_WINDOW_SYSTEM */ /* Include systime.h after xterm.h to avoid double inclusion of time.h. */ #include "systime.h" #include -/* Get number of chars of output now in the buffer of a stdio stream. - This ought to be built in stdio, but it isn't. Some s- files - override this because their stdio internals differ. */ -#ifdef __GNU_LIBRARY__ - -/* The s- file might have overridden the definition with one that - works for the system's C library. But we are using the GNU C - library, so this is the right definition for every system. */ -#ifdef GNU_LIBRARY_PENDING_OUTPUT_COUNT -#define PENDING_OUTPUT_COUNT GNU_LIBRARY_PENDING_OUTPUT_COUNT -#else -#undef PENDING_OUTPUT_COUNT -#define PENDING_OUTPUT_COUNT(FILE) ((FILE)->__bufp - (FILE)->__buffer) -#endif - -/* not __GNU_LIBRARY__ and no PENDING_OUTPUT_COUNT defined */ -#elif !defined (PENDING_OUTPUT_COUNT) - -#if HAVE_STDIO_EXT_H && HAVE___FPENDING +#ifdef DISPNEW_NEEDS_STDIO_EXT #include -#define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE) -#else -#define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base) #endif -#endif /* not __GNU_LIBRARY__ and no PENDING_OUTPUT_COUNT defined */ - #if defined (HAVE_TERM_H) && defined (GNU_LINUX) #include /* for tgetent */ #endif @@ -109,7 +78,7 @@ static void update_frame_line (struct frame *, int); static int required_matrix_height (struct window *); static int required_matrix_width (struct window *); static void adjust_frame_glyphs (struct frame *); -static void change_frame_size_1 (struct frame *, int, int, int, int, int); +static void change_frame_size_1 (struct frame *, int, int, bool, bool, bool); static void increment_row_positions (struct glyph_row *, ptrdiff_t, ptrdiff_t); static void fill_up_frame_row_with_spaces (struct glyph_row *, int); static void build_frame_matrix_from_window_tree (struct glyph_matrix *, @@ -119,20 +88,20 @@ static void build_frame_matrix_from_leaf_window (struct glyph_matrix *, static void adjust_frame_message_buffer (struct frame *); static void adjust_decode_mode_spec_buffer (struct frame *); static void fill_up_glyph_row_with_spaces (struct glyph_row *); -static void clear_window_matrices (struct window *, int); +static void clear_window_matrices (struct window *, bool); static void fill_up_glyph_row_area_with_spaces (struct glyph_row *, int); -static int scrolling_window (struct window *, int); -static int update_window_line (struct window *, int, int *); +static int scrolling_window (struct window *, bool); +static bool update_window_line (struct window *, int, bool *); static void mirror_make_current (struct window *, int); #ifdef GLYPH_DEBUG static void check_matrix_pointers (struct glyph_matrix *, struct glyph_matrix *); #endif static void mirror_line_dance (struct window *, int, int, int *, char *); -static int update_window_tree (struct window *, int); -static int update_window (struct window *, int); -static int update_frame_1 (struct frame *, int, int); -static int scrolling (struct frame *); +static bool update_window_tree (struct window *, bool); +static bool update_window (struct window *, bool); +static bool update_frame_1 (struct frame *, bool, bool); +static bool scrolling (struct frame *); static void set_window_cursor_after_update (struct window *); static void adjust_frame_glyphs_for_window_redisplay (struct frame *); static void adjust_frame_glyphs_for_frame_redisplay (struct frame *); @@ -143,14 +112,14 @@ static void adjust_frame_glyphs_for_frame_redisplay (struct frame *); static EMACS_TIME preemption_period; static EMACS_TIME preemption_next_check; -/* Nonzero upon entry to redisplay means do not assume anything about +/* True upon entry to redisplay means do not assume anything about current contents of actual terminal frame; clear and redraw it. */ -int frame_garbaged; +bool frame_garbaged; -/* Nonzero means last display completed. Zero means it was preempted. */ +/* True means last display completed. False means it was preempted. */ -int display_completed; +bool display_completed; Lisp_Object Qdisplay_table, Qredisplay_dont_pause; @@ -167,13 +136,13 @@ Lisp_Object selected_frame; struct frame *last_nonminibuf_frame; -/* 1 means SIGWINCH happened when not safe. */ +/* True means SIGWINCH happened when not safe. */ -static int delayed_size_change; +static bool delayed_size_change; /* 1 means glyph initialization has been completed at startup. */ -static int glyphs_initialized_initially_p; +static bool glyphs_initialized_initially_p; /* Updated window if != 0. Set by update_window. */ @@ -199,15 +168,15 @@ static int glyph_pool_count; static struct frame *frame_matrix_frame; -/* Non-zero means that fonts have been loaded since the last glyph +/* True means that fonts have been loaded since the last glyph matrix adjustments. Redisplay must stop, and glyph matrices must - be adjusted when this flag becomes non-zero during display. The + be adjusted when this flag becomes true during display. The reason fonts can be loaded so late is that fonts of fontsets are loaded on demand. Another reason is that a line contains many characters displayed by zero width or very narrow glyphs of variable-width fonts. */ -int fonts_changed_p; +bool fonts_changed_p; /* Convert vpos and hpos from frame to window and vice versa. This may only be used for terminal frames. */ @@ -243,16 +212,14 @@ static int history_idx; history. */ static uprintmax_t history_tick; - -static void add_frame_display_history (struct frame *, int); /* Add to the redisplay history how window W has been displayed. MSG is a trace containing the information how W's glyph matrix - has been constructed. PAUSED_P non-zero means that the update + has been constructed. PAUSED_P means that the update has been interrupted for pending input. */ static void -add_window_display_history (struct window *w, const char *msg, int paused_p) +add_window_display_history (struct window *w, const char *msg, bool paused_p) { char *buf; @@ -275,11 +242,11 @@ add_window_display_history (struct window *w, const char *msg, int paused_p) /* Add to the redisplay history that frame F has been displayed. - PAUSED_P non-zero means that the update has been interrupted for + PAUSED_P means that the update has been interrupted for pending input. */ static void -add_frame_display_history (struct frame *f, int paused_p) +add_frame_display_history (struct frame *f, bool paused_p) { char *buf; @@ -328,7 +295,7 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history, void __executable_start (void) { - abort (); + emacs_abort (); } #endif @@ -378,7 +345,7 @@ free_glyph_matrix (struct glyph_matrix *matrix) /* Detect the case that more matrices are freed than were allocated. */ if (--glyph_matrix_count < 0) - abort (); + emacs_abort (); /* Free glyph memory if MATRIX owns it. */ if (matrix->pool == NULL) @@ -416,10 +383,10 @@ margin_glyphs_to_reserve (struct window *w, int total_glyphs, Lisp_Object margin return n; } -/* Return non-zero if ROW's hash value is correct, zero if not. +/* Return true if ROW's hash value is correct. Optimized away if ENABLE_CHECKING is not defined. */ -static int +static bool verify_row_hash (struct glyph_row *row) { return row->hash == row_hash (row); @@ -452,9 +419,9 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y { int i; int new_rows; - int marginal_areas_changed_p = 0; - int header_line_changed_p = 0; - int header_line_p = 0; + bool marginal_areas_changed_p = 0; + bool header_line_changed_p = 0; + bool header_line_p = 0; int left = -1, right = -1; int window_width = -1, window_height = -1; @@ -642,7 +609,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y are invalidated below. */ if (INTEGERP (w->window_end_vpos) && XFASTINT (w->window_end_vpos) >= i) - w->window_end_valid = Qnil; + wset_window_end_valid (w, Qnil); while (i < matrix->nrows) matrix->rows[i++].enabled_p = 0; @@ -757,30 +724,28 @@ increment_matrix_positions (struct glyph_matrix *matrix, int start, int end, } -/* Enable a range of rows in glyph matrix MATRIX. START and END are - the row indices of the first and last + 1 row to enable. If - ENABLED_P is non-zero, enabled_p flags in rows will be set to 1. */ +/* Clear the enable_p flags in a range of rows in glyph matrix MATRIX. + START and END are the row indices of the first and last + 1 row to clear. */ void -enable_glyph_matrix_rows (struct glyph_matrix *matrix, int start, int end, int enabled_p) +clear_glyph_matrix_rows (struct glyph_matrix *matrix, int start, int end) { eassert (start <= end); eassert (start >= 0 && start < matrix->nrows); eassert (end >= 0 && end <= matrix->nrows); for (; start < end; ++start) - matrix->rows[start].enabled_p = enabled_p != 0; + matrix->rows[start].enabled_p = 0; } /* Clear MATRIX. - This empties all rows in MATRIX by setting the enabled_p flag for - all rows of the matrix to zero. The function prepare_desired_row - will eventually really clear a row when it sees one with a zero - enabled_p flag. + Empty all rows in MATRIX by clearing their enabled_p flags. + The function prepare_desired_row will eventually really clear a row + when it sees one with a false enabled_p flag. - Resets update hints to defaults value. The only update hint + Reset update hints to default values. The only update hint currently present is the flag MATRIX->no_scrolling_p. */ void @@ -788,7 +753,7 @@ clear_glyph_matrix (struct glyph_matrix *matrix) { if (matrix) { - enable_glyph_matrix_rows (matrix, 0, matrix->nrows, 0); + clear_glyph_matrix_rows (matrix, 0, matrix->nrows); matrix->no_scrolling_p = 0; } } @@ -874,11 +839,11 @@ clear_desired_matrices (register struct frame *f) } -/* Clear matrices in window tree rooted in W. If DESIRED_P is - non-zero clear desired matrices, otherwise clear current matrices. */ +/* Clear matrices in window tree rooted in W. If DESIRED_P, + clear desired matrices, otherwise clear current matrices. */ static void -clear_window_matrices (struct window *w, int desired_p) +clear_window_matrices (struct window *w, bool desired_p) { while (w) { @@ -899,7 +864,7 @@ clear_window_matrices (struct window *w, int desired_p) else { clear_glyph_matrix (w->current_matrix); - w->window_end_valid = Qnil; + wset_window_end_valid (w, Qnil); } } @@ -1130,12 +1095,12 @@ assign_row (struct glyph_row *to, struct glyph_row *from) /* Test whether the glyph memory of the glyph row WINDOW_ROW, which is a row in a window matrix, is a slice of the glyph memory of the glyph row FRAME_ROW which is a row in a frame glyph matrix. Value - is non-zero if the glyph memory of WINDOW_ROW is part of the glyph + is true if the glyph memory of WINDOW_ROW is part of the glyph memory of FRAME_ROW. */ #ifdef GLYPH_DEBUG -static int +static bool glyph_row_slice_p (struct glyph_row *window_row, struct glyph_row *frame_row) { struct glyph *window_glyph_start = window_row->glyphs[0]; @@ -1182,7 +1147,7 @@ prepare_desired_row (struct glyph_row *row) { if (!row->enabled_p) { - int rp = row->reversed_p; + bool rp = row->reversed_p; clear_glyph_row (row); row->enabled_p = 1; @@ -1281,12 +1246,11 @@ line_draw_cost (struct glyph_matrix *matrix, int vpos) } -/* Test two glyph rows A and B for equality. Value is non-zero if A - and B have equal contents. MOUSE_FACE_P non-zero means compare the - mouse_face_p flags of A and B, too. */ +/* Return true if the glyph rows A and B have equal contents. + MOUSE_FACE_P means compare the mouse_face_p flags of A and B, too. */ -static inline int -row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p) +static inline bool +row_equal_p (struct glyph_row *a, struct glyph_row *b, bool mouse_face_p) { eassert (verify_row_hash (a)); eassert (verify_row_hash (b)); @@ -1401,14 +1365,14 @@ free_glyph_pool (struct glyph_pool *pool) is changed from a large value to a smaller one. But, if someone does it once, we can expect that he will do it again. - Value is non-zero if the pool changed in a way which makes + Return true if the pool changed in a way which makes re-adjusting window glyph matrices necessary. */ -static int +static bool realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim) { ptrdiff_t needed; - int changed_p; + bool changed_p; changed_p = (pool->glyphs == 0 || matrix_dim.height != pool->nrows @@ -1582,7 +1546,7 @@ check_matrix_invariants (struct window *w) X and Y are column/row within the frame glyph matrix where sub-matrices for the window tree rooted at WINDOW must be - allocated. DIM_ONLY_P non-zero means that the caller of this + allocated. DIM_ONLY_P means that the caller of this function is only interested in the result matrix dimension, and matrix adjustments should not be performed. @@ -1659,7 +1623,7 @@ check_matrix_invariants (struct window *w) static struct dim allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y, - int dim_only_p, int *window_change_flags) + bool dim_only_p, int *window_change_flags) { struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (window))); int x0 = x, y0 = y; @@ -1667,7 +1631,7 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y, struct dim total; struct dim dim; struct window *w; - int in_horz_combination_p; + bool in_horz_combination_p; /* What combination is WINDOW part of? Compute this once since the result is the same for all windows in the `next' chain. The @@ -1725,7 +1689,7 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y, /* Actually change matrices, if allowed. Do not consider CHANGED_LEAF_MATRIX computed above here because the pool may have been changed which we don't now here. We trust - that we only will be called with DIM_ONLY_P != 0 when + that we only will be called with DIM_ONLY_P when necessary. */ if (!dim_only_p) { @@ -1870,7 +1834,7 @@ adjust_glyphs (struct frame *f) { /* Block input so that expose events and other events that access glyph matrices are not processed while we are changing them. */ - BLOCK_INPUT; + block_input (); if (f) adjust_frame_glyphs (f); @@ -1882,7 +1846,7 @@ adjust_glyphs (struct frame *f) adjust_frame_glyphs (XFRAME (lisp_frame)); } - UNBLOCK_INPUT; + unblock_input (); } @@ -1908,14 +1872,14 @@ adjust_frame_glyphs_initially (void) int top_margin = FRAME_TOP_MARGIN (sf); /* Do it for the root window. */ - XSETFASTINT (root->top_line, top_margin); - XSETFASTINT (root->total_lines, frame_lines - 1 - top_margin); - XSETFASTINT (root->total_cols, frame_cols); + wset_top_line (root, make_number (top_margin)); + wset_total_lines (root, make_number (frame_lines - 1 - top_margin)); + wset_total_cols (root, make_number (frame_cols)); /* Do it for the mini-buffer window. */ - XSETFASTINT (mini->top_line, frame_lines - 1); - XSETFASTINT (mini->total_lines, 1); - XSETFASTINT (mini->total_cols, frame_cols); + wset_top_line (mini, make_number (frame_lines - 1)); + wset_total_lines (mini, make_number (1)); + wset_total_cols (mini, make_number (frame_cols)); adjust_frame_glyphs (sf); glyphs_initialized_initially_p = 1; @@ -1940,9 +1904,9 @@ adjust_frame_glyphs (struct frame *f) f->glyphs_initialized_p = 1; } -/* Return 1 if any window in the tree has nonzero window margins. See +/* Return true if any window in the tree has nonzero window margins. See the hack at the end of adjust_frame_glyphs_for_frame_redisplay. */ -static int +static bool showing_window_margins_p (struct window *w) { while (w) @@ -2073,7 +2037,7 @@ static void adjust_frame_glyphs_for_frame_redisplay (struct frame *f) { struct dim matrix_dim; - int pool_changed_p; + bool pool_changed_p; int window_change_flags; int top_window_y; @@ -2186,9 +2150,11 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f) struct window *w; if (NILP (f->menu_bar_window)) { - f->menu_bar_window = make_window (); + Lisp_Object frame; + fset_menu_bar_window (f, make_window ()); w = XWINDOW (f->menu_bar_window); - XSETFRAME (w->frame, f); + XSETFRAME (frame, f); + wset_frame (w, frame); w->pseudo_window_p = 1; } else @@ -2196,10 +2162,10 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f) /* Set window dimensions to frame dimensions and allocate or adjust glyph matrices of W. */ - XSETFASTINT (w->top_line, 0); - XSETFASTINT (w->left_col, 0); - XSETFASTINT (w->total_lines, FRAME_MENU_BAR_LINES (f)); - XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f)); + wset_top_line (w, make_number (0)); + wset_left_col (w, make_number (0)); + wset_total_lines (w, make_number (FRAME_MENU_BAR_LINES (f))); + wset_total_cols (w, make_number (FRAME_TOTAL_COLS (f))); allocate_matrices_for_window_redisplay (w); } #endif /* not USE_X_TOOLKIT && not USE_GTK */ @@ -2212,18 +2178,20 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f) struct window *w; if (NILP (f->tool_bar_window)) { - f->tool_bar_window = make_window (); + Lisp_Object frame; + fset_tool_bar_window (f, make_window ()); w = XWINDOW (f->tool_bar_window); - XSETFRAME (w->frame, f); + XSETFRAME (frame, f); + wset_frame (w, frame); w->pseudo_window_p = 1; } else w = XWINDOW (f->tool_bar_window); - XSETFASTINT (w->top_line, FRAME_MENU_BAR_LINES (f)); - XSETFASTINT (w->left_col, 0); - XSETFASTINT (w->total_lines, FRAME_TOOL_BAR_LINES (f)); - XSETFASTINT (w->total_cols, FRAME_TOTAL_COLS (f)); + wset_top_line (w, make_number (FRAME_MENU_BAR_LINES (f))); + wset_left_col (w, make_number (0)); + wset_total_lines (w, make_number (FRAME_TOOL_BAR_LINES (f))); + wset_total_cols (w, make_number (FRAME_TOTAL_COLS (f))); allocate_matrices_for_window_redisplay (w); } #endif @@ -2274,7 +2242,7 @@ free_glyphs (struct frame *f) { /* Block interrupt input so that we don't get surprised by an X event while we're in an inconsistent state. */ - BLOCK_INPUT; + block_input (); f->glyphs_initialized_p = 0; /* Release window sub-matrices. */ @@ -2289,7 +2257,7 @@ free_glyphs (struct frame *f) free_glyph_matrix (w->desired_matrix); free_glyph_matrix (w->current_matrix); w->desired_matrix = w->current_matrix = NULL; - f->menu_bar_window = Qnil; + fset_menu_bar_window (f, Qnil); } /* Free the tool bar window and its glyph matrices. */ @@ -2299,7 +2267,7 @@ free_glyphs (struct frame *f) free_glyph_matrix (w->desired_matrix); free_glyph_matrix (w->current_matrix); w->desired_matrix = w->current_matrix = NULL; - f->tool_bar_window = Qnil; + fset_tool_bar_window (f, Qnil); } /* Release frame glyph matrices. Reset fields to zero in @@ -2319,7 +2287,7 @@ free_glyphs (struct frame *f) f->desired_pool = f->current_pool = NULL; } - UNBLOCK_INPUT; + unblock_input (); } } @@ -2369,9 +2337,9 @@ check_glyph_memory (void) /* Check that nothing is left allocated. */ if (glyph_matrix_count) - abort (); + emacs_abort (); if (glyph_pool_count) - abort (); + emacs_abort (); } @@ -2485,7 +2453,7 @@ build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window desired frame matrix built. W is a leaf window whose desired or current matrix is to be added to FRAME_MATRIX. W's flag must_be_updated_p determines which matrix it contributes to - FRAME_MATRIX. If must_be_updated_p is non-zero, W's desired matrix + FRAME_MATRIX. If W->must_be_updated_p, W's desired matrix is added to FRAME_MATRIX, otherwise W's current matrix is added. Adding a desired matrix means setting up used counters and such in frame rows, while adding a current window matrix to FRAME_MATRIX @@ -2536,7 +2504,7 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w { struct glyph_row *frame_row = frame_matrix->rows + frame_y; struct glyph_row *window_row = window_matrix->rows + window_y; - int current_row_p = window_matrix == w->current_matrix; + bool current_row_p = window_matrix == w->current_matrix; /* Fill up the frame row with spaces up to the left margin of the window row. */ @@ -2709,7 +2677,7 @@ make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_ { struct glyph_row *current_row = MATRIX_ROW (current_matrix, row); struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, row); - int mouse_face_p = current_row->mouse_face_p; + bool mouse_face_p = current_row->mouse_face_p; /* Do current_row = desired_row. This exchanges glyph pointers between both rows, and does a structure assignment otherwise. */ @@ -2806,7 +2774,7 @@ mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlin /* Assign new rows, maybe clear lines. */ for (i = 0; i < nlines; ++i) { - int enabled_before_p = new_rows[i].enabled_p; + bool enabled_before_p = new_rows[i].enabled_p; eassert (i + unchanged_at_top < matrix->nrows); eassert (unchanged_at_top + copy_from[i] < matrix->nrows); @@ -2914,7 +2882,8 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy /* W is a leaf window, and we are working on its current matrix m. */ struct glyph_matrix *m = w->current_matrix; - int i, sync_p = 0; + int i; + bool sync_p = 0; struct glyph_row *old_rows; /* Make a copy of the original rows of matrix m. */ @@ -2936,22 +2905,19 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy int window_from = frame_from - m->matrix_y; /* Is assigned line inside window? */ - int from_inside_window_p + bool from_inside_window_p = window_from >= 0 && window_from < m->matrix_h; /* Is assigned to line inside window? */ - int to_inside_window_p + bool to_inside_window_p = window_to >= 0 && window_to < m->matrix_h; if (from_inside_window_p && to_inside_window_p) { - /* Enabled setting before assignment. */ - int enabled_before_p; - /* Do the assignment. The enabled_p flag is saved over the assignment because the old redisplay did that. */ - enabled_before_p = m->rows[window_to].enabled_p; + bool enabled_before_p = m->rows[window_to].enabled_p; m->rows[window_to] = old_rows[window_from]; m->rows[window_to].enabled_p = enabled_before_p; @@ -3056,7 +3022,7 @@ check_matrix_pointers (struct glyph_matrix *window_matrix, { if (!glyph_row_slice_p (window_matrix->rows + i, frame_matrix->rows + j)) - abort (); + emacs_abort (); ++i, ++j; } } @@ -3172,17 +3138,16 @@ DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "", /* Update frame F based on the data in desired matrices. - If FORCE_P is non-zero, don't let redisplay be stopped by detecting - pending input. If INHIBIT_HAIRY_ID_P is non-zero, don't try - scrolling. + If FORCE_P, don't let redisplay be stopped by detecting pending input. + If INHIBIT_HAIRY_ID_P, don't try scrolling. - Value is non-zero if redisplay was stopped due to pending input. */ + Value is true if redisplay was stopped due to pending input. */ -int -update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p) +bool +update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p) { - /* 1 means display has been paused because of pending input. */ - int paused_p; + /* True means display has been paused because of pending input. */ + bool paused_p; struct window *root_window = XWINDOW (f->root_window); if (redisplay_dont_pause) @@ -3237,8 +3202,8 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p) /* Swap tool-bar strings. We swap because we want to reuse strings. */ tem = f->current_tool_bar_string; - f->current_tool_bar_string = f->desired_tool_bar_string; - f->desired_tool_bar_string = tem; + fset_current_tool_bar_string (f, f->desired_tool_bar_string); + fset_desired_tool_bar_string (f, tem); } } @@ -3300,13 +3265,13 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p) Window-based updates ************************************************************************/ -/* Perform updates in window tree rooted at W. FORCE_P non-zero means - don't stop updating when input is pending. */ +/* Perform updates in window tree rooted at W. + If FORCE_P, don't stop updating if input is pending. */ -static int -update_window_tree (struct window *w, int force_p) +static bool +update_window_tree (struct window *w, bool force_p) { - int paused_p = 0; + bool paused_p = 0; while (w && !paused_p) { @@ -3324,11 +3289,11 @@ update_window_tree (struct window *w, int force_p) } -/* Update window W if its flag must_be_updated_p is non-zero. If - FORCE_P is non-zero, don't stop updating if input is pending. */ +/* Update window W if its flag must_be_updated_p is set. + If FORCE_P, don't stop updating if input is pending. */ void -update_single_window (struct window *w, int force_p) +update_single_window (struct window *w, bool force_p) { if (w->must_be_updated_p) { @@ -3477,7 +3442,7 @@ redraw_overlapping_rows (struct window *w, int yb) static void check_current_matrix_flags (struct window *w) { - int last_seen_p = 0; + bool last_seen_p = 0; int i, yb = window_text_bottom_y (w); for (i = 0; i < w->current_matrix->nrows - 1; ++i) @@ -3486,21 +3451,21 @@ check_current_matrix_flags (struct window *w) if (!last_seen_p && MATRIX_ROW_BOTTOM_Y (row) >= yb) last_seen_p = 1; else if (last_seen_p && row->enabled_p) - abort (); + emacs_abort (); } } #endif /* GLYPH_DEBUG */ -/* Update display of window W. FORCE_P non-zero means that we should - not stop when detecting pending input. */ +/* Update display of window W. + If FORCE_P, don't stop updating when input is pending. */ -static int -update_window (struct window *w, int force_p) +static bool +update_window (struct window *w, bool force_p) { struct glyph_matrix *desired_matrix = w->desired_matrix; - int paused_p; + bool paused_p; #if !PERIODIC_PREEMPTION_CHECKING int preempt_count = baud_rate / 2400 + 1; #endif @@ -3523,7 +3488,8 @@ update_window (struct window *w, int force_p) struct glyph_row *row, *end; struct glyph_row *mode_line_row; struct glyph_row *header_line_row; - int yb, changed_p = 0, mouse_face_overwritten_p = 0; + int yb; + bool changed_p = 0, mouse_face_overwritten_p = 0; #if ! PERIODIC_PREEMPTION_CHECKING int n_updated = 0; #endif @@ -3710,15 +3676,15 @@ update_marginal_area (struct window *w, int area, int vpos) /* Update the display of the text area of row VPOS in window W. - Value is non-zero if display has changed. */ + Value is true if display has changed. */ -static int +static bool update_text_area (struct window *w, int vpos) { struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos); struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos); struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w))); - int changed_p = 0; + bool changed_p = 0; /* Let functions in xterm.c know what area subsequent X positions will be relative to. */ @@ -3768,9 +3734,9 @@ update_text_area (struct window *w, int vpos) int stop, i, x; struct glyph *current_glyph = current_row->glyphs[TEXT_AREA]; struct glyph *desired_glyph = desired_row->glyphs[TEXT_AREA]; - int overlapping_glyphs_p = current_row->contains_overlapping_glyphs_p; + bool overlapping_glyphs_p = current_row->contains_overlapping_glyphs_p; int desired_stop_pos = desired_row->used[TEXT_AREA]; - int abort_skipping = 0; + bool abort_skipping = 0; /* If the desired row extends its face to the text area end, and unless the current row also does so at the same position, @@ -3790,7 +3756,7 @@ update_text_area (struct window *w, int vpos) in common. */ while (i < stop) { - int can_skip_p = !abort_skipping; + bool can_skip_p = !abort_skipping; /* Skip over glyphs that both rows have in common. These don't have to be written. We can't skip if the last @@ -3837,7 +3803,8 @@ update_text_area (struct window *w, int vpos) { int left, right; - rif->get_glyph_overhangs (current_glyph, XFRAME (w->frame), + rif->get_glyph_overhangs (current_glyph, + XFRAME (w->frame), &left, &right); while (left > 0 && i > 0) { @@ -3863,7 +3830,7 @@ update_text_area (struct window *w, int vpos) int start_x = x, start_hpos = i; struct glyph *start = desired_glyph; int current_x = x; - int skip_first_p = !can_skip_p; + bool skip_first_p = !can_skip_p; /* Find the next glyph that's equal again. */ while (i < stop @@ -3954,16 +3921,15 @@ update_text_area (struct window *w, int vpos) } -/* Update row VPOS in window W. Value is non-zero if display has been - changed. */ +/* Update row VPOS in window W. Value is true if display has been changed. */ -static int -update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p) +static bool +update_window_line (struct window *w, int vpos, bool *mouse_face_overwritten_p) { struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos); struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos); struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w))); - int changed_p = 0; + bool changed_p = 0; /* Set the row being updated. This is important to let xterm.c know what line height values are in effect. */ @@ -3984,6 +3950,11 @@ update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p) { changed_p = 1; update_marginal_area (w, LEFT_MARGIN_AREA, vpos); + /* Setting this flag will ensure the vertical border, if + any, between this window and the one on its left will be + redrawn. This is necessary because updating the left + margin area can potentially draw over the border. */ + current_row->redraw_fringe_bitmaps_p = 1; } /* Update the display of the text area. */ @@ -4111,7 +4082,7 @@ set_window_cursor_after_update (struct window *w) tree rooted at W. */ void -set_window_update_flags (struct window *w, int on_p) +set_window_update_flags (struct window *w, bool on_p) { while (w) { @@ -4214,7 +4185,7 @@ add_row_entry (struct glyph_row *row) /* Try to reuse part of the current display of W by scrolling lines. - HEADER_LINE_P non-zero means W has a header line. + HEADER_LINE_P means W has a header line. The algorithm is taken from Communications of the ACM, Apr78 "A Technique for Isolating Differences Between Files." It should take @@ -4240,7 +4211,7 @@ add_row_entry (struct glyph_row *row) 1 if we did scroll. */ static int -scrolling_window (struct window *w, int header_line_p) +scrolling_window (struct window *w, bool header_line_p) { struct glyph_matrix *desired_matrix = w->desired_matrix; struct glyph_matrix *current_matrix = w->current_matrix; @@ -4253,7 +4224,7 @@ scrolling_window (struct window *w, int header_line_p) struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w))); /* Skip over rows equal at the start. */ - for (i = header_line_p ? 1 : 0; i < current_matrix->nrows - 1; ++i) + for (i = header_line_p; i < current_matrix->nrows - 1; ++i) { struct glyph_row *d = MATRIX_ROW (desired_matrix, i); struct glyph_row *c = MATRIX_ROW (current_matrix, i); @@ -4512,7 +4483,7 @@ scrolling_window (struct window *w, int header_line_p) for (j = nruns - 1; j > i; --j) { struct run *p = runs[j]; - int truncated_p = 0; + bool truncated_p = 0; if (p->nrows > 0 && p->desired_y < r->desired_y + r->height @@ -4575,7 +4546,7 @@ scrolling_window (struct window *w, int header_line_p) for (j = 0; j < r->nrows; ++j) { struct glyph_row *from, *to; - int to_overlapped_p; + bool to_overlapped_p; to = MATRIX_ROW (current_matrix, r->desired_vpos + j); from = MATRIX_ROW (desired_matrix, r->desired_vpos + j); @@ -4610,20 +4581,19 @@ scrolling_window (struct window *w, int header_line_p) /* Update the desired frame matrix of frame F. - FORCE_P non-zero means that the update should not be stopped by - pending input. INHIBIT_HAIRY_ID_P non-zero means that scrolling - should not be tried. + FORCE_P means that the update should not be stopped by pending input. + INHIBIT_HAIRY_ID_P means that scrolling should not be tried. - Value is non-zero if update was stopped due to pending input. */ + Value is true if update was stopped due to pending input. */ -static int -update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) +static bool +update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p) { /* Frame matrices to work on. */ struct glyph_matrix *current_matrix = f->current_matrix; struct glyph_matrix *desired_matrix = f->desired_matrix; int i; - int pause_p; + bool pause_p; int preempt_count = baud_rate / 2400 + 1; eassert (current_matrix && desired_matrix); @@ -4715,7 +4685,8 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) } } - pause_p = (i < FRAME_LINES (f) - 1) ? i : 0; + lint_assume (0 <= FRAME_LINES (f)); + pause_p = 0 < i && i < FRAME_LINES (f) - 1; /* Now just clean up termcap drivers and set cursor, etc. */ if (!pause_p) @@ -4825,7 +4796,7 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) /* Do line insertions/deletions on frame F for frame-based redisplay. */ -static int +static bool scrolling (struct frame *frame) { int unchanged_at_top, unchanged_at_bottom; @@ -4841,7 +4812,7 @@ scrolling (struct frame *frame) struct glyph_matrix *desired_matrix = frame->desired_matrix; if (!current_matrix) - abort (); + emacs_abort (); /* Compute hash codes of all the lines. Also calculate number of changed lines, number of unchanged lines at the beginning, and @@ -4968,10 +4939,10 @@ update_frame_line (struct frame *f, int vpos) struct glyph_matrix *desired_matrix = f->desired_matrix; struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos); struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos); - int must_write_whole_line_p; - int write_spaces_p = FRAME_MUST_WRITE_SPACES (f); - int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background - != FACE_TTY_DEFAULT_BG_COLOR); + bool must_write_whole_line_p; + bool write_spaces_p = FRAME_MUST_WRITE_SPACES (f); + bool colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background + != FACE_TTY_DEFAULT_BG_COLOR); if (colored_spaces_p) write_spaces_p = 1; @@ -5305,7 +5276,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p /* start_display takes into account the header-line row, but IT's vpos still counts from the glyph row that includes the window's start position. Adjust for a possible header-line row. */ - it.vpos += WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0; + it.vpos += WINDOW_WANTS_HEADER_LINE_P (w); x0 = *x; @@ -5509,7 +5480,7 @@ marginal_area_string (struct window *w, enum window_part part, else if (part == ON_RIGHT_MARGIN) area = RIGHT_MARGIN_AREA; else - abort (); + emacs_abort (); for (i = 0; row->enabled_p && i < w->current_matrix->nrows; ++i, ++row) if (wy >= row->y && wy < MATRIX_ROW_BOTTOM_Y (row)) @@ -5584,18 +5555,14 @@ marginal_area_string (struct window *w, enum window_part part, #ifdef SIGWINCH +static void deliver_window_change_signal (int); + static void -window_change_signal (int signalnum) /* If we don't have an argument, */ - /* some compilers complain in signal calls. */ +handle_window_change_signal (int sig) { int width, height; - int old_errno = errno; - struct tty_display_info *tty; - signal (SIGWINCH, window_change_signal); - SIGNAL_THREAD_CHECK (signalnum); - /* The frame size change obviously applies to a single termcap-controlled terminal, but we can't decide which. Therefore, we resize the frames corresponding to each tty. @@ -5623,20 +5590,24 @@ window_change_signal (int signalnum) /* If we don't have an argument, */ change_frame_size (XFRAME (frame), height, width, 0, 1, 0); } } +} - errno = old_errno; +static void +deliver_window_change_signal (int sig) +{ + deliver_process_signal (sig, handle_window_change_signal); } #endif /* SIGWINCH */ -/* Do any change in frame size that was requested by a signal. SAFE - non-zero means this function is called from a place where it is - safe to change frame sizes while a redisplay is in progress. */ +/* Do any change in frame size that was requested by a signal. + SAFE means this function is called from a place where it is + safe to change frame sizes while a redisplay is in progress. */ void -do_pending_window_change (int safe) +do_pending_window_change (bool safe) { - /* If window_change_signal should have run before, run it now. */ + /* If window change signal handler should have run before, run it now. */ if (redisplaying_p && !safe) return; @@ -5661,16 +5632,17 @@ do_pending_window_change (int safe) /* Change the frame height and/or width. Values may be given as zero to indicate no change is to take place. - If DELAY is non-zero, then assume we're being called from a signal - handler, and queue the change for later - perhaps the next - redisplay. Since this tries to resize windows, we can't call it + If DELAY, assume we're being called from a signal handler, and + queue the change for later - perhaps the next redisplay. + Since this tries to resize windows, we can't call it from a signal handler. - SAFE non-zero means this function is called from a place where it's + SAFE means this function is called from a place where it's safe to change frame sizes while a redisplay is in progress. */ void -change_frame_size (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe) +change_frame_size (struct frame *f, int newheight, int newwidth, + bool pretend, bool delay, bool safe) { Lisp_Object tail, frame; @@ -5689,7 +5661,8 @@ change_frame_size (register struct frame *f, int newheight, int newwidth, int pr } static void -change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int pretend, int delay, int safe) +change_frame_size_1 (struct frame *f, int newheight, int newwidth, + bool pretend, bool delay, bool safe) { int new_frame_total_cols; ptrdiff_t count = SPECPDL_INDEX (); @@ -5731,7 +5704,7 @@ change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int && new_frame_total_cols == FRAME_TOTAL_COLS (f)) return; - BLOCK_INPUT; + block_input (); #ifdef MSDOS /* We only can set screen dimensions to certain values supported @@ -5760,7 +5733,7 @@ change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int FrameCols (FRAME_TTY (f)) = newwidth; if (WINDOWP (f->tool_bar_window)) - XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth); + wset_total_cols (XWINDOW (f->tool_bar_window), make_number (newwidth)); } FRAME_LINES (f) = newheight; @@ -5783,9 +5756,9 @@ change_frame_size_1 (register struct frame *f, int newheight, int newwidth, int SET_FRAME_GARBAGED (f); f->resized_p = 1; - UNBLOCK_INPUT; + unblock_input (); - record_unwind_protect (Fset_buffer, Fcurrent_buffer ()); + record_unwind_current_buffer (); run_window_configuration_change_hook (f); @@ -5814,9 +5787,9 @@ FILE = nil means just close any termscript file currently open. */) if (tty->termscript != 0) { - BLOCK_INPUT; + block_input (); fclose (tty->termscript); - UNBLOCK_INPUT; + unblock_input (); } tty->termscript = 0; @@ -5847,7 +5820,7 @@ when TERMINAL is nil. */) /* ??? Perhaps we should do something special for multibyte strings here. */ CHECK_STRING (string); - BLOCK_INPUT; + block_input (); if (!t) error ("Unknown terminal device"); @@ -5872,7 +5845,7 @@ when TERMINAL is nil. */) } fwrite (SDATA (string), 1, SBYTES (string), out); fflush (out); - UNBLOCK_INPUT; + unblock_input (); return Qnil; } @@ -5945,13 +5918,13 @@ additional wait period, in milliseconds; this is for backwards compatibility. TIMEOUT is number of seconds to wait (float or integer), or t to wait forever. - READING is 1 if reading input. + READING is true if reading input. If DO_DISPLAY is >0 display process output while waiting. If DO_DISPLAY is >1 perform an initial redisplay before waiting. */ Lisp_Object -sit_for (Lisp_Object timeout, int reading, int do_display) +sit_for (Lisp_Object timeout, bool reading, int do_display) { intmax_t sec; int nsec; @@ -5993,8 +5966,8 @@ sit_for (Lisp_Object timeout, int reading, int do_display) wrong_type_argument (Qnumberp, timeout); -#ifdef SIGIO - gobble_input (0); +#ifdef USABLE_SIGIO + gobble_input (); #endif wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display, @@ -6060,8 +6033,7 @@ pass nil for VARIABLE. */) (Lisp_Object variable) { Lisp_Object state, tail, frame, buf; - Lisp_Object *vecp, *end; - ptrdiff_t n; + ptrdiff_t n, idx; if (! NILP (variable)) { @@ -6073,18 +6045,16 @@ pass nil for VARIABLE. */) else state = frame_and_buffer_state; - vecp = XVECTOR (state)->contents; - end = vecp + ASIZE (state); - + idx = 0; FOR_EACH_FRAME (tail, frame) { - if (vecp == end) + if (idx == ASIZE (state)) goto changed; - if (!EQ (*vecp++, frame)) + if (!EQ (AREF (state, idx++), frame)) goto changed; - if (vecp == end) + if (idx == ASIZE (state)) goto changed; - if (!EQ (*vecp++, XFRAME (frame)->name)) + if (!EQ (AREF (state, idx++), XFRAME (frame)->name)) goto changed; } /* Check that the buffer info matches. */ @@ -6094,23 +6064,23 @@ pass nil for VARIABLE. */) /* Ignore buffers that aren't included in buffer lists. */ if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ') continue; - if (vecp == end) + if (idx == ASIZE (state)) goto changed; - if (!EQ (*vecp++, buf)) + if (!EQ (AREF (state, idx++), buf)) goto changed; - if (vecp == end) + if (idx == ASIZE (state)) goto changed; - if (!EQ (*vecp++, BVAR (XBUFFER (buf), read_only))) + if (!EQ (AREF (state, idx++), BVAR (XBUFFER (buf), read_only))) goto changed; - if (vecp == end) + if (idx == ASIZE (state)) goto changed; - if (!EQ (*vecp++, Fbuffer_modified_p (buf))) + if (!EQ (AREF (state, idx++), Fbuffer_modified_p (buf))) goto changed; } - if (vecp == end) + if (idx == ASIZE (state)) goto changed; /* Detect deletion of a buffer at the end of the list. */ - if (EQ (*vecp, Qlambda)) + if (EQ (AREF (state, idx), Qlambda)) return Qnil; /* Come here if we decide the data has changed. */ @@ -6137,11 +6107,13 @@ pass nil for VARIABLE. */) } /* Record the new data in the (possibly reallocated) vector. */ - vecp = XVECTOR (state)->contents; + idx = 0; FOR_EACH_FRAME (tail, frame) { - *vecp++ = frame; - *vecp++ = XFRAME (frame)->name; + ASET (state, idx, frame); + idx++; + ASET (state, idx, XFRAME (frame)->name); + idx++; } for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) { @@ -6149,19 +6121,23 @@ pass nil for VARIABLE. */) /* Ignore buffers that aren't included in buffer lists. */ if (SREF (BVAR (XBUFFER (buf), name), 0) == ' ') continue; - *vecp++ = buf; - *vecp++ = BVAR (XBUFFER (buf), read_only); - *vecp++ = Fbuffer_modified_p (buf); + ASET (state, idx, buf); + idx++; + ASET (state, idx, BVAR (XBUFFER (buf), read_only)); + idx++; + ASET (state, idx, Fbuffer_modified_p (buf)); + idx++; } /* Fill up the vector with lambdas (always at least one). */ - *vecp++ = Qlambda; - while (vecp - XVECTOR (state)->contents - < ASIZE (state)) - *vecp++ = Qlambda; + ASET (state, idx, Qlambda); + idx++; + while (idx < ASIZE (state)) + { + ASET (state, idx, Qlambda); + idx++; + } /* Make sure we didn't overflow the vector. */ - if (vecp - XVECTOR (state)->contents - > ASIZE (state)) - abort (); + eassert (idx <= ASIZE (state)); return Qt; } @@ -6200,7 +6176,11 @@ init_display (void) #ifndef CANNOT_DUMP if (initialized) #endif /* CANNOT_DUMP */ - signal (SIGWINCH, window_change_signal); + { + struct sigaction action; + emacs_sigaction_init (&action, deliver_window_change_signal); + sigaction (SIGWINCH, &action, 0); + } #endif /* SIGWINCH */ /* If running as a daemon, no need to initialize any frames/terminal. */ @@ -6304,7 +6284,7 @@ init_display (void) /* Convert the initial frame to use the new display. */ if (f->output_method != output_initial) - abort (); + emacs_abort (); f->output_method = t->type; f->terminal = t;