Port --enable-gcc-warnings to GCC 6.1

* configure.ac (WERROR_CFLAGS): Omit -Wunused-const-variable=2.
* lib-src/etags.c (LOOKING_AT, LOOKING_AT_NOCASE):
Omit test whether pointer plus a constant equals a null pointer.
* src/alloc.c (compact_small_strings):
Avoid pointer arithmetic on null pointers.
* src/alloc.c (mark_face_cache):
* src/fontset.c (free_realized_fontsets, Fset_fontset_font):
* src/fringe.c (draw_fringe_bitmap_1)
(Fset_fringe_bitmap_face):
* src/macfont.m (macfont_draw):
* src/msdos.c (IT_set_face, IT_clear_screen):
* src/nsfont.m (nsfont_draw):
* src/nsterm.h (FRAME_DEFAULT_FACE):
* src/nsterm.m (ns_draw_window_cursor)
(ns_draw_vertical_window_border, ns_draw_window_divider)
(ns_dumpglyphs_box_or_relief)
(ns_maybe_dumpglyphs_background, ns_dumpglyphs_image)
(ns_dumpglyphs_stretch):
* src/w32term.c (w32_draw_vertical_window_border)
(w32_draw_window_divider, x_set_mouse_face_gc):
* src/xdisp.c (estimate_mode_line_height, init_iterator)
(handle_face_prop, handle_single_display_spec, pop_it)
(CHAR_COMPOSED_P, get_next_display_element)
(next_element_from_display_vector, extend_face_to_end_of_line)
(fill_gstring_glyph_string,BUILD_COMPOSITE_GLYPH_STRING):
* src/xfaces.c (Finternal_merge_in_global_face, Fface_font)
(lookup_named_face):
* src/xterm.c (x_draw_vertical_window_border)
(x_draw_window_divider, x_set_mouse_face_gc):
Prefer FACE_OPT_FROM_ID to FACE_FROM_ID when the result might be null.
* src/xterm.c (try_window_id):
Redo loop to convince GCC 6.1 that it is null pointer safe.
(x_color_cells):
Use eassume as necessary to pacify GCC 6.1.
* src/dispextern.h (FACE_FROM_ID, IMAGE_FROM_ID): Now returns non-null.
(FACE_OPT_FROM_ID, IMAGE_OPT_FROM_ID): New macro, with the old
behavior of the non-_OPT macro, to be used when the result
might be a null pointer.
* src/dispnew.c (buffer_posn_from_coords, marginal_area_string)
[HAVE_WINDOW_SYSTEM]:
* src/intervals.h (INTERVAL_WRITABLE_P):
* src/term.c (turn_off_face):
* src/xdisp.c (get_glyph_face_and_encoding, fill_image_glyph_string)
(produce_image_glyph, produce_xwidget_glyph):
* src/xfaces.c (lookup_named_face):
Remove unnecessary test for null pointer.
* src/keyboard.c (read_char): Suppress bogus -Wclobbered warning.
* src/process.c (would_block): New function.
(server_accept_connection, wait_reading_process_output, send_process):
Use it.
* src/xdisp.c (get_window_cursor_type, note_mouse_highlight):
Prefer IMAGE_OPT_FROM_ID to IMAGE_FROM_ID when the result
might be null.

1 files changed, 69 insertions, 62 deletions

diff --git a/src/alloc.c b/src/alloc.c
index c5a4f425f6e..054e1ca23ca 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2174,89 +2174,96 @@ free_large_strings (void)
 static void
 compact_small_strings (void)
 {
-  struct sblock *b, *tb, *next;
-  sdata *from, *to, *end, *tb_end;
-  sdata *to_end, *from_end;
-
   /* TB is the sblock we copy to, TO is the sdata within TB we copy
      to, and TB_END is the end of TB.  */
-  tb = oldest_sblock;
-  tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
-  to = tb->data;
-
-  /* Step through the blocks from the oldest to the youngest.  We
-     expect that old blocks will stabilize over time, so that less
-     copying will happen this way.  */
-  for (b = oldest_sblock; b; b = b->next)
+  struct sblock *tb = oldest_sblock;
+  if (tb)
     {
-      end = b->next_free;
-      eassert ((char *) end <= (char *) b + SBLOCK_SIZE);
+      sdata *tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
+      sdata *to = tb->data;
 
-      for (from = b->data; from < end; from = from_end)
+      /* Step through the blocks from the oldest to the youngest.  We
+         expect that old blocks will stabilize over time, so that less
+         copying will happen this way.  */
+      struct sblock *b = tb;
+      do
         {
-          /* Compute the next FROM here because copying below may
-             overwrite data we need to compute it.  */
-          ptrdiff_t nbytes;
-          struct Lisp_String *s = from->string;
+          sdata *end = b->next_free;
+          eassert ((char *) end <= (char *) b + SBLOCK_SIZE);
+
+          for (sdata *from = b->data; from < end; )
+            {
+              /* Compute the next FROM here because copying below may
+                 overwrite data we need to compute it.  */
+              ptrdiff_t nbytes;
+              struct Lisp_String *s = from->string;
 
 #ifdef GC_CHECK_STRING_BYTES
-          /* Check that the string size recorded in the string is the
-             same as the one recorded in the sdata structure.  */
-          if (s && string_bytes (s) != SDATA_NBYTES (from))
-            emacs_abort ();
+              /* Check that the string size recorded in the string is the
+                 same as the one recorded in the sdata structure.  */
+              if (s && string_bytes (s) != SDATA_NBYTES (from))
+                emacs_abort ();
 #endif /* GC_CHECK_STRING_BYTES */
 
-          nbytes = s ? STRING_BYTES (s) : SDATA_NBYTES (from);
-          eassert (nbytes <= LARGE_STRING_BYTES);
+              nbytes = s ? STRING_BYTES (s) : SDATA_NBYTES (from);
+              eassert (nbytes <= LARGE_STRING_BYTES);
 
-          nbytes = SDATA_SIZE (nbytes);
-          from_end = (sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
+              nbytes = SDATA_SIZE (nbytes);
+              sdata *from_end = (sdata *) ((char *) from
+                                           + nbytes + GC_STRING_EXTRA);
 
 #ifdef GC_CHECK_STRING_OVERRUN
-          if (memcmp (string_overrun_cookie,
-                      (char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
-                      GC_STRING_OVERRUN_COOKIE_SIZE))
-            emacs_abort ();
+              if (memcmp (string_overrun_cookie,
+                          (char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
+                          GC_STRING_OVERRUN_COOKIE_SIZE))
+                emacs_abort ();
 #endif
 
-          /* Non-NULL S means it's alive.  Copy its data.  */
-          if (s)
-            {
-              /* If TB is full, proceed with the next sblock.  */
-              to_end = (sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
-              if (to_end > tb_end)
+              /* Non-NULL S means it's alive.  Copy its data.  */
+              if (s)
                 {
-                  tb->next_free = to;
-                  tb = tb->next;
-                  tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
-                  to = tb->data;
-                  to_end = (sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
-                }
+                  /* If TB is full, proceed with the next sblock.  */
+                  sdata *to_end = (sdata *) ((char *) to
+                                             + nbytes + GC_STRING_EXTRA);
+                  if (to_end > tb_end)
+                    {
+                      tb->next_free = to;
+                      tb = tb->next;
+                      tb_end = (sdata *) ((char *) tb + SBLOCK_SIZE);
+                      to = tb->data;
+                      to_end = (sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
+                    }
 
-              /* Copy, and update the string's `data' pointer.  */
-              if (from != to)
-                {
-                  eassert (tb != b || to < from);
-                  memmove (to, from, nbytes + GC_STRING_EXTRA);
-                  to->string->data = SDATA_DATA (to);
-                }
+                  /* Copy, and update the string's `data' pointer.  */
+                  if (from != to)
+                    {
+                      eassert (tb != b || to < from);
+                      memmove (to, from, nbytes + GC_STRING_EXTRA);
+                      to->string->data = SDATA_DATA (to);
+                    }
 
-              /* Advance past the sdata we copied to.  */
-              to = to_end;
+                  /* Advance past the sdata we copied to.  */
+                  to = to_end;
+                }
+              from = from_end;
             }
+          b = b->next;
         }
-    }
+      while (b);
 
-  /* The rest of the sblocks following TB don't contain live data, so
-     we can free them.  */
-  for (b = tb->next; b; b = next)
-    {
-      next = b->next;
-      lisp_free (b);
+      /* The rest of the sblocks following TB don't contain live data, so
+         we can free them.  */
+      for (b = tb->next; b; )
+        {
+          struct sblock *next = b->next;
+          lisp_free (b);
+          b = next;
+        }
+
+      tb->next_free = to;
+      tb->next = NULL;
     }
 
-  tb->next_free = to;
-  tb->next = NULL;
   current_sblock = tb;
 }
 
@@ -6119,7 +6126,7 @@ mark_face_cache (struct face_cache *c)
       int i, j;
       for (i = 0; i < c->used; ++i)
         {
-          struct face *face = FACE_FROM_ID (c->f, i);
+          struct face *face = FACE_OPT_FROM_ID (c->f, i);
 
           if (face)
             {