From 7272a47df18873f8583e88c88d38b9c21a96fea4 Mon Sep 17 00:00:00 2001 From: Alan Mackenzie Date: Tue, 8 Mar 2016 12:47:28 +0000 Subject: [PATCH] First "working" version of cacheing comments in a text property. To test this facility, set `comment-cacheing-flag' to non-nil. * src/buffer.c, src/buffer.h: Create BVAR variable `comment-depth-hwm'. * src/insdel.c (signal_after_change): call Ftrim_comment_cache. * src/syntax.c (comment-depth-hwm): Removed (moved into buffer.c/h). (scan_sexps_forward): Restore to the previous functionality by removing the parameter `propertize' and the code which applied text properties. (Ftrim_comment_cache, syntax_table_value_is_interesting_for_literals) (check_comment_depth_hwm_for_prop, scan_literals_forward_to): New functions. (back_comment): Extensive rework. It now calls old_back_comment only when `comment-cacheing-flag' is non-nil. (comment-depth-values): New variable. * src/syntax.h (check_comment_depth_hwm_for_prop): Exported. * src/textprop.c (set_properties, add_properties, remove_properties): * call check_comment_depth_hwm_for_prop. --- src/buffer.c | 11 ++ src/buffer.h | 5 +- src/insdel.c | 2 + src/syntax.c | 393 ++++++++++++++++++++++++++++++++++++++++--------- src/syntax.h | 2 + src/textprop.c | 36 ++++- 6 files changed, 372 insertions(+), 77 deletions(-) diff --git a/src/buffer.c b/src/buffer.c index 98b61c350e2..1065e4da6f3 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -358,6 +358,11 @@ bset_zv_marker (struct buffer *b, Lisp_Object val) { b->zv_marker_ = val; } +static void +bset_comment_depth_hwm (struct buffer *b, Lisp_Object val) +{ + b->comment_depth_hwm_ = val; +} void nsberror (Lisp_Object spec) @@ -5098,6 +5103,7 @@ init_buffer_once (void) XSETFASTINT (BVAR (&buffer_local_flags, cursor_type), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, extra_line_spacing), idx); ++idx; XSETFASTINT (BVAR (&buffer_local_flags, cursor_in_non_selected_windows), idx); ++idx; + XSETFASTINT (BVAR (&buffer_local_flags, comment_depth_hwm), idx); ++idx; /* Need more room? */ if (idx >= MAX_PER_BUFFER_VARS) @@ -5184,6 +5190,7 @@ init_buffer_once (void) bset_scroll_up_aggressively (&buffer_defaults, Qnil); bset_scroll_down_aggressively (&buffer_defaults, Qnil); bset_display_time (&buffer_defaults, Qnil); + bset_comment_depth_hwm (&buffer_defaults, make_number (1)); /* Assign the local-flags to the slots that have default values. The local flag is a bit that is used in the buffer @@ -6254,6 +6261,10 @@ If t, displays a cursor related to the usual cursor type You can also specify the cursor type as in the `cursor-type' variable. Use Custom to set this variable and update the display. */); + DEFVAR_PER_BUFFER ("comment-depth-hwm", + &BVAR (current_buffer, comment_depth_hwm), Qintegerp, + doc: /* Buffer position below which the `comment-depth' property is valid. */); + DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions, doc: /* List of functions called with no args to query before killing a buffer. The buffer being killed will be current while the functions are running. diff --git a/src/buffer.h b/src/buffer.h index 5783bfb51ab..a5343707221 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -748,6 +748,9 @@ struct buffer See `cursor-type' for other values. */ Lisp_Object cursor_in_non_selected_windows_; + /* Buffer position below which the `comment-depth' property is valid. */ + Lisp_Object comment_depth_hwm_; + /* No more Lisp_Object beyond this point. Except undo_list, which is handled specially in Fgarbage_collect. */ @@ -1267,7 +1270,7 @@ extern int last_per_buffer_idx; #define FOR_EACH_PER_BUFFER_OBJECT_AT(offset) \ for (offset = PER_BUFFER_VAR_OFFSET (name); \ - offset <= PER_BUFFER_VAR_OFFSET (cursor_in_non_selected_windows); \ + offset <= PER_BUFFER_VAR_OFFSET (comment_depth_hwm); \ offset += word_size) /* Return the index of buffer-local variable VAR. Each per-buffer diff --git a/src/insdel.c b/src/insdel.c index 05f37d6f647..119f713c387 100644 --- a/src/insdel.c +++ b/src/insdel.c @@ -2083,6 +2083,8 @@ signal_after_change (ptrdiff_t charpos, ptrdiff_t lendel, ptrdiff_t lenins) specbind (Qinhibit_modification_hooks, Qt); + Ftrim_comment_cache (make_number (charpos)); + if (!NILP (Vafter_change_functions)) { rvoe_arg.location = &Vafter_change_functions; diff --git a/src/syntax.c b/src/syntax.c index c08e29a7e7e..4a30afa03a0 100644 --- a/src/syntax.c +++ b/src/syntax.c @@ -176,7 +176,7 @@ static Lisp_Object skip_syntaxes (bool, Lisp_Object, Lisp_Object); static Lisp_Object scan_lists (EMACS_INT, EMACS_INT, EMACS_INT, bool); static void scan_sexps_forward (struct lisp_parse_state *, ptrdiff_t, ptrdiff_t, ptrdiff_t, EMACS_INT, - bool, int, bool); + bool, int); static void internalize_parse_state (Lisp_Object, struct lisp_parse_state *); static bool in_classes (int, Lisp_Object); static void parse_sexp_propertize (ptrdiff_t charpos); @@ -917,7 +917,7 @@ old_back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, scan_sexps_forward (&state, defun_start, defun_start_byte, comment_end, TYPE_MINIMUM (EMACS_INT), - 0, 0, false); + 0, 0); defun_start = comment_end; if (!adjusted) { @@ -958,64 +958,328 @@ old_back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, return from != comment_end; } -static bool -back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, - bool comnested, int comstyle, ptrdiff_t *charpos_ptr, - ptrdiff_t *bytepos_ptr) +/* `comment-depth' text properties + ------------------------------- +These are applied to all text between BOB and `comment-depth-hwm'. +They are primarily to record whether or not the current character is +inside a literal, and if so, what type. + +On a buffer change (when `inhibit-modification-hooks' is nil), any +buffer change (including changing text-properties) will reduce +`comment-depth-hwm' to the change position, if it is higher. When +`inhibit-modification-hooks' is non-nil, only changes to the +`syntax-table' text property (possibly via a `category' text property) +which affect the scanning of literals cause the setting of +`comment-depth-hwm'. + +The `comment-depth' text property for a literal is applied on the text +between just after its opening delimiter and just after its closing +delimiter. + +The value of the `comment-depth' text property is a cons. For a +string, its car is the symbol `string' and its cdr is the expected +closing delimiter (or ST_STRING_STYLE in the case of a string fence +string). For a comment, the car is -1 for a non-nestable comment, or +the current nesting depth for a nestable comment. When not in a +literal, the value is '(0 . 0). These values match the internal +values used in `scan_sexps_forward. */ + +DEFUN ("trim-comment-cache", Ftrim_comment_cache, Strim_comment_cache, 0, 1, 0, + doc: /* Mark the selected buffer's "comment cache" as invalid from POS. +By default, POS is the beginning of the buffer (position 1). If the cache is +already invalid from an earlier position than POS, this function has no +effect. The return value is the new bound. */) + (Lisp_Object pos) +{ + ptrdiff_t position, cache_limit; + + if (!NILP (pos)) + { + CHECK_NUMBER (pos); + position = max (XINT (pos), 1); + } + else + position = 1; + cache_limit = XINT (BVAR (current_buffer, comment_depth_hwm)); + BVAR (current_buffer, comment_depth_hwm) + = make_number (min (cache_limit, position)); + return BVAR (current_buffer, comment_depth_hwm); +} + +static +bool syntax_table_value_is_interesting_for_literals (Lisp_Object val) { + ptrdiff_t syntax, code; + if (!CONSP (val) + || !INTEGERP (XCAR (val))) + return false; + syntax = XINT (XCAR (val)); + code = syntax & 0xff; + return (code == Sstring + || code == Sescape + || code == Scharquote /* Check this! 2016-03-06. */ + || code == Scomment + || code == Sendcomment + /* || (code == Sinherit && ....) This isn't implemented in syntax.c. */ + || code == Scomment_fence + || code == Sstring_fence + || (syntax & 0xF0000) != 0); /* Flags `1', `2', `3', '4'. */ +} + +/* The text property PROP is having its value VAL at position POS in buffer BUF +either set or cleared. If this value is relevant to the syntax of literals, +reduce the BUF's value of comment_depth_hwm to POS. */ +void +check_comment_depth_hwm_for_prop (ptrdiff_t pos, Lisp_Object prop, + Lisp_Object val, Lisp_Object buffer) +{ + struct buffer *b; + ptrdiff_t hwm; + Lisp_Object plist; + + if (!BUFFERP (buffer)) + return; + b = XBUFFER (buffer); + hwm = XINT (BVAR (b, comment_depth_hwm)); + if (pos >= hwm) + return; + + if (EQ (prop, Qcategory) + && SYMBOLP (val)) + { + plist = Fsymbol_plist (val); + while (CONSP (plist)) + { + prop = XCAR (plist); + plist = XCDR (plist); + if (!CONSP (plist)) + return; + val = XCAR (plist); + if (EQ (prop, Qsyntax_table)) + break; + plist = XCDR (plist); + } + } + if (EQ (prop, Qsyntax_table) + && syntax_table_value_is_interesting_for_literals (val)) + BVAR (b, comment_depth_hwm) = make_number (pos); +} + +/* Scan forward over all text between comment-depth-hwm and TO, + marking literals (strings and comments) with the `comment-depth' + text property. `comment-depth-hwm' is updated to TO. */ +static void +scan_comments_forward_to (ptrdiff_t to, ptrdiff_t to_byte) +{ + ptrdiff_t count = SPECPDL_INDEX (); ptrdiff_t hwm, hwm_byte; struct lisp_parse_state state; ptrdiff_t orig_begv = BEGV, orig_begv_byte = BEGV_BYTE; + ptrdiff_t tmp, tmp_byte; + int c, syntax; + enum syntaxcode code; Lisp_Object depth; + Lisp_Object comment_depth_value; + Lisp_Object tem; - if (comment_cacheing_flag) + hwm = XINT (BVAR (current_buffer, comment_depth_hwm)); + + if (hwm < to) { - hwm = XINT (Vcomment_depth_hwm); - if (hwm < from) + record_unwind_protect (save_restriction_restore, + save_restriction_save ()); + BEGV = BEG; BEGV_BYTE = BEG_BYTE; + + hwm_byte = CHAR_TO_BYTE (hwm); + /* We mustn't start scanning just after the first half of a + double character comment starter or ender. */ + if (hwm > BEG) { - hwm_byte = CHAR_TO_BYTE (hwm); - internalize_parse_state (Qnil, &state); - BEGV = BEG; BEGV_BYTE = BEG_BYTE; - if (hwm > BEG) + tmp = hwm; tmp_byte = hwm_byte; + do { - depth = Fget_text_property (make_number (hwm - 1), - Qcomment_depth, Qnil); - if (CONSP (depth)) - { - if (EQ (Fcar (depth), Qstring)) - { - state.instring = XINT (Fcdr (depth)); - state.incomment = 0; - } - else if (EQ (Fcar (depth), make_number (0))) - { - state.instring = -1; - state.incomment = 0; - } - else - { - state.instring = -1; - state.incomment = XINT (Fcar (depth)); - state.comstyle = XINT (Fcdr (depth)); - } - } + DEC_BOTH (tmp, tmp_byte); + UPDATE_SYNTAX_TABLE_BACKWARD (tmp); + c = FETCH_CHAR_AS_MULTIBYTE (tmp_byte); + syntax = SYNTAX_WITH_FLAGS (c); + code = SYNTAX (c); } - while (hwm < from) + while (tmp > BEG + && (code == Sescape + || (syntax & 0xF0000))); /* Flags `1', `2', `3', `4'. */ + if (tmp > BEG) + INC_BOTH (tmp, tmp_byte); + hwm = tmp; hwm_byte = tmp_byte; + } + + internalize_parse_state (Qnil, &state); + if (hwm > BEG) + /* Initialize STATE with the current value of the + `comment-depth' text property. */ + { + depth = Fget_text_property (make_number (hwm - 1), + Qcomment_depth, Qnil); + if (CONSP (depth)) { - scan_sexps_forward (&state, hwm, hwm_byte, from, - -100, false, - -1, /* stop after literal boundary */ - true); - hwm = state.location; - hwm_byte = state.location_byte; + if (EQ (Fcar (depth), Qstring)) + { + state.instring = XINT (Fcdr (depth)); + state.incomment = 0; + } + else if (EQ (Fcar (depth), make_number (0))) + { + state.instring = -1; + state.incomment = 0; + } + else + { + state.instring = -1; + state.incomment = XINT (Fcar (depth)); + state.comstyle = XINT (Fcdr (depth)); + } } - Vcomment_depth_hwm = make_number (hwm); - BEGV = orig_begv; BEGV_BYTE = orig_begv_byte; } + + { + /* Setup the buffer to write text properties discreetly. */ + Lisp_Object modified = Fbuffer_modified_p (Qnil); + ptrdiff_t count1 = SPECPDL_INDEX (); + + specbind (Qinhibit_modification_hooks, Qt); + specbind (intern ("buffer-undo-list"), Qt); + specbind (Qinhibit_read_only, Qt); + specbind (Qdeactivate_mark, Qnil); + if (NILP (modified)) + record_unwind_protect + ((void (*) (Lisp_Object))Frestore_buffer_modified_p, Qnil); + + while (hwm < to) + { + /* For each literal we scan, we apply the `comment-depth' + property on its innards and closing delimiter. Calculate + the value we will use first. */ + comment_depth_value = (state.instring != -1) + ? Fcons (Qstring, make_number (state.instring)) + : (state.incomment + ? Fcons (make_number (state.incomment), + make_number (state.comstyle)) + : Fcons (make_number (0), make_number (0))); + /* Ensure all `equal' values of comment-depth-value are also `eq'. */ + tem = Fmember (comment_depth_value, Vcomment_depth_values); + if (CONSP (tem)) + comment_depth_value = XCAR (tem); + else + Vcomment_depth_values = Fcons (comment_depth_value, Vcomment_depth_values); + + scan_sexps_forward (&state, hwm, hwm_byte, to, + TYPE_MINIMUM (EMACS_INT), false, + -1); /* stop after literal boundary */ + + Fput_text_property (make_number (hwm), make_number (state.location), + Qcomment_depth, + comment_depth_value, Qnil); + + hwm = state.location; + hwm_byte = state.location_byte; + } + unbind_to (count1, Qnil); + if (NILP (modified)) + /* Frestore_buffer_modified_p overwrites gl_state, hence: */ + SETUP_SYNTAX_TABLE (to, -1); + } + BVAR (current_buffer, comment_depth_hwm) = make_number (hwm); + unbind_to (count, Qnil); } +} + +/* Check whether charpos FROM is at the end of a comment. + FROM_BYTE is the bytepos corresponding to FROM. + Do not move back before STOP. + + Return true if we find a comment ending at FROM/FROM_BYTE. + + If successful, store the charpos of the comment's beginning + into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR. + + Global syntax data remains valid for backward search starting at + the returned value (or at FROM, if the search was not successful). */ +static bool +back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, + bool comnested, int comstyle, ptrdiff_t *charpos_ptr, + ptrdiff_t *bytepos_ptr) +{ + Lisp_Object depth; + ptrdiff_t comment_depth, target_depth, comment_style; + Lisp_Object temp; + int c; + int syntax, code; - return old_back_comment (from, from_byte, stop, comnested, comstyle, - charpos_ptr, bytepos_ptr); + if (comment_cacheing_flag) + { + scan_comments_forward_to (from, from_byte); + if (from <= stop) + return false; + depth = Fget_text_property (make_number (from - 1), Qcomment_depth, Qnil); + if (!CONSP (depth) + || !INTEGERP (XCAR (depth))) /* A string. */ + return false; + comment_depth = XINT (XCAR (depth)); + if (!comment_depth) /* Not in a comment. */ + return false; + comment_style = XINT (XCDR (depth)); + if (comment_style != comstyle) /* Wrong sort of comment. This + can happen with "*|" at the + end of a "||" line comment. */ + return false; + + /* comment_depth: -1 is a non-nested comment, otherwise it's + the depth of nesting of nested comments. */ + target_depth = comment_depth < 0 ? 0 : comment_depth - 1; + do + { + temp = Fprevious_single_property_change (make_number (from), + Qcomment_depth, Qnil, Qnil); + if (NILP (temp)) + return false; + from = XINT (temp); + } + while (from > stop + && (depth = Fget_text_property (make_number (from - 1), + Qcomment_depth, Qnil), + XINT (XCAR (depth)) > target_depth)); + if (from <= stop) + return false; + from_byte = CHAR_TO_BYTE (from); + + /* Having passed back over the body of the comment, we should now find a + comment opener. */ + DEC_BOTH (from, from_byte); + UPDATE_SYNTAX_TABLE_BACKWARD (from); + + c = FETCH_CHAR_AS_MULTIBYTE (from_byte); + syntax = SYNTAX_WITH_FLAGS (c); + code = SYNTAX (c); + if (code != Scomment) + { + if (from <= stop) + return false; + if (!SYNTAX_FLAGS_COMSTART_SECOND (syntax)) + return false; + DEC_BOTH (from, from_byte); + UPDATE_SYNTAX_TABLE_BACKWARD (from); + c = FETCH_CHAR_AS_MULTIBYTE (from_byte); + syntax = SYNTAX_WITH_FLAGS (c); + if (!SYNTAX_FLAGS_COMSTART_FIRST (syntax)) + return false; + } + *charpos_ptr = from; + *bytepos_ptr = from_byte; + return true; + } + + else + return old_back_comment (from, from_byte, stop, comnested, comstyle, + charpos_ptr, bytepos_ptr); } DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0, @@ -3187,17 +3451,15 @@ the prefix syntax flag (p). */) If STOPBEFORE, stop at the start of an atom. If COMMENTSTOP is 1, stop at the start of a comment. If COMMENTSTOP is -1, stop at the start or end of a comment, - after the beginning of a string, or after the end of a string. - If PROPERTIZE is true, apply a `comment-depth' property to the region - just scanned over. This should only be done when COMMENTSTOP is -1 and - TARGETDEPTH is ???? and STOPBEFORE is false. */ + after the beginning of a string, or after the end of a string. */ static void scan_sexps_forward (struct lisp_parse_state *stateptr, ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t end, EMACS_INT targetdepth, bool stopbefore, - int commentstop, bool propertize) + int commentstop) { + ptrdiff_t count = SPECPDL_INDEX (); struct lisp_parse_state state; enum syntaxcode code; int c1; @@ -3219,8 +3481,6 @@ scan_sexps_forward (struct lisp_parse_state *stateptr, bool nofence; bool found; ptrdiff_t out_bytepos, out_charpos; - Lisp_Object comment_depth_value; - ptrdiff_t orig_from = from; int temp; prev_from = from; @@ -3259,12 +3519,6 @@ do { prev_from = from; \ tem = Fcdr (tem); } - comment_depth_value = (state.instring != -1) - ? Fcons (Qstring, make_number (state.instring)) - : (state.incomment - ? Fcons (make_number (state.incomment), - make_number (state.comstyle)) - : Fcons (make_number (0), make_number (0))); state.quoted = 0; mindepth = depth; @@ -3504,16 +3758,13 @@ do { prev_from = from; \ while (curlevel > levelstart) state.levelstarts = Fcons (make_number ((--curlevel)->last), state.levelstarts); - if (propertize && commentstop == -1) - Fput_text_property (make_number (orig_from), make_number (from), - Qcomment_depth, - comment_depth_value, Qnil); - immediate_quit = 0; *stateptr = state; } +/* Convert a (lisp) parse state to the internal form used in + scan_sexps_forward. */ static void internalize_parse_state (Lisp_Object external, struct lisp_parse_state *state) { @@ -3627,8 +3878,7 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment. XINT (to), target, !NILP (stopbefore), (NILP (commentstop) - ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)), - false); + ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1))); SET_PT_BOTH (state.location, state.location_byte); @@ -3765,10 +4015,14 @@ syms_of_syntax (void) DEFVAR_BOOL ("comment-cacheing-flag", comment_cacheing_flag, doc: /* Non-nil means use new style comment handling. */); comment_cacheing_flag = 0; - DEFVAR_LISP ("comment-depth-hwm", Vcomment_depth_hwm, - doc: /* Buffer position below which the `comment-depth' property is valid. */); - Vcomment_depth_hwm = make_number (1); - Fmake_variable_buffer_local (intern ("comment-depth-hwm")); + + DEFVAR_LISP ("comment-depth-values", Vcomment_depth_values, + doc: /* A list of values which the text property `comment-depth' can assume. +This is to ensure that any values which are `equal' are also `eq', as required by the text +property functions. The list starts off empty, and any time a new value is needed, it is +pushed onto the list. The second time a value is needed, it is found by `member', and the +canonical equivalent used. */); + Vcomment_depth_values = Qnil; DEFVAR_BOOL ("parse-sexp-ignore-comments", parse_sexp_ignore_comments, doc: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */); @@ -3823,6 +4077,7 @@ In both cases, LIMIT bounds the search. */); DEFSYM (Qcomment_end_can_be_escaped, "comment-end-can-be-escaped"); Fmake_variable_buffer_local (Qcomment_end_can_be_escaped); + defsubr (&Strim_comment_cache); defsubr (&Ssyntax_table_p); defsubr (&Ssyntax_table); defsubr (&Sstandard_syntax_table); diff --git a/src/syntax.h b/src/syntax.h index c3575d4a9b4..57c08737a63 100644 --- a/src/syntax.h +++ b/src/syntax.h @@ -28,6 +28,8 @@ INLINE_HEADER_BEGIN extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object); extern void update_syntax_table_forward (ptrdiff_t, bool, Lisp_Object); +extern void check_comment_depth_hwm_for_prop (ptrdiff_t, Lisp_Object, + Lisp_Object, Lisp_Object); /* The standard syntax table is stored where it will automatically be used in all new buffers. */ diff --git a/src/textprop.c b/src/textprop.c index 70091b939a2..a0191ad69cc 100644 --- a/src/textprop.c +++ b/src/textprop.c @@ -23,6 +23,7 @@ along with GNU Emacs. If not, see . */ #include "intervals.h" #include "buffer.h" #include "window.h" +#include "syntax.h" /* Test for membership, allowing for t (actually any non-cons) to mean the universal set. */ @@ -340,6 +341,12 @@ set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object) record_property_change (interval->position, LENGTH (interval), XCAR (sym), XCAR (value), object); + check_comment_depth_hwm_for_prop + (interval->position, XCAR (sym), XCAR (value), object); + if (!EQ (property_value (properties, XCAR (sym)), Qunbound)) + check_comment_depth_hwm_for_prop + (interval->position, XCAR (sym), + property_value (properties, XCAR (sym)), object); } /* For each new property that has no value at all in the old plist, @@ -352,6 +359,8 @@ set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object) record_property_change (interval->position, LENGTH (interval), XCAR (sym), Qnil, object); + check_comment_depth_hwm_for_prop + (interval->position, XCAR (sym), XCAR (value), object); } } @@ -406,6 +415,10 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object, { record_property_change (i->position, LENGTH (i), sym1, Fcar (this_cdr), object); + check_comment_depth_hwm_for_prop + (i->position, sym1, Fcar (this_cdr), object); + check_comment_depth_hwm_for_prop + (i->position, sym1, val1, object); } /* I's property has a different value -- change it */ @@ -442,6 +455,8 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object, { record_property_change (i->position, LENGTH (i), sym1, Qnil, object); + check_comment_depth_hwm_for_prop + (i->position, sym1, val1, object); } set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist))); changed = true; @@ -475,11 +490,14 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object /* First, remove the symbol if it's at the head of the list */ while (CONSP (current_plist) && EQ (sym, XCAR (current_plist))) { - if (BUFFERP (object)) - record_property_change (i->position, LENGTH (i), - sym, XCAR (XCDR (current_plist)), - object); - + if (BUFFERP (object)) + { + record_property_change (i->position, LENGTH (i), + sym, XCAR (XCDR (current_plist)), + object); + check_comment_depth_hwm_for_prop + (i->position, sym, XCAR (XCDR (current_plist)), object); + } current_plist = XCDR (XCDR (current_plist)); changed = true; } @@ -492,8 +510,12 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object if (CONSP (this) && EQ (sym, XCAR (this))) { if (BUFFERP (object)) - record_property_change (i->position, LENGTH (i), - sym, XCAR (XCDR (this)), object); + { + record_property_change (i->position, LENGTH (i), + sym, XCAR (XCDR (this)), object); + check_comment_depth_hwm_for_prop + (i->position, sym, XCAR (XCDR (this)), object); + } Fsetcdr (XCDR (tail2), XCDR (XCDR (this))); changed = true; -- 2.39.5