X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/bd358779861f265a7acff31ead40172735af693e..aab1fcdf812a7ebd32b8312c05ffcdd1bf610d2b:/src/buffer.c diff --git a/src/buffer.c b/src/buffer.c index abebdf2113..5244b7043d 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -108,9 +108,9 @@ static void call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay, static void swap_out_buffer_local_variables (struct buffer *b); static void reset_buffer_local_variables (struct buffer *, bool); -/* Alist of all buffer names vs the buffers. */ -/* This used to be a variable, but is no longer, - to prevent lossage due to user rplac'ing this alist or its elements. */ +/* Alist of all buffer names vs the buffers. This used to be + a Lisp-visible variable, but is no longer, to prevent lossage + due to user rplac'ing this alist or its elements. */ Lisp_Object Vbuffer_alist; static Lisp_Object Qkill_buffer_query_functions; @@ -150,6 +150,12 @@ static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t); static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool); +static void +CHECK_OVERLAY (Lisp_Object x) +{ + CHECK_TYPE (OVERLAYP (x), Qoverlayp, x); +} + /* These setters are used only in this file, so they can be private. */ static void bset_abbrev_mode (struct buffer *b, Lisp_Object val) @@ -197,9 +203,9 @@ bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val) b->INTERNAL_FIELD (buffer_file_coding_system) = val; } static void -bset_cache_long_line_scans (struct buffer *b, Lisp_Object val) +bset_cache_long_scans (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (cache_long_line_scans) = val; + b->INTERNAL_FIELD (cache_long_scans) = val; } static void bset_case_fold_search (struct buffer *b, Lisp_Object val) @@ -472,8 +478,7 @@ If there is no such live buffer, return nil. See also `find-buffer-visiting'. */) (register Lisp_Object filename) { - register Lisp_Object tail, buf, tem; - Lisp_Object handler; + register Lisp_Object tail, buf, handler; CHECK_STRING (filename); filename = Fexpand_file_name (filename, Qnil); @@ -488,13 +493,10 @@ See also `find-buffer-visiting'. */) return BUFFERP (handled_buf) ? handled_buf : Qnil; } - for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) + FOR_EACH_LIVE_BUFFER (tail, buf) { - buf = Fcdr (XCAR (tail)); - if (!BUFFERP (buf)) continue; if (!STRINGP (BVAR (XBUFFER (buf), filename))) continue; - tem = Fstring_equal (BVAR (XBUFFER (buf), filename), filename); - if (!NILP (tem)) + if (!NILP (Fstring_equal (BVAR (XBUFFER (buf), filename), filename))) return buf; } return Qnil; @@ -503,15 +505,12 @@ See also `find-buffer-visiting'. */) Lisp_Object get_truename_buffer (register Lisp_Object filename) { - register Lisp_Object tail, buf, tem; + register Lisp_Object tail, buf; - for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) + FOR_EACH_LIVE_BUFFER (tail, buf) { - buf = Fcdr (XCAR (tail)); - if (!BUFFERP (buf)) continue; if (!STRINGP (BVAR (XBUFFER (buf), file_truename))) continue; - tem = Fstring_equal (BVAR (XBUFFER (buf), file_truename), filename); - if (!NILP (tem)) + if (!NILP (Fstring_equal (BVAR (XBUFFER (buf), file_truename), filename))) return buf; } return Qnil; @@ -584,6 +583,7 @@ even if it is dead. The return value is never nil. */) b->newline_cache = 0; b->width_run_cache = 0; + b->bidi_paragraph_cache = 0; bset_width_table (b, Qnil); b->prevent_redisplay_optimizations_p = 1; @@ -607,7 +607,7 @@ even if it is dead. The return value is never nil. */) /* Put this in the alist of all live buffers. */ XSETBUFFER (buffer, b); - Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buffer), Qnil)); + Vbuffer_alist = nconc2 (Vbuffer_alist, list1 (Fcons (name, buffer))); /* And run buffer-list-update-hook. */ if (!NILP (Vrun_hooks)) call1 (Vrun_hooks, Qbuffer_list_update_hook); @@ -807,6 +807,7 @@ CLONE nil means the indirect buffer's state is reset to default values. */) b->newline_cache = 0; b->width_run_cache = 0; + b->bidi_paragraph_cache = 0; bset_width_table (b, Qnil); name = Fcopy_sequence (name); @@ -818,7 +819,7 @@ CLONE nil means the indirect buffer's state is reset to default values. */) /* Put this in the alist of all live buffers. */ XSETBUFFER (buf, b); - Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil)); + Vbuffer_alist = nconc2 (Vbuffer_alist, list1 (Fcons (name, buf))); bset_mark (b, Fmake_marker ()); @@ -1539,7 +1540,7 @@ candidate_buffer (Lisp_Object b, Lisp_Object buffer) && BUFFER_LIVE_P (XBUFFER (b)) && !BUFFER_HIDDEN_P (XBUFFER (b))); } - + DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0, doc: /* Return most recently selected buffer other than BUFFER. Buffers not visible in windows are preferred to visible buffers, unless @@ -1575,10 +1576,8 @@ exists, return the buffer `*scratch*' (creating it if necessary). */) } /* Consider alist of all buffers next. */ - tail = Vbuffer_alist; - for (; CONSP (tail); tail = XCDR (tail)) + FOR_EACH_LIVE_BUFFER (tail, buf) { - buf = Fcdr (XCAR (tail)); if (candidate_buffer (buf, buffer) /* If the frame has a buffer_predicate, disregard buffers that don't fit the predicate. */ @@ -1615,12 +1614,9 @@ other_buffer_safely (Lisp_Object buffer) { Lisp_Object tail, buf; - for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail)) - { - buf = Fcdr (XCAR (tail)); - if (candidate_buffer (buf, buffer)) - return buf; - } + FOR_EACH_LIVE_BUFFER (tail, buf) + if (candidate_buffer (buf, buffer)) + return buf; buf = Fget_buffer (build_string ("*scratch*")); if (NILP (buf)) @@ -1728,18 +1724,6 @@ cleaning up all windows currently displaying the buffer to be killed. */) if (!BUFFER_LIVE_P (b)) return Qnil; - /* Query if the buffer is still modified. */ - if (INTERACTIVE && !NILP (BVAR (b, filename)) - && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b)) - { - GCPRO1 (buffer); - tem = do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ", - BVAR (b, name), make_number (0))); - UNGCPRO; - if (NILP (tem)) - return Qnil; - } - /* Run hooks with the buffer to be killed the current buffer. */ { ptrdiff_t count = SPECPDL_INDEX (); @@ -1755,6 +1739,22 @@ cleaning up all windows currently displaying the buffer to be killed. */) if (NILP (tem)) return unbind_to (count, Qnil); + /* Query if the buffer is still modified. */ + if (INTERACTIVE && !NILP (BVAR (b, filename)) + && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b)) + { + GCPRO1 (buffer); + tem = do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ", + BVAR (b, name), make_number (0))); + UNGCPRO; + if (NILP (tem)) + return unbind_to (count, Qnil); + } + + /* If the hooks have killed the buffer, exit now. */ + if (!BUFFER_LIVE_P (b)) + return unbind_to (count, Qt); + /* Then run the hooks. */ Frun_hooks (1, &Qkill_buffer_hook); unbind_to (count, Qnil); @@ -1947,6 +1947,11 @@ cleaning up all windows currently displaying the buffer to be killed. */) free_region_cache (b->width_run_cache); b->width_run_cache = 0; } + if (b->bidi_paragraph_cache) + { + free_region_cache (b->bidi_paragraph_cache); + b->bidi_paragraph_cache = 0; + } bset_width_table (b, Qnil); unblock_input (); bset_undo_list (b, Qnil); @@ -2196,14 +2201,19 @@ ends when the current command terminates. Use `switch-to-buffer' or return buffer; } +void +restore_buffer (Lisp_Object buffer_or_name) +{ + Fset_buffer (buffer_or_name); +} + /* Set the current buffer to BUFFER provided if it is alive. */ -Lisp_Object +void set_buffer_if_live (Lisp_Object buffer) { if (BUFFER_LIVE_P (XBUFFER (buffer))) set_buffer_internal (XBUFFER (buffer)); - return Qnil; } DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, @@ -2352,6 +2362,7 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text, current_buffer->clip_changed = 1; other_buffer->clip_changed = 1; swapfield (newline_cache, struct region_cache *); swapfield (width_run_cache, struct region_cache *); + swapfield (bidi_paragraph_cache, struct region_cache *); current_buffer->prevent_redisplay_optimizations_p = 1; other_buffer->prevent_redisplay_optimizations_p = 1; swapfield (overlays_before, struct Lisp_Overlay *); @@ -2398,7 +2409,7 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text, live window points to that window's buffer. So since we just swapped the markers between the two buffers, we need to undo the effect of this swap for window markers. */ - Lisp_Object w = Fselected_window (), ws = Qnil; + Lisp_Object w = selected_window, ws = Qnil; Lisp_Object buf1, buf2; XSETBUFFER (buf1, current_buffer); XSETBUFFER (buf2, other_buffer); @@ -3135,8 +3146,8 @@ struct sortvec static int compare_overlays (const void *v1, const void *v2) { - const struct sortvec *s1 = (const struct sortvec *) v1; - const struct sortvec *s2 = (const struct sortvec *) v2; + const struct sortvec *s1 = v1; + const struct sortvec *s2 = v2; if (s1->priority != s2->priority) return s1->priority < s2->priority ? -1 : 1; if (s1->beg != s2->beg) @@ -3242,8 +3253,8 @@ static ptrdiff_t overlay_str_len; static int cmp_for_strings (const void *as1, const void *as2) { - struct sortstr *s1 = (struct sortstr *)as1; - struct sortstr *s2 = (struct sortstr *)as2; + struct sortstr const *s1 = as1; + struct sortstr const *s2 = as2; if (s1->size != s2->size) return s2->size < s1->size ? -1 : 1; if (s1->priority != s2->priority) @@ -4593,7 +4604,6 @@ evaporate_overlays (ptrdiff_t pos) #ifdef USE_MMAP_FOR_BUFFERS -#include #include #ifndef MAP_ANON @@ -4608,8 +4618,6 @@ evaporate_overlays (ptrdiff_t pos) #define MAP_FAILED ((void *) -1) #endif -#include - #if MAP_ANON == 0 #include #endif @@ -4719,7 +4727,7 @@ mmap_init (void) if (mmap_fd <= 0) { /* No anonymous mmap -- we need the file descriptor. */ - mmap_fd = open ("/dev/zero", O_RDONLY); + mmap_fd = emacs_open ("/dev/zero", O_RDONLY, 0); if (mmap_fd == -1) fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno)); } @@ -4744,7 +4752,7 @@ static struct mmap_region * mmap_find (void *start, void *end) { struct mmap_region *r; - char *s = (char *) start, *e = (char *) end; + char *s = start, *e = end; for (r = mmap_regions; r; r = r->next) { @@ -4903,7 +4911,7 @@ mmap_alloc (void **var, size_t nbytes) } else { - struct mmap_region *r = (struct mmap_region *) p; + struct mmap_region *r = p; r->nbytes_specified = nbytes; r->nbytes_mapped = map; @@ -5043,7 +5051,7 @@ alloc_buffer_text (struct buffer *b, ptrdiff_t nbytes) memory_full (nbytes); } - b->text->beg = (unsigned char *) p; + b->text->beg = p; unblock_input (); } @@ -5071,7 +5079,7 @@ enlarge_buffer_text (struct buffer *b, ptrdiff_t delta) memory_full (nbytes); } - BUF_BEG_ADDR (b) = (unsigned char *) p; + BUF_BEG_ADDR (b) = p; unblock_input (); } @@ -5169,7 +5177,7 @@ init_buffer_once (void) bset_buffer_file_coding_system (&buffer_defaults, Qnil); XSETFASTINT (BVAR (&buffer_defaults, fill_column), 70); XSETFASTINT (BVAR (&buffer_defaults, left_margin), 0); - bset_cache_long_line_scans (&buffer_defaults, Qnil); + bset_cache_long_scans (&buffer_defaults, Qnil); bset_file_truename (&buffer_defaults, Qnil); XSETFASTINT (BVAR (&buffer_defaults, display_count), 0); XSETFASTINT (BVAR (&buffer_defaults, left_margin_cols), 0); @@ -5233,7 +5241,7 @@ init_buffer_once (void) XSETFASTINT (BVAR (&buffer_local_flags, abbrev_table), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, display_table), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, syntax_table), idx); ++idx; - XSETFASTINT (BVAR (&buffer_local_flags, cache_long_line_scans), idx); ++idx; + XSETFASTINT (BVAR (&buffer_local_flags, cache_long_scans), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, category_table), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, bidi_display_reordering), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, bidi_paragraph_direction), idx); ++idx; @@ -5389,11 +5397,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring, bo_fwd->predicate = predicate; sym->declared_special = 1; sym->redirect = SYMBOL_FORWARDED; - { - /* I tried to do the job without a cast, but it seems impossible. - union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */ - SET_SYMBOL_FWD (sym, (union Lisp_Fwd *)bo_fwd); - } + SET_SYMBOL_FWD (sym, (union Lisp_Fwd *) bo_fwd); XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym); if (PER_BUFFER_IDX (offset) == 0) @@ -6088,6 +6092,11 @@ and is the visited file's modification time, as of that time. If the modification time of the most recent save is different, this entry is obsolete. +An entry (t . 0) means means the buffer was previously unmodified but +its time stamp was unknown because it was not associated with a file. +An entry (t . -1) is similar, except that it means the buffer's visited +file did not exist. + An entry (nil PROPERTY VALUE BEG . END) indicates that a text property was modified between BEG and END. PROPERTY is the property name, and VALUE is the old value. @@ -6115,8 +6124,8 @@ If the value of the variable is t, undo information is not recorded. */); DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer, mark_active), Qnil, doc: /* Non-nil means the mark and region are currently active in this buffer. */); - DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer, cache_long_line_scans), Qnil, - doc: /* Non-nil means that Emacs should use caches to handle long lines more quickly. + DEFVAR_PER_BUFFER ("cache-long-scans", &BVAR (current_buffer, cache_long_scans), Qnil, + doc: /* Non-nil means that Emacs should use caches in attempt to speedup buffer scans. Normally, the line-motion functions work by scanning the buffer for newlines. Columnar operations (like `move-to-column' and @@ -6126,18 +6135,24 @@ buffer's lines are very long (say, more than 500 characters), these motion functions will take longer to execute. Emacs may also take longer to update the display. -If `cache-long-line-scans' is non-nil, these motion functions cache the +If `cache-long-scans' is non-nil, these motion functions cache the results of their scans, and consult the cache to avoid rescanning regions of the buffer until the text is modified. The caches are most beneficial when they prevent the most searching---that is, when the buffer contains long lines and large regions of characters with the same, fixed screen width. -When `cache-long-line-scans' is non-nil, processing short lines will +When `cache-long-scans' is non-nil, processing short lines will become slightly slower (because of the overhead of consulting the cache), and the caches will use memory roughly proportional to the number of newlines and characters whose screen width varies. +Bidirectional editing also requires buffer scans to find paragraph +separators. If you have large paragraphs or no paragraph separators +at all, these scans may be slow. If `cache-long-scans' is non-nil, +results of these scans are cached. This doesn't help too much if +paragraphs are of the reasonable (few thousands of characters) size. + The caches require no explicit maintenance; their accuracy is maintained internally by the Emacs primitives. Enabling or disabling the cache should not affect the behavior of any of the motion