diff options
| author | Eli Zaretskii <eliz@gnu.org> | 2013-09-05 11:01:04 +0300 |
|---|---|---|
| committer | Eli Zaretskii <eliz@gnu.org> | 2013-09-05 11:01:04 +0300 |
| commit | 41306318777a942420bc4feadbfacf662ea179dc (patch) | |
| tree | 669e5cca02f95d6064ce73c0d3fbbf91b8c8b563 /src/dispnew.c | |
| parent | 141f1ff7a40cda10f0558e891dd196a943a5082e (diff) | |
| parent | 257b3b03cb1cff917e0b3b7832ad3eab5b59f257 (diff) | |
Merge from trunk after a lot of time.
Diffstat (limited to 'src/dispnew.c')
| -rw-r--r-- | src/dispnew.c | 1454 |
1 files changed, 553 insertions, 901 deletions
diff --git a/src/dispnew.c b/src/dispnew.c index 1cb30b84d6..824c62bcf3 100644 --- a/src/dispnew.c +++ b/src/dispnew.c @@ -1,6 +1,7 @@ /* Updating of data structures for redisplay. -Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc. +Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software Foundation, +Inc. This file is part of GNU Emacs. @@ -18,20 +19,19 @@ You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ #include <config.h> -#include <signal.h> -#include <stdio.h> -#include <ctype.h> -#include <setjmp.h> + +#define DISPEXTERN_INLINE EXTERN_INLINE + +#include "sysstdio.h" #include <unistd.h> #include "lisp.h" #include "termchar.h" -#include "termopts.h" /* cm.h must come after dispextern.h on Windows. */ #include "dispextern.h" #include "cm.h" -#include "buffer.h" #include "character.h" +#include "buffer.h" #include "keyboard.h" #include "frame.h" #include "termhooks.h" @@ -45,52 +45,22 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ #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 - -/* Include systime.h after xterm.h to avoid double inclusion of time.h. */ +#ifdef HAVE_WINDOW_SYSTEM +#include TERM_HEADER +#endif /* HAVE_WINDOW_SYSTEM */ -#include "systime.h" #include <errno.h> -/* 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 -#else /* not __GNU_LIBRARY__ */ -#if !defined (PENDING_OUTPUT_COUNT) && HAVE_STDIO_EXT_H && HAVE___FPENDING -#include <stdio_ext.h> -#define PENDING_OUTPUT_COUNT(FILE) __fpending (FILE) -#endif -#ifndef PENDING_OUTPUT_COUNT -#define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_ptr - (FILE)->_base) -#endif -#endif /* not __GNU_LIBRARY__ */ +#include <fpending.h> +#include <timespec.h> #if defined (HAVE_TERM_H) && defined (GNU_LINUX) #include <term.h> /* for tgetent */ #endif + +#ifdef WINDOWSNT +#include "w32.h" +#endif /* Structure to pass dimensions around. Used for character bounding boxes, glyph matrix dimensions and alike. */ @@ -108,61 +78,41 @@ 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 *, struct window *); static void build_frame_matrix_from_leaf_window (struct glyph_matrix *, struct window *); -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); -#if GLYPH_DEBUG +#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 *); - -/* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers - are supported, so we can check for input during redisplay at - regular intervals. */ -#ifdef EMACS_HAS_USECS -#define PERIODIC_PREEMPTION_CHECKING 1 -#else -#define PERIODIC_PREEMPTION_CHECKING 0 -#endif - -#if PERIODIC_PREEMPTION_CHECKING - -/* Redisplay preemption timers. */ - -static EMACS_TIME preemption_period; -static EMACS_TIME preemption_next_check; - -#endif - -/* 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; @@ -179,52 +129,43 @@ Lisp_Object selected_frame; struct frame *last_nonminibuf_frame; -/* 1 means SIGWINCH happened when not safe. */ - -static int delayed_size_change; - -/* 1 means glyph initialization has been completed at startup. */ - -static int glyphs_initialized_initially_p; - -/* Updated window if != 0. Set by update_window. */ - -struct window *updated_window; +/* True means SIGWINCH happened when not safe. */ -/* Glyph row updated in update_window_line, and area that is updated. */ - -struct glyph_row *updated_row; -int updated_area; +static bool delayed_size_change; /* A glyph for a space. */ struct glyph space_glyph; +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING + /* Counts of allocated structures. These counts serve to diagnose memory leaks and double frees. */ static int glyph_matrix_count; static int glyph_pool_count; +#endif /* GLYPH_DEBUG and ENABLE_CHECKING */ + /* If non-null, the frame whose frame matrices are manipulated. If null, window matrices are worked on. */ 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. */ -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG static int window_to_frame_vpos (struct window *, int); static int window_to_frame_hpos (struct window *, int); @@ -255,18 +196,17 @@ 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; + void *ptr = w; if (history_idx >= REDISPLAY_HISTORY_SIZE) history_idx = 0; @@ -276,10 +216,10 @@ add_window_display_history (struct window *w, const char *msg, int paused_p) snprintf (buf, sizeof redisplay_history[0].trace, "%"pMu": window %p (`%s')%s\n%s", history_tick++, - w, - ((BUFFERP (w->buffer) - && STRINGP (BVAR (XBUFFER (w->buffer), name))) - ? SSDATA (BVAR (XBUFFER (w->buffer), name)) + ptr, + ((BUFFERP (w->contents) + && STRINGP (BVAR (XBUFFER (w->contents), name))) + ? SSDATA (BVAR (XBUFFER (w->contents), name)) : "???"), paused_p ? " ***paused***" : "", msg); @@ -287,13 +227,14 @@ 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; + void *ptr = f; if (history_idx >= REDISPLAY_HISTORY_SIZE) history_idx = 0; @@ -302,7 +243,7 @@ add_frame_display_history (struct frame *f, int paused_p) sprintf (buf, "%"pMu": update frame %p%s", history_tick++, - f, paused_p ? " ***paused***" : ""); + ptr, paused_p ? " ***paused***" : ""); } @@ -324,12 +265,12 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history, } -#else /* GLYPH_DEBUG == 0 */ +#else /* not GLYPH_DEBUG */ #define WINDOW_TO_FRAME_VPOS(W, VPOS) ((VPOS) + WINDOW_TOP_EDGE_LINE (W)) #define WINDOW_TO_FRAME_HPOS(W, HPOS) ((HPOS) + WINDOW_LEFT_EDGE_COL (W)) -#endif /* GLYPH_DEBUG == 0 */ +#endif /* GLYPH_DEBUG */ #if (defined PROFILING \ @@ -340,7 +281,7 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history, void __executable_start (void) { - abort (); + emacs_abort (); } #endif @@ -357,15 +298,13 @@ __executable_start (void) static struct glyph_matrix * new_glyph_matrix (struct glyph_pool *pool) { - struct glyph_matrix *result; - - /* Allocate and clear. */ - result = (struct glyph_matrix *) xmalloc (sizeof *result); - memset (result, 0, sizeof *result); + struct glyph_matrix *result = xzalloc (sizeof *result); +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING /* Increment number of allocated matrices. This count is used to detect memory leaks. */ ++glyph_matrix_count; +#endif /* Set pool and return. */ result->pool = pool; @@ -375,10 +314,10 @@ new_glyph_matrix (struct glyph_pool *pool) /* Free glyph matrix MATRIX. Passing in a null MATRIX is allowed. - The global counter glyph_matrix_count is decremented when a matrix - is freed. If the count gets negative, more structures were freed - than allocated, i.e. one matrix was freed more than once or a bogus - pointer was passed to this function. + If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global counter + glyph_matrix_count is decremented when a matrix is freed. If the count + gets negative, more structures were freed than allocated, i.e. one matrix + was freed more than once or a bogus pointer was passed to this function. If MATRIX->pool is null, this means that the matrix manages its own glyph memory---this is done for matrices on X frames. Freeing the @@ -391,10 +330,12 @@ free_glyph_matrix (struct glyph_matrix *matrix) { int i; +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING /* Detect the case that more matrices are freed than were allocated. */ - if (--glyph_matrix_count < 0) - abort (); + --glyph_matrix_count; + eassert (glyph_matrix_count >= 0); +#endif /* Free glyph memory if MATRIX owns it. */ if (matrix->pool == NULL) @@ -411,35 +352,29 @@ free_glyph_matrix (struct glyph_matrix *matrix) /* Return the number of glyphs to reserve for a marginal area of window W. TOTAL_GLYPHS is the number of glyphs in a complete display line of window W. MARGIN gives the width of the marginal - area in canonical character units. MARGIN should be an integer - or a float. */ + area in canonical character units. */ static int -margin_glyphs_to_reserve (struct window *w, int total_glyphs, Lisp_Object margin) +margin_glyphs_to_reserve (struct window *w, int total_glyphs, int margin) { - int n; - - if (NUMBERP (margin)) + if (margin > 0) { - int width = XFASTINT (w->total_cols); - double d = max (0, XFLOATINT (margin)); + int width = w->total_cols; + double d = max (0, margin); d = min (width / 2 - 1, d); - n = (int) ((double) total_glyphs / width * d); + return (int) ((double) total_glyphs / width * d); } - else - n = 0; - - return n; + return 0; } -#if XASSERTS -/* Return non-zero if ROW's hash value is correct, zero if not. */ -int +/* Return true if ROW's hash value is correct. + Optimized away if ENABLE_CHECKING is not defined. */ + +static bool verify_row_hash (struct glyph_row *row) { return row->hash == row_hash (row); } -#endif /* Adjust glyph matrix MATRIX on window W or on a frame to changed window sizes. @@ -468,9 +403,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; @@ -478,7 +413,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y Get W's size. */ if (w) { - window_box (w, -1, 0, 0, &window_width, &window_height); + window_box (w, ANY_AREA, 0, 0, &window_width, &window_height); header_line_p = WINDOW_WANTS_HEADER_LINE_P (w); header_line_changed_p = header_line_p != matrix->header_line_p; @@ -493,7 +428,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y { left = margin_glyphs_to_reserve (w, dim.width, w->left_margin_cols); right = margin_glyphs_to_reserve (w, dim.width, w->right_margin_cols); - xassert (left >= 0 && right >= 0); + eassert (left >= 0 && right >= 0); marginal_areas_changed_p = (left != matrix->left_margin_glyphs || right != matrix->right_margin_glyphs); @@ -526,7 +461,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y each row into the glyph pool. */ if (matrix->pool) { - xassert (matrix->pool->glyphs); + eassert (matrix->pool->glyphs); if (w) { @@ -615,14 +550,14 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y } } - xassert (left >= 0 && right >= 0); + eassert (left >= 0 && right >= 0); matrix->left_margin_glyphs = left; matrix->right_margin_glyphs = right; } /* Number of rows to be used by MATRIX. */ matrix->nrows = dim.height; - xassert (matrix->nrows >= 0); + eassert (matrix->nrows >= 0); if (w) { @@ -656,9 +591,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y /* Window end is invalid, if inside of the rows that are invalidated below. */ - if (INTEGERP (w->window_end_vpos) - && XFASTINT (w->window_end_vpos) >= i) - w->window_end_valid = Qnil; + if (w->window_end_vpos >= i) + w->window_end_valid = 0; while (i < matrix->nrows) matrix->rows[i++].enabled_p = 0; @@ -764,39 +698,37 @@ increment_matrix_positions (struct glyph_matrix *matrix, int start, int end, ptrdiff_t delta, ptrdiff_t delta_bytes) { /* Check that START and END are reasonable values. */ - xassert (start >= 0 && start <= matrix->nrows); - xassert (end >= 0 && end <= matrix->nrows); - xassert (start <= end); + eassert (start >= 0 && start <= matrix->nrows); + eassert (end >= 0 && end <= matrix->nrows); + eassert (start <= end); for (; start < end; ++start) increment_row_positions (matrix->rows + start, delta, delta_bytes); } -/* 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) { - xassert (start <= end); - xassert (start >= 0 && start < matrix->nrows); - xassert (end >= 0 && end <= matrix->nrows); + 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 @@ -804,7 +736,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; } } @@ -819,9 +751,9 @@ shift_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int start, in { int min_y, max_y; - xassert (start <= end); - xassert (start >= 0 && start < matrix->nrows); - xassert (end >= 0 && end <= matrix->nrows); + eassert (start <= end); + eassert (start >= 0 && start < matrix->nrows); + eassert (end >= 0 && end <= matrix->nrows); min_y = WINDOW_HEADER_LINE_HEIGHT (w); max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (w); @@ -854,18 +786,20 @@ clear_current_matrices (register struct frame *f) if (f->current_matrix) clear_glyph_matrix (f->current_matrix); +#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) /* Clear the matrix of the menu bar window, if such a window exists. The menu bar window is currently used to display menus on X when no toolkit support is compiled in. */ if (WINDOWP (f->menu_bar_window)) clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix); +#endif /* Clear the matrix of the tool-bar window, if any. */ if (WINDOWP (f->tool_bar_window)) clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix); /* Clear current window matrices. */ - xassert (WINDOWP (FRAME_ROOT_WINDOW (f))); + eassert (WINDOWP (FRAME_ROOT_WINDOW (f))); clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 0); } @@ -878,36 +812,30 @@ clear_desired_matrices (register struct frame *f) if (f->desired_matrix) clear_glyph_matrix (f->desired_matrix); +#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) if (WINDOWP (f->menu_bar_window)) clear_glyph_matrix (XWINDOW (f->menu_bar_window)->desired_matrix); +#endif if (WINDOWP (f->tool_bar_window)) clear_glyph_matrix (XWINDOW (f->tool_bar_window)->desired_matrix); /* Do it for window matrices. */ - xassert (WINDOWP (FRAME_ROOT_WINDOW (f))); + eassert (WINDOWP (FRAME_ROOT_WINDOW (f))); clear_window_matrices (XWINDOW (FRAME_ROOT_WINDOW (f)), 1); } -/* 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) { - if (!NILP (w->hchild)) - { - xassert (WINDOWP (w->hchild)); - clear_window_matrices (XWINDOW (w->hchild), desired_p); - } - else if (!NILP (w->vchild)) - { - xassert (WINDOWP (w->vchild)); - clear_window_matrices (XWINDOW (w->vchild), desired_p); - } + if (WINDOWP (w->contents)) + clear_window_matrices (XWINDOW (w->contents), desired_p); else { if (desired_p) @@ -915,7 +843,7 @@ clear_window_matrices (struct window *w, int desired_p) else { clear_glyph_matrix (w->current_matrix); - w->window_end_valid = Qnil; + w->window_end_valid = 0; } } @@ -1079,7 +1007,7 @@ swap_glyphs_in_rows (struct glyph_row *a, struct glyph_row *b) these should all go together for the row's hash value to be correct. */ -static inline void +static void swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b) { int i; @@ -1108,7 +1036,7 @@ swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b) that glyph pointers, the `used' counts, and the hash values in the structures are left unchanged. */ -static inline void +static void copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from) { struct glyph *pointers[1 + LAST_AREA]; @@ -1135,7 +1063,7 @@ copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from) exchanged between TO and FROM. Pointers must be exchanged to avoid a memory leak. */ -static inline void +static void assign_row (struct glyph_row *to, struct glyph_row *from) { swap_glyph_pointers (to, from); @@ -1146,12 +1074,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. */ -#if GLYPH_DEBUG +#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]; @@ -1176,7 +1104,7 @@ find_glyph_row_slice (struct glyph_matrix *window_matrix, { int i; - xassert (row >= 0 && row < frame_matrix->nrows); + eassert (row >= 0 && row < frame_matrix->nrows); for (i = 0; i < window_matrix->nrows; ++i) if (glyph_row_slice_p (window_matrix->rows + i, @@ -1198,7 +1126,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; @@ -1297,15 +1225,14 @@ 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 bool +row_equal_p (struct glyph_row *a, struct glyph_row *b, bool mouse_face_p) { - xassert (verify_row_hash (a)); - xassert (verify_row_hash (b)); + eassert (verify_row_hash (a)); + eassert (verify_row_hash (b)); if (a == b) return 1; @@ -1373,42 +1300,41 @@ row_equal_p (struct glyph_row *a, struct glyph_row *b, int mouse_face_p) See dispextern.h for an overall explanation of glyph pools. ***********************************************************************/ -/* Allocate a glyph_pool structure. The structure returned is - initialized with zeros. The global variable glyph_pool_count is - incremented for each pool allocated. */ +/* Allocate a glyph_pool structure. The structure returned is initialized + with zeros. If GLYPH_DEBUG and ENABLE_CHECKING are in effect, the global + variable glyph_pool_count is incremented for each pool allocated. */ static struct glyph_pool * new_glyph_pool (void) { - struct glyph_pool *result; - - /* Allocate a new glyph_pool and clear it. */ - result = (struct glyph_pool *) xmalloc (sizeof *result); - memset (result, 0, sizeof *result); + struct glyph_pool *result = xzalloc (sizeof *result); +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING /* For memory leak and double deletion checking. */ ++glyph_pool_count; +#endif return result; } /* Free a glyph_pool structure POOL. The function may be called with - a null POOL pointer. The global variable glyph_pool_count is - decremented with every pool structure freed. If this count gets - negative, more structures were freed than allocated, i.e. one - structure must have been freed more than once or a bogus pointer - was passed to free_glyph_pool. */ + a null POOL pointer. If GLYPH_DEBUG and ENABLE_CHECKING are in effect, + global variable glyph_pool_count is decremented with every pool structure + freed. If this count gets negative, more structures were freed than + allocated, i.e. one structure must have been freed more than once or + a bogus pointer was passed to free_glyph_pool. */ static void free_glyph_pool (struct glyph_pool *pool) { if (pool) { +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING /* More freed than allocated? */ --glyph_pool_count; - xassert (glyph_pool_count >= 0); - + eassert (glyph_pool_count >= 0); +#endif xfree (pool->glyphs); xfree (pool); } @@ -1421,14 +1347,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 @@ -1464,7 +1390,7 @@ realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim) Debug Code ***********************************************************************/ -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Flush standard output. This is sometimes useful to call from the debugger. @@ -1493,7 +1419,7 @@ check_matrix_pointer_lossage (struct glyph_matrix *matrix) for (i = 0; i < matrix->nrows; ++i) for (j = 0; j < matrix->nrows; ++j) - xassert (i == j + eassert (i == j || (matrix->rows[i].glyphs[TEXT_AREA] != matrix->rows[j].glyphs[TEXT_AREA])); } @@ -1504,8 +1430,8 @@ check_matrix_pointer_lossage (struct glyph_matrix *matrix) struct glyph_row * matrix_row (struct glyph_matrix *matrix, int row) { - xassert (matrix && matrix->rows); - xassert (row >= 0 && row < matrix->nrows); + eassert (matrix && matrix->rows); + eassert (row >= 0 && row < matrix->nrows); /* That's really too slow for normal testing because this function is called almost everywhere. Although---it's still astonishingly @@ -1533,7 +1459,7 @@ check_matrix_invariants (struct window *w) struct glyph_row *row = matrix->rows; struct glyph_row *last_text_row = NULL; struct buffer *saved = current_buffer; - struct buffer *buffer = XBUFFER (w->buffer); + struct buffer *buffer = XBUFFER (w->contents); int c; /* This can sometimes happen for a fresh window. */ @@ -1552,9 +1478,9 @@ check_matrix_invariants (struct window *w) last_text_row = row; /* Check that character and byte positions are in sync. */ - xassert (MATRIX_ROW_START_BYTEPOS (row) + eassert (MATRIX_ROW_START_BYTEPOS (row) == CHAR_TO_BYTE (MATRIX_ROW_START_CHARPOS (row))); - xassert (BYTEPOS (row->start.pos) + eassert (BYTEPOS (row->start.pos) == CHAR_TO_BYTE (CHARPOS (row->start.pos))); /* CHAR_TO_BYTE aborts when invoked for a position > Z. We can @@ -1562,9 +1488,9 @@ check_matrix_invariants (struct window *w) displaying something like `[Sole completion]' at its end. */ if (MATRIX_ROW_END_CHARPOS (row) < BUF_ZV (current_buffer)) { - xassert (MATRIX_ROW_END_BYTEPOS (row) + eassert (MATRIX_ROW_END_BYTEPOS (row) == CHAR_TO_BYTE (MATRIX_ROW_END_CHARPOS (row))); - xassert (BYTEPOS (row->end.pos) + eassert (BYTEPOS (row->end.pos) == CHAR_TO_BYTE (CHARPOS (row->end.pos))); } @@ -1572,24 +1498,24 @@ check_matrix_invariants (struct window *w) of next row. */ if (next->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (next)) { - xassert (MATRIX_ROW_END_CHARPOS (row) + eassert (MATRIX_ROW_END_CHARPOS (row) == MATRIX_ROW_START_CHARPOS (next)); - xassert (MATRIX_ROW_END_BYTEPOS (row) + eassert (MATRIX_ROW_END_BYTEPOS (row) == MATRIX_ROW_START_BYTEPOS (next)); - xassert (CHARPOS (row->end.pos) == CHARPOS (next->start.pos)); - xassert (BYTEPOS (row->end.pos) == BYTEPOS (next->start.pos)); + eassert (CHARPOS (row->end.pos) == CHARPOS (next->start.pos)); + eassert (BYTEPOS (row->end.pos) == BYTEPOS (next->start.pos)); } row = next; } - xassert (w->current_matrix->nrows == w->desired_matrix->nrows); - xassert (w->desired_matrix->rows != NULL); + eassert (w->current_matrix->nrows == w->desired_matrix->nrows); + eassert (w->desired_matrix->rows != NULL); set_buffer_temp (saved); } #endif /* 0 */ -#endif /* GLYPH_DEBUG != 0 */ +#endif /* GLYPH_DEBUG */ @@ -1602,7 +1528,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. @@ -1679,7 +1605,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; @@ -1687,7 +1613,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 @@ -1697,7 +1623,7 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y, vertically below other windows. */ in_horz_combination_p = (!NILP (XWINDOW (window)->parent) - && !NILP (XWINDOW (XWINDOW (window)->parent)->hchild)); + && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (XWINDOW (window)->parent))); /* For WINDOW and all windows on the same level. */ do @@ -1706,12 +1632,8 @@ allocate_matrices_for_frame_redisplay (Lisp_Object window, int x, int y, /* Get the dimension of the window sub-matrix for W, depending on whether this is a combination or a leaf window. */ - if (!NILP (w->hchild)) - dim = allocate_matrices_for_frame_redisplay (w->hchild, x, y, - dim_only_p, - window_change_flags); - else if (!NILP (w->vchild)) - dim = allocate_matrices_for_frame_redisplay (w->vchild, x, y, + if (WINDOWP (w->contents)) + dim = allocate_matrices_for_frame_redisplay (w->contents, x, y, dim_only_p, window_change_flags); else @@ -1745,7 +1667,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) { @@ -1841,7 +1763,7 @@ required_matrix_width (struct window *w) } #endif /* HAVE_WINDOW_SYSTEM */ - return XINT (w->total_cols); + return w->total_cols; } @@ -1853,10 +1775,8 @@ allocate_matrices_for_window_redisplay (struct window *w) { while (w) { - if (!NILP (w->vchild)) - allocate_matrices_for_window_redisplay (XWINDOW (w->vchild)); - else if (!NILP (w->hchild)) - allocate_matrices_for_window_redisplay (XWINDOW (w->hchild)); + if (WINDOWP (w->contents)) + allocate_matrices_for_window_redisplay (XWINDOW (w->contents)); else { /* W is a leaf window. */ @@ -1890,7 +1810,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); @@ -1902,46 +1822,9 @@ adjust_glyphs (struct frame *f) adjust_frame_glyphs (XFRAME (lisp_frame)); } - UNBLOCK_INPUT; -} - - -/* Adjust frame glyphs when Emacs is initialized. - - To be called from init_display. - - We need a glyph matrix because redraw will happen soon. - Unfortunately, window sizes on selected_frame are not yet set to - meaningful values. I believe we can assume that there are only two - windows on the frame---the mini-buffer and the root window. Frame - height and width seem to be correct so far. So, set the sizes of - windows to estimated values. */ - -static void -adjust_frame_glyphs_initially (void) -{ - struct frame *sf = SELECTED_FRAME (); - struct window *root = XWINDOW (sf->root_window); - struct window *mini = XWINDOW (root->next); - int frame_lines = FRAME_LINES (sf); - int frame_cols = FRAME_COLS (sf); - 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); - - /* 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); - - adjust_frame_glyphs (sf); - glyphs_initialized_initially_p = 1; + unblock_input (); } - /* Allocate/reallocate glyph matrices of a single frame F. */ static void @@ -1952,33 +1835,25 @@ adjust_frame_glyphs (struct frame *f) else adjust_frame_glyphs_for_frame_redisplay (f); - /* Don't forget the message buffer and the buffer for - decode_mode_spec. */ - adjust_frame_message_buffer (f); + /* Don't forget the buffer for decode_mode_spec. */ adjust_decode_mode_spec_buffer (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) { - if (!NILP (w->hchild)) - { - if (showing_window_margins_p (XWINDOW (w->hchild))) - return 1; - } - else if (!NILP (w->vchild)) + if (WINDOWP (w->contents)) { - if (showing_window_margins_p (XWINDOW (w->vchild))) + if (showing_window_margins_p (XWINDOW (w->contents))) return 1; } - else if (!NILP (w->left_margin_cols) - || !NILP (w->right_margin_cols)) + else if (w->left_margin_cols > 0 || w->right_margin_cols > 0) return 1; w = NILP (w->next) ? 0 : XWINDOW (w->next); @@ -1999,10 +1874,8 @@ fake_current_matrices (Lisp_Object window) { w = XWINDOW (window); - if (!NILP (w->hchild)) - fake_current_matrices (w->hchild); - else if (!NILP (w->vchild)) - fake_current_matrices (w->vchild); + if (WINDOWP (w->contents)) + fake_current_matrices (w->contents); else { int i; @@ -2010,15 +1883,15 @@ fake_current_matrices (Lisp_Object window) struct glyph_matrix *m = w->current_matrix; struct glyph_matrix *fm = f->current_matrix; - xassert (m->matrix_h == WINDOW_TOTAL_LINES (w)); - xassert (m->matrix_w == WINDOW_TOTAL_COLS (w)); + eassert (m->matrix_h == WINDOW_TOTAL_LINES (w)); + eassert (m->matrix_w == WINDOW_TOTAL_COLS (w)); for (i = 0; i < m->matrix_h; ++i) { struct glyph_row *r = m->rows + i; struct glyph_row *fr = fm->rows + i + WINDOW_TOP_EDGE_LINE (w); - xassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA] + eassert (r->glyphs[TEXT_AREA] >= fr->glyphs[TEXT_AREA] && r->glyphs[LAST_AREA] <= fr->glyphs[LAST_AREA]); r->enabled_p = fr->enabled_p; @@ -2044,14 +1917,9 @@ struct glyph_matrix * save_current_matrix (struct frame *f) { int i; - struct glyph_matrix *saved; - - saved = (struct glyph_matrix *) xmalloc (sizeof *saved); - memset (saved, 0, sizeof *saved); + struct glyph_matrix *saved = xzalloc (sizeof *saved); saved->nrows = f->current_matrix->nrows; - saved->rows = (struct glyph_row *) xmalloc (saved->nrows - * sizeof *saved->rows); - memset (saved->rows, 0, saved->nrows * sizeof *saved->rows); + saved->rows = xzalloc (saved->nrows * sizeof *saved->rows); for (i = 0; i < saved->nrows; ++i) { @@ -2059,7 +1927,7 @@ save_current_matrix (struct frame *f) struct glyph_row *to = saved->rows + i; ptrdiff_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph); - to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes); + to->glyphs[TEXT_AREA] = xmalloc (nbytes); memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes); to->used[TEXT_AREA] = from->used[TEXT_AREA]; if (from->used[LEFT_MARGIN_AREA]) @@ -2136,7 +2004,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; @@ -2191,7 +2059,7 @@ adjust_frame_glyphs_for_frame_redisplay (struct frame *f) /* Size of frame matrices must equal size of frame. Note that we are called for X frames with window widths NOT equal to the frame width (from CHANGE_FRAME_SIZE_1). */ - xassert (matrix_dim.width == FRAME_COLS (f) + eassert (matrix_dim.width == FRAME_COLS (f) && matrix_dim.height == FRAME_LINES (f)); /* Pointers to glyph memory in glyph rows are exchanged during @@ -2235,7 +2103,7 @@ adjust_frame_glyphs_for_frame_redisplay (struct frame *f) static void adjust_frame_glyphs_for_window_redisplay (struct frame *f) { - xassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f)); + eassert (FRAME_WINDOW_P (f) && FRAME_LIVE_P (f)); /* Allocate/reallocate window matrices. */ allocate_matrices_for_window_redisplay (XWINDOW (FRAME_ROOT_WINDOW (f))); @@ -2249,9 +2117,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 @@ -2259,10 +2129,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)); + w->top_line = 0; + w->left_col = 0; + w->total_lines = FRAME_MENU_BAR_LINES (f); + w->total_cols = FRAME_TOTAL_COLS (f); allocate_matrices_for_window_redisplay (w); } #endif /* not USE_X_TOOLKIT && not USE_GTK */ @@ -2275,57 +2145,33 @@ 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)); + w->top_line = FRAME_MENU_BAR_LINES (f); + w->left_col = 0; + w->total_lines = FRAME_TOOL_BAR_LINES (f); + w->total_cols = FRAME_TOTAL_COLS (f); allocate_matrices_for_window_redisplay (w); } #endif } -/* Adjust/ allocate message buffer of frame F. - - Note that the message buffer is never freed. Since I could not - find a free in 19.34, I assume that freeing it would be - problematic in some way and don't do it either. - - (Implementation note: It should be checked if we can free it - eventually without causing trouble). */ - -static void -adjust_frame_message_buffer (struct frame *f) -{ - ptrdiff_t size = FRAME_MESSAGE_BUF_SIZE (f) + 1; - - if (FRAME_MESSAGE_BUF (f)) - { - char *buffer = FRAME_MESSAGE_BUF (f); - char *new_buffer = (char *) xrealloc (buffer, size); - FRAME_MESSAGE_BUF (f) = new_buffer; - } - else - FRAME_MESSAGE_BUF (f) = (char *) xmalloc (size); -} - - /* Re-allocate buffer for decode_mode_spec on frame F. */ static void adjust_decode_mode_spec_buffer (struct frame *f) { - f->decode_mode_spec_buffer - = (char *) xrealloc (f->decode_mode_spec_buffer, - FRAME_MESSAGE_BUF_SIZE (f) + 1); + f->decode_mode_spec_buffer = xrealloc (f->decode_mode_spec_buffer, + FRAME_MESSAGE_BUF_SIZE (f) + 1); } @@ -2346,13 +2192,14 @@ 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. */ if (!NILP (f->root_window)) free_window_matrices (XWINDOW (f->root_window)); +#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) /* Free the dummy window for menu bars without X toolkit and its glyph matrices. */ if (!NILP (f->menu_bar_window)) @@ -2361,8 +2208,9 @@ 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); } +#endif /* Free the tool bar window and its glyph matrices. */ if (!NILP (f->tool_bar_window)) @@ -2371,7 +2219,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 @@ -2391,7 +2239,7 @@ free_glyphs (struct frame *f) f->desired_pool = f->current_pool = NULL; } - UNBLOCK_INPUT; + unblock_input (); } } @@ -2405,10 +2253,8 @@ free_window_matrices (struct window *w) { while (w) { - if (!NILP (w->hchild)) - free_window_matrices (XWINDOW (w->hchild)); - else if (!NILP (w->vchild)) - free_window_matrices (XWINDOW (w->vchild)); + if (WINDOWP (w->contents)) + free_window_matrices (XWINDOW (w->contents)); else { /* This is a leaf window. Free its memory and reset fields @@ -2439,11 +2285,11 @@ check_glyph_memory (void) FOR_EACH_FRAME (tail, frame) free_glyphs (XFRAME (frame)); +#if defined GLYPH_DEBUG && defined ENABLE_CHECKING /* Check that nothing is left allocated. */ - if (glyph_matrix_count) - abort (); - if (glyph_pool_count) - abort (); + eassert (glyph_matrix_count == 0); + eassert (glyph_pool_count == 0); +#endif } @@ -2460,7 +2306,7 @@ check_glyph_memory (void) screen. We build such a view by constructing a frame matrix from window matrices in this section. - Windows that must be updated have their must_be_update_p flag set. + Windows that must be updated have their must_be_updated_p flag set. For all such windows, their desired matrix is made part of the desired frame matrix. For other windows, their current matrix is made part of the desired frame matrix. @@ -2520,7 +2366,7 @@ build_frame_matrix (struct frame *f) int i; /* F must have a frame matrix when this function is called. */ - xassert (!FRAME_WINDOW_P (f)); + eassert (!FRAME_WINDOW_P (f)); /* Clear all rows in the frame matrix covered by window matrices. Menu bar lines are not covered by windows. */ @@ -2541,10 +2387,8 @@ build_frame_matrix_from_window_tree (struct glyph_matrix *matrix, struct window { while (w) { - if (!NILP (w->hchild)) - build_frame_matrix_from_window_tree (matrix, XWINDOW (w->hchild)); - else if (!NILP (w->vchild)) - build_frame_matrix_from_window_tree (matrix, XWINDOW (w->vchild)); + if (WINDOWP (w->contents)) + build_frame_matrix_from_window_tree (matrix, XWINDOW (w->contents)); else build_frame_matrix_from_leaf_window (matrix, w); @@ -2557,7 +2401,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 @@ -2608,7 +2452,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. */ @@ -2636,7 +2480,7 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w } else { - xassert (window_row->enabled_p); + eassert (window_row->enabled_p); /* Only when a desired row has been displayed, we want the corresponding frame row to be updated. */ @@ -2650,10 +2494,10 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w SET_CHAR_GLYPH_FROM_GLYPH (*border, right_border_glyph); } -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Window row window_y must be a slice of frame row frame_y. */ - xassert (glyph_row_slice_p (window_row, frame_row)); + eassert (glyph_row_slice_p (window_row, frame_row)); /* If rows are in sync, we don't have to copy glyphs because frame and window share glyphs. */ @@ -2761,7 +2605,7 @@ fill_up_frame_row_with_spaces (struct glyph_row *row, int upto) function must be called before updates to make explicit that we are working on frame matrices or not. */ -static inline void +static void set_frame_matrix_frame (struct frame *f) { frame_matrix_frame = f; @@ -2776,12 +2620,12 @@ set_frame_matrix_frame (struct frame *f) done in frame matrices, and that we have to perform analogous operations in window matrices of frame_matrix_frame. */ -static inline void +static void make_current (struct glyph_matrix *desired_matrix, struct glyph_matrix *current_matrix, int row) { 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. */ @@ -2808,10 +2652,8 @@ mirror_make_current (struct window *w, int frame_row) { while (w) { - if (!NILP (w->hchild)) - mirror_make_current (XWINDOW (w->hchild), frame_row); - else if (!NILP (w->vchild)) - mirror_make_current (XWINDOW (w->vchild), frame_row); + if (WINDOWP (w->contents)) + mirror_make_current (XWINDOW (w->contents), frame_row); else { /* Row relative to window W. Don't use FRAME_TO_WINDOW_VPOS @@ -2872,16 +2714,16 @@ mirrored_line_dance (struct glyph_matrix *matrix, int unchanged_at_top, int nlin int i; /* Make a copy of the original rows. */ - old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows); + old_rows = alloca (nlines * sizeof *old_rows); memcpy (old_rows, new_rows, nlines * sizeof *old_rows); /* 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; - xassert (i + unchanged_at_top < matrix->nrows); - xassert (unchanged_at_top + copy_from[i] < matrix->nrows); + eassert (i + unchanged_at_top < matrix->nrows); + eassert (unchanged_at_top + copy_from[i] < matrix->nrows); new_rows[i] = old_rows[copy_from[i]]; new_rows[i].enabled_p = enabled_before_p; @@ -2907,9 +2749,9 @@ sync_window_with_frame_matrix_rows (struct window *w) struct glyph_row *window_row, *window_row_end, *frame_row; int left, right, x, width; - /* Preconditions: W must be a leaf window on a tty frame. */ - xassert (NILP (w->hchild) && NILP (w->vchild)); - xassert (!FRAME_WINDOW_P (f)); + /* Preconditions: W must be a live window on a tty frame. */ + eassert (BUFFERP (w->contents)); + eassert (!FRAME_WINDOW_P (f)); left = margin_glyphs_to_reserve (w, 1, w->left_margin_cols); right = margin_glyphs_to_reserve (w, 1, w->right_margin_cols); @@ -2944,10 +2786,8 @@ frame_row_to_window (struct window *w, int row) while (w && !found) { - if (!NILP (w->hchild)) - found = frame_row_to_window (XWINDOW (w->hchild), row); - else if (!NILP (w->vchild)) - found = frame_row_to_window (XWINDOW (w->vchild), row); + if (WINDOWP (w->contents)) + found = frame_row_to_window (XWINDOW (w->contents), row); else if (row >= WINDOW_TOP_EDGE_LINE (w) && row < WINDOW_BOTTOM_EDGE_LINE (w)) found = w; @@ -2975,22 +2815,20 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy { while (w) { - if (!NILP (w->hchild)) - mirror_line_dance (XWINDOW (w->hchild), unchanged_at_top, - nlines, copy_from, retained_p); - else if (!NILP (w->vchild)) - mirror_line_dance (XWINDOW (w->vchild), unchanged_at_top, + if (WINDOWP (w->contents)) + mirror_line_dance (XWINDOW (w->contents), unchanged_at_top, nlines, copy_from, retained_p); else { /* 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. */ - old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows); + old_rows = alloca (m->nrows * sizeof *old_rows); memcpy (old_rows, m->rows, m->nrows * sizeof *old_rows); for (i = 0; i < nlines; ++i) @@ -3008,22 +2846,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; @@ -3077,7 +2912,7 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy } -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Check that window and frame matrices agree about their understanding where glyphs of the rows are to find. For each @@ -3090,10 +2925,8 @@ check_window_matrix_pointers (struct window *w) { while (w) { - if (!NILP (w->hchild)) - check_window_matrix_pointers (XWINDOW (w->hchild)); - else if (!NILP (w->vchild)) - check_window_matrix_pointers (XWINDOW (w->vchild)); + if (WINDOWP (w->contents)) + check_window_matrix_pointers (XWINDOW (w->contents)); else { struct frame *f = XFRAME (w->frame); @@ -3128,12 +2961,12 @@ 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; } } -#endif /* GLYPH_DEBUG != 0 */ +#endif /* GLYPH_DEBUG */ @@ -3141,7 +2974,7 @@ check_matrix_pointers (struct glyph_matrix *window_matrix, VPOS and HPOS translations **********************************************************************/ -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Translate vertical position VPOS which is relative to window W to a vertical position relative to W's frame. */ @@ -3149,10 +2982,10 @@ check_matrix_pointers (struct glyph_matrix *window_matrix, static int window_to_frame_vpos (struct window *w, int vpos) { - xassert (!FRAME_WINDOW_P (XFRAME (w->frame))); - xassert (vpos >= 0 && vpos <= w->desired_matrix->nrows); + eassert (!FRAME_WINDOW_P (XFRAME (w->frame))); + eassert (vpos >= 0 && vpos <= w->desired_matrix->nrows); vpos += WINDOW_TOP_EDGE_LINE (w); - xassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (w->frame))); + eassert (vpos >= 0 && vpos <= FRAME_LINES (XFRAME (w->frame))); return vpos; } @@ -3163,7 +2996,7 @@ window_to_frame_vpos (struct window *w, int vpos) static int window_to_frame_hpos (struct window *w, int hpos) { - xassert (!FRAME_WINDOW_P (XFRAME (w->frame))); + eassert (!FRAME_WINDOW_P (XFRAME (w->frame))); hpos += WINDOW_LEFT_EDGE_COL (w); return hpos; } @@ -3176,21 +3009,13 @@ window_to_frame_hpos (struct window *w, int hpos) Redrawing Frames **********************************************************************/ -DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0, - doc: /* Clear frame FRAME and output again what is supposed to appear on it. */) - (Lisp_Object frame) -{ - struct frame *f; - - CHECK_LIVE_FRAME (frame); - f = XFRAME (frame); - - /* Ignore redraw requests, if frame has no glyphs yet. - (Implementation note: It still has to be checked why we are - called so early here). */ - if (!glyphs_initialized_initially_p) - return Qnil; +/* Redraw frame F. */ +void +redraw_frame (struct frame *f) +{ + /* Error if F has no glyphs. */ + eassert (f->glyphs_initialized_p); update_begin (f); #ifdef MSDOS if (FRAME_MSDOS_P (f)) @@ -3207,22 +3032,17 @@ DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0, mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0); set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), 1); f->garbaged = 0; - return Qnil; } - -/* Redraw frame F. This is nothing more than a call to the Lisp - function redraw-frame. */ - -void -redraw_frame (struct frame *f) +DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 0, 1, 0, + doc: /* Clear frame FRAME and output again what is supposed to appear on it. +If FRAME is omitted or nil, the selected frame is used. */) + (Lisp_Object frame) { - Lisp_Object frame; - XSETFRAME (frame, f); - Fredraw_frame (frame); + redraw_frame (decode_live_frame (frame)); + return Qnil; } - DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "", doc: /* Clear and redisplay all visible frames. */) (void) @@ -3231,7 +3051,7 @@ DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "", FOR_EACH_FRAME (tail, frame) if (FRAME_VISIBLE_P (XFRAME (frame))) - Fredraw_frame (frame); + redraw_frame (XFRAME (frame)); return Qnil; } @@ -3244,44 +3064,25 @@ 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) force_p = 1; -#if PERIODIC_PREEMPTION_CHECKING - else if (NILP (Vredisplay_preemption_period)) - force_p = 1; - else if (!force_p && NUMBERP (Vredisplay_preemption_period)) + else if (!force_p && detect_input_pending_ignore_squeezables ()) { - EMACS_TIME tm; - double p = XFLOATINT (Vredisplay_preemption_period); - int sec, usec; - - if (detect_input_pending_ignore_squeezables ()) - { - paused_p = 1; - goto do_pause; - } - - sec = (int) p; - usec = (p - sec) * 1000000; - - EMACS_GET_TIME (tm); - EMACS_SET_SECS_USECS (preemption_period, sec, usec); - EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); + paused_p = 1; + goto do_pause; } -#endif if (FRAME_WINDOW_P (f)) { @@ -3295,10 +3096,12 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p) when pending input is detected. */ update_begin (f); +#if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) /* Update the menu bar on X frames that don't have toolkit support. */ if (WINDOWP (f->menu_bar_window)) update_window (XWINDOW (f->menu_bar_window), 1); +#endif /* Update the tool-bar window, if present. */ if (WINDOWP (f->tool_bar_window)) @@ -3316,8 +3119,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); } } @@ -3359,15 +3162,13 @@ update_frame (struct frame *f, int force_p, int inhibit_hairy_id_p) } /* Check window matrices for lost pointers. */ -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG check_window_matrix_pointers (root_window); add_frame_display_history (f, paused_p); #endif } -#if PERIODIC_PREEMPTION_CHECKING do_pause: -#endif /* Reset flags indicating that a window should be updated. */ set_window_update_flags (root_window, 0); @@ -3416,20 +3217,18 @@ update_frame_with_menu (struct frame *f) 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) { - if (!NILP (w->hchild)) - paused_p |= update_window_tree (XWINDOW (w->hchild), force_p); - else if (!NILP (w->vchild)) - paused_p |= update_window_tree (XWINDOW (w->vchild), force_p); + if (WINDOWP (w->contents)) + paused_p |= update_window_tree (XWINDOW (w->contents), force_p); else if (w->must_be_updated_p) paused_p |= update_window (w, force_p); @@ -3440,11 +3239,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) { @@ -3455,23 +3254,6 @@ update_single_window (struct window *w, int force_p) if (redisplay_dont_pause) force_p = 1; -#if PERIODIC_PREEMPTION_CHECKING - else if (NILP (Vredisplay_preemption_period)) - force_p = 1; - else if (!force_p && NUMBERP (Vredisplay_preemption_period)) - { - EMACS_TIME tm; - double p = XFLOATINT (Vredisplay_preemption_period); - int sec, usec; - - sec = (int) p; - usec = (p - sec) * 1000000; - - EMACS_GET_TIME (tm); - EMACS_SET_SECS_USECS (preemption_period, sec, usec); - EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); - } -#endif /* Update W. */ update_begin (f); @@ -3514,14 +3296,12 @@ redraw_overlapped_rows (struct window *w, int yb) for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area) { - updated_row = row; - updated_area = area; - FRAME_RIF (f)->cursor_to (i, 0, row->y, - area == TEXT_AREA ? row->x : 0); + output_cursor_to (w, i, 0, row->y, + area == TEXT_AREA ? row->x : 0); if (row->used[area]) - FRAME_RIF (f)->write_glyphs (row->glyphs[area], - row->used[area]); - FRAME_RIF (f)->clear_end_of_line (-1); + FRAME_RIF (f)->write_glyphs (w, row, row->glyphs[area], + area, row->used[area]); + FRAME_RIF (f)->clear_end_of_line (w, row, area, -1); } row->overlapped_p = 0; @@ -3601,7 +3381,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) @@ -3610,35 +3390,31 @@ 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; -#if !PERIODIC_PREEMPTION_CHECKING + bool paused_p; int preempt_count = baud_rate / 2400 + 1; -#endif struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w))); -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Check that W's frame doesn't have glyph matrices. */ - xassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w)))); + eassert (FRAME_WINDOW_P (XFRAME (WINDOW_FRAME (w)))); #endif /* Check pending input the first time so that we can quickly return. */ -#if !PERIODIC_PREEMPTION_CHECKING if (!force_p) detect_input_pending_ignore_squeezables (); -#endif /* If forced to complete the update, or if no input is pending, do the update. */ @@ -3647,15 +3423,14 @@ 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; -#if ! PERIODIC_PREEMPTION_CHECKING + int yb; + bool changed_p = 0, mouse_face_overwritten_p = 0; int n_updated = 0; -#endif rif->update_window_begin_hook (w); yb = window_text_bottom_y (w); - row = desired_matrix->rows; - end = row + desired_matrix->nrows - 1; + row = MATRIX_ROW (desired_matrix, 0); + end = MATRIX_MODE_LINE_ROW (desired_matrix); /* Take note of the header line, if there is one. We will update it below, after updating all of the window's lines. */ @@ -3714,23 +3489,8 @@ update_window (struct window *w, int force_p) detect_input_pending. If it's done too often, scrolling large windows with repeated scroll-up commands will too quickly pause redisplay. */ -#if PERIODIC_PREEMPTION_CHECKING - if (!force_p) - { - EMACS_TIME tm, dif; - EMACS_GET_TIME (tm); - EMACS_SUB_TIME (dif, preemption_next_check, tm); - if (EMACS_TIME_NEG_P (dif)) - { - EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); - if (detect_input_pending_ignore_squeezables ()) - break; - } - } -#else if (!force_p && ++n_updated % preempt_count == 0) detect_input_pending_ignore_squeezables (); -#endif changed_p |= update_window_line (w, vpos, &mouse_face_overwritten_p); @@ -3782,7 +3542,7 @@ update_window (struct window *w, int force_p) #endif } -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* Remember the redisplay method used to display the matrix. */ strcpy (w->current_matrix->method, w->desired_matrix->method); #endif @@ -3794,13 +3554,13 @@ update_window (struct window *w, int force_p) /* End the update of window W. Don't set the cursor if we paused updating the display because in this case, set_window_cursor_after_update hasn't been called, and - output_cursor doesn't contain the cursor location. */ + W->output_cursor doesn't contain the cursor location. */ rif->update_window_end_hook (w, !paused_p, mouse_face_overwritten_p); } else paused_p = 1; -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG /* check_current_matrix_flags (w); */ add_window_display_history (w, w->current_matrix->method, paused_p); #endif @@ -3815,39 +3575,33 @@ update_window (struct window *w, int force_p) AREA can be either LEFT_MARGIN_AREA or RIGHT_MARGIN_AREA. */ static void -update_marginal_area (struct window *w, int area, int vpos) +update_marginal_area (struct window *w, struct glyph_row *updated_row, + enum glyph_row_area area, int vpos) { struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos); struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w))); - /* Let functions in xterm.c know what area subsequent X positions - will be relative to. */ - updated_area = area; - /* Set cursor to start of glyphs, write them, and clear to the end of the area. I don't think that something more sophisticated is necessary here, since marginal areas will not be the default. */ - rif->cursor_to (vpos, 0, desired_row->y, 0); + output_cursor_to (w, vpos, 0, desired_row->y, 0); if (desired_row->used[area]) - rif->write_glyphs (desired_row->glyphs[area], desired_row->used[area]); - rif->clear_end_of_line (-1); + rif->write_glyphs (w, updated_row, desired_row->glyphs[area], + area, desired_row->used[area]); + rif->clear_end_of_line (w, updated_row, area, -1); } /* 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 -update_text_area (struct window *w, int vpos) +static bool +update_text_area (struct window *w, struct glyph_row *updated_row, 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; - - /* Let functions in xterm.c know what area subsequent X positions - will be relative to. */ - updated_area = TEXT_AREA; + bool changed_p = 0; /* If rows are at different X or Y, or rows have different height, or the current row is marked invalid, write the entire line. */ @@ -3868,14 +3622,14 @@ update_text_area (struct window *w, int vpos) && !(current_row->mode_line_p && vpos > 0)) || current_row->x != desired_row->x) { - rif->cursor_to (vpos, 0, desired_row->y, desired_row->x); + output_cursor_to (w, vpos, 0, desired_row->y, desired_row->x); if (desired_row->used[TEXT_AREA]) - rif->write_glyphs (desired_row->glyphs[TEXT_AREA], - desired_row->used[TEXT_AREA]); + rif->write_glyphs (w, updated_row, desired_row->glyphs[TEXT_AREA], + TEXT_AREA, desired_row->used[TEXT_AREA]); /* Clear to end of window. */ - rif->clear_end_of_line (-1); + rif->clear_end_of_line (w, updated_row, TEXT_AREA, -1); changed_p = 1; /* This erases the cursor. We do this here because @@ -3893,9 +3647,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, @@ -3915,7 +3669,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 @@ -3962,7 +3716,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) { @@ -3988,7 +3743,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 @@ -4010,8 +3765,9 @@ update_text_area (struct window *w, int vpos) break; } - rif->cursor_to (vpos, start_hpos, desired_row->y, start_x); - rif->write_glyphs (start, i - start_hpos); + output_cursor_to (w, vpos, start_hpos, desired_row->y, start_x); + rif->write_glyphs (w, updated_row, start, + TEXT_AREA, i - start_hpos); changed_p = 1; } } @@ -4019,8 +3775,9 @@ update_text_area (struct window *w, int vpos) /* Write the rest. */ if (i < desired_row->used[TEXT_AREA]) { - rif->cursor_to (vpos, i, desired_row->y, x); - rif->write_glyphs (desired_glyph, desired_row->used[TEXT_AREA] - i); + output_cursor_to (w, vpos, i, desired_row->y, x); + rif->write_glyphs (w, updated_row, desired_glyph, + TEXT_AREA, desired_row->used[TEXT_AREA] - i); changed_p = 1; } @@ -4031,7 +3788,7 @@ update_text_area (struct window *w, int vpos) has to be cleared, if and only if we did a write_glyphs above. This is made sure by setting desired_stop_pos appropriately above. */ - xassert (i < desired_row->used[TEXT_AREA] + eassert (i < desired_row->used[TEXT_AREA] || ((desired_row->used[TEXT_AREA] == current_row->used[TEXT_AREA]) && MATRIX_ROW_EXTENDS_FACE_P (current_row))); @@ -4040,9 +3797,9 @@ update_text_area (struct window *w, int vpos) { /* If old row extends to the end of the text area, clear. */ if (i >= desired_row->used[TEXT_AREA]) - rif->cursor_to (vpos, i, desired_row->y, - desired_row->pixel_width); - rif->clear_end_of_line (-1); + output_cursor_to (w, vpos, i, desired_row->y, + desired_row->pixel_width); + rif->clear_end_of_line (w, updated_row, TEXT_AREA, -1); changed_p = 1; } else if (desired_row->pixel_width < current_row->pixel_width) @@ -4052,8 +3809,8 @@ update_text_area (struct window *w, int vpos) int xlim; if (i >= desired_row->used[TEXT_AREA]) - rif->cursor_to (vpos, i, desired_row->y, - desired_row->pixel_width); + output_cursor_to (w, vpos, i, desired_row->y, + desired_row->pixel_width); /* If cursor is displayed at the end of the line, make sure it's cleared. Nowadays we don't have a phys_cursor_glyph @@ -4070,7 +3827,7 @@ update_text_area (struct window *w, int vpos) } else xlim = current_row->pixel_width; - rif->clear_end_of_line (xlim); + rif->clear_end_of_line (w, updated_row, TEXT_AREA, xlim); changed_p = 1; } } @@ -4079,20 +3836,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; - - /* Set the row being updated. This is important to let xterm.c - know what line height values are in effect. */ - updated_row = desired_row; + bool changed_p = 0; /* A row can be completely invisible in case a desired matrix was built with a vscroll and then make_cursor_line_fully_visible shifts @@ -4101,18 +3853,22 @@ update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p) if (desired_row->mode_line_p || desired_row->visible_height > 0) { - xassert (desired_row->enabled_p); + eassert (desired_row->enabled_p); /* Update display of the left margin area, if there is one. */ - if (!desired_row->full_width_p - && !NILP (w->left_margin_cols)) + if (!desired_row->full_width_p && w->left_margin_cols > 0) { changed_p = 1; - update_marginal_area (w, LEFT_MARGIN_AREA, vpos); + update_marginal_area (w, desired_row, 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. */ - if (update_text_area (w, vpos)) + if (update_text_area (w, desired_row, vpos)) { changed_p = 1; if (current_row->mouse_face_p) @@ -4120,11 +3876,10 @@ update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p) } /* Update display of the right margin area, if there is one. */ - if (!desired_row->full_width_p - && !NILP (w->right_margin_cols)) + if (!desired_row->full_width_p && w->right_margin_cols > 0) { changed_p = 1; - update_marginal_area (w, RIGHT_MARGIN_AREA, vpos); + update_marginal_area (w, desired_row, RIGHT_MARGIN_AREA, vpos); } /* Draw truncation marks etc. */ @@ -4138,12 +3893,11 @@ update_window_line (struct window *w, int vpos, int *mouse_face_overwritten_p) || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row) != MATRIX_ROW_CONTINUATION_LINE_P (current_row))) - rif->after_update_window_line_hook (desired_row); + rif->after_update_window_line_hook (w, desired_row); } /* Update current_row from desired_row. */ make_current (w->desired_matrix, w->current_matrix, vpos); - updated_row = NULL; return changed_p; } @@ -4155,11 +3909,10 @@ static void set_window_cursor_after_update (struct window *w) { struct frame *f = XFRAME (w->frame); - struct redisplay_interface *rif = FRAME_RIF (f); int cx, cy, vpos, hpos; /* Not intended for frame matrix updates. */ - xassert (FRAME_WINDOW_P (f)); + eassert (FRAME_WINDOW_P (f)); if (cursor_in_echo_area && !NILP (echo_area_buffer[0]) @@ -4223,12 +3976,11 @@ set_window_cursor_after_update (struct window *w) vpos = w->cursor.vpos; } - /* Window cursor can be out of sync for horizontally split windows. */ - hpos = max (-1, hpos); /* -1 is for when cursor is on the left fringe */ - hpos = min (w->current_matrix->matrix_w - 1, hpos); - vpos = max (0, vpos); - vpos = min (w->current_matrix->nrows - 1, vpos); - rif->cursor_to (vpos, hpos, cy, cx); + /* Window cursor can be out of sync for horizontally split windows. + Horizontal position is -1 when cursor is on the left fringe. */ + hpos = clip_to_bounds (-1, hpos, w->current_matrix->matrix_w - 1); + vpos = clip_to_bounds (0, vpos, w->current_matrix->nrows - 1); + output_cursor_to (w, vpos, hpos, cy, cx); } @@ -4236,14 +3988,12 @@ 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) { - if (!NILP (w->hchild)) - set_window_update_flags (XWINDOW (w->hchild), on_p); - else if (!NILP (w->vchild)) - set_window_update_flags (XWINDOW (w->vchild), on_p); + if (WINDOWP (w->contents)) + set_window_update_flags (XWINDOW (w->contents), on_p); else w->must_be_updated_p = on_p; @@ -4312,14 +4062,14 @@ static struct run **runs; /* Add glyph row ROW to the scrolling hash table. */ -static inline struct row_entry * +static struct row_entry * add_row_entry (struct glyph_row *row) { struct row_entry *entry; ptrdiff_t i = row->hash % row_table_size; entry = row_table[i]; - xassert (entry || verify_row_hash (row)); + eassert (entry || verify_row_hash (row)); while (entry && !row_equal_p (entry->row, row, 1)) entry = entry->next; @@ -4339,7 +4089,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 @@ -4365,7 +4115,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; @@ -4378,7 +4128,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); @@ -4533,7 +4283,7 @@ scrolling_window (struct window *w, int header_line_p) for (i = first_new; i < last_new; ++i) { - xassert (MATRIX_ROW_ENABLED_P (desired_matrix, i)); + eassert (MATRIX_ROW_ENABLED_P (desired_matrix, i)); entry = add_row_entry (MATRIX_ROW (desired_matrix, i)); ++entry->new_uses; entry->new_line_number = i; @@ -4637,7 +4387,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 @@ -4700,7 +4450,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); @@ -4713,7 +4463,7 @@ scrolling_window (struct window *w, int header_line_p) row. But thanks to the truncation code in the preceding for-loop, we no longer have such an overlap, and thus the assigned row should always be enabled. */ - xassert (to->enabled_p); + eassert (to->enabled_p); from->enabled_p = 0; to->overlapped_p = to_overlapped_p; } @@ -4724,7 +4474,7 @@ scrolling_window (struct window *w, int header_line_p) row_table[row_entry_pool[i].bucket] = NULL; /* Value is 1 to indicate that we scrolled the display. */ - return 0 < nruns; + return nruns > 0; } @@ -4735,23 +4485,22 @@ 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; - xassert (current_matrix && desired_matrix); + eassert (current_matrix && desired_matrix); if (baud_rate != FRAME_COST_BAUD_RATE (f)) calculate_costs (f); @@ -4759,13 +4508,11 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) if (preempt_count <= 0) preempt_count = 1; -#if !PERIODIC_PREEMPTION_CHECKING if (!force_p && detect_input_pending_ignore_squeezables ()) { pause_p = 1; goto do_pause; } -#endif /* If we cannot insert/delete lines, it's no use trying it. */ if (!FRAME_LINE_INS_DEL_OK (f)) @@ -4799,50 +4546,22 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) FILE *display_output = FRAME_TTY (f)->output; if (display_output) { - int outq = PENDING_OUTPUT_COUNT (display_output); + ptrdiff_t outq = __fpending (display_output); if (outq > 900 || (outq > 20 && ((i - 1) % preempt_count == 0))) - { - fflush (display_output); - if (preempt_count == 1) - { -#ifdef EMACS_OUTQSIZE - if (EMACS_OUTQSIZE (0, &outq) < 0) - /* Probably not a tty. Ignore the error and reset - the outq count. */ - outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f->output)); -#endif - outq *= 10; - if (baud_rate <= outq && baud_rate > 0) - sleep (outq / baud_rate); - } - } + fflush (display_output); } } -#if PERIODIC_PREEMPTION_CHECKING - if (!force_p) - { - EMACS_TIME tm, dif; - EMACS_GET_TIME (tm); - EMACS_SUB_TIME (dif, preemption_next_check, tm); - if (EMACS_TIME_NEG_P (dif)) - { - EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); - if (detect_input_pending_ignore_squeezables ()) - break; - } - } -#else if (!force_p && (i - 1) % preempt_count == 0) detect_input_pending_ignore_squeezables (); -#endif update_frame_line (f, i); } } - 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) @@ -4932,18 +4651,13 @@ update_frame_1 (struct frame *f, int force_p, int inhibit_id_p) int x = WINDOW_TO_FRAME_HPOS (w, w->cursor.hpos); int y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos); - if (INTEGERP (w->left_margin_cols)) - x += XFASTINT (w->left_margin_cols); - - /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */ + x += max (0, w->left_margin_cols); cursor_to (f, y, x); } } } -#if !PERIODIC_PREEMPTION_CHECKING do_pause: -#endif clear_desired_matrices (f); return pause_p; @@ -4952,23 +4666,23 @@ 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; int window_size; int changed_lines; - int *old_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int)); - int *new_hash = (int *) alloca (FRAME_LINES (frame) * sizeof (int)); - int *draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int)); - int *old_draw_cost = (int *) alloca (FRAME_LINES (frame) * sizeof (int)); + int *old_hash = alloca (FRAME_LINES (frame) * sizeof (int)); + int *new_hash = alloca (FRAME_LINES (frame) * sizeof (int)); + int *draw_cost = alloca (FRAME_LINES (frame) * sizeof (int)); + int *old_draw_cost = alloca (FRAME_LINES (frame) * sizeof (int)); register int i; int free_at_end_vpos = FRAME_LINES (frame); struct glyph_matrix *current_matrix = frame->current_matrix; 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 @@ -5095,10 +4809,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; @@ -5423,16 +5137,14 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p /* We used to set current_buffer directly here, but that does the wrong thing with `face-remapping-alist' (bug#2044). */ - Fset_buffer (w->buffer); + Fset_buffer (w->contents); itdata = bidi_shelve_cache (); - SET_TEXT_POS_FROM_MARKER (startp, w->start); - CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp))); - BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp))); + CLIP_TEXT_POS_FROM_MARKER (startp, w->start); start_display (&it, w, startp); /* 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; @@ -5469,7 +5181,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p *dx = x0 + it.first_visible_x - it.current_x; *dy = *y - it.current_y; - string = w->buffer; + string = w->contents; if (STRINGP (it.string)) string = it.string; *pos = it.current; @@ -5487,7 +5199,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p if (STRINGP (it.string)) BYTEPOS (pos->pos) = string_char_to_byte (string, CHARPOS (pos->pos)); else - BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->buffer), + BYTEPOS (pos->pos) = buf_charpos_to_bytepos (XBUFFER (w->contents), CHARPOS (pos->pos)); } @@ -5636,7 +5348,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)) @@ -5711,18 +5423,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. @@ -5750,20 +5458,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; @@ -5788,16 +5500,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; @@ -5816,7 +5529,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 (); @@ -5858,7 +5572,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 @@ -5887,7 +5601,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); + XWINDOW (f->tool_bar_window)->total_cols = newwidth; } FRAME_LINES (f) = newheight; @@ -5910,9 +5624,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); @@ -5940,19 +5654,19 @@ FILE = nil means just close any termscript file currently open. */) tty = CURTTY (); if (tty->termscript != 0) - { - BLOCK_INPUT; - fclose (tty->termscript); - UNBLOCK_INPUT; - } - tty->termscript = 0; + { + block_input (); + fclose (tty->termscript); + tty->termscript = 0; + unblock_input (); + } if (! NILP (file)) { file = Fexpand_file_name (file, Qnil); - tty->termscript = fopen (SSDATA (file), "w"); + tty->termscript = emacs_fopen (SSDATA (file), "w"); if (tty->termscript == 0) - report_file_error ("Opening termscript", Fcons (file, Qnil)); + report_file_error ("Opening termscript", file); } return Qnil; } @@ -5974,7 +5688,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"); @@ -5999,7 +5713,7 @@ when TERMINAL is nil. */) } fwrite (SDATA (string), 1, SBYTES (string), out); fflush (out); - UNBLOCK_INPUT; + unblock_input (); return Qnil; } @@ -6029,7 +5743,11 @@ bitch_at_user (void) if (noninteractive) putchar (07); else if (!INTERACTIVE) /* Stop executing a keyboard macro. */ - error ("Keyboard macro terminated by a command ringing the bell"); + { + const char *msg + = "Keyboard macro terminated by a command ringing the bell"; + Fsignal (Quser_error, list1 (build_string (msg))); + } else ring_bell (XFRAME (selected_frame)); } @@ -6040,48 +5758,14 @@ bitch_at_user (void) Sleeping, Waiting ***********************************************************************/ -/* Convert a positive value DURATION to a seconds count *PSEC plus a - microseconds count *PUSEC, rounding up. On overflow return the - maximal value. */ -void -duration_to_sec_usec (double duration, int *psec, int *pusec) -{ - int MILLION = 1000000; - int sec = INT_MAX, usec = MILLION - 1; - - if (duration < INT_MAX + 1.0) - { - int s = duration; - double usdouble = (duration - s) * MILLION; - int usfloor = usdouble; - int usceil = usfloor + (usfloor < usdouble); - - if (usceil < MILLION) - { - sec = s; - usec = usceil; - } - else if (sec < INT_MAX) - { - sec = s + 1; - usec = 0; - } - } - - *psec = sec; - *pusec = usec; -} - DEFUN ("sleep-for", Fsleep_for, Ssleep_for, 1, 2, 0, doc: /* Pause, without updating display, for SECONDS seconds. SECONDS may be a floating-point value, meaning that you can wait for a fraction of a second. Optional second arg MILLISECONDS specifies an -additional wait period, in milliseconds; this may be useful if your -Emacs was built without floating point support. +additional wait period, in milliseconds; this is for backwards compatibility. \(Not all operating systems support waiting for a fraction of a second.) */) (Lisp_Object seconds, Lisp_Object milliseconds) { - int sec, usec; double duration = extract_float (seconds); if (!NILP (milliseconds)) @@ -6090,17 +5774,12 @@ Emacs was built without floating point support. duration += XINT (milliseconds) / 1000.0; } - if (! (0 < duration)) - return Qnil; - - duration_to_sec_usec (duration, &sec, &usec); - -#ifndef EMACS_HAS_USECS - if (sec == 0 && usec != 0) - error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE); -#endif - - wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0); + if (duration > 0) + { + struct timespec t = dtotimespec (duration); + wait_reading_process_output (min (t.tv_sec, WAIT_READING_MAX), + t.tv_nsec, 0, 0, Qnil, NULL, 0); + } return Qnil; } @@ -6111,15 +5790,17 @@ Emacs was built without floating point support. TIMEOUT is number of seconds to wait (float or integer), or t to wait forever. - READING is 1 if reading input. - If DO_DISPLAY is >0 display process output while waiting. - If DO_DISPLAY is >1 perform an initial redisplay before waiting. + READING is true if reading input. + If DISPLAY_OPTION is >0 display process output while waiting. + If DISPLAY_OPTION 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 display_option) { - int sec, usec; + intmax_t sec; + int nsec; + bool do_display = display_option > 0; swallow_events (do_display); @@ -6127,29 +5808,42 @@ sit_for (Lisp_Object timeout, int reading, int do_display) || !NILP (Vexecuting_kbd_macro)) return Qnil; - if (do_display >= 2) + if (display_option > 1) redisplay_preserve_echo_area (2); - if (EQ (timeout, Qt)) + if (INTEGERP (timeout)) { - sec = 0; - usec = 0; + sec = XINT (timeout); + if (sec <= 0) + return Qt; + nsec = 0; } - else + else if (FLOATP (timeout)) { - double duration = extract_float (timeout); - - if (! (0 < duration)) + double seconds = XFLOAT_DATA (timeout); + if (! (0 < seconds)) return Qt; - - duration_to_sec_usec (duration, &sec, &usec); + else + { + struct timespec t = dtotimespec (seconds); + sec = min (t.tv_sec, WAIT_READING_MAX); + nsec = t.tv_nsec; + } } + else if (EQ (timeout, Qt)) + { + sec = 0; + nsec = 0; + } + else + wrong_type_argument (Qnumberp, timeout); -#ifdef SIGIO - gobble_input (0); + +#ifdef USABLE_SIGIO + gobble_input (); #endif - wait_reading_process_output (sec, usec, reading ? -1 : 1, do_display, + wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display, Qnil, NULL, 0); return detect_input_pending () ? Qnil : Qt; @@ -6212,8 +5906,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)) { @@ -6225,44 +5918,41 @@ 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. */ - for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) + FOR_EACH_LIVE_BUFFER (tail, buf) { - buf = XCDR (XCAR (tail)); /* 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. */ @@ -6272,7 +5962,7 @@ pass nil for VARIABLE. */) n = 1; FOR_EACH_FRAME (tail, frame) n += 2; - for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) + FOR_EACH_LIVE_BUFFER (tail, buf) n += 3; /* Reallocate the vector if data has grown to need it, or if it has shrunk a lot. */ @@ -6289,31 +5979,36 @@ 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)) + FOR_EACH_LIVE_BUFFER (tail, buf) { - buf = XCDR (XCAR (tail)); /* 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; } @@ -6339,7 +6034,6 @@ init_display (void) inverse_video = 0; cursor_in_echo_area = 0; - terminal_type = (char *) 0; /* Now is the time to initialize this; it's used by init_sys_modes during startup. */ @@ -6352,7 +6046,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. */ @@ -6388,13 +6086,12 @@ init_display (void) #ifdef HAVE_X11 Vwindow_system_version = make_number (11); #endif -#ifdef GNU_LINUX +#ifdef USE_NCURSES /* In some versions of ncurses, tputs crashes if we have not called tgetent. So call tgetent. */ { char b[2044]; tgetent (b, "xterm");} #endif - adjust_frame_glyphs_initially (); return; } #endif /* HAVE_X_WINDOWS */ @@ -6404,7 +6101,6 @@ init_display (void) { Vinitial_window_system = Qw32; Vwindow_system_version = make_number (1); - adjust_frame_glyphs_initially (); return; } #endif /* HAVE_NTGUI */ @@ -6418,23 +6114,18 @@ init_display (void) { Vinitial_window_system = Qns; Vwindow_system_version = make_number (10); - adjust_frame_glyphs_initially (); return; } #endif /* If no window system has been specified, try to use the terminal. */ if (! isatty (0)) - { - fatal ("standard input is not a tty"); - exit (1); - } + fatal ("standard input is not a tty"); #ifdef WINDOWSNT terminal_type = "w32console"; #else - /* Look at the TERM variable. */ - terminal_type = (char *) getenv ("TERM"); + terminal_type = getenv ("TERM"); #endif if (!terminal_type) { @@ -6451,12 +6142,14 @@ init_display (void) struct terminal *t; struct frame *f = XFRAME (selected_frame); + init_foreground_group (); + /* Open a display on the controlling tty. */ t = init_tty (0, terminal_type, 1); /* Errors are fatal. */ /* 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; @@ -6479,15 +6172,14 @@ init_display (void) /* Update frame parameters to reflect the new type. */ Fmodify_frame_parameters - (selected_frame, Fcons (Fcons (Qtty_type, - Ftty_type (selected_frame)), Qnil)); + (selected_frame, list1 (Fcons (Qtty_type, + Ftty_type (selected_frame)))); if (t->display_info.tty->name) - Fmodify_frame_parameters (selected_frame, - Fcons (Fcons (Qtty, build_string (t->display_info.tty->name)), - Qnil)); + Fmodify_frame_parameters + (selected_frame, + list1 (Fcons (Qtty, build_string (t->display_info.tty->name)))); else - Fmodify_frame_parameters (selected_frame, Fcons (Fcons (Qtty, Qnil), - Qnil)); + Fmodify_frame_parameters (selected_frame, list1 (Fcons (Qtty, Qnil))); } { @@ -6506,7 +6198,6 @@ init_display (void) fatal ("screen size %dx%d too big", width, height); } - adjust_frame_glyphs_initially (); calculate_costs (XFRAME (selected_frame)); /* Set up faces of the initial terminal frame of a dumped Emacs. */ @@ -6541,15 +6232,7 @@ don't show a cursor. */) /* Don't change cursor state while redisplaying. This could confuse output routines. */ if (!redisplaying_p) - { - if (NILP (window)) - window = selected_window; - else - CHECK_WINDOW (window); - - XWINDOW (window)->cursor_off_p = NILP (show); - } - + decode_any_window (window)->cursor_off_p = NILP (show); return Qnil; } @@ -6560,28 +6243,7 @@ DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p, WINDOW nil or omitted means report on the selected window. */) (Lisp_Object window) { - struct window *w; - - if (NILP (window)) - window = selected_window; - else - CHECK_WINDOW (window); - - w = XWINDOW (window); - return w->cursor_off_p ? Qnil : Qt; -} - -DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame, - Slast_nonminibuf_frame, 0, 0, 0, - doc: /* Value is last nonminibuffer frame. */) - (void) -{ - Lisp_Object frame = Qnil; - - if (last_nonminibuf_frame) - XSETFRAME (frame, last_nonminibuf_frame); - - return frame; + return decode_any_window (window)->cursor_off_p ? Qnil : Qt; } /*********************************************************************** @@ -6601,9 +6263,8 @@ syms_of_display (void) defsubr (&Ssend_string_to_terminal); defsubr (&Sinternal_show_cursor); defsubr (&Sinternal_show_cursor_p); - defsubr (&Slast_nonminibuf_frame); -#if GLYPH_DEBUG +#ifdef GLYPH_DEBUG defsubr (&Sdump_redisplay_history); #endif @@ -6686,15 +6347,6 @@ See `buffer-display-table' for more information. */); doc: /* Non-nil means display update isn't paused when input is detected. */); redisplay_dont_pause = 1; -#if PERIODIC_PREEMPTION_CHECKING - DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period, - doc: /* Period in seconds between checking for input during redisplay. -This has an effect only if `redisplay-dont-pause' is nil; in that -case, arriving input preempts redisplay until the input is processed. -If the value is nil, redisplay is never preempted. */); - Vredisplay_preemption_period = make_float (0.10); -#endif - #ifdef CANNOT_DUMP if (noninteractive) #endif |