Merge remote-tracking branch 'savannah/master' into HEAD

7 files changed, 55 insertions, 65 deletions

diff --git a/src/alloc.c b/src/alloc.c
index dc92d67f163..281525b20e5 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -67,7 +67,8 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 # include <malloc.h>
 #endif
 
-#if defined HAVE_VALGRIND_VALGRIND_H && !defined USE_VALGRIND
+#if (defined ENABLE_CHECKING \
+     && defined HAVE_VALGRIND_VALGRIND_H && !defined USE_VALGRIND)
 # define USE_VALGRIND 1
 #endif
 
@@ -4463,7 +4464,7 @@ live_string_holding (struct mem_node *m, void *p)
 
       /* P must point into a Lisp_String structure, and it
          must not be on the free-list.  */
-      if (0 <= offset && offset < STRING_BLOCK_SIZE * sizeof b->strings[0])
+      if (0 <= offset && offset < sizeof b->strings)
         {
           cp = ptr_bounds_copy (cp, b);
           struct Lisp_String *s = p = cp -= offset % sizeof b->strings[0];
@@ -4496,7 +4497,7 @@ live_cons_holding (struct mem_node *m, void *p)
       /* P must point into a Lisp_Cons, not be
          one of the unused cells in the current cons block,
          and not be on the free-list.  */
-      if (0 <= offset && offset < CONS_BLOCK_SIZE * sizeof b->conses[0]
+      if (0 <= offset && offset < sizeof b->conses
           && (b != cons_block
               || offset / sizeof b->conses[0] < cons_block_index))
         {
@@ -4532,7 +4533,7 @@ live_symbol_holding (struct mem_node *m, void *p)
       /* P must point into the Lisp_Symbol, not be
          one of the unused cells in the current symbol block,
          and not be on the free-list.  */
-      if (0 <= offset && offset < SYMBOL_BLOCK_SIZE * sizeof b->symbols[0]
+      if (0 <= offset && offset < sizeof b->symbols
           && (b != symbol_block
               || offset / sizeof b->symbols[0] < symbol_block_index))
         {
@@ -4566,9 +4567,8 @@ live_float_p (struct mem_node *m, void *p)
 
       /* P must point to the start of a Lisp_Float and not be
          one of the unused cells in the current float block.  */
-      return (offset >= 0
+      return (0 <= offset && offset < sizeof b->floats
               && offset % sizeof b->floats[0] == 0
-              && offset < (FLOAT_BLOCK_SIZE * sizeof b->floats[0])
               && (b != float_block
                   || offset / sizeof b->floats[0] < float_block_index));
     }
@@ -4694,35 +4694,6 @@ mark_maybe_objects (Lisp_Object const *array, ptrdiff_t nelts)
     mark_maybe_object (*array);
 }
 
-/* A lower bound on the alignment of Lisp objects that need marking.
-   Although 1 is safe, higher values speed up mark_maybe_pointer.
-   If USE_LSB_TAG, this value is typically GCALIGNMENT; otherwise,
-   it's determined by the natural alignment of Lisp structs.
-   All vectorlike objects have alignment at least that of union
-   vectorlike_header and it's unlikely they all have alignment greater,
-   so use the union as a safe and likely-accurate standin for
-   vectorlike objects.  */
-
-enum { GC_OBJECT_ALIGNMENT_MINIMUM
-         = max (GCALIGNMENT,
-                min (alignof (union vectorlike_header),
-                     min (min (alignof (struct Lisp_Cons),
-                               alignof (struct Lisp_Float)),
-                          min (alignof (struct Lisp_String),
-                               alignof (struct Lisp_Symbol))))) };
-
-/* Return true if P might point to Lisp data that can be garbage
-   collected, and false otherwise (i.e., false if it is easy to see
-   that P cannot point to Lisp data that can be garbage collected).
-   Symbols are implemented via offsets not pointers, but the offsets
-   are also multiples of GC_OBJECT_ALIGNMENT_MINIMUM.  */
-
-static bool
-maybe_lisp_pointer (void *p)
-{
-  return (uintptr_t) p % GC_OBJECT_ALIGNMENT_MINIMUM == 0;
-}
-
 /* If P points to Lisp data, mark that as live if it isn't already
    marked.  */
 
@@ -4731,13 +4702,10 @@ mark_maybe_pointer (void *p)
 {
   struct mem_node *m;
 
-#ifdef USE_VALGRIND
+#if USE_VALGRIND
   VALGRIND_MAKE_MEM_DEFINED (&p, sizeof (p));
 #endif
 
-  if (!maybe_lisp_pointer (p))
-    return;
-
   if (pdumper_object_p (p))
     {
       int type = pdumper_find_object_type (p);
@@ -4837,7 +4805,16 @@ mark_memory (void const *start, void const *end)
 
   for (pp = start; (void const *) pp < end; pp += GC_POINTER_ALIGNMENT)
     {
-      mark_maybe_pointer (*(void *const *) pp);
+      char *p = *(char *const *) pp;
+      mark_maybe_pointer (p);
+
+      /* Unmask any struct Lisp_Symbol pointer that make_lisp_symbol
+         previously disguised by adding the address of 'lispsym'.
+         On a host with 32-bit pointers and 64-bit Lisp_Objects,
+         a Lisp_Object might be split into registers saved into
+         non-adjacent words and P might be the low-order word's value.  */
+      p += (intptr_t) lispsym;
+      mark_maybe_pointer (p);
 
       verify (alignof (Lisp_Object) % GC_POINTER_ALIGNMENT == 0);
       if (alignof (Lisp_Object) == GC_POINTER_ALIGNMENT
diff --git a/src/composite.c b/src/composite.c
index 518502be49f..2c589e4f3a9 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1987,7 +1987,9 @@ preceding and/or following characters, this char-table contains
 a function to call to compose that character.
 
 The element at index C in the table, if non-nil, is a list of
-composition rules of this form: ([PATTERN PREV-CHARS FUNC] ...)
+composition rules of the form ([PATTERN PREV-CHARS FUNC] ...);
+the rules must be specified in the descending order of PREV-CHARS
+values.
 
 PATTERN is a regular expression which C and the surrounding
 characters must match.
diff --git a/src/emacs.c b/src/emacs.c
index 8ecf9b4aeba..228ac293370 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -358,7 +358,10 @@ setlocale (int cat, char const *locale)
 static bool
 using_utf8 (void)
 {
-#ifdef HAVE_WCHAR_H
+  /* We don't want to compile in mbrtowc on WINDOWSNT because that
+     will prevent Emacs from starting on older Windows systems, while
+     the result is known in advance anyway...  */
+#if defined HAVE_WCHAR_H && !defined WINDOWSNT
   wchar_t wc;
   mbstate_t mbs = { 0 };
   return mbrtowc (&wc, "\xc4\x80", 2, &mbs) == 2 && wc == 0x100;
diff --git a/src/lread.c b/src/lread.c
index 9f849eda423..026f3b6d98f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3030,17 +3030,18 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           struct Lisp_Vector *vec;
           tmp = read_vector (readcharfun, 1);
           vec = XVECTOR (tmp);
-          if (! (COMPILED_STACK_DEPTH < vec->header.size
-                 && (FIXNUMP (vec->contents[COMPILED_ARGLIST])
-                     || CONSP (vec->contents[COMPILED_ARGLIST])
-                     || NILP (vec->contents[COMPILED_ARGLIST]))
-                 && ((STRINGP (vec->contents[COMPILED_BYTECODE])
-                      && VECTORP (vec->contents[COMPILED_CONSTANTS]))
-                     || CONSP (vec->contents[COMPILED_BYTECODE]))
-                 && FIXNATP (vec->contents[COMPILED_STACK_DEPTH])))
+          if (! (COMPILED_STACK_DEPTH < ASIZE (tmp)
+                 && (FIXNUMP (AREF (tmp, COMPILED_ARGLIST))
+                     || CONSP (AREF (tmp, COMPILED_ARGLIST))
+                     || NILP (AREF (tmp, COMPILED_ARGLIST)))
+                 && ((STRINGP (AREF (tmp, COMPILED_BYTECODE))
+                      && VECTORP (AREF (tmp, COMPILED_CONSTANTS)))
+                     || CONSP (AREF (tmp, COMPILED_BYTECODE)))
+                 && FIXNATP (AREF (tmp, COMPILED_STACK_DEPTH))))
             invalid_syntax ("Invalid byte-code object");
 
-          if (STRING_MULTIBYTE (AREF (tmp, COMPILED_BYTECODE)))
+          if (STRINGP (AREF (tmp, COMPILED_BYTECODE))
+              && STRING_MULTIBYTE (AREF (tmp, COMPILED_BYTECODE)))
             {
               /* BYTESTR must have been produced by Emacs 20.2 or earlier
                  because it produced a raw 8-bit string for byte-code and
@@ -3051,7 +3052,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                     Fstring_as_unibyte (AREF (tmp, COMPILED_BYTECODE)));
             }
 
-          if (COMPILED_DOC_STRING < vec->header.size
+          if (COMPILED_DOC_STRING < ASIZE (tmp)
               && EQ (AREF (tmp, COMPILED_DOC_STRING), make_fixnum (0)))
             {
               /* read_list found a docstring like '(#$ . 5521)' and treated it
diff --git a/src/pdumper.c b/src/pdumper.c
index 29e3560ee5a..ffe59fbb306 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2256,7 +2256,7 @@ dump_bignum (struct dump_context *ctx, Lisp_Object object)
 static dump_off
 dump_float (struct dump_context *ctx, const struct Lisp_Float *lfloat)
 {
-#if CHECK_STRUCTS && !defined (HASH_Lisp_Float_50A7B216D9)
+#if CHECK_STRUCTS && !defined (HASH_Lisp_Float_7E7D284C02)
 # error "Lisp_Float changed. See CHECK_STRUCTS comment in config.h."
 #endif
   eassert (ctx->header.cold_start);
diff --git a/src/xdisp.c b/src/xdisp.c
index ea28395cf55..327e8a183b1 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -8692,6 +8692,7 @@ handle_stop_backwards (struct it *it, ptrdiff_t charpos)
   ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
   struct display_pos save_current = it->current;
   struct text_pos save_position = it->position;
+  struct composition_it save_cmp_it = it->cmp_it;
   struct text_pos pos1;
   ptrdiff_t next_stop;
 
@@ -8719,6 +8720,7 @@ handle_stop_backwards (struct it *it, ptrdiff_t charpos)
   it->bidi_p = true;
   it->current = save_current;
   it->position = save_position;
+  it->cmp_it = save_cmp_it;
   next_stop = it->stop_charpos;
   it->stop_charpos = it->prev_stop;
   handle_stop (it);
@@ -11575,7 +11577,9 @@ display_echo_area_1 (ptrdiff_t a1, Lisp_Object a2)
   /* Display.  */
   clear_glyph_matrix (w->desired_matrix);
   XSETWINDOW (window, w);
+  void *itdata = bidi_shelve_cache ();
   try_window (window, start, 0);
+  bidi_unshelve_cache (itdata, false);
 
   return window_height_changed_p;
 }
@@ -19748,7 +19752,7 @@ find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
    by changes at the start of current_buffer that occurred since W's
    current matrix was built.  Value is null if no such row exists.
 
-   BEG_UNCHANGED us the number of characters unchanged at the start of
+   BEG_UNCHANGED is the number of characters unchanged at the start of
    current_buffer.  BEG + BEG_UNCHANGED is the buffer position of the
    first changed character in current_buffer.  Characters at positions <
    BEG + BEG_UNCHANGED are at the same buffer positions as they were
@@ -27702,6 +27706,7 @@ fill_gstring_glyph_string (struct glyph_string *s, int face_id,
   while (glyph < last
          && glyph->u.cmp.automatic
          && glyph->u.cmp.id == s->cmp_id
+         && glyph->face_id == face_id
          && s->cmp_to == glyph->slice.cmp.from)
     {
       s->width += glyph->pixel_width;
diff --git a/src/xfaces.c b/src/xfaces.c
index 7d7aff95c11..cf155288bd1 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -4356,15 +4356,15 @@ color_distance (Emacs_Color *x, Emacs_Color *y)
 
      See <https://www.compuphase.com/cmetric.htm> for more info.  */
 
-  long r = (x->red   - y->red)   >> 8;
-  long g = (x->green - y->green) >> 8;
-  long b = (x->blue  - y->blue)  >> 8;
-  long r_mean = (x->red + y->red) >> 9;
-
-  return
-    (((512 + r_mean) * r * r) >> 8)
-    + 4 * g * g
-    + (((767 - r_mean) * b * b) >> 8);
+  long long r = x->red   - y->red;
+  long long g = x->green - y->green;
+  long long b = x->blue  - y->blue;
+  long long r_mean = (x->red + y->red) >> 1;
+
+  return (((((2 * 65536 + r_mean) * r * r) >> 16)
+           + 4 * g * g
+           + (((2 * 65536 + 65535 - r_mean) * b * b) >> 16))
+          >> 16);
 }
 
 
@@ -4374,7 +4374,9 @@ COLOR1 and COLOR2 may be either strings containing the color name,
 or lists of the form (RED GREEN BLUE), each in the range 0 to 65535 inclusive.
 If FRAME is unspecified or nil, the current frame is used.
 If METRIC is specified, it should be a function that accepts
-two lists of the form (RED GREEN BLUE) aforementioned. */)
+two lists of the form (RED GREEN BLUE) aforementioned.
+Despite the name, this is not a true distance metric as it does not satisfy
+the triangle inequality.  */)
   (Lisp_Object color1, Lisp_Object color2, Lisp_Object frame,
    Lisp_Object metric)
 {
@@ -4931,7 +4933,7 @@ DEFUN ("face-attributes-as-vector", Fface_attributes_as_vector,
 
 /* If the distance (as returned by color_distance) between two colors is
    less than this, then they are considered the same, for determining
-   whether a color is supported or not.  The range of values is 0-65535.  */
+   whether a color is supported or not.  */
 
 #define TTY_SAME_COLOR_THRESHOLD  10000