User: stephent Date: 06/02/22 04:30:14 Modified: xemacs/src ChangeLog syntax.c Log: Fix out-of-order definition. <87fymcnkdu.fsf(a)tleepslib.sk.tsukuba.ac.jp&gt; Revision Changes Path 1.923 +4 -0 XEmacs/xemacs/src/ChangeLog Index: ChangeLog =================================================================== RCS file: /pack/xemacscvs/XEmacs/xemacs/src/ChangeLog,v retrieving revision 1.922 retrieving revision 1.923 diff -u -p -r1.922 -r1.923 --- ChangeLog 2006/02/21 11:33:41 1.922 +++ ChangeLog 2006/02/22 03:30:06 1.923 ＠＠ -1,3 +1,7 ＠＠ +2006-02-22 Stephen J. Turnbull <stephen(a)xemacs.org&gt; + + * syntax.c: Move static functions in syntax_cache page to top. + 2006-02-19 Stephen J. Turnbull <stephen(a)xemacs.org&gt; Fix crash (cf. Holger Schauer <yxz7j7xzk97.fsf(a)gimli.holgi.priv>). 1.28 +171 -152 XEmacs/xemacs/src/syntax.c Index: syntax.c =================================================================== RCS file: /pack/xemacscvs/XEmacs/xemacs/src/syntax.c,v retrieving revision 1.27 retrieving revision 1.28 diff -u -p -r1.27 -r1.28 --- syntax.c 2006/02/21 11:33:46 1.27 +++ syntax.c 2006/02/22 03:30:08 1.28 ＠＠ -238,9 +238,77 ＠＠ BUFFER defaults to the current buffer if buf->local_var_flags |= XINT (buffer_local_flags.syntax_table); return syntax_table; } + +  +/* + * Syntax caching + */ + +/* syntax_cache object implementation */ + +static const struct memory_description syntax_cache_description_1 [] = { + { XD_LISP_OBJECT, offsetof (struct syntax_cache, object) }, + { XD_LISP_OBJECT, offsetof (struct syntax_cache, buffer) }, + { XD_LISP_OBJECT, offsetof (struct syntax_cache, syntax_table) }, + { XD_LISP_OBJECT, offsetof (struct syntax_cache, mirror_table) }, + { XD_LISP_OBJECT, offsetof (struct syntax_cache, start) }, + { XD_LISP_OBJECT, offsetof (struct syntax_cache, end) }, + { XD_END } +}; + +#ifdef NEW_GC +DEFINE_LRECORD_IMPLEMENTATION ("syntax-cache", syntax_cache, + 1, /*dumpable-flag*/ + 0, 0, 0, 0, 0, + syntax_cache_description_1, + Lisp_Syntax_Cache); +#else /* not NEW_GC */ + +const struct sized_memory_description syntax_cache_description = { + sizeof (struct syntax_cache), + syntax_cache_description_1 +}; +#endif /* not NEW_GC */ + +/* static syntax cache utilities */ static void +syntax_cache_table_was_changed (struct buffer *buf) +{ + struct syntax_cache *cache = buf->syntax_cache; + if (cache->no_syntax_table_prop) + { + cache->syntax_table = + BUFFER_SYNTAX_TABLE (buf); + cache->mirror_table = + BUFFER_MIRROR_SYNTAX_TABLE (buf); + } +} + +static void +reset_buffer_syntax_cache_range (struct syntax_cache *cache, + Lisp_Object buffer, int infinite) +{ + Fset_marker (cache->start, make_int (1), buffer); + Fset_marker (cache->end, make_int (1), buffer); + Fset_marker_insertion_type (cache->start, Qt); + Fset_marker_insertion_type (cache->end, Qnil); + /* #### Should we "cache->no_syntax_table_prop = 1;" here? */ + /* #### Cf comment on INFINITE in init_syntax_cache. -- sjt */ + if (infinite) + { + cache->prev_change = EMACS_INT_MIN; + cache->next_change = EMACS_INT_MAX; + } + else + { + cache->prev_change = -1; + cache->next_change = -1; + } +} + +static void init_syntax_cache (struct syntax_cache *cache, Lisp_Object object, struct buffer *buffer, int infinite) { ＠＠ -271,6 +339,8 ＠＠ init_syntax_cache (struct syntax_cache * } } +/* external syntax cache API */ + /* #### This function and associated logic still needs work, and especially documentation. */ struct syntax_cache * /* return CACHE or the cache of OBJECT */ ＠＠ -318,158 +388,6 ＠＠ setup_buffer_syntax_cache (struct buffer return setup_syntax_cache (NULL, wrap_buffer (buffer), buffer, from, count); } -static const struct memory_description syntax_cache_description_1 [] = { - { XD_LISP_OBJECT, offsetof (struct syntax_cache, object) }, - { XD_LISP_OBJECT, offsetof (struct syntax_cache, buffer) }, - { XD_LISP_OBJECT, offsetof (struct syntax_cache, syntax_table) }, - { XD_LISP_OBJECT, offsetof (struct syntax_cache, mirror_table) }, - { XD_LISP_OBJECT, offsetof (struct syntax_cache, start) }, - { XD_LISP_OBJECT, offsetof (struct syntax_cache, end) }, - { XD_END } -}; - -#ifdef NEW_GC -DEFINE_LRECORD_IMPLEMENTATION ("syntax-cache", syntax_cache, - 1, /*dumpable-flag*/ - 0, 0, 0, 0, 0, - syntax_cache_description_1, - Lisp_Syntax_Cache); -#else /* not NEW_GC */ - -const struct sized_memory_description syntax_cache_description = { - sizeof (struct syntax_cache), - syntax_cache_description_1 -}; -#endif /* not NEW_GC */ - -void -mark_buffer_syntax_cache (struct buffer *buf) -{ - struct syntax_cache *cache = buf->syntax_cache; - if (!cache) /* Vbuffer_defaults and such don't have caches */ - return; - mark_object (cache->object); - if (cache->buffer) - mark_object (wrap_buffer (cache->buffer)); - mark_object (cache->syntax_table); - mark_object (cache->mirror_table); - mark_object (cache->start); - mark_object (cache->end); -} - -static void -reset_buffer_syntax_cache_range (struct syntax_cache *cache, - Lisp_Object buffer, int infinite) -{ - Fset_marker (cache->start, make_int (1), buffer); - Fset_marker (cache->end, make_int (1), buffer); - Fset_marker_insertion_type (cache->start, Qt); - Fset_marker_insertion_type (cache->end, Qnil); - /* #### Should we "cache->no_syntax_table_prop = 1;" here? */ - /* #### Cf comment on INFINITE in init_syntax_cache. -- sjt */ - if (infinite) - { - cache->prev_change = EMACS_INT_MIN; - cache->next_change = EMACS_INT_MAX; - } - else - { - cache->prev_change = -1; - cache->next_change = -1; - } -} - -void -init_buffer_syntax_cache (struct buffer *buf) -{ - struct syntax_cache *cache; -#ifdef NEW_GC - buf->syntax_cache = alloc_lrecord_type (struct syntax_cache, - &lrecord_syntax_cache); -#else /* not NEW_GC */ - buf->syntax_cache = xnew_and_zero (struct syntax_cache); -#endif /* not NEW_GC */ - cache = buf->syntax_cache; - cache->object = wrap_buffer (buf); - cache->buffer = buf; - cache->no_syntax_table_prop = 1; - cache->syntax_table = BUFFER_SYNTAX_TABLE (cache->buffer); - cache->mirror_table = BUFFER_MIRROR_SYNTAX_TABLE (cache->buffer); - cache->start = Fmake_marker (); - cache->end = Fmake_marker (); - reset_buffer_syntax_cache_range (cache, cache->object, 0); -} - -/* finalize the syntax cache for BUF */ -void -uninit_buffer_syntax_cache (struct buffer *buf) -{ -#ifdef NEW_GC - mc_free (buf->syntax_cache); -#else /* not NEW_GC */ - xfree (buf->syntax_cache, struct syntax_cache *); -#endif /* not NEW_GC */ - buf->syntax_cache = 0; -} - - -static void -syntax_cache_table_was_changed (struct buffer *buf) -{ - struct syntax_cache *cache = buf->syntax_cache; - if (cache->no_syntax_table_prop) - { - cache->syntax_table = - BUFFER_SYNTAX_TABLE (buf); - cache->mirror_table = - BUFFER_MIRROR_SYNTAX_TABLE (buf); - } -} - -/* The syntax-table property on the range covered by EXTENT may be changing, - either because EXTENT has a syntax-table property and is being attached - or detached (this includes having its endpoints changed), or because - the value of EXTENT's syntax-table property is changing. */ - -void -signal_syntax_cache_extent_changed (EXTENT extent) -{ - Lisp_Object buffer = Fextent_object (wrap_extent (extent)); - if (BUFFERP (buffer)) - { - /* This was getting called with the buffer's start and end null, eg in - cperl mode, which triggers an assert in byte_marker_position. Cf - thread rooted at <yxz7j7xzk97.fsf(a)gimli.holgi.priv&gt; on xemacs-beta. - <yxzfymklb6p.fsf(a)gimli.holgi.priv&gt; has a recipe, but you also need - to delete or type SPC to get the crash. - #### Delete this comment when setup_syntax_cache is made sane. */ - struct syntax_cache *cache = XBUFFER (buffer)->syntax_cache; - /* #### would this be slower or less accurate in character terms? */ - Bytexpos start = extent_endpoint_byte (extent, 0); - Bytexpos end = extent_endpoint_byte (extent, 1); - Bytexpos start2 = byte_marker_position (cache->start); - Bytexpos end2 = byte_marker_position (cache->end); - /* If the extent is entirely before or entirely after the cache - range, it doesn't overlap. Otherwise, invalidate the range. */ - if (!(end < start2 || start > end2)) - reset_buffer_syntax_cache_range (cache, buffer, 0); - } -} - -/* Extents have been adjusted for insertion or deletion, so we need to - refetch the start and end position of the extent */ -void -signal_syntax_cache_extent_adjust (struct buffer *buf) -{ - struct syntax_cache *cache = buf->syntax_cache; - /* If the cache was invalid before, leave it that way. We only want - to update the limits of validity when they were actually valid. */ - if (cache->prev_change < 0) - return; - cache->prev_change = marker_position (cache->start); - cache->next_change = marker_position (cache->end); -} - /* Update syntax_cache to an appropriate setting for position POS ＠＠ -579,6 +497,107 ＠＠ update_syntax_cache (struct syntax_cache #endif /* NOT_WORTH_THE_EFFORT */ } } + +/* buffer-specific APIs used in buffer.c + #### This is really unclean; + the syntax cache should just be a LISP object */ + +void +mark_buffer_syntax_cache (struct buffer *buf) +{ + struct syntax_cache *cache = buf->syntax_cache; + if (!cache) /* Vbuffer_defaults and such don't have caches */ + return; + mark_object (cache->object); + if (cache->buffer) + mark_object (wrap_buffer (cache->buffer)); + mark_object (cache->syntax_table); + mark_object (cache->mirror_table); + mark_object (cache->start); + mark_object (cache->end); +} + +void +init_buffer_syntax_cache (struct buffer *buf) +{ + struct syntax_cache *cache; +#ifdef NEW_GC + buf->syntax_cache = alloc_lrecord_type (struct syntax_cache, + &lrecord_syntax_cache); +#else /* not NEW_GC */ + buf->syntax_cache = xnew_and_zero (struct syntax_cache); +#endif /* not NEW_GC */ + cache = buf->syntax_cache; + cache->object = wrap_buffer (buf); + cache->buffer = buf; + cache->no_syntax_table_prop = 1; + cache->syntax_table = BUFFER_SYNTAX_TABLE (cache->buffer); + cache->mirror_table = BUFFER_MIRROR_SYNTAX_TABLE (cache->buffer); + cache->start = Fmake_marker (); + cache->end = Fmake_marker (); + reset_buffer_syntax_cache_range (cache, cache->object, 0); +} + +/* finalize the syntax cache for BUF */ + +void +uninit_buffer_syntax_cache (struct buffer *buf) +{ +#ifdef NEW_GC + mc_free (buf->syntax_cache); +#else /* not NEW_GC */ + xfree (buf->syntax_cache, struct syntax_cache *); +#endif /* not NEW_GC */ + buf->syntax_cache = 0; +} + +/* extent-specific APIs used in extents.c and insdel.c */ + +/* The syntax-table property on the range covered by EXTENT may be changing, + either because EXTENT has a syntax-table property and is being attached + or detached (this includes having its endpoints changed), or because + the value of EXTENT's syntax-table property is changing. */ + +void +signal_syntax_cache_extent_changed (EXTENT extent) +{ + Lisp_Object buffer = Fextent_object (wrap_extent (extent)); + if (BUFFERP (buffer)) + { + /* This was getting called with the buffer's start and end null, eg in + cperl mode, which triggers an assert in byte_marker_position. Cf + thread rooted at <yxz7j7xzk97.fsf(a)gimli.holgi.priv&gt; on xemacs-beta. + <yxzfymklb6p.fsf(a)gimli.holgi.priv&gt; has a recipe, but you also need + to delete or type SPC to get the crash. + #### Delete this comment when setup_syntax_cache is made sane. */ + struct syntax_cache *cache = XBUFFER (buffer)->syntax_cache; + /* #### would this be slower or less accurate in character terms? */ + Bytexpos start = extent_endpoint_byte (extent, 0); + Bytexpos end = extent_endpoint_byte (extent, 1); + Bytexpos start2 = byte_marker_position (cache->start); + Bytexpos end2 = byte_marker_position (cache->end); + /* If the extent is entirely before or entirely after the cache + range, it doesn't overlap. Otherwise, invalidate the range. */ + if (!(end < start2 || start > end2)) + reset_buffer_syntax_cache_range (cache, buffer, 0); + } +} + +/* Extents have been adjusted for insertion or deletion, so we need to + refetch the start and end position of the extent */ +void +signal_syntax_cache_extent_adjust (struct buffer *buf) +{ + struct syntax_cache *cache = buf->syntax_cache; + /* If the cache was invalid before, leave it that way. We only want + to update the limits of validity when they were actually valid. */ + if (cache->prev_change < 0) + return; + cache->prev_change = marker_position (cache->start); + cache->next_change = marker_position (cache->end); +} + +  /* Convert a letter which signifies a syntax code into the code it signifies.