Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

29 files changed, 1377 insertions, 1236 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index b90471e8dea..9e3fb904b93 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,120 @@
+2014-12-28  Paul Eggert  <eggert@Penguin.CS.UCLA.EDU>
+
+        Wrap dll functions more simply
+        * decompress.c, gnutls.c, image.c, xml.c:
+        If WINDOWSNT, use '#define FOO fn_FOO' to wrap dll functions,
+        rather than the inverse when not WINDOWSNT.  This isolates the
+        fn_* business into the WINDOWSNT-specific section of the code,
+        which makes it easier to maintain the generic code.
+        * decompress.c (DEF_ZLIB_FN, LOAD_ZLIB_FN):
+        * gnutls.c (DEF_GNUTLS_FN, LOAD_GNUTLS_FN):
+        * image.c (DEF_IMGLIB_FN, LOAD_IMGLIB_FN):
+        * xml.c (DEF_XML2_FN, LOAD_XML2_FN):
+        Remove.  All uses replaced by DEF_DLL_FN.
+        * decompress.c (inflateInit2): Remove; no longer needed.
+        * w32.h (DEF_DLL_FN, LOAD_DLL_FN): New macros.
+
+        Port memory-full checking to GnuTLS 3.3
+        Instead of using gnutls_global_set_mem_functions, check every call
+        to a GnuTLS function that might return an indication of memory
+        exhaustion.  Suggested by Dmitry Antipov in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-12/msg02056.html
+        * gnutls.c (gnutls_global_set_mem_functions) [WINDOWSNT]: Remove.
+        (init_gnutls_functions): Do not load gnutls_global_set_mem_functions.
+        (fn_gnutls_global_set_mem_functions) [!WINDOWSNT]: Remove.
+        All uses removed.
+        (check_memory_full): New function.
+        (emacs_gnutls_handshake, emacs_gnutls_handle_error)
+        (gnutls_make_error, gnutls_certificate_details, Fgnutls_peer_status)
+        (Fgnutls_boot): Use it.
+        (emacs_gnutls_global_init): Avoid gnutls_global_set_mem_functions.
+
+2014-12-27  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix parse_settings to match internal documentation
+        * xsettings.c (parse_settings): Return the number of settings seen.
+        Count the settings changes accurately.
+        (read_settings): Don't confuse number of settings changes with
+        the return code from XGetWindowProperty.
+
+2014-12-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_iterator_to_next) <GET_FROM_STRING>: Limit search in
+        composition_compute_stop_pos to the number of characters in the
+        string.  (Bug#19435)
+        <GET_FROM_BUFFER, GET_FROM_STRING>: Simplify code.
+
+        * composite.c (composition_compute_stop_pos): If no composition
+        was found in a string before ENDPOS, and ENDPOS is the string end,
+        no need to back up to a safe point.
+
+        * dispextern.h (struct it) <end_charpos>: Improve commentary.
+
+2014-12-27  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsimage.m (allocInitFromFile:): Initialize bmRep.
+        (dealloc): Release bmRep.
+        (setPixmapData): Make bmRep local so class member is not
+        set (Bug#19133).
+        (setPixmapData): Rename local variable bmRep to avoid compiler
+        warning.
+
+2014-12-27  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (do_ewmh_fullscreen): Don't remove maximized_horz/vert
+        when going to fullscreen (Bug#0x180004f).
+
+2014-12-27  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (syms_of_buffer) <Vafter_change_functions>: fix docstring.
+
+2014-12-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * gnutls.c (gnutls_init): Fix deprecation warning from GCC.
+
+2014-12-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use bool for boolean in xselect.c, xsettings.c
+        * xselect.c (x_get_local_selection, struct selection_data)
+        (x_selection_request_lisp_error, struct prop_location)
+        (x_handle_selection_request, x_convert_selection)
+        (waiting_for_other_props_on_window, expect_property_change)
+        (wait_for_property_change, x_handle_property_notify)
+        (x_get_foreign_selection, x_get_window_property)
+        (receive_incremental_selection)
+        (x_get_window_property_as_lisp_data)
+        (lisp_data_to_selection_data, Fx_get_selection_internal)
+        (x_send_client_event):
+        * xselect.c, xterm.h (x_handle_dnd_message):
+        * xsettings.c (dpyinfo_valid, parse_settings, read_settings)
+        (apply_xft_settings, read_and_apply_settings)
+        (xft_settings_event, init_gsettings, init_xsettings)
+        (syms_of_xsettings):
+        Use bool for boolean.
+        * xselect.c (x_get_window_property): Omit last arg, which was an
+        unused boolean.
+        * xsettings.c (apply_xft_settings): Remove 2nd arg, which was
+        always true.  All callers changed.
+
+2014-12-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (sys_spawnve, get_lcid_callback): Use strcpy instead
+        of strcat.
+
+        * w32menu.c (add_menu_item): Use stpcpy instead of strcat.
+
+        * w32.c (sys_readdir, stat_worker, symlink): Use strcpy instead of
+        strcat.
+
+2014-12-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use bool for boolean in xsmfns.c
+        * xsmfns.c, xterm.h (x_session_have_connection):
+        * xsmfns.c (doing_interact, smc_interact_CB, Fhandle_save_session):
+        Use bool for boolean.
+        (x_session_initialize, Fhandle_save_session):
+        Prefer NILP (x) to EQ (x, Qnil).
+
 2014-12-23  Didier Verna  <didier@didierverna.net> (tiny change).
 
         * nsselect.m (Fns_selection_owner_p): Return a Lisp boolean, not a
@@ -202,6 +319,10 @@
         Call gnutls_certificate_set_x509_system_trust.  Log an error message if
         it fails.
 
+2014-12-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * regex.c (analyze_first): Rename from analyze_first.
+
 2014-12-13  Paul Eggert  <eggert@cs.ucla.edu>
 
         * alloc.c (XMALLOC_BASE_ALIGNMENT): Use max_align_t instead of
@@ -871,6 +992,8 @@
         * fileio.c (Fexpand_file_name): Use make_unibyte_string, not
         build_string, when importing a home directory.  (Bug#18873)
 
+2014-12-27  Eli Zaretskii  <eliz@gnu.org>
+
         * dispnew.c (buffer_posn_from_coords):
         Use WINDOW_WANTS_HEADER_LINE_P, not WINDOW_WANTS_MODELINE_P, to
         account for the header-line height.  (Bug#18839)
diff --git a/src/buffer.c b/src/buffer.c
index b57d968e73a..9a5c4a8824f 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -6066,9 +6066,9 @@ from happening repeatedly and making Emacs nonfunctional.  */);
                doc: /* List of functions to call after each text change.
 Three arguments are passed to each function: the positions of
 the beginning and end of the range of changed text,
-and the length in bytes of the pre-change text replaced by that range.
+and the length in chars of the pre-change text replaced by that range.
 \(For an insertion, the pre-change length is zero;
-for a deletion, that length is the number of bytes deleted,
+for a deletion, that length is the number of chars deleted,
 and the post-change beginning and end are at the same place.)
 
 Buffer changes made while executing the `after-change-functions'
diff --git a/src/callproc.c b/src/callproc.c
index a677334b3b7..f40ed3244a5 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1315,13 +1315,10 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
 
     if (STRINGP (display))
       {
-        char *vdata;
-
         if (MAX_ALLOCA - sizeof "DISPLAY=" < SBYTES (display))
           exec_failed (new_argv[0], ENOMEM);
-        vdata = alloca (sizeof "DISPLAY=" + SBYTES (display));
-        strcpy (vdata, "DISPLAY=");
-        strcat (vdata, SSDATA (display));
+        char *vdata = alloca (sizeof "DISPLAY=" + SBYTES (display));
+        lispstpcpy (stpcpy (vdata, "DISPLAY="), display);
         new_env = add_env (env, new_env, vdata);
       }
 
diff --git a/src/composite.c b/src/composite.c
index 8982c904096..0b52a9fcd2b 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1032,7 +1032,8 @@ composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos,
                 }
             }
         }
-      if (charpos == endpos)
+      if (charpos == endpos
+          && !(STRINGP (string) && endpos == SCHARS (string)))
         {
           /* We couldn't find a composition point before ENDPOS.  But,
              some character after ENDPOS may be composed with
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 4852739d8e4..983b05c4206 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -357,7 +357,7 @@ xd_signature_cat (char *signature, char const *x)
   ptrdiff_t xlen = strlen (x);
   if (DBUS_MAXIMUM_SIGNATURE_LENGTH - xlen <= siglen)
     string_overflow ();
-  strcat (signature, x);
+  strcpy (signature + siglen, x);
 }
 
 /* Compute SIGNATURE of OBJECT.  It must have a form that it can be
diff --git a/src/decompress.c b/src/decompress.c
index 24ce852245c..f86aa6facbf 100644
--- a/src/decompress.c
+++ b/src/decompress.c
@@ -31,26 +31,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static Lisp_Object Qzlib_dll;
 
 #ifdef WINDOWSNT
-#include <windows.h>
-#include "w32.h"
+# include <windows.h>
+# include "w32.h"
 
-/* Macro for defining functions that will be loaded from the zlib DLL.  */
-#define DEF_ZLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
-
-/* Macro for loading zlib functions from the library.  */
-#define LOAD_ZLIB_FN(lib,func) {                                        \
-    fn_##func = (void *) GetProcAddress (lib, #func);                   \
-    if (!fn_##func) return false;                                       \
-  }
-
-DEF_ZLIB_FN (int, inflateInit2_,
-             (z_streamp strm, int  windowBits, const char *version, int stream_size));
-
-DEF_ZLIB_FN (int, inflate,
-             (z_streamp strm, int flush));
-
-DEF_ZLIB_FN (int, inflateEnd,
-             (z_streamp strm));
+DEF_DLL_FN (int, inflateInit2_,
+            (z_streamp strm, int windowBits, const char *version,
+             int stream_size));
+DEF_DLL_FN (int, inflate, (z_streamp strm, int flush));
+DEF_DLL_FN (int, inflateEnd, (z_streamp strm));
 
 static bool zlib_initialized;
 
@@ -62,20 +50,19 @@ init_zlib_functions (void)
   if (!library)
     return false;
 
-  LOAD_ZLIB_FN (library, inflateInit2_);
-  LOAD_ZLIB_FN (library, inflate);
-  LOAD_ZLIB_FN (library, inflateEnd);
+  LOAD_DLL_FN (library, inflateInit2_);
+  LOAD_DLL_FN (library, inflate);
+  LOAD_DLL_FN (library, inflateEnd);
   return true;
 }
 
-#define fn_inflateInit2(strm, windowBits) \
-        fn_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
-
-#else /* !WINDOWSNT */
+# undef inflate
+# undef inflateEnd
+# undef inflateInit2_
 
-#define fn_inflateInit2         inflateInit2
-#define fn_inflate              inflate
-#define fn_inflateEnd           inflateEnd
+# define inflate fn_inflate
+# define inflateEnd fn_inflateEnd
+# define inflateInit2_ fn_inflateInit2_
 
 #endif  /* WINDOWSNT */
 
@@ -90,7 +77,7 @@ static void
 unwind_decompress (void *ddata)
 {
   struct decompress_unwind_data *data = ddata;
-  fn_inflateEnd (data->stream);
+  inflateEnd (data->stream);
 
   /* Delete any uncompressed data already inserted on error.  */
   if (data->start)
@@ -167,7 +154,7 @@ This function can be called only in unibyte buffers.  */)
 
   /* The magic number 32 apparently means "autodetect both the gzip and
      zlib formats" according to zlib.h.  */
-  if (fn_inflateInit2 (&stream, MAX_WBITS + 32) != Z_OK)
+  if (inflateInit2 (&stream, MAX_WBITS + 32) != Z_OK)
     return Qnil;
 
   unwind_data.start = iend;
@@ -197,7 +184,7 @@ This function can be called only in unibyte buffers.  */)
       stream.avail_in = avail_in;
       stream.next_out = GPT_ADDR;
       stream.avail_out = avail_out;
-      inflate_status = fn_inflate (&stream, Z_NO_FLUSH);
+      inflate_status = inflate (&stream, Z_NO_FLUSH);
       pos_byte += avail_in - stream.avail_in;
       decompressed = avail_out - stream.avail_out;
       insert_from_gap (decompressed, decompressed, 0);
diff --git a/src/dispextern.h b/src/dispextern.h
index 8fd3ef935f6..051629641ed 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2235,7 +2235,10 @@ struct it
   ptrdiff_t base_level_stop;
 
   /* Maximum string or buffer position + 1.  ZV when iterating over
-     current_buffer.  */
+     current_buffer.  When iterating over a string in display_string,
+     this can be smaller or greater than the number of string
+     characters, depending on the values of PRECISION and FIELD_WIDTH
+     with which display_string was called.  */
   ptrdiff_t end_charpos;
 
   /* C string to iterate over.  Non-null means get characters from
diff --git a/src/doc.c b/src/doc.c
index 1b87c23e949..1d9c330d12c 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -42,6 +42,8 @@ static ptrdiff_t get_doc_string_buffer_size;
 
 static unsigned char *read_bytecode_pointer;
 
+static char const sibling_etc[] = "../etc/";
+
 /* `readchar' in lread.c calls back here to fetch the next byte.
    If UNREADFLAG is 1, we unread a byte.  */
 
@@ -80,7 +82,6 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
 {
   char *from, *to, *name, *p, *p1;
   int fd;
-  ptrdiff_t minsize;
   int offset;
   EMACS_INT position;
   Lisp_Object file, tem, pos;
@@ -113,21 +114,14 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
 
   tem = Ffile_name_absolute_p (file);
   file = ENCODE_FILE (file);
-  if (NILP (tem))
-    {
-      Lisp_Object docdir = ENCODE_FILE (Vdoc_directory);
-      minsize = SCHARS (docdir);
-      /* sizeof ("../etc/") == 8 */
-      if (minsize < 8)
-        minsize = 8;
-      name = SAFE_ALLOCA (minsize + SCHARS (file) + 8);
-      char *z = lispstpcpy (name, docdir);
-      strcpy (z, SSDATA (file));
-    }
-  else
-    {
-      name = SSDATA (file);
-    }
+  Lisp_Object docdir
+    = NILP (tem) ? ENCODE_FILE (Vdoc_directory) : empty_unibyte_string;
+  ptrdiff_t docdir_sizemax = SBYTES (docdir) + 1;
+#ifndef CANNOT_DUMP
+  docdir_sizemax = max (docdir_sizemax, sizeof sibling_etc);
+#endif
+  name = SAFE_ALLOCA (docdir_sizemax + SBYTES (file));
+  lispstpcpy (lispstpcpy (name, docdir), file);
 
   fd = emacs_open (name, O_RDONLY, 0);
   if (fd < 0)
@@ -137,8 +131,7 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
         {
           /* Preparing to dump; DOC file is probably not installed.
              So check in ../etc.  */
-          strcpy (name, "../etc/");
-          strcat (name, SSDATA (file));
+          lispstpcpy (stpcpy (name, sibling_etc), file);
 
           fd = emacs_open (name, O_RDONLY, 0);
         }
@@ -580,7 +573,6 @@ the same file name is found in the `doc-directory'.  */)
       (0)
 #endif /* CANNOT_DUMP */
     {
-      static char const sibling_etc[] = "../etc/";
       dirname = sibling_etc;
       dirlen = sizeof sibling_etc - 1;
     }
@@ -594,8 +586,7 @@ the same file name is found in the `doc-directory'.  */)
   count = SPECPDL_INDEX ();
   USE_SAFE_ALLOCA;
   name = SAFE_ALLOCA (dirlen + SBYTES (filename) + 1);
-  strcpy (name, dirname);
-  strcat (name, SSDATA (filename));     /*** Add this line ***/
+  lispstpcpy (stpcpy (name, dirname), filename);        /*** Add this line ***/
 
   /* Vbuild_files is nil when temacs is run, and non-nil after that.  */
   if (NILP (Vbuild_files))
diff --git a/src/editfns.c b/src/editfns.c
index 0a07886934c..430c4c91fb3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1350,10 +1350,9 @@ name, or nil if there is no such user.  */)
       USE_SAFE_ALLOCA;
       char *r = SAFE_ALLOCA (strlen (p) + SBYTES (login) + 1);
       memcpy (r, p, q - p);
-      r[q - p] = 0;
-      strcat (r, SSDATA (login));
+      char *s = lispstpcpy (&r[q - p], login);
       r[q - p] = upcase ((unsigned char) r[q - p]);
-      strcat (r, q + 1);
+      strcpy (s, q + 1);
       full = build_string (r);
       SAFE_FREE ();
     }
diff --git a/src/frame.c b/src/frame.c
index 31273665e88..2ad1c1b52b7 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -4076,23 +4076,23 @@ xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Li
 
   /* Start with emacs.FRAMENAME for the name (the specific one)
      and with `Emacs' for the class key (the general one).  */
-  lispstpcpy (name_key, Vx_resource_name);
-  lispstpcpy (class_key, Vx_resource_class);
+  char *nz = lispstpcpy (name_key, Vx_resource_name);
+  char *cz = lispstpcpy (class_key, Vx_resource_class);
 
-  strcat (class_key, ".");
-  strcat (class_key, SSDATA (class));
+  *cz++ = '.';
+  cz = lispstpcpy (cz, class);
 
   if (!NILP (component))
     {
-      strcat (class_key, ".");
-      strcat (class_key, SSDATA (subclass));
+      *cz++ = '.';
+      lispstpcpy (cz, subclass);
 
-      strcat (name_key, ".");
-      strcat (name_key, SSDATA (component));
+      *nz++ = '.';
+      nz = lispstpcpy (nz, component);
     }
 
-  strcat (name_key, ".");
-  strcat (name_key, SSDATA (attribute));
+  *nz++ = '.';
+  lispstpcpy (nz, attribute);
 
   char *value = x_get_string_resource (rdb, name_key, class_key);
   SAFE_FREE();
diff --git a/src/gnutls.c b/src/gnutls.c
index bf9f1323546..f945778cc91 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -71,142 +71,129 @@ enum extra_peer_verification
 
 #ifdef WINDOWSNT
 
-/* Macro for defining functions that will be loaded from the GnuTLS DLL.  */
-#define DEF_GNUTLS_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
-
-/* Macro for loading GnuTLS functions from the library.  */
-#define LOAD_GNUTLS_FN(lib,func) {                                      \
-    fn_##func = (void *) GetProcAddress (lib, #func);                   \
-    if (!fn_##func) return 0;                                           \
-  }
-
-DEF_GNUTLS_FN (gnutls_alert_description_t, gnutls_alert_get,
-               (gnutls_session_t));
-DEF_GNUTLS_FN (const char *, gnutls_alert_get_name,
-               (gnutls_alert_description_t));
-DEF_GNUTLS_FN (int, gnutls_alert_send_appropriate, (gnutls_session_t, int));
-DEF_GNUTLS_FN (int, gnutls_anon_allocate_client_credentials,
-               (gnutls_anon_client_credentials_t *));
-DEF_GNUTLS_FN (void, gnutls_anon_free_client_credentials,
-               (gnutls_anon_client_credentials_t));
-DEF_GNUTLS_FN (int, gnutls_bye, (gnutls_session_t, gnutls_close_request_t));
-DEF_GNUTLS_FN (int, gnutls_certificate_allocate_credentials,
-               (gnutls_certificate_credentials_t *));
-DEF_GNUTLS_FN (void, gnutls_certificate_free_credentials,
-               (gnutls_certificate_credentials_t));
-DEF_GNUTLS_FN (const gnutls_datum_t *, gnutls_certificate_get_peers,
-               (gnutls_session_t, unsigned int *));
-DEF_GNUTLS_FN (void, gnutls_certificate_set_verify_flags,
-               (gnutls_certificate_credentials_t, unsigned int));
-DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_crl_file,
-               (gnutls_certificate_credentials_t, const char *,
-                gnutls_x509_crt_fmt_t));
-DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_key_file,
-               (gnutls_certificate_credentials_t, const char *, const char *,
-                gnutls_x509_crt_fmt_t));
-#if GNUTLS_VERSION_MAJOR +                                      \
-  (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20) > 3
-DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_system_trust,
-               (gnutls_certificate_credentials_t));
-#endif
-DEF_GNUTLS_FN (int, gnutls_certificate_set_x509_trust_file,
-               (gnutls_certificate_credentials_t, const char *,
-                gnutls_x509_crt_fmt_t));
-DEF_GNUTLS_FN (gnutls_certificate_type_t, gnutls_certificate_type_get,
-               (gnutls_session_t));
-DEF_GNUTLS_FN (int, gnutls_certificate_verify_peers2,
-               (gnutls_session_t, unsigned int *));
-DEF_GNUTLS_FN (int, gnutls_credentials_set,
-               (gnutls_session_t, gnutls_credentials_type_t, void *));
-DEF_GNUTLS_FN (void, gnutls_deinit, (gnutls_session_t));
-DEF_GNUTLS_FN (void, gnutls_dh_set_prime_bits,
-               (gnutls_session_t, unsigned int));
-DEF_GNUTLS_FN (int, gnutls_dh_get_prime_bits, (gnutls_session_t));
-DEF_GNUTLS_FN (int, gnutls_error_is_fatal, (int));
-DEF_GNUTLS_FN (int, gnutls_global_init, (void));
-DEF_GNUTLS_FN (void, gnutls_global_set_log_function, (gnutls_log_func));
-#ifdef HAVE_GNUTLS3
-DEF_GNUTLS_FN (void, gnutls_global_set_audit_log_function, (gnutls_audit_log_func));
-#endif
-DEF_GNUTLS_FN (void, gnutls_global_set_log_level, (int));
-DEF_GNUTLS_FN (void, gnutls_global_set_mem_functions,
-               (gnutls_alloc_function, gnutls_alloc_function,
-                gnutls_is_secure_function, gnutls_realloc_function,
-                gnutls_free_function));
-DEF_GNUTLS_FN (int, gnutls_handshake, (gnutls_session_t));
-DEF_GNUTLS_FN (int, gnutls_init, (gnutls_session_t *, gnutls_connection_end_t));
-DEF_GNUTLS_FN (int, gnutls_priority_set_direct,
-               (gnutls_session_t, const char *, const char **));
-DEF_GNUTLS_FN (size_t, gnutls_record_check_pending, (gnutls_session_t));
-DEF_GNUTLS_FN (ssize_t, gnutls_record_recv, (gnutls_session_t, void *, size_t));
-DEF_GNUTLS_FN (ssize_t, gnutls_record_send,
-               (gnutls_session_t, const void *, size_t));
-DEF_GNUTLS_FN (const char *, gnutls_strerror, (int));
-DEF_GNUTLS_FN (void, gnutls_transport_set_errno, (gnutls_session_t, int));
-DEF_GNUTLS_FN (const char *, gnutls_check_version, (const char *));
-DEF_GNUTLS_FN (void, gnutls_transport_set_lowat, (gnutls_session_t, int));
-DEF_GNUTLS_FN (void, gnutls_transport_set_ptr2,
-               (gnutls_session_t, gnutls_transport_ptr_t,
-                gnutls_transport_ptr_t));
-DEF_GNUTLS_FN (void, gnutls_transport_set_pull_function,
-               (gnutls_session_t, gnutls_pull_func));
-DEF_GNUTLS_FN (void, gnutls_transport_set_push_function,
-               (gnutls_session_t, gnutls_push_func));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_check_hostname,
-               (gnutls_x509_crt_t, const char *));
-DEF_GNUTLS_FN (void, gnutls_x509_crt_deinit, (gnutls_x509_crt_t));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_import,
-               (gnutls_x509_crt_t, const gnutls_datum_t *,
-                gnutls_x509_crt_fmt_t));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_init, (gnutls_x509_crt_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_fingerprint,
-               (gnutls_x509_crt_t,
-                gnutls_digest_algorithm_t, void *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_version,
-               (gnutls_x509_crt_t));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_serial,
-               (gnutls_x509_crt_t, void *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_issuer_dn,
-               (gnutls_x509_crt_t, char *, size_t *));
-DEF_GNUTLS_FN (time_t, gnutls_x509_crt_get_activation_time,
-               (gnutls_x509_crt_t));
-DEF_GNUTLS_FN (time_t, gnutls_x509_crt_get_expiration_time,
-               (gnutls_x509_crt_t));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_dn,
-               (gnutls_x509_crt_t, char *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_pk_algorithm,
-               (gnutls_x509_crt_t, unsigned int *));
-DEF_GNUTLS_FN (const char*, gnutls_pk_algorithm_get_name,
-               (gnutls_pk_algorithm_t));
-DEF_GNUTLS_FN (int, gnutls_pk_bits_to_sec_param,
-               (gnutls_pk_algorithm_t, unsigned int));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_issuer_unique_id,
-               (gnutls_x509_crt_t, char *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_subject_unique_id,
-               (gnutls_x509_crt_t, char *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_signature_algorithm,
-               (gnutls_x509_crt_t));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_signature,
-               (gnutls_x509_crt_t, char *, size_t *));
-DEF_GNUTLS_FN (int, gnutls_x509_crt_get_key_id,
-               (gnutls_x509_crt_t, unsigned int,
-                unsigned char *, size_t *_size));
-DEF_GNUTLS_FN (const char*, gnutls_sec_param_get_name, (gnutls_sec_param_t));
-DEF_GNUTLS_FN (const char*, gnutls_sign_get_name, (gnutls_sign_algorithm_t));
-DEF_GNUTLS_FN (int, gnutls_server_name_set, (gnutls_session_t,
-                                             gnutls_server_name_type_t,
-                                             const void *, size_t));
-DEF_GNUTLS_FN (gnutls_kx_algorithm_t, gnutls_kx_get, (gnutls_session_t));
-DEF_GNUTLS_FN (const char*, gnutls_kx_get_name, (gnutls_kx_algorithm_t));
-DEF_GNUTLS_FN (gnutls_protocol_t, gnutls_protocol_get_version,
-               (gnutls_session_t));
-DEF_GNUTLS_FN (const char*, gnutls_protocol_get_name, (gnutls_protocol_t));
-DEF_GNUTLS_FN (gnutls_cipher_algorithm_t, gnutls_cipher_get,
-               (gnutls_session_t));
-DEF_GNUTLS_FN (const char*, gnutls_cipher_get_name,
-               (gnutls_cipher_algorithm_t));
-DEF_GNUTLS_FN (gnutls_mac_algorithm_t, gnutls_mac_get, (gnutls_session_t));
-DEF_GNUTLS_FN (const char*, gnutls_mac_get_name, (gnutls_mac_algorithm_t));
+DEF_DLL_FN (gnutls_alert_description_t, gnutls_alert_get,
+            (gnutls_session_t));
+DEF_DLL_FN (const char *, gnutls_alert_get_name,
+            (gnutls_alert_description_t));
+DEF_DLL_FN (int, gnutls_alert_send_appropriate, (gnutls_session_t, int));
+DEF_DLL_FN (int, gnutls_anon_allocate_client_credentials,
+            (gnutls_anon_client_credentials_t *));
+DEF_DLL_FN (void, gnutls_anon_free_client_credentials,
+            (gnutls_anon_client_credentials_t));
+DEF_DLL_FN (int, gnutls_bye, (gnutls_session_t, gnutls_close_request_t));
+DEF_DLL_FN (int, gnutls_certificate_allocate_credentials,
+            (gnutls_certificate_credentials_t *));
+DEF_DLL_FN (void, gnutls_certificate_free_credentials,
+            (gnutls_certificate_credentials_t));
+DEF_DLL_FN (const gnutls_datum_t *, gnutls_certificate_get_peers,
+            (gnutls_session_t, unsigned int *));
+DEF_DLL_FN (void, gnutls_certificate_set_verify_flags,
+            (gnutls_certificate_credentials_t, unsigned int));
+DEF_DLL_FN (int, gnutls_certificate_set_x509_crl_file,
+            (gnutls_certificate_credentials_t, const char *,
+             gnutls_x509_crt_fmt_t));
+DEF_DLL_FN (int, gnutls_certificate_set_x509_key_file,
+            (gnutls_certificate_credentials_t, const char *, const char *,
+             gnutls_x509_crt_fmt_t));
+# if ((GNUTLS_VERSION_MAJOR                                             \
+       + (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20))      \
+      > 3)
+DEF_DLL_FN (int, gnutls_certificate_set_x509_system_trust,
+            (gnutls_certificate_credentials_t));
+# endif
+DEF_DLL_FN (int, gnutls_certificate_set_x509_trust_file,
+            (gnutls_certificate_credentials_t, const char *,
+             gnutls_x509_crt_fmt_t));
+DEF_DLL_FN (gnutls_certificate_type_t, gnutls_certificate_type_get,
+            (gnutls_session_t));
+DEF_DLL_FN (int, gnutls_certificate_verify_peers2,
+            (gnutls_session_t, unsigned int *));
+DEF_DLL_FN (int, gnutls_credentials_set,
+            (gnutls_session_t, gnutls_credentials_type_t, void *));
+DEF_DLL_FN (void, gnutls_deinit, (gnutls_session_t));
+DEF_DLL_FN (void, gnutls_dh_set_prime_bits,
+            (gnutls_session_t, unsigned int));
+DEF_DLL_FN (int, gnutls_dh_get_prime_bits, (gnutls_session_t));
+DEF_DLL_FN (int, gnutls_error_is_fatal, (int));
+DEF_DLL_FN (int, gnutls_global_init, (void));
+DEF_DLL_FN (void, gnutls_global_set_log_function, (gnutls_log_func));
+# ifdef HAVE_GNUTLS3
+DEF_DLL_FN (void, gnutls_global_set_audit_log_function, (gnutls_audit_log_func));
+# endif
+DEF_DLL_FN (void, gnutls_global_set_log_level, (int));
+DEF_DLL_FN (int, gnutls_handshake, (gnutls_session_t));
+DEF_DLL_FN (int, gnutls_init, (gnutls_session_t *, unsigned int));
+DEF_DLL_FN (int, gnutls_priority_set_direct,
+            (gnutls_session_t, const char *, const char **));
+DEF_DLL_FN (size_t, gnutls_record_check_pending, (gnutls_session_t));
+DEF_DLL_FN (ssize_t, gnutls_record_recv, (gnutls_session_t, void *, size_t));
+DEF_DLL_FN (ssize_t, gnutls_record_send,
+            (gnutls_session_t, const void *, size_t));
+DEF_DLL_FN (const char *, gnutls_strerror, (int));
+DEF_DLL_FN (void, gnutls_transport_set_errno, (gnutls_session_t, int));
+DEF_DLL_FN (const char *, gnutls_check_version, (const char *));
+DEF_DLL_FN (void, gnutls_transport_set_lowat, (gnutls_session_t, int));
+DEF_DLL_FN (void, gnutls_transport_set_ptr2,
+            (gnutls_session_t, gnutls_transport_ptr_t,
+             gnutls_transport_ptr_t));
+DEF_DLL_FN (void, gnutls_transport_set_pull_function,
+            (gnutls_session_t, gnutls_pull_func));
+DEF_DLL_FN (void, gnutls_transport_set_push_function,
+            (gnutls_session_t, gnutls_push_func));
+DEF_DLL_FN (int, gnutls_x509_crt_check_hostname,
+            (gnutls_x509_crt_t, const char *));
+DEF_DLL_FN (void, gnutls_x509_crt_deinit, (gnutls_x509_crt_t));
+DEF_DLL_FN (int, gnutls_x509_crt_import,
+            (gnutls_x509_crt_t, const gnutls_datum_t *,
+             gnutls_x509_crt_fmt_t));
+DEF_DLL_FN (int, gnutls_x509_crt_init, (gnutls_x509_crt_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_fingerprint,
+            (gnutls_x509_crt_t,
+             gnutls_digest_algorithm_t, void *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_version,
+            (gnutls_x509_crt_t));
+DEF_DLL_FN (int, gnutls_x509_crt_get_serial,
+            (gnutls_x509_crt_t, void *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_issuer_dn,
+            (gnutls_x509_crt_t, char *, size_t *));
+DEF_DLL_FN (time_t, gnutls_x509_crt_get_activation_time,
+            (gnutls_x509_crt_t));
+DEF_DLL_FN (time_t, gnutls_x509_crt_get_expiration_time,
+            (gnutls_x509_crt_t));
+DEF_DLL_FN (int, gnutls_x509_crt_get_dn,
+            (gnutls_x509_crt_t, char *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_pk_algorithm,
+            (gnutls_x509_crt_t, unsigned int *));
+DEF_DLL_FN (const char*, gnutls_pk_algorithm_get_name,
+            (gnutls_pk_algorithm_t));
+DEF_DLL_FN (int, gnutls_pk_bits_to_sec_param,
+            (gnutls_pk_algorithm_t, unsigned int));
+DEF_DLL_FN (int, gnutls_x509_crt_get_issuer_unique_id,
+            (gnutls_x509_crt_t, char *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_subject_unique_id,
+            (gnutls_x509_crt_t, char *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_signature_algorithm,
+            (gnutls_x509_crt_t));
+DEF_DLL_FN (int, gnutls_x509_crt_get_signature,
+            (gnutls_x509_crt_t, char *, size_t *));
+DEF_DLL_FN (int, gnutls_x509_crt_get_key_id,
+            (gnutls_x509_crt_t, unsigned int, unsigned char *, size_t *_size));
+DEF_DLL_FN (const char*, gnutls_sec_param_get_name, (gnutls_sec_param_t));
+DEF_DLL_FN (const char*, gnutls_sign_get_name, (gnutls_sign_algorithm_t));
+DEF_DLL_FN (int, gnutls_server_name_set,
+            (gnutls_session_t, gnutls_server_name_type_t,
+             const void *, size_t));
+DEF_DLL_FN (gnutls_kx_algorithm_t, gnutls_kx_get, (gnutls_session_t));
+DEF_DLL_FN (const char*, gnutls_kx_get_name, (gnutls_kx_algorithm_t));
+DEF_DLL_FN (gnutls_protocol_t, gnutls_protocol_get_version,
+            (gnutls_session_t));
+DEF_DLL_FN (const char*, gnutls_protocol_get_name, (gnutls_protocol_t));
+DEF_DLL_FN (gnutls_cipher_algorithm_t, gnutls_cipher_get,
+            (gnutls_session_t));
+DEF_DLL_FN (const char*, gnutls_cipher_get_name,
+            (gnutls_cipher_algorithm_t));
+DEF_DLL_FN (gnutls_mac_algorithm_t, gnutls_mac_get, (gnutls_session_t));
+DEF_DLL_FN (const char*, gnutls_mac_get_name, (gnutls_mac_algorithm_t));
 
 
 static bool
@@ -221,83 +208,83 @@ init_gnutls_functions (void)
       return 0;
     }
 
-  LOAD_GNUTLS_FN (library, gnutls_alert_get);
-  LOAD_GNUTLS_FN (library, gnutls_alert_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_alert_send_appropriate);
-  LOAD_GNUTLS_FN (library, gnutls_anon_allocate_client_credentials);
-  LOAD_GNUTLS_FN (library, gnutls_anon_free_client_credentials);
-  LOAD_GNUTLS_FN (library, gnutls_bye);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_allocate_credentials);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_free_credentials);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_get_peers);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_set_verify_flags);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_set_x509_crl_file);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_set_x509_key_file);
-#if GNUTLS_VERSION_MAJOR +                                      \
-  (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20) > 3
-  LOAD_GNUTLS_FN (library, gnutls_certificate_set_x509_system_trust);
-#endif
-  LOAD_GNUTLS_FN (library, gnutls_certificate_set_x509_trust_file);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_type_get);
-  LOAD_GNUTLS_FN (library, gnutls_certificate_verify_peers2);
-  LOAD_GNUTLS_FN (library, gnutls_credentials_set);
-  LOAD_GNUTLS_FN (library, gnutls_deinit);
-  LOAD_GNUTLS_FN (library, gnutls_dh_set_prime_bits);
-  LOAD_GNUTLS_FN (library, gnutls_dh_get_prime_bits);
-  LOAD_GNUTLS_FN (library, gnutls_error_is_fatal);
-  LOAD_GNUTLS_FN (library, gnutls_global_init);
-  LOAD_GNUTLS_FN (library, gnutls_global_set_log_function);
-#ifdef HAVE_GNUTLS3
-  LOAD_GNUTLS_FN (library, gnutls_global_set_audit_log_function);
-#endif
-  LOAD_GNUTLS_FN (library, gnutls_global_set_log_level);
-  LOAD_GNUTLS_FN (library, gnutls_global_set_mem_functions);
-  LOAD_GNUTLS_FN (library, gnutls_handshake);
-  LOAD_GNUTLS_FN (library, gnutls_init);
-  LOAD_GNUTLS_FN (library, gnutls_priority_set_direct);
-  LOAD_GNUTLS_FN (library, gnutls_record_check_pending);
-  LOAD_GNUTLS_FN (library, gnutls_record_recv);
-  LOAD_GNUTLS_FN (library, gnutls_record_send);
-  LOAD_GNUTLS_FN (library, gnutls_strerror);
-  LOAD_GNUTLS_FN (library, gnutls_transport_set_errno);
-  LOAD_GNUTLS_FN (library, gnutls_check_version);
+  LOAD_DLL_FN (library, gnutls_alert_get);
+  LOAD_DLL_FN (library, gnutls_alert_get_name);
+  LOAD_DLL_FN (library, gnutls_alert_send_appropriate);
+  LOAD_DLL_FN (library, gnutls_anon_allocate_client_credentials);
+  LOAD_DLL_FN (library, gnutls_anon_free_client_credentials);
+  LOAD_DLL_FN (library, gnutls_bye);
+  LOAD_DLL_FN (library, gnutls_certificate_allocate_credentials);
+  LOAD_DLL_FN (library, gnutls_certificate_free_credentials);
+  LOAD_DLL_FN (library, gnutls_certificate_get_peers);
+  LOAD_DLL_FN (library, gnutls_certificate_set_verify_flags);
+  LOAD_DLL_FN (library, gnutls_certificate_set_x509_crl_file);
+  LOAD_DLL_FN (library, gnutls_certificate_set_x509_key_file);
+# if ((GNUTLS_VERSION_MAJOR                                             \
+       + (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20))      \
+      > 3)
+  LOAD_DLL_FN (library, gnutls_certificate_set_x509_system_trust);
+# endif
+  LOAD_DLL_FN (library, gnutls_certificate_set_x509_trust_file);
+  LOAD_DLL_FN (library, gnutls_certificate_type_get);
+  LOAD_DLL_FN (library, gnutls_certificate_verify_peers2);
+  LOAD_DLL_FN (library, gnutls_credentials_set);
+  LOAD_DLL_FN (library, gnutls_deinit);
+  LOAD_DLL_FN (library, gnutls_dh_set_prime_bits);
+  LOAD_DLL_FN (library, gnutls_dh_get_prime_bits);
+  LOAD_DLL_FN (library, gnutls_error_is_fatal);
+  LOAD_DLL_FN (library, gnutls_global_init);
+  LOAD_DLL_FN (library, gnutls_global_set_log_function);
+# ifdef HAVE_GNUTLS3
+  LOAD_DLL_FN (library, gnutls_global_set_audit_log_function);
+# endif
+  LOAD_DLL_FN (library, gnutls_global_set_log_level);
+  LOAD_DLL_FN (library, gnutls_handshake);
+  LOAD_DLL_FN (library, gnutls_init);
+  LOAD_DLL_FN (library, gnutls_priority_set_direct);
+  LOAD_DLL_FN (library, gnutls_record_check_pending);
+  LOAD_DLL_FN (library, gnutls_record_recv);
+  LOAD_DLL_FN (library, gnutls_record_send);
+  LOAD_DLL_FN (library, gnutls_strerror);
+  LOAD_DLL_FN (library, gnutls_transport_set_errno);
+  LOAD_DLL_FN (library, gnutls_check_version);
   /* We don't need to call gnutls_transport_set_lowat in GnuTLS 2.11.1
      and later, and the function was removed entirely in 3.0.0.  */
   if (!fn_gnutls_check_version ("2.11.1"))
-    LOAD_GNUTLS_FN (library, gnutls_transport_set_lowat);
-  LOAD_GNUTLS_FN (library, gnutls_transport_set_ptr2);
-  LOAD_GNUTLS_FN (library, gnutls_transport_set_pull_function);
-  LOAD_GNUTLS_FN (library, gnutls_transport_set_push_function);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_check_hostname);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_deinit);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_import);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_init);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_fingerprint);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_version);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_serial);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_issuer_dn);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_activation_time);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_expiration_time);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_dn);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_pk_algorithm);
-  LOAD_GNUTLS_FN (library, gnutls_pk_algorithm_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_pk_bits_to_sec_param);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_issuer_unique_id);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_subject_unique_id);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_signature_algorithm);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_signature);
-  LOAD_GNUTLS_FN (library, gnutls_x509_crt_get_key_id);
-  LOAD_GNUTLS_FN (library, gnutls_sec_param_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_sign_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_server_name_set);
-  LOAD_GNUTLS_FN (library, gnutls_kx_get);
-  LOAD_GNUTLS_FN (library, gnutls_kx_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_protocol_get_version);
-  LOAD_GNUTLS_FN (library, gnutls_protocol_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_cipher_get);
-  LOAD_GNUTLS_FN (library, gnutls_cipher_get_name);
-  LOAD_GNUTLS_FN (library, gnutls_mac_get);
-  LOAD_GNUTLS_FN (library, gnutls_mac_get_name);
+    LOAD_DLL_FN (library, gnutls_transport_set_lowat);
+  LOAD_DLL_FN (library, gnutls_transport_set_ptr2);
+  LOAD_DLL_FN (library, gnutls_transport_set_pull_function);
+  LOAD_DLL_FN (library, gnutls_transport_set_push_function);
+  LOAD_DLL_FN (library, gnutls_x509_crt_check_hostname);
+  LOAD_DLL_FN (library, gnutls_x509_crt_deinit);
+  LOAD_DLL_FN (library, gnutls_x509_crt_import);
+  LOAD_DLL_FN (library, gnutls_x509_crt_init);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_fingerprint);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_version);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_serial);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_issuer_dn);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_activation_time);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_expiration_time);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_dn);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_pk_algorithm);
+  LOAD_DLL_FN (library, gnutls_pk_algorithm_get_name);
+  LOAD_DLL_FN (library, gnutls_pk_bits_to_sec_param);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_issuer_unique_id);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_subject_unique_id);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_signature_algorithm);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_signature);
+  LOAD_DLL_FN (library, gnutls_x509_crt_get_key_id);
+  LOAD_DLL_FN (library, gnutls_sec_param_get_name);
+  LOAD_DLL_FN (library, gnutls_sign_get_name);
+  LOAD_DLL_FN (library, gnutls_server_name_set);
+  LOAD_DLL_FN (library, gnutls_kx_get);
+  LOAD_DLL_FN (library, gnutls_kx_get_name);
+  LOAD_DLL_FN (library, gnutls_protocol_get_version);
+  LOAD_DLL_FN (library, gnutls_protocol_get_name);
+  LOAD_DLL_FN (library, gnutls_cipher_get);
+  LOAD_DLL_FN (library, gnutls_cipher_get_name);
+  LOAD_DLL_FN (library, gnutls_mac_get);
+  LOAD_DLL_FN (library, gnutls_mac_get_name);
 
   max_log_level = global_gnutls_log_level;
 
@@ -310,80 +297,89 @@ init_gnutls_functions (void)
   return 1;
 }
 
-#else /* !WINDOWSNT */
-
-#define fn_gnutls_alert_get                     gnutls_alert_get
-#define fn_gnutls_alert_get_name                gnutls_alert_get_name
-#define fn_gnutls_alert_send_appropriate        gnutls_alert_send_appropriate
-#define fn_gnutls_anon_allocate_client_credentials gnutls_anon_allocate_client_credentials
-#define fn_gnutls_anon_free_client_credentials  gnutls_anon_free_client_credentials
-#define fn_gnutls_bye                           gnutls_bye
-#define fn_gnutls_certificate_allocate_credentials gnutls_certificate_allocate_credentials
-#define fn_gnutls_certificate_free_credentials  gnutls_certificate_free_credentials
-#define fn_gnutls_certificate_get_peers         gnutls_certificate_get_peers
-#define fn_gnutls_certificate_set_verify_flags  gnutls_certificate_set_verify_flags
-#define fn_gnutls_certificate_set_x509_crl_file gnutls_certificate_set_x509_crl_file
-#define fn_gnutls_certificate_set_x509_key_file gnutls_certificate_set_x509_key_file
-#if GNUTLS_VERSION_MAJOR +                                      \
-  (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20) > 3
-#define fn_gnutls_certificate_set_x509_system_trust gnutls_certificate_set_x509_system_trust
-#endif
-#define fn_gnutls_certificate_set_x509_trust_file gnutls_certificate_set_x509_trust_file
-#define fn_gnutls_certificate_type_get          gnutls_certificate_type_get
-#define fn_gnutls_certificate_verify_peers2     gnutls_certificate_verify_peers2
-#define fn_gnutls_cipher_get                    gnutls_cipher_get
-#define fn_gnutls_cipher_get_name               gnutls_cipher_get_name
-#define fn_gnutls_credentials_set               gnutls_credentials_set
-#define fn_gnutls_deinit                        gnutls_deinit
-#define fn_gnutls_dh_get_prime_bits             gnutls_dh_get_prime_bits
-#define fn_gnutls_dh_set_prime_bits             gnutls_dh_set_prime_bits
-#define fn_gnutls_error_is_fatal                gnutls_error_is_fatal
-#define fn_gnutls_global_init                   gnutls_global_init
-#ifdef HAVE_GNUTLS3
-#define fn_gnutls_global_set_audit_log_function gnutls_global_set_audit_log_function
+# define gnutls_alert_get fn_gnutls_alert_get
+# define gnutls_alert_get_name fn_gnutls_alert_get_name
+# define gnutls_alert_send_appropriate fn_gnutls_alert_send_appropriate
+# define gnutls_anon_allocate_client_credentials fn_gnutls_anon_allocate_client_credentials
+# define gnutls_anon_free_client_credentials fn_gnutls_anon_free_client_credentials
+# define gnutls_bye fn_gnutls_bye
+# define gnutls_certificate_allocate_credentials fn_gnutls_certificate_allocate_credentials
+# define gnutls_certificate_free_credentials fn_gnutls_certificate_free_credentials
+# define gnutls_certificate_get_peers fn_gnutls_certificate_get_peers
+# define gnutls_certificate_set_verify_flags fn_gnutls_certificate_set_verify_flags
+# define gnutls_certificate_set_x509_crl_file fn_gnutls_certificate_set_x509_crl_file
+# define gnutls_certificate_set_x509_key_file fn_gnutls_certificate_set_x509_key_file
+# define gnutls_certificate_set_x509_system_trust fn_gnutls_certificate_set_x509_system_trust
+# define gnutls_certificate_set_x509_trust_file fn_gnutls_certificate_set_x509_trust_file
+# define gnutls_certificate_type_get fn_gnutls_certificate_type_get
+# define gnutls_certificate_verify_peers2 fn_gnutls_certificate_verify_peers2
+# define gnutls_check_version fn_gnutls_check_version
+# define gnutls_cipher_get fn_gnutls_cipher_get
+# define gnutls_cipher_get_name fn_gnutls_cipher_get_name
+# define gnutls_credentials_set fn_gnutls_credentials_set
+# define gnutls_deinit fn_gnutls_deinit
+# define gnutls_dh_get_prime_bits fn_gnutls_dh_get_prime_bits
+# define gnutls_dh_set_prime_bits fn_gnutls_dh_set_prime_bits
+# define gnutls_error_is_fatal fn_gnutls_error_is_fatal
+# define gnutls_global_init fn_gnutls_global_init
+# define gnutls_global_set_audit_log_function fn_gnutls_global_set_audit_log_function
+# define gnutls_global_set_log_function fn_gnutls_global_set_log_function
+# define gnutls_global_set_log_level fn_gnutls_global_set_log_level
+# define gnutls_handshake fn_gnutls_handshake
+# define gnutls_init fn_gnutls_init
+# define gnutls_kx_get fn_gnutls_kx_get
+# define gnutls_kx_get_name fn_gnutls_kx_get_name
+# define gnutls_mac_get fn_gnutls_mac_get
+# define gnutls_mac_get_name fn_gnutls_mac_get_name
+# define gnutls_pk_algorithm_get_name fn_gnutls_pk_algorithm_get_name
+# define gnutls_pk_bits_to_sec_param fn_gnutls_pk_bits_to_sec_param
+# define gnutls_priority_set_direct fn_gnutls_priority_set_direct
+# define gnutls_protocol_get_name fn_gnutls_protocol_get_name
+# define gnutls_protocol_get_version fn_gnutls_protocol_get_version
+# define gnutls_record_check_pending fn_gnutls_record_check_pending
+# define gnutls_record_recv fn_gnutls_record_recv
+# define gnutls_record_send fn_gnutls_record_send
+# define gnutls_sec_param_get_name fn_gnutls_sec_param_get_name
+# define gnutls_server_name_set fn_gnutls_server_name_set
+# define gnutls_sign_get_name fn_gnutls_sign_get_name
+# define gnutls_strerror fn_gnutls_strerror
+# define gnutls_transport_set_errno fn_gnutls_transport_set_errno
+# define gnutls_transport_set_lowat fn_gnutls_transport_set_lowat
+# define gnutls_transport_set_ptr2 fn_gnutls_transport_set_ptr2
+# define gnutls_transport_set_pull_function fn_gnutls_transport_set_pull_function
+# define gnutls_transport_set_push_function fn_gnutls_transport_set_push_function
+# define gnutls_x509_crt_check_hostname fn_gnutls_x509_crt_check_hostname
+# define gnutls_x509_crt_deinit fn_gnutls_x509_crt_deinit
+# define gnutls_x509_crt_get_activation_time fn_gnutls_x509_crt_get_activation_time
+# define gnutls_x509_crt_get_dn fn_gnutls_x509_crt_get_dn
+# define gnutls_x509_crt_get_expiration_time fn_gnutls_x509_crt_get_expiration_time
+# define gnutls_x509_crt_get_fingerprint fn_gnutls_x509_crt_get_fingerprint
+# define gnutls_x509_crt_get_issuer_dn fn_gnutls_x509_crt_get_issuer_dn
+# define gnutls_x509_crt_get_issuer_unique_id fn_gnutls_x509_crt_get_issuer_unique_id
+# define gnutls_x509_crt_get_key_id fn_gnutls_x509_crt_get_key_id
+# define gnutls_x509_crt_get_pk_algorithm fn_gnutls_x509_crt_get_pk_algorithm
+# define gnutls_x509_crt_get_serial fn_gnutls_x509_crt_get_serial
+# define gnutls_x509_crt_get_signature fn_gnutls_x509_crt_get_signature
+# define gnutls_x509_crt_get_signature_algorithm fn_gnutls_x509_crt_get_signature_algorithm
+# define gnutls_x509_crt_get_subject_unique_id fn_gnutls_x509_crt_get_subject_unique_id
+# define gnutls_x509_crt_get_version fn_gnutls_x509_crt_get_version
+# define gnutls_x509_crt_import fn_gnutls_x509_crt_import
+# define gnutls_x509_crt_init fn_gnutls_x509_crt_init
+
 #endif
-#define fn_gnutls_global_set_log_function       gnutls_global_set_log_function
-#define fn_gnutls_global_set_log_level          gnutls_global_set_log_level
-#define fn_gnutls_global_set_mem_functions      gnutls_global_set_mem_functions
-#define fn_gnutls_handshake                     gnutls_handshake
-#define fn_gnutls_init                          gnutls_init
-#define fn_gnutls_kx_get                        gnutls_kx_get
-#define fn_gnutls_kx_get_name                   gnutls_kx_get_name
-#define fn_gnutls_mac_get                       gnutls_mac_get
-#define fn_gnutls_mac_get_name                  gnutls_mac_get_name
-#define fn_gnutls_pk_algorithm_get_name         gnutls_pk_algorithm_get_name
-#define fn_gnutls_pk_bits_to_sec_param          gnutls_pk_bits_to_sec_param
-#define fn_gnutls_priority_set_direct           gnutls_priority_set_direct
-#define fn_gnutls_protocol_get_name             gnutls_protocol_get_name
-#define fn_gnutls_protocol_get_version          gnutls_protocol_get_version
-#define fn_gnutls_record_check_pending          gnutls_record_check_pending
-#define fn_gnutls_record_recv                   gnutls_record_recv
-#define fn_gnutls_record_send                   gnutls_record_send
-#define fn_gnutls_sec_param_get_name            gnutls_sec_param_get_name
-#define fn_gnutls_server_name_set               gnutls_server_name_set
-#define fn_gnutls_sign_get_name                 gnutls_sign_get_name
-#define fn_gnutls_strerror                      gnutls_strerror
-#define fn_gnutls_transport_set_ptr2            gnutls_transport_set_ptr2
-#define fn_gnutls_x509_crt_check_hostname       gnutls_x509_crt_check_hostname
-#define fn_gnutls_x509_crt_deinit               gnutls_x509_crt_deinit
-#define fn_gnutls_x509_crt_get_activation_time  gnutls_x509_crt_get_activation_time
-#define fn_gnutls_x509_crt_get_dn               gnutls_x509_crt_get_dn
-#define fn_gnutls_x509_crt_get_expiration_time  gnutls_x509_crt_get_expiration_time
-#define fn_gnutls_x509_crt_get_fingerprint      gnutls_x509_crt_get_fingerprint
-#define fn_gnutls_x509_crt_get_issuer_dn        gnutls_x509_crt_get_issuer_dn
-#define fn_gnutls_x509_crt_get_issuer_unique_id gnutls_x509_crt_get_issuer_unique_id
-#define fn_gnutls_x509_crt_get_key_id           gnutls_x509_crt_get_key_id
-#define fn_gnutls_x509_crt_get_pk_algorithm     gnutls_x509_crt_get_pk_algorithm
-#define fn_gnutls_x509_crt_get_serial           gnutls_x509_crt_get_serial
-#define fn_gnutls_x509_crt_get_signature_algorithm gnutls_x509_crt_get_signature_algorithm
-#define fn_gnutls_x509_crt_get_subject_unique_id gnutls_x509_crt_get_subject_unique_id
-#define fn_gnutls_x509_crt_get_version          gnutls_x509_crt_get_version
-#define fn_gnutls_x509_crt_import               gnutls_x509_crt_import
-#define fn_gnutls_x509_crt_init                 gnutls_x509_crt_init
-
-#endif /* !WINDOWSNT */
 
 
+/* Report memory exhaustion if ERR is an out-of-memory indication.  */
+static void
+check_memory_full (int err)
+{
+  /* When GnuTLS exhausts memory, it doesn't say how much memory it
+     asked for, so tell the Emacs allocator that GnuTLS asked for no
+     bytes.  This isn't accurate, but it's good enough.  */
+  if (err == GNUTLS_E_MEMORY_ERROR)
+    memory_full (0);
+}
+
 #ifdef HAVE_GNUTLS3
 /* Log a simple audit message.  */
 static void
@@ -432,11 +428,11 @@ emacs_gnutls_handshake (struct Lisp_Process *proc)
       /* On W32 we cannot transfer socket handles between different runtime
          libraries, so we tell GnuTLS to use our special push/pull
          functions.  */
-      fn_gnutls_transport_set_ptr2 (state,
-                                    (gnutls_transport_ptr_t) proc,
-                                    (gnutls_transport_ptr_t) proc);
-      fn_gnutls_transport_set_push_function (state, &emacs_gnutls_push);
-      fn_gnutls_transport_set_pull_function (state, &emacs_gnutls_pull);
+      gnutls_transport_set_ptr2 (state,
+                                 (gnutls_transport_ptr_t) proc,
+                                 (gnutls_transport_ptr_t) proc);
+      gnutls_transport_set_push_function (state, &emacs_gnutls_push);
+      gnutls_transport_set_pull_function (state, &emacs_gnutls_pull);
 
       /* For non blocking sockets or other custom made pull/push
          functions the gnutls_transport_set_lowat must be called, with
@@ -449,15 +445,15 @@ emacs_gnutls_handshake (struct Lisp_Process *proc)
          zero by default in version 2.11.1, and the function
          gnutls_transport_set_lowat was removed from the library in
          version 2.99.0.  */
-      if (!fn_gnutls_check_version ("2.11.1"))
-        fn_gnutls_transport_set_lowat (state, 0);
+      if (!gnutls_check_version ("2.11.1"))
+        gnutls_transport_set_lowat (state, 0);
 #else
       /* This is how GnuTLS takes sockets: as file descriptors passed
          in.  For an Emacs process socket, infd and outfd are the
          same but we use this two-argument version for clarity.  */
-      fn_gnutls_transport_set_ptr2 (state,
-                                    (void *) (intptr_t) proc->infd,
-                                    (void *) (intptr_t) proc->outfd);
+      gnutls_transport_set_ptr2 (state,
+                                 (void *) (intptr_t) proc->infd,
+                                 (void *) (intptr_t) proc->outfd);
 #endif
 
       proc->gnutls_initstage = GNUTLS_STAGE_TRANSPORT_POINTERS_SET;
@@ -465,11 +461,11 @@ emacs_gnutls_handshake (struct Lisp_Process *proc)
 
   do
     {
-      ret = fn_gnutls_handshake (state);
+      ret = gnutls_handshake (state);
       emacs_gnutls_handle_error (state, ret);
       QUIT;
     }
-  while (ret < 0 && fn_gnutls_error_is_fatal (ret) == 0);
+  while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 
   proc->gnutls_initstage = GNUTLS_STAGE_HANDSHAKE_TRIED;
 
@@ -480,7 +476,7 @@ emacs_gnutls_handshake (struct Lisp_Process *proc)
     }
   else
     {
-      fn_gnutls_alert_send_appropriate (state, ret);
+      check_memory_full (gnutls_alert_send_appropriate (state, ret));
     }
   return ret;
 }
@@ -488,14 +484,14 @@ emacs_gnutls_handshake (struct Lisp_Process *proc)
 ptrdiff_t
 emacs_gnutls_record_check_pending (gnutls_session_t state)
 {
-  return fn_gnutls_record_check_pending (state);
+  return gnutls_record_check_pending (state);
 }
 
 #ifdef WINDOWSNT
 void
 emacs_gnutls_transport_set_errno (gnutls_session_t state, int err)
 {
-  fn_gnutls_transport_set_errno (state, err);
+  gnutls_transport_set_errno (state, err);
 }
 #endif
 
@@ -516,7 +512,7 @@ emacs_gnutls_write (struct Lisp_Process *proc, const char *buf, ptrdiff_t nbyte)
 
   while (nbyte > 0)
     {
-      rtnval = fn_gnutls_record_send (state, buf, nbyte);
+      rtnval = gnutls_record_send (state, buf, nbyte);
 
       if (rtnval < 0)
         {
@@ -568,7 +564,7 @@ emacs_gnutls_read (struct Lisp_Process *proc, char *buf, ptrdiff_t nbyte)
       proc->gnutls_handshakes_tried = 0;
       return 0;
     }
-  rtnval = fn_gnutls_record_recv (state, buf, nbyte);
+  rtnval = gnutls_record_recv (state, buf, nbyte);
   if (rtnval >= 0)
     return rtnval;
   else if (rtnval == GNUTLS_E_UNEXPECTED_PACKET_LENGTH)
@@ -597,15 +593,17 @@ emacs_gnutls_handle_error (gnutls_session_t session, int err)
   if (err >= 0)
     return 1;
 
+  check_memory_full (err);
+
   max_log_level = global_gnutls_log_level;
 
   /* TODO: use gnutls-error-fatalp and gnutls-error-string.  */
 
-  str = fn_gnutls_strerror (err);
+  str = gnutls_strerror (err);
   if (!str)
     str = "unknown";
 
-  if (fn_gnutls_error_is_fatal (err))
+  if (gnutls_error_is_fatal (err))
     {
       ret = 0;
       GNUTLS_LOG2 (1, max_log_level, "fatal error:", str);
@@ -632,9 +630,9 @@ emacs_gnutls_handle_error (gnutls_session_t session, int err)
   if (err == GNUTLS_E_WARNING_ALERT_RECEIVED
       || err == GNUTLS_E_FATAL_ALERT_RECEIVED)
     {
-      int alert = fn_gnutls_alert_get (session);
+      int alert = gnutls_alert_get (session);
       int level = (err == GNUTLS_E_FATAL_ALERT_RECEIVED) ? 0 : 1;
-      str = fn_gnutls_alert_get_name (alert);
+      str = gnutls_alert_get_name (alert);
       if (!str)
         str = "unknown";
 
@@ -662,6 +660,7 @@ gnutls_make_error (int err)
       return Qgnutls_e_invalid_session;
     }
 
+  check_memory_full (err);
   return make_number (err);
 }
 
@@ -680,20 +679,20 @@ emacs_gnutls_deinit (Lisp_Object proc)
   if (XPROCESS (proc)->gnutls_x509_cred)
     {
       GNUTLS_LOG (2, log_level, "Deallocating x509 credentials");
-      fn_gnutls_certificate_free_credentials (XPROCESS (proc)->gnutls_x509_cred);
+      gnutls_certificate_free_credentials (XPROCESS (proc)->gnutls_x509_cred);
       XPROCESS (proc)->gnutls_x509_cred = NULL;
     }
 
   if (XPROCESS (proc)->gnutls_anon_cred)
     {
       GNUTLS_LOG (2, log_level, "Deallocating anon credentials");
-      fn_gnutls_anon_free_client_credentials (XPROCESS (proc)->gnutls_anon_cred);
+      gnutls_anon_free_client_credentials (XPROCESS (proc)->gnutls_anon_cred);
       XPROCESS (proc)->gnutls_anon_cred = NULL;
     }
 
   if (XPROCESS (proc)->gnutls_state)
     {
-      fn_gnutls_deinit (XPROCESS (proc)->gnutls_state);
+      gnutls_deinit (XPROCESS (proc)->gnutls_state);
       XPROCESS (proc)->gnutls_state = NULL;
       if (GNUTLS_INITSTAGE (proc) >= GNUTLS_STAGE_INIT)
         GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_INIT - 1;
@@ -750,7 +749,7 @@ Usage: (gnutls-error-fatalp ERROR)  */)
   if (! TYPE_RANGED_INTEGERP (int, err))
     error ("Not an error symbol or code");
 
-  if (0 == fn_gnutls_error_is_fatal (XINT (err)))
+  if (0 == gnutls_error_is_fatal (XINT (err)))
     return Qnil;
 
   return Qt;
@@ -782,7 +781,7 @@ usage: (gnutls-error-string ERROR)  */)
   if (! TYPE_RANGED_INTEGERP (int, err))
     return build_string ("Not an error symbol or code");
 
-  return build_string (fn_gnutls_strerror (XINT (err)));
+  return build_string (gnutls_strerror (XINT (err)));
 }
 
 DEFUN ("gnutls-deinit", Fgnutls_deinit, Sgnutls_deinit, 1, 1, 0,
@@ -821,7 +820,8 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Version. */
   {
-    int version = fn_gnutls_x509_crt_get_version (cert);
+    int version = gnutls_x509_crt_get_version (cert);
+    check_memory_full (version);
     if (version >= GNUTLS_E_SUCCESS)
       res = nconc2 (res, list2 (intern (":version"),
                                 make_number (version)));
@@ -829,11 +829,13 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Serial. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_serial (cert, NULL, &buf_size);
+  err = gnutls_x509_crt_get_serial (cert, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       void *serial = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_serial (cert, serial, &buf_size);
+      err = gnutls_x509_crt_get_serial (cert, serial, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":serial-number"),
                                   gnutls_hex_string (serial, buf_size, "")));
@@ -842,11 +844,13 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Issuer. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_issuer_dn (cert, NULL, &buf_size);
+  err = gnutls_x509_crt_get_issuer_dn (cert, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       char *dn = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_issuer_dn (cert, dn, &buf_size);
+      err = gnutls_x509_crt_get_issuer_dn (cert, dn, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":issuer"),
                                   make_string (dn, buf_size)));
@@ -859,23 +863,25 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
        that might add 1 to the year length.  */
     char buf[INT_STRLEN_BOUND (int) + 1 + sizeof "-12-31"];
     struct tm t;
-    time_t tim = fn_gnutls_x509_crt_get_activation_time (cert);
+    time_t tim = gnutls_x509_crt_get_activation_time (cert);
 
     if (gmtime_r (&tim, &t) && strftime (buf, sizeof buf, "%Y-%m-%d", &t))
       res = nconc2 (res, list2 (intern (":valid-from"), build_string (buf)));
 
-    tim = fn_gnutls_x509_crt_get_expiration_time (cert);
+    tim = gnutls_x509_crt_get_expiration_time (cert);
     if (gmtime_r (&tim, &t) && strftime (buf, sizeof buf, "%Y-%m-%d", &t))
       res = nconc2 (res, list2 (intern (":valid-to"), build_string (buf)));
   }
 
   /* Subject. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_dn (cert, NULL, &buf_size);
+  err = gnutls_x509_crt_get_dn (cert, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       char *dn = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_dn (cert, dn, &buf_size);
+      err = gnutls_x509_crt_get_dn (cert, dn, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":subject"),
                                   make_string (dn, buf_size)));
@@ -888,16 +894,17 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
   {
     unsigned int bits;
 
-    err = fn_gnutls_x509_crt_get_pk_algorithm (cert, &bits);
+    err = gnutls_x509_crt_get_pk_algorithm (cert, &bits);
+    check_memory_full (err);
     if (err >= GNUTLS_E_SUCCESS)
       {
-        const char *name = fn_gnutls_pk_algorithm_get_name (err);
+        const char *name = gnutls_pk_algorithm_get_name (err);
         if (name)
           res = nconc2 (res, list2 (intern (":public-key-algorithm"),
                                     build_string (name)));
 
-        name = fn_gnutls_sec_param_get_name (fn_gnutls_pk_bits_to_sec_param
-                                             (err, bits));
+        name = gnutls_sec_param_get_name (gnutls_pk_bits_to_sec_param
+                                          (err, bits));
         res = nconc2 (res, list2 (intern (":certificate-security-level"),
                                   build_string (name)));
       }
@@ -905,11 +912,13 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Unique IDs. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_issuer_unique_id (cert, NULL, &buf_size);
+  err = gnutls_x509_crt_get_issuer_unique_id (cert, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       char *buf = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_issuer_unique_id (cert, buf, &buf_size);
+      err = gnutls_x509_crt_get_issuer_unique_id (cert, buf, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":issuer-unique-id"),
                                   make_string (buf, buf_size)));
@@ -917,11 +926,13 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
     }
 
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_subject_unique_id (cert, NULL, &buf_size);
+  err = gnutls_x509_crt_get_subject_unique_id (cert, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       char *buf = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_subject_unique_id (cert, buf, &buf_size);
+      err = gnutls_x509_crt_get_subject_unique_id (cert, buf, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":subject-unique-id"),
                                   make_string (buf, buf_size)));
@@ -930,10 +941,11 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 #endif
 
   /* Signature. */
-  err = fn_gnutls_x509_crt_get_signature_algorithm (cert);
+  err = gnutls_x509_crt_get_signature_algorithm (cert);
+  check_memory_full (err);
   if (err >= GNUTLS_E_SUCCESS)
     {
-      const char *name = fn_gnutls_sign_get_name (err);
+      const char *name = gnutls_sign_get_name (err);
       if (name)
         res = nconc2 (res, list2 (intern (":signature-algorithm"),
                                   build_string (name)));
@@ -941,11 +953,13 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Public key ID. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_key_id (cert, 0, NULL, &buf_size);
+  err = gnutls_x509_crt_get_key_id (cert, 0, NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       void *buf = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_key_id (cert, 0, buf, &buf_size);
+      err = gnutls_x509_crt_get_key_id (cert, 0, buf, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":public-key-id"),
                                   gnutls_hex_string (buf, buf_size, "sha1:")));
@@ -954,13 +968,15 @@ gnutls_certificate_details (gnutls_x509_crt_t cert)
 
   /* Certificate fingerprint. */
   buf_size = 0;
-  err = fn_gnutls_x509_crt_get_fingerprint (cert, GNUTLS_DIG_SHA1,
-                                            NULL, &buf_size);
+  err = gnutls_x509_crt_get_fingerprint (cert, GNUTLS_DIG_SHA1,
+                                         NULL, &buf_size);
+  check_memory_full (err);
   if (err == GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       void *buf = xmalloc (buf_size);
-      err = fn_gnutls_x509_crt_get_fingerprint (cert, GNUTLS_DIG_SHA1,
-                                                buf, &buf_size);
+      err = gnutls_x509_crt_get_fingerprint (cert, GNUTLS_DIG_SHA1,
+                                             buf, &buf_size);
+      check_memory_full (err);
       if (err >= GNUTLS_E_SUCCESS)
         res = nconc2 (res, list2 (intern (":certificate-id"),
                                   gnutls_hex_string (buf, buf_size, "sha1:")));
@@ -1061,7 +1077,8 @@ The return value is a property list with top-level keys :warnings and
 
   /* Diffie-Hellman prime bits. */
   {
-    int bits = fn_gnutls_dh_get_prime_bits (state);
+    int bits = gnutls_dh_get_prime_bits (state);
+    check_memory_full (bits);
     if (bits > 0)
       result = nconc2 (result, list2 (intern (":diffie-hellman-prime-bits"),
                                       make_number (bits)));
@@ -1070,26 +1087,26 @@ The return value is a property list with top-level keys :warnings and
   /* Key exchange. */
   result = nconc2
     (result, list2 (intern (":key-exchange"),
-                    build_string (fn_gnutls_kx_get_name
-                                  (fn_gnutls_kx_get (state)))));
+                    build_string (gnutls_kx_get_name
+                                  (gnutls_kx_get (state)))));
 
   /* Protocol name. */
   result = nconc2
     (result, list2 (intern (":protocol"),
-                    build_string (fn_gnutls_protocol_get_name
-                                  (fn_gnutls_protocol_get_version (state)))));
+                    build_string (gnutls_protocol_get_name
+                                  (gnutls_protocol_get_version (state)))));
 
   /* Cipher name. */
   result = nconc2
     (result, list2 (intern (":cipher"),
-                    build_string (fn_gnutls_cipher_get_name
-                                  (fn_gnutls_cipher_get (state)))));
+                    build_string (gnutls_cipher_get_name
+                                  (gnutls_cipher_get (state)))));
 
   /* MAC name. */
   result = nconc2
     (result, list2 (intern (":mac"),
-                    build_string (fn_gnutls_mac_get_name
-                                  (fn_gnutls_mac_get (state)))));
+                    build_string (gnutls_mac_get_name
+                                  (gnutls_mac_get (state)))));
 
 
   return result;
@@ -1104,11 +1121,8 @@ emacs_gnutls_global_init (void)
   int ret = GNUTLS_E_SUCCESS;
 
   if (!gnutls_global_initialized)
-    {
-      fn_gnutls_global_set_mem_functions (xmalloc, xmalloc, NULL,
-                                          xrealloc, xfree);
-      ret = fn_gnutls_global_init ();
-    }
+    ret = gnutls_global_init ();
+
   gnutls_global_initialized = 1;
 
   return gnutls_make_error (ret);
@@ -1257,11 +1271,11 @@ one trustfile (usually a CA bundle).  */)
 
   if (TYPE_RANGED_INTEGERP (int, loglevel))
     {
-      fn_gnutls_global_set_log_function (gnutls_log_function);
+      gnutls_global_set_log_function (gnutls_log_function);
 #ifdef HAVE_GNUTLS3
-      fn_gnutls_global_set_audit_log_function (gnutls_audit_log_function);
+      gnutls_global_set_audit_log_function (gnutls_audit_log_function);
 #endif
-      fn_gnutls_global_set_log_level (XINT (loglevel));
+      gnutls_global_set_log_level (XINT (loglevel));
       max_log_level = XINT (loglevel);
       XPROCESS (proc)->gnutls_log_level = max_log_level;
     }
@@ -1291,7 +1305,7 @@ one trustfile (usually a CA bundle).  */)
       unsigned int gnutls_verify_flags = GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT;
 
       GNUTLS_LOG (2, max_log_level, "allocating x509 credentials");
-      fn_gnutls_certificate_allocate_credentials (&x509_cred);
+      check_memory_full (gnutls_certificate_allocate_credentials (&x509_cred));
       XPROCESS (proc)->gnutls_x509_cred = x509_cred;
 
       verify_flags = Fplist_get (proplist, QCgnutls_bootprop_verify_flags);
@@ -1305,12 +1319,12 @@ one trustfile (usually a CA bundle).  */)
       else
         GNUTLS_LOG (2, max_log_level, "ignoring invalid verify-flags");
 
-      fn_gnutls_certificate_set_verify_flags (x509_cred, gnutls_verify_flags);
+      gnutls_certificate_set_verify_flags (x509_cred, gnutls_verify_flags);
     }
   else /* Qgnutls_anon: */
     {
       GNUTLS_LOG (2, max_log_level, "allocating anon credentials");
-      fn_gnutls_anon_allocate_client_credentials (&anon_cred);
+      check_memory_full (gnutls_anon_allocate_client_credentials (&anon_cred));
       XPROCESS (proc)->gnutls_anon_cred = anon_cred;
     }
 
@@ -1324,10 +1338,13 @@ one trustfile (usually a CA bundle).  */)
 
 #if GNUTLS_VERSION_MAJOR +                                      \
   (GNUTLS_VERSION_MINOR > 0 || GNUTLS_VERSION_PATCH >= 20) > 3
-      ret = fn_gnutls_certificate_set_x509_system_trust (x509_cred);
+      ret = gnutls_certificate_set_x509_system_trust (x509_cred);
       if (ret < GNUTLS_E_SUCCESS)
-        GNUTLS_LOG2i (4, max_log_level,
-                      "setting system trust failed with code ", ret);
+        {
+          check_memory_full (ret);
+          GNUTLS_LOG2i (4, max_log_level,
+                        "setting system trust failed with code ", ret);
+        }
 #endif
 
       for (tail = trustfiles; CONSP (tail); tail = XCDR (tail))
@@ -1344,7 +1361,7 @@ one trustfile (usually a CA bundle).  */)
                  name using the current ANSI codepage.  */
               trustfile = ansi_encode_filename (trustfile);
 #endif
-              ret = fn_gnutls_certificate_set_x509_trust_file
+              ret = gnutls_certificate_set_x509_trust_file
                 (x509_cred,
                  SSDATA (trustfile),
                  file_format);
@@ -1370,7 +1387,7 @@ one trustfile (usually a CA bundle).  */)
 #ifdef WINDOWSNT
               crlfile = ansi_encode_filename (crlfile);
 #endif
-              ret = fn_gnutls_certificate_set_x509_crl_file
+              ret = gnutls_certificate_set_x509_crl_file
                 (x509_cred, SSDATA (crlfile), file_format);
 
               if (ret < GNUTLS_E_SUCCESS)
@@ -1399,7 +1416,7 @@ one trustfile (usually a CA bundle).  */)
               keyfile = ansi_encode_filename (keyfile);
               certfile = ansi_encode_filename (certfile);
 #endif
-              ret = fn_gnutls_certificate_set_x509_key_file
+              ret = gnutls_certificate_set_x509_key_file
                 (x509_cred, SSDATA (certfile), SSDATA (keyfile), file_format);
 
               if (ret < GNUTLS_E_SUCCESS)
@@ -1421,7 +1438,7 @@ one trustfile (usually a CA bundle).  */)
   /* Call gnutls_init here: */
 
   GNUTLS_LOG (1, max_log_level, "gnutls_init");
-  ret = fn_gnutls_init (&state, GNUTLS_CLIENT);
+  ret = gnutls_init (&state, GNUTLS_CLIENT);
   XPROCESS (proc)->gnutls_state = state;
   if (ret < GNUTLS_E_SUCCESS)
     return gnutls_make_error (ret);
@@ -1440,27 +1457,25 @@ one trustfile (usually a CA bundle).  */)
     }
 
   GNUTLS_LOG (1, max_log_level, "setting the priority string");
-  ret = fn_gnutls_priority_set_direct (state,
-                                       priority_string_ptr,
-                                       NULL);
+  ret = gnutls_priority_set_direct (state, priority_string_ptr, NULL);
   if (ret < GNUTLS_E_SUCCESS)
     return gnutls_make_error (ret);
 
   GNUTLS_INITSTAGE (proc) = GNUTLS_STAGE_PRIORITY;
 
   if (INTEGERP (prime_bits))
-    fn_gnutls_dh_set_prime_bits (state, XUINT (prime_bits));
+    gnutls_dh_set_prime_bits (state, XUINT (prime_bits));
 
   ret = EQ (type, Qgnutls_x509pki)
-    ? fn_gnutls_credentials_set (state, GNUTLS_CRD_CERTIFICATE, x509_cred)
-    : fn_gnutls_credentials_set (state, GNUTLS_CRD_ANON, anon_cred);
+    ? gnutls_credentials_set (state, GNUTLS_CRD_CERTIFICATE, x509_cred)
+    : gnutls_credentials_set (state, GNUTLS_CRD_ANON, anon_cred);
   if (ret < GNUTLS_E_SUCCESS)
     return gnutls_make_error (ret);
 
   if (!gnutls_ip_address_p (c_hostname))
     {
-      ret = fn_gnutls_server_name_set (state, GNUTLS_NAME_DNS, c_hostname,
-                                       strlen (c_hostname));
+      ret = gnutls_server_name_set (state, GNUTLS_NAME_DNS, c_hostname,
+                                    strlen (c_hostname));
       if (ret < GNUTLS_E_SUCCESS)
         return gnutls_make_error (ret);
     }
@@ -1476,7 +1491,7 @@ one trustfile (usually a CA bundle).  */)
      check of the certificate's hostname with
      gnutls_x509_crt_check_hostname against :hostname.  */
 
-  ret = fn_gnutls_certificate_verify_peers2 (state, &peer_verification);
+  ret = gnutls_certificate_verify_peers2 (state, &peer_verification);
   if (ret < GNUTLS_E_SUCCESS)
     return gnutls_make_error (ret);
 
@@ -1514,47 +1529,50 @@ one trustfile (usually a CA bundle).  */)
   /* Up to here the process is the same for X.509 certificates and
      OpenPGP keys.  From now on X.509 certificates are assumed.  This
      can be easily extended to work with openpgp keys as well.  */
-  if (fn_gnutls_certificate_type_get (state) == GNUTLS_CRT_X509)
+  if (gnutls_certificate_type_get (state) == GNUTLS_CRT_X509)
     {
       gnutls_x509_crt_t gnutls_verify_cert;
       const gnutls_datum_t *gnutls_verify_cert_list;
       unsigned int gnutls_verify_cert_list_size;
 
-      ret = fn_gnutls_x509_crt_init (&gnutls_verify_cert);
+      ret = gnutls_x509_crt_init (&gnutls_verify_cert);
       if (ret < GNUTLS_E_SUCCESS)
         return gnutls_make_error (ret);
 
       gnutls_verify_cert_list =
-        fn_gnutls_certificate_get_peers (state, &gnutls_verify_cert_list_size);
+        gnutls_certificate_get_peers (state, &gnutls_verify_cert_list_size);
 
       if (gnutls_verify_cert_list == NULL)
         {
-          fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
+          gnutls_x509_crt_deinit (gnutls_verify_cert);
           emacs_gnutls_deinit (proc);
           error ("No x509 certificate was found\n");
         }
 
       /* We only check the first certificate in the given chain.  */
-      ret = fn_gnutls_x509_crt_import (gnutls_verify_cert,
+      ret = gnutls_x509_crt_import (gnutls_verify_cert,
                                        &gnutls_verify_cert_list[0],
                                        GNUTLS_X509_FMT_DER);
 
       if (ret < GNUTLS_E_SUCCESS)
         {
-          fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
+          gnutls_x509_crt_deinit (gnutls_verify_cert);
           return gnutls_make_error (ret);
         }
 
       XPROCESS (proc)->gnutls_certificate = gnutls_verify_cert;
 
-      if (!fn_gnutls_x509_crt_check_hostname (gnutls_verify_cert, c_hostname))
+      int err = gnutls_x509_crt_check_hostname (gnutls_verify_cert,
+                                                c_hostname);
+      check_memory_full (err);
+      if (!err)
         {
           XPROCESS (proc)->gnutls_extra_peer_verification |=
             CERTIFICATE_NOT_MATCHING;
           if (verify_error_all
               || !NILP (Fmember (QCgnutls_bootprop_hostname, verify_error)))
             {
-              fn_gnutls_x509_crt_deinit (gnutls_verify_cert);
+              gnutls_x509_crt_deinit (gnutls_verify_cert);
               emacs_gnutls_deinit (proc);
               error ("The x509 certificate does not match \"%s\"", c_hostname);
             }
@@ -1595,10 +1613,9 @@ This function may also return `gnutls-e-again', or
 
   state = XPROCESS (proc)->gnutls_state;
 
-  fn_gnutls_x509_crt_deinit (XPROCESS (proc)->gnutls_certificate);
+  gnutls_x509_crt_deinit (XPROCESS (proc)->gnutls_certificate);
 
-  ret = fn_gnutls_bye (state,
-                       NILP (cont) ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
+  ret = gnutls_bye (state, NILP (cont) ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
 
   return gnutls_make_error (ret);
 }
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 9465d5479df..f61cbc2c85c 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1839,12 +1839,12 @@ xg_get_file_with_chooser (struct frame *f,
 
   if (x_gtk_file_dialog_help_text)
     {
-      msgbuf[0] = '\0';
+      char *z = msgbuf;
       /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
          Show the C-l help text only for versions < 2.10.  */
       if (gtk_check_version (2, 10, 0) && action != GTK_FILE_CHOOSER_ACTION_SAVE)
-        strcat (msgbuf, "\nType C-l to display a file name text entry box.\n");
-      strcat (msgbuf, "\nIf you don't like this file selector, use the "
+        z = stpcpy (z, "\nType C-l to display a file name text entry box.\n");
+      strcpy (z, "\nIf you don't like this file selector, use the "
               "corresponding\nkey binding or customize "
               "use-file-dialog to turn it off.");
 
diff --git a/src/image.c b/src/image.c
index a73a7251753..4cba8863b88 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1859,19 +1859,6 @@ mark_image_cache (struct image_cache *c)
                           X / NS / W32 support code
  ***********************************************************************/
 
-#ifdef WINDOWSNT
-
-/* Macro for defining functions that will be loaded from image DLLs.  */
-#define DEF_IMGLIB_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
-
-/* Macro for loading those image functions from the library.  */
-#define LOAD_IMGLIB_FN(lib,func) {                                      \
-    fn_##func = (void *) GetProcAddress (lib, #func);                   \
-    if (!fn_##func) return 0;                                           \
-  }
-
-#endif /* WINDOWSNT */
-
 /* Return true if XIMG's size WIDTH x HEIGHT doesn't break the
    windowing system.
    WIDTH and HEIGHT must both be positive.
@@ -3377,12 +3364,14 @@ xpm_free_colors (Display *dpy, Colormap cmap, Pixel *pixels, int npixels, void *
 
 /* XPM library details.  */
 
-DEF_IMGLIB_FN (void, XpmFreeAttributes, (XpmAttributes *));
-DEF_IMGLIB_FN (int, XpmCreateImageFromBuffer, (Display *, char *, xpm_XImage **,
-                                          xpm_XImage **, XpmAttributes *));
-DEF_IMGLIB_FN (int, XpmReadFileToImage, (Display *, char *, xpm_XImage **,
-                                    xpm_XImage **, XpmAttributes *));
-DEF_IMGLIB_FN (void, XImageFree, (xpm_XImage *));
+DEF_DLL_FN (void, XpmFreeAttributes, (XpmAttributes *));
+DEF_DLL_FN (int, XpmCreateImageFromBuffer,
+            (Display *, char *, xpm_XImage **,
+             xpm_XImage **, XpmAttributes *));
+DEF_DLL_FN (int, XpmReadFileToImage,
+            (Display *, char *, xpm_XImage **,
+             xpm_XImage **, XpmAttributes *));
+DEF_DLL_FN (void, XImageFree, (xpm_XImage *));
 
 static bool
 init_xpm_functions (void)
@@ -3392,22 +3381,24 @@ init_xpm_functions (void)
   if (!(library = w32_delayed_load (Qxpm)))
     return 0;
 
-  LOAD_IMGLIB_FN (library, XpmFreeAttributes);
-  LOAD_IMGLIB_FN (library, XpmCreateImageFromBuffer);
-  LOAD_IMGLIB_FN (library, XpmReadFileToImage);
-  LOAD_IMGLIB_FN (library, XImageFree);
+  LOAD_DLL_FN (library, XpmFreeAttributes);
+  LOAD_DLL_FN (library, XpmCreateImageFromBuffer);
+  LOAD_DLL_FN (library, XpmReadFileToImage);
+  LOAD_DLL_FN (library, XImageFree);
   return 1;
 }
 
-#endif /* WINDOWSNT */
+# undef XImageFree
+# undef XpmCreateImageFromBuffer
+# undef XpmFreeAttributes
+# undef XpmReadFileToImage
 
-#if defined HAVE_NTGUI && !defined WINDOWSNT
-/* Glue for code below */
-#define fn_XpmReadFileToImage XpmReadFileToImage
-#define fn_XpmCreateImageFromBuffer XpmCreateImageFromBuffer
-#define fn_XImageFree XImageFree
-#define fn_XpmFreeAttributes XpmFreeAttributes
-#endif /* HAVE_NTGUI && !WINDOWSNT */
+# define XImageFree fn_XImageFree
+# define XpmCreateImageFromBuffer fn_XpmCreateImageFromBuffer
+# define XpmFreeAttributes fn_XpmFreeAttributes
+# define XpmReadFileToImage fn_XpmReadFileToImage
+
+#endif /* WINDOWSNT */
 
 /* Value is true if COLOR_SYMBOLS is a valid color symbols list
    for XPM images.  Such a list must consist of conses whose car and
@@ -3624,9 +3615,9 @@ xpm_load (struct frame *f, struct image *img)
 #endif
       /* XpmReadFileToPixmap is not available in the Windows port of
          libxpm.  But XpmReadFileToImage almost does what we want.  */
-      rc = fn_XpmReadFileToImage (&hdc, SDATA (file),
-                                  &xpm_image, &xpm_mask,
-                                  &attrs);
+      rc = XpmReadFileToImage (&hdc, SDATA (file),
+                               &xpm_image, &xpm_mask,
+                               &attrs);
 #else
       rc = XpmReadFileToImage (FRAME_X_DISPLAY (f), SSDATA (file),
                                &img->ximg, &img->mask_img,
@@ -3648,9 +3639,9 @@ xpm_load (struct frame *f, struct image *img)
 #ifdef HAVE_NTGUI
       /* XpmCreatePixmapFromBuffer is not available in the Windows port
          of libxpm.  But XpmCreateImageFromBuffer almost does what we want.  */
-      rc = fn_XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
-                                        &xpm_image, &xpm_mask,
-                                        &attrs);
+      rc = XpmCreateImageFromBuffer (&hdc, SDATA (buffer),
+                                     &xpm_image, &xpm_mask,
+                                     &attrs);
 #else
       rc = XpmCreateImageFromBuffer (FRAME_X_DISPLAY (f), SSDATA (buffer),
                                      &img->ximg, &img->mask_img,
@@ -3699,7 +3690,7 @@ xpm_load (struct frame *f, struct image *img)
           img->pixmap = xpm_image->bitmap;
           /* XImageFree in libXpm frees XImage struct without destroying
              the bitmap, which is what we want.  */
-          fn_XImageFree (xpm_image);
+          XImageFree (xpm_image);
         }
       if (xpm_mask && xpm_mask->bitmap)
         {
@@ -3713,7 +3704,7 @@ xpm_load (struct frame *f, struct image *img)
           SelectObject (hdc, old_obj);
 
           img->mask = xpm_mask->bitmap;
-          fn_XImageFree (xpm_mask);
+          XImageFree (xpm_mask);
           DeleteDC (hdc);
         }
 
@@ -3737,11 +3728,7 @@ xpm_load (struct frame *f, struct image *img)
       eassert (img->width > 0 && img->height > 0);
 
       /* The call to XpmFreeAttributes below frees attrs.alloc_pixels.  */
-#ifdef HAVE_NTGUI
-      fn_XpmFreeAttributes (&attrs);
-#else
       XpmFreeAttributes (&attrs);
-#endif /* HAVE_NTGUI */
 
 #ifdef HAVE_X_WINDOWS
       /* Maybe fill in the background field while we have ximg handy.  */
@@ -5535,39 +5522,42 @@ png_image_p (Lisp_Object object)
 
 #if defined HAVE_PNG && !defined HAVE_NS
 
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
 /* PNG library details.  */
 
-DEF_IMGLIB_FN (png_voidp, png_get_io_ptr, (png_structp));
-DEF_IMGLIB_FN (int, png_sig_cmp, (png_bytep, png_size_t, png_size_t));
-DEF_IMGLIB_FN (png_structp, png_create_read_struct, (png_const_charp, png_voidp,
-                                                     png_error_ptr, png_error_ptr));
-DEF_IMGLIB_FN (png_infop, png_create_info_struct, (png_structp));
-DEF_IMGLIB_FN (void, png_destroy_read_struct, (png_structpp, png_infopp, png_infopp));
-DEF_IMGLIB_FN (void, png_set_read_fn, (png_structp, png_voidp, png_rw_ptr));
-DEF_IMGLIB_FN (void, png_set_sig_bytes, (png_structp, int));
-DEF_IMGLIB_FN (void, png_read_info, (png_structp, png_infop));
-DEF_IMGLIB_FN (png_uint_32, png_get_IHDR, (png_structp, png_infop,
-                              png_uint_32 *, png_uint_32 *,
-                              int *, int *, int *, int *, int *));
-DEF_IMGLIB_FN (png_uint_32, png_get_valid, (png_structp, png_infop, png_uint_32));
-DEF_IMGLIB_FN (void, png_set_strip_16, (png_structp));
-DEF_IMGLIB_FN (void, png_set_expand, (png_structp));
-DEF_IMGLIB_FN (void, png_set_gray_to_rgb, (png_structp));
-DEF_IMGLIB_FN (void, png_set_background, (png_structp, png_color_16p,
-                                    int, int, double));
-DEF_IMGLIB_FN (png_uint_32, png_get_bKGD, (png_structp, png_infop, png_color_16p *));
-DEF_IMGLIB_FN (void, png_read_update_info, (png_structp, png_infop));
-DEF_IMGLIB_FN (png_byte, png_get_channels, (png_structp, png_infop));
-DEF_IMGLIB_FN (png_size_t, png_get_rowbytes, (png_structp, png_infop));
-DEF_IMGLIB_FN (void, png_read_image, (png_structp, png_bytepp));
-DEF_IMGLIB_FN (void, png_read_end, (png_structp, png_infop));
-DEF_IMGLIB_FN (void, png_error, (png_structp, png_const_charp));
-
-#if (PNG_LIBPNG_VER >= 10500)
-DEF_IMGLIB_FN (void, png_longjmp, (png_structp, int)) PNG_NORETURN;
-DEF_IMGLIB_FN (jmp_buf *, png_set_longjmp_fn, (png_structp, png_longjmp_ptr, size_t));
-#endif /* libpng version >= 1.5 */
+DEF_DLL_FN (png_voidp, png_get_io_ptr, (png_structp));
+DEF_DLL_FN (int, png_sig_cmp, (png_bytep, png_size_t, png_size_t));
+DEF_DLL_FN (png_structp, png_create_read_struct,
+            (png_const_charp, png_voidp, png_error_ptr, png_error_ptr));
+DEF_DLL_FN (png_infop, png_create_info_struct, (png_structp));
+DEF_DLL_FN (void, png_destroy_read_struct,
+            (png_structpp, png_infopp, png_infopp));
+DEF_DLL_FN (void, png_set_read_fn, (png_structp, png_voidp, png_rw_ptr));
+DEF_DLL_FN (void, png_set_sig_bytes, (png_structp, int));
+DEF_DLL_FN (void, png_read_info, (png_structp, png_infop));
+DEF_DLL_FN (png_uint_32, png_get_IHDR,
+            (png_structp, png_infop, png_uint_32 *, png_uint_32 *,
+             int *, int *, int *, int *, int *));
+DEF_DLL_FN (png_uint_32, png_get_valid, (png_structp, png_infop, png_uint_32));
+DEF_DLL_FN (void, png_set_strip_16, (png_structp));
+DEF_DLL_FN (void, png_set_expand, (png_structp));
+DEF_DLL_FN (void, png_set_gray_to_rgb, (png_structp));
+DEF_DLL_FN (void, png_set_background,
+            (png_structp, png_color_16p, int, int, double));
+DEF_DLL_FN (png_uint_32, png_get_bKGD,
+            (png_structp, png_infop, png_color_16p *));
+DEF_DLL_FN (void, png_read_update_info, (png_structp, png_infop));
+DEF_DLL_FN (png_byte, png_get_channels, (png_structp, png_infop));
+DEF_DLL_FN (png_size_t, png_get_rowbytes, (png_structp, png_infop));
+DEF_DLL_FN (void, png_read_image, (png_structp, png_bytepp));
+DEF_DLL_FN (void, png_read_end, (png_structp, png_infop));
+DEF_DLL_FN (void, png_error, (png_structp, png_const_charp));
+
+#  if (PNG_LIBPNG_VER >= 10500)
+DEF_DLL_FN (void, png_longjmp, (png_structp, int)) PNG_NORETURN;
+DEF_DLL_FN (jmp_buf *, png_set_longjmp_fn,
+            (png_structp, png_longjmp_ptr, size_t));
+#  endif /* libpng version >= 1.5 */
 
 static bool
 init_png_functions (void)
@@ -5577,87 +5567,107 @@ init_png_functions (void)
   if (!(library = w32_delayed_load (Qpng)))
     return 0;
 
-  LOAD_IMGLIB_FN (library, png_get_io_ptr);
-  LOAD_IMGLIB_FN (library, png_sig_cmp);
-  LOAD_IMGLIB_FN (library, png_create_read_struct);
-  LOAD_IMGLIB_FN (library, png_create_info_struct);
-  LOAD_IMGLIB_FN (library, png_destroy_read_struct);
-  LOAD_IMGLIB_FN (library, png_set_read_fn);
-  LOAD_IMGLIB_FN (library, png_set_sig_bytes);
-  LOAD_IMGLIB_FN (library, png_read_info);
-  LOAD_IMGLIB_FN (library, png_get_IHDR);
-  LOAD_IMGLIB_FN (library, png_get_valid);
-  LOAD_IMGLIB_FN (library, png_set_strip_16);
-  LOAD_IMGLIB_FN (library, png_set_expand);
-  LOAD_IMGLIB_FN (library, png_set_gray_to_rgb);
-  LOAD_IMGLIB_FN (library, png_set_background);
-  LOAD_IMGLIB_FN (library, png_get_bKGD);
-  LOAD_IMGLIB_FN (library, png_read_update_info);
-  LOAD_IMGLIB_FN (library, png_get_channels);
-  LOAD_IMGLIB_FN (library, png_get_rowbytes);
-  LOAD_IMGLIB_FN (library, png_read_image);
-  LOAD_IMGLIB_FN (library, png_read_end);
-  LOAD_IMGLIB_FN (library, png_error);
-
-#if (PNG_LIBPNG_VER >= 10500)
-  LOAD_IMGLIB_FN (library, png_longjmp);
-  LOAD_IMGLIB_FN (library, png_set_longjmp_fn);
-#endif /* libpng version >= 1.5 */
+  LOAD_DLL_FN (library, png_get_io_ptr);
+  LOAD_DLL_FN (library, png_sig_cmp);
+  LOAD_DLL_FN (library, png_create_read_struct);
+  LOAD_DLL_FN (library, png_create_info_struct);
+  LOAD_DLL_FN (library, png_destroy_read_struct);
+  LOAD_DLL_FN (library, png_set_read_fn);
+  LOAD_DLL_FN (library, png_set_sig_bytes);
+  LOAD_DLL_FN (library, png_read_info);
+  LOAD_DLL_FN (library, png_get_IHDR);
+  LOAD_DLL_FN (library, png_get_valid);
+  LOAD_DLL_FN (library, png_set_strip_16);
+  LOAD_DLL_FN (library, png_set_expand);
+  LOAD_DLL_FN (library, png_set_gray_to_rgb);
+  LOAD_DLL_FN (library, png_set_background);
+  LOAD_DLL_FN (library, png_get_bKGD);
+  LOAD_DLL_FN (library, png_read_update_info);
+  LOAD_DLL_FN (library, png_get_channels);
+  LOAD_DLL_FN (library, png_get_rowbytes);
+  LOAD_DLL_FN (library, png_read_image);
+  LOAD_DLL_FN (library, png_read_end);
+  LOAD_DLL_FN (library, png_error);
+
+#  if (PNG_LIBPNG_VER >= 10500)
+  LOAD_DLL_FN (library, png_longjmp);
+  LOAD_DLL_FN (library, png_set_longjmp_fn);
+#  endif /* libpng version >= 1.5 */
 
   return 1;
 }
-#else
-
-#define fn_png_get_io_ptr               png_get_io_ptr
-#define fn_png_sig_cmp                  png_sig_cmp
-#define fn_png_create_read_struct       png_create_read_struct
-#define fn_png_create_info_struct       png_create_info_struct
-#define fn_png_destroy_read_struct      png_destroy_read_struct
-#define fn_png_set_read_fn              png_set_read_fn
-#define fn_png_set_sig_bytes            png_set_sig_bytes
-#define fn_png_read_info                png_read_info
-#define fn_png_get_IHDR                 png_get_IHDR
-#define fn_png_get_valid                png_get_valid
-#define fn_png_set_strip_16             png_set_strip_16
-#define fn_png_set_expand               png_set_expand
-#define fn_png_set_gray_to_rgb          png_set_gray_to_rgb
-#define fn_png_set_background           png_set_background
-#define fn_png_get_bKGD                 png_get_bKGD
-#define fn_png_read_update_info         png_read_update_info
-#define fn_png_get_channels             png_get_channels
-#define fn_png_get_rowbytes             png_get_rowbytes
-#define fn_png_read_image               png_read_image
-#define fn_png_read_end                 png_read_end
-#define fn_png_error                    png_error
-
-#if (PNG_LIBPNG_VER >= 10500)
-#define fn_png_longjmp                  png_longjmp
-#define fn_png_set_longjmp_fn           png_set_longjmp_fn
-#endif /* libpng version >= 1.5 */
 
-#endif /* WINDOWSNT */
+#  undef png_create_info_struct
+#  undef png_create_read_struct
+#  undef png_destroy_read_struct
+#  undef png_error
+#  undef png_get_bKGD
+#  undef png_get_channels
+#  undef png_get_IHDR
+#  undef png_get_io_ptr
+#  undef png_get_rowbytes
+#  undef png_get_valid
+#  undef png_longjmp
+#  undef png_read_end
+#  undef png_read_image
+#  undef png_read_info
+#  undef png_read_update_info
+#  undef png_set_background
+#  undef png_set_expand
+#  undef png_set_gray_to_rgb
+#  undef png_set_longjmp_fn
+#  undef png_set_read_fn
+#  undef png_set_sig_bytes
+#  undef png_set_strip_16
+#  undef png_sig_cmp
+
+#  define png_create_info_struct fn_png_create_info_struct
+#  define png_create_read_struct fn_png_create_read_struct
+#  define png_destroy_read_struct fn_png_destroy_read_struct
+#  define png_error fn_png_error
+#  define png_get_bKGD fn_png_get_bKGD
+#  define png_get_channels fn_png_get_channels
+#  define png_get_IHDR fn_png_get_IHDR
+#  define png_get_io_ptr fn_png_get_io_ptr
+#  define png_get_rowbytes fn_png_get_rowbytes
+#  define png_get_valid fn_png_get_valid
+#  define png_longjmp fn_png_longjmp
+#  define png_read_end fn_png_read_end
+#  define png_read_image fn_png_read_image
+#  define png_read_info fn_png_read_info
+#  define png_read_update_info fn_png_read_update_info
+#  define png_set_background fn_png_set_background
+#  define png_set_expand fn_png_set_expand
+#  define png_set_gray_to_rgb fn_png_set_gray_to_rgb
+#  define png_set_longjmp_fn fn_png_set_longjmp_fn
+#  define png_set_read_fn fn_png_set_read_fn
+#  define png_set_sig_bytes fn_png_set_sig_bytes
+#  define png_set_strip_16 fn_png_set_strip_16
+#  define png_sig_cmp fn_png_sig_cmp
+
+# endif /* WINDOWSNT */
 
 /* Fast implementations of setjmp and longjmp.  Although setjmp and longjmp
    will do, POSIX _setjmp and _longjmp (if available) are often faster.
    Do not use sys_setjmp, as PNG supports only jmp_buf.
    It's OK if the longjmp substitute restores the signal mask.  */
-#ifdef HAVE__SETJMP
-# define FAST_SETJMP(j) _setjmp (j)
-# define FAST_LONGJMP _longjmp
-#else
-# define FAST_SETJMP(j) setjmp (j)
-# define FAST_LONGJMP longjmp
-#endif
-
-#if PNG_LIBPNG_VER < 10500
-#define PNG_LONGJMP(ptr) FAST_LONGJMP ((ptr)->jmpbuf, 1)
-#define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
-#else
+# ifdef HAVE__SETJMP
+#  define FAST_SETJMP(j) _setjmp (j)
+#  define FAST_LONGJMP _longjmp
+# else
+#  define FAST_SETJMP(j) setjmp (j)
+#  define FAST_LONGJMP longjmp
+# endif
+
+# if PNG_LIBPNG_VER < 10500
+#  define PNG_LONGJMP(ptr) FAST_LONGJMP ((ptr)->jmpbuf, 1)
+#  define PNG_JMPBUF(ptr) ((ptr)->jmpbuf)
+# else
 /* In libpng version 1.5, the jmpbuf member is hidden. (Bug#7908)  */
-#define PNG_LONGJMP(ptr) fn_png_longjmp (ptr, 1)
-#define PNG_JMPBUF(ptr) \
-  (*fn_png_set_longjmp_fn (ptr, FAST_LONGJMP, sizeof (jmp_buf)))
-#endif
+#  define PNG_LONGJMP(ptr) png_longjmp (ptr, 1)
+#  define PNG_JMPBUF(ptr) \
+     (*png_set_longjmp_fn (ptr, FAST_LONGJMP, sizeof (jmp_buf)))
+# endif
 
 /* Error and warning handlers installed when the PNG library
    is initialized.  */
@@ -5697,10 +5707,10 @@ struct png_memory_storage
 static void
 png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  struct png_memory_storage *tbr = fn_png_get_io_ptr (png_ptr);
+  struct png_memory_storage *tbr = png_get_io_ptr (png_ptr);
 
   if (length > tbr->len - tbr->index)
-    fn_png_error (png_ptr, "Read error");
+    png_error (png_ptr, "Read error");
 
   memcpy (data, tbr->bytes + tbr->index, length);
   tbr->index = tbr->index + length;
@@ -5714,10 +5724,10 @@ png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
 static void
 png_read_from_file (png_structp png_ptr, png_bytep data, png_size_t length)
 {
-  FILE *fp = fn_png_get_io_ptr (png_ptr);
+  FILE *fp = png_get_io_ptr (png_ptr);
 
   if (fread (data, 1, length, fp) < length)
-    fn_png_error (png_ptr, "Read error");
+    png_error (png_ptr, "Read error");
 }
 
 
@@ -5779,7 +5789,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
       /* Check PNG signature.  */
       if (fread (sig, 1, sizeof sig, fp) != sizeof sig
-          || fn_png_sig_cmp (sig, 0, sizeof sig))
+          || png_sig_cmp (sig, 0, sizeof sig))
         {
           fclose (fp);
           image_error ("Not a PNG file: `%s'", file, Qnil);
@@ -5801,7 +5811,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
       /* Check PNG signature.  */
       if (tbr.len < sizeof sig
-          || fn_png_sig_cmp (tbr.bytes, 0, sizeof sig))
+          || png_sig_cmp (tbr.bytes, 0, sizeof sig))
         {
           image_error ("Not a PNG image: `%s'", img->spec, Qnil);
           return 0;
@@ -5812,13 +5822,13 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     }
 
   /* Initialize read and info structs for PNG lib.  */
-  png_ptr = fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
+  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
                                        NULL, my_png_error,
                                        my_png_warning);
   if (png_ptr)
     {
-      info_ptr = fn_png_create_info_struct (png_ptr);
-      end_info = fn_png_create_info_struct (png_ptr);
+      info_ptr = png_create_info_struct (png_ptr);
+      end_info = png_create_info_struct (png_ptr);
     }
 
   c->png_ptr = png_ptr;
@@ -5830,7 +5840,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   if (! (info_ptr && end_info))
     {
-      fn_png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
+      png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
       png_ptr = 0;
     }
   if (! png_ptr)
@@ -5845,7 +5855,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     {
     error:
       if (c->png_ptr)
-        fn_png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
+        png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
       xfree (c->pixels);
       xfree (c->rows);
       if (c->fp)
@@ -5858,14 +5868,14 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Read image info.  */
   if (!NILP (specified_data))
-    fn_png_set_read_fn (png_ptr, &tbr, png_read_from_memory);
+    png_set_read_fn (png_ptr, &tbr, png_read_from_memory);
   else
-    fn_png_set_read_fn (png_ptr, fp, png_read_from_file);
+    png_set_read_fn (png_ptr, fp, png_read_from_file);
 
-  fn_png_set_sig_bytes (png_ptr, sizeof sig);
-  fn_png_read_info (png_ptr, info_ptr);
-  fn_png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-                   &interlace_type, NULL, NULL);
+  png_set_sig_bytes (png_ptr, sizeof sig);
+  png_read_info (png_ptr, info_ptr);
+  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+                &interlace_type, NULL, NULL);
 
   if (! (width <= INT_MAX && height <= INT_MAX
          && check_image_size (f, width, height)))
@@ -5881,7 +5891,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* If image contains simply transparency data, we prefer to
      construct a clipping mask.  */
-  if (fn_png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+  if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
     transparent_p = 1;
   else
     transparent_p = 0;
@@ -5892,16 +5902,16 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Strip more than 8 bits per channel.  */
   if (bit_depth == 16)
-    fn_png_set_strip_16 (png_ptr);
+    png_set_strip_16 (png_ptr);
 
   /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
      if available.  */
-  fn_png_set_expand (png_ptr);
+  png_set_expand (png_ptr);
 
   /* Convert grayscale images to RGB.  */
   if (color_type == PNG_COLOR_TYPE_GRAY
       || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
-    fn_png_set_gray_to_rgb (png_ptr);
+    png_set_gray_to_rgb (png_ptr);
 
   /* Handle alpha channel by combining the image with a background
      color.  Do this only if a real alpha channel is supplied.  For
@@ -5927,24 +5937,24 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
           bg.green = color.green >> shift;
           bg.blue = color.blue >> shift;
 
-          fn_png_set_background (png_ptr, &bg,
-                                 PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
+          png_set_background (png_ptr, &bg,
+                              PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
         }
     }
 
   /* Update info structure.  */
-  fn_png_read_update_info (png_ptr, info_ptr);
+  png_read_update_info (png_ptr, info_ptr);
 
   /* Get number of channels.  Valid values are 1 for grayscale images
      and images with a palette, 2 for grayscale images with transparency
      information (alpha channel), 3 for RGB images, and 4 for RGB
      images with alpha channel, i.e. RGBA.  If conversions above were
      sufficient we should only have 3 or 4 channels here.  */
-  channels = fn_png_get_channels (png_ptr, info_ptr);
+  channels = png_get_channels (png_ptr, info_ptr);
   eassert (channels == 3 || channels == 4);
 
   /* Number of bytes needed for one row of the image.  */
-  row_bytes = fn_png_get_rowbytes (png_ptr, info_ptr);
+  row_bytes = png_get_rowbytes (png_ptr, info_ptr);
 
   /* Allocate memory for the image.  */
   if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *rows < height
@@ -5956,8 +5966,8 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
     rows[i] = pixels + i * row_bytes;
 
   /* Read the entire image.  */
-  fn_png_read_image (png_ptr, rows);
-  fn_png_read_end (png_ptr, info_ptr);
+  png_read_image (png_ptr, rows);
+  png_read_end (png_ptr, info_ptr);
   if (fp)
     {
       fclose (fp);
@@ -6021,21 +6031,21 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
        overrode it.  */
     {
       png_color_16 *bg;
-      if (fn_png_get_bKGD (png_ptr, info_ptr, &bg))
+      if (png_get_bKGD (png_ptr, info_ptr, &bg))
         {
           img->background = lookup_rgb_color (f, bg->red, bg->green, bg->blue);
           img->background_valid = 1;
         }
     }
 
-#ifdef COLOR_TABLE_SUPPORT
+# ifdef COLOR_TABLE_SUPPORT
   /* Remember colors allocated for this image.  */
   img->colors = colors_in_color_table (&img->ncolors);
   free_color_table ();
-#endif /* COLOR_TABLE_SUPPORT */
+# endif /* COLOR_TABLE_SUPPORT */
 
   /* Clean up.  */
-  fn_png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
+  png_destroy_read_struct (&c->png_ptr, &c->info_ptr, &c->end_info);
   xfree (rows);
   xfree (pixels);
 
@@ -6170,15 +6180,15 @@ jpeg_image_p (Lisp_Object object)
 
 /* Work around a warning about HAVE_STDLIB_H being redefined in
    jconfig.h.  */
-#ifdef HAVE_STDLIB_H
-#undef HAVE_STDLIB_H
-#endif /* HAVE_STLIB_H */
+# ifdef HAVE_STDLIB_H
+#  undef HAVE_STDLIB_H
+# endif
 
-#if defined (HAVE_NTGUI) && !defined (__WIN32__)
+# if defined (HAVE_NTGUI) && !defined (__WIN32__)
 /* In older releases of the jpeg library, jpeglib.h will define boolean
    differently depending on __WIN32__, so make sure it is defined.  */
-#define __WIN32__ 1
-#endif
+#  define __WIN32__ 1
+# endif
 
 /* rpcndr.h (via windows.h) and jpeglib.h both define boolean types.
    Some versions of jpeglib try to detect whether rpcndr.h is loaded,
@@ -6194,23 +6204,25 @@ jpeg_image_p (Lisp_Object object)
    different name.  This name, jpeg_boolean, remains in effect through
    the rest of image.c.
 */
-#if defined CYGWIN && defined HAVE_NTGUI
-#define boolean jpeg_boolean
-#endif
-#include <jpeglib.h>
-#include <jerror.h>
+# if defined CYGWIN && defined HAVE_NTGUI
+#  define boolean jpeg_boolean
+# endif
+# include <jpeglib.h>
+# include <jerror.h>
 
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
 
 /* JPEG library details.  */
-DEF_IMGLIB_FN (void, jpeg_CreateDecompress, (j_decompress_ptr, int, size_t));
-DEF_IMGLIB_FN (boolean, jpeg_start_decompress, (j_decompress_ptr));
-DEF_IMGLIB_FN (boolean, jpeg_finish_decompress, (j_decompress_ptr));
-DEF_IMGLIB_FN (void, jpeg_destroy_decompress, (j_decompress_ptr));
-DEF_IMGLIB_FN (int, jpeg_read_header, (j_decompress_ptr, boolean));
-DEF_IMGLIB_FN (JDIMENSION, jpeg_read_scanlines, (j_decompress_ptr, JSAMPARRAY, JDIMENSION));
-DEF_IMGLIB_FN (struct jpeg_error_mgr *, jpeg_std_error, (struct jpeg_error_mgr *));
-DEF_IMGLIB_FN (boolean, jpeg_resync_to_restart, (j_decompress_ptr, int));
+DEF_DLL_FN (void, jpeg_CreateDecompress, (j_decompress_ptr, int, size_t));
+DEF_DLL_FN (boolean, jpeg_start_decompress, (j_decompress_ptr));
+DEF_DLL_FN (boolean, jpeg_finish_decompress, (j_decompress_ptr));
+DEF_DLL_FN (void, jpeg_destroy_decompress, (j_decompress_ptr));
+DEF_DLL_FN (int, jpeg_read_header, (j_decompress_ptr, boolean));
+DEF_DLL_FN (JDIMENSION, jpeg_read_scanlines,
+            (j_decompress_ptr, JSAMPARRAY, JDIMENSION));
+DEF_DLL_FN (struct jpeg_error_mgr *, jpeg_std_error,
+            (struct jpeg_error_mgr *));
+DEF_DLL_FN (boolean, jpeg_resync_to_restart, (j_decompress_ptr, int));
 
 static bool
 init_jpeg_functions (void)
@@ -6220,37 +6232,46 @@ init_jpeg_functions (void)
   if (!(library = w32_delayed_load (Qjpeg)))
     return 0;
 
-  LOAD_IMGLIB_FN (library, jpeg_finish_decompress);
-  LOAD_IMGLIB_FN (library, jpeg_read_scanlines);
-  LOAD_IMGLIB_FN (library, jpeg_start_decompress);
-  LOAD_IMGLIB_FN (library, jpeg_read_header);
-  LOAD_IMGLIB_FN (library, jpeg_CreateDecompress);
-  LOAD_IMGLIB_FN (library, jpeg_destroy_decompress);
-  LOAD_IMGLIB_FN (library, jpeg_std_error);
-  LOAD_IMGLIB_FN (library, jpeg_resync_to_restart);
+  LOAD_DLL_FN (library, jpeg_finish_decompress);
+  LOAD_DLL_FN (library, jpeg_read_scanlines);
+  LOAD_DLL_FN (library, jpeg_start_decompress);
+  LOAD_DLL_FN (library, jpeg_read_header);
+  LOAD_DLL_FN (library, jpeg_CreateDecompress);
+  LOAD_DLL_FN (library, jpeg_destroy_decompress);
+  LOAD_DLL_FN (library, jpeg_std_error);
+  LOAD_DLL_FN (library, jpeg_resync_to_restart);
   return 1;
 }
 
+#  undef jpeg_CreateDecompress
+#  undef jpeg_destroy_decompress
+#  undef jpeg_finish_decompress
+#  undef jpeg_read_header
+#  undef jpeg_read_scanlines
+#  undef jpeg_resync_to_restart
+#  undef jpeg_start_decompress
+#  undef jpeg_std_error
+
+#  define jpeg_CreateDecompress fn_jpeg_CreateDecompress
+#  define jpeg_destroy_decompress fn_jpeg_destroy_decompress
+#  define jpeg_finish_decompress fn_jpeg_finish_decompress
+#  define jpeg_read_header fn_jpeg_read_header
+#  define jpeg_read_scanlines fn_jpeg_read_scanlines
+#  define jpeg_resync_to_restart fn_jpeg_resync_to_restart
+#  define jpeg_start_decompress fn_jpeg_start_decompress
+#  define jpeg_std_error fn_jpeg_std_error
+
 /* Wrapper since we can't directly assign the function pointer
    to another function pointer that was declared more completely easily.  */
 static boolean
 jpeg_resync_to_restart_wrapper (j_decompress_ptr cinfo, int desired)
 {
-  return fn_jpeg_resync_to_restart (cinfo, desired);
+  return jpeg_resync_to_restart (cinfo, desired);
 }
+#  undef jpeg_resync_to_restart
+#  define jpeg_resync_to_restart jpeg_resync_to_restart_wrapper
 
-#else
-
-#define fn_jpeg_CreateDecompress(a,b,c) jpeg_create_decompress (a)
-#define fn_jpeg_start_decompress        jpeg_start_decompress
-#define fn_jpeg_finish_decompress       jpeg_finish_decompress
-#define fn_jpeg_destroy_decompress      jpeg_destroy_decompress
-#define fn_jpeg_read_header             jpeg_read_header
-#define fn_jpeg_read_scanlines          jpeg_read_scanlines
-#define fn_jpeg_std_error               jpeg_std_error
-#define jpeg_resync_to_restart_wrapper  jpeg_resync_to_restart
-
-#endif /* WINDOWSNT */
+# endif /* WINDOWSNT */
 
 struct my_jpeg_error_mgr
 {
@@ -6358,7 +6379,7 @@ jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, ptrdiff_t len)
   src->init_source = our_common_init_source;
   src->fill_input_buffer = our_memory_fill_input_buffer;
   src->skip_input_data = our_memory_skip_input_data;
-  src->resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method.  */
+  src->resync_to_restart = jpeg_resync_to_restart; /* Use default method.  */
   src->term_source = our_common_term_source;
   src->bytes_in_buffer = len;
   src->next_input_byte = data;
@@ -6464,7 +6485,7 @@ jpeg_file_src (j_decompress_ptr cinfo, FILE *fp)
   src->mgr.init_source = our_common_init_source;
   src->mgr.fill_input_buffer = our_stdio_fill_input_buffer;
   src->mgr.skip_input_data = our_stdio_skip_input_data;
-  src->mgr.resync_to_restart = jpeg_resync_to_restart_wrapper; /* Use default method.  */
+  src->mgr.resync_to_restart = jpeg_resync_to_restart; /* Use default.  */
   src->mgr.term_source = our_common_term_source;
   src->mgr.bytes_in_buffer = 0;
   src->mgr.next_input_byte = NULL;
@@ -6515,7 +6536,7 @@ jpeg_load_body (struct frame *f, struct image *img,
 
   /* Customize libjpeg's error handling to call my_error_exit when an
      error is detected.  This function will perform a longjmp.  */
-  mgr->cinfo.err = fn_jpeg_std_error (&mgr->pub);
+  mgr->cinfo.err = jpeg_std_error (&mgr->pub);
   mgr->pub.error_exit = my_error_exit;
   if (sys_setjmp (mgr->setjmp_buffer))
     {
@@ -6541,7 +6562,7 @@ jpeg_load_body (struct frame *f, struct image *img,
       /* Close the input file and destroy the JPEG object.  */
       if (fp)
         fclose (fp);
-      fn_jpeg_destroy_decompress (&mgr->cinfo);
+      jpeg_destroy_decompress (&mgr->cinfo);
 
       /* If we already have an XImage, free that.  */
       x_destroy_x_image (ximg);
@@ -6553,7 +6574,7 @@ jpeg_load_body (struct frame *f, struct image *img,
 
   /* Create the JPEG decompression object.  Let it read from fp.
          Read the JPEG image header.  */
-  fn_jpeg_CreateDecompress (&mgr->cinfo, JPEG_LIB_VERSION, sizeof *&mgr->cinfo);
+  jpeg_CreateDecompress (&mgr->cinfo, JPEG_LIB_VERSION, sizeof *&mgr->cinfo);
 
   if (NILP (specified_data))
     jpeg_file_src (&mgr->cinfo, fp);
@@ -6561,12 +6582,12 @@ jpeg_load_body (struct frame *f, struct image *img,
     jpeg_memory_src (&mgr->cinfo, SDATA (specified_data),
                      SBYTES (specified_data));
 
-  fn_jpeg_read_header (&mgr->cinfo, 1);
+  jpeg_read_header (&mgr->cinfo, 1);
 
   /* Customize decompression so that color quantization will be used.
          Start decompression.  */
   mgr->cinfo.quantize_colors = 1;
-  fn_jpeg_start_decompress (&mgr->cinfo);
+  jpeg_start_decompress (&mgr->cinfo);
   width = img->width = mgr->cinfo.output_width;
   height = img->height = mgr->cinfo.output_height;
 
@@ -6629,14 +6650,14 @@ jpeg_load_body (struct frame *f, struct image *img,
                                          JPOOL_IMAGE, row_stride, 1);
   for (y = 0; y < height; ++y)
     {
-      fn_jpeg_read_scanlines (&mgr->cinfo, buffer, 1);
+      jpeg_read_scanlines (&mgr->cinfo, buffer, 1);
       for (x = 0; x < mgr->cinfo.output_width; ++x)
         XPutPixel (ximg, x, y, colors[buffer[0][x]]);
     }
 
   /* Clean up.  */
-  fn_jpeg_finish_decompress (&mgr->cinfo);
-  fn_jpeg_destroy_decompress (&mgr->cinfo);
+  jpeg_finish_decompress (&mgr->cinfo);
+  jpeg_destroy_decompress (&mgr->cinfo);
   if (fp)
     fclose (fp);
 
@@ -6760,22 +6781,22 @@ tiff_image_p (Lisp_Object object)
 
 #ifdef HAVE_TIFF
 
-#include <tiffio.h>
+# include <tiffio.h>
 
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
 
 /* TIFF library details.  */
-DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler));
-DEF_IMGLIB_FN (TIFFErrorHandler, TIFFSetWarningHandler, (TIFFErrorHandler));
-DEF_IMGLIB_FN (TIFF *, TIFFOpen, (const char *, const char *));
-DEF_IMGLIB_FN (TIFF *, TIFFClientOpen, (const char *, const char *, thandle_t,
-                                TIFFReadWriteProc, TIFFReadWriteProc,
-                                TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
-                                TIFFMapFileProc, TIFFUnmapFileProc));
-DEF_IMGLIB_FN (int, TIFFGetField, (TIFF *, ttag_t, ...));
-DEF_IMGLIB_FN (int, TIFFReadRGBAImage, (TIFF *, uint32, uint32, uint32 *, int));
-DEF_IMGLIB_FN (void, TIFFClose, (TIFF *));
-DEF_IMGLIB_FN (int, TIFFSetDirectory, (TIFF *, tdir_t));
+DEF_DLL_FN (TIFFErrorHandler, TIFFSetErrorHandler, (TIFFErrorHandler));
+DEF_DLL_FN (TIFFErrorHandler, TIFFSetWarningHandler, (TIFFErrorHandler));
+DEF_DLL_FN (TIFF *, TIFFOpen, (const char *, const char *));
+DEF_DLL_FN (TIFF *, TIFFClientOpen,
+            (const char *, const char *, thandle_t, TIFFReadWriteProc,
+             TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
+             TIFFMapFileProc, TIFFUnmapFileProc));
+DEF_DLL_FN (int, TIFFGetField, (TIFF *, ttag_t, ...));
+DEF_DLL_FN (int, TIFFReadRGBAImage, (TIFF *, uint32, uint32, uint32 *, int));
+DEF_DLL_FN (void, TIFFClose, (TIFF *));
+DEF_DLL_FN (int, TIFFSetDirectory, (TIFF *, tdir_t));
 
 static bool
 init_tiff_functions (void)
@@ -6785,28 +6806,36 @@ init_tiff_functions (void)
   if (!(library = w32_delayed_load (Qtiff)))
     return 0;
 
-  LOAD_IMGLIB_FN (library, TIFFSetErrorHandler);
-  LOAD_IMGLIB_FN (library, TIFFSetWarningHandler);
-  LOAD_IMGLIB_FN (library, TIFFOpen);
-  LOAD_IMGLIB_FN (library, TIFFClientOpen);
-  LOAD_IMGLIB_FN (library, TIFFGetField);
-  LOAD_IMGLIB_FN (library, TIFFReadRGBAImage);
-  LOAD_IMGLIB_FN (library, TIFFClose);
-  LOAD_IMGLIB_FN (library, TIFFSetDirectory);
+  LOAD_DLL_FN (library, TIFFSetErrorHandler);
+  LOAD_DLL_FN (library, TIFFSetWarningHandler);
+  LOAD_DLL_FN (library, TIFFOpen);
+  LOAD_DLL_FN (library, TIFFClientOpen);
+  LOAD_DLL_FN (library, TIFFGetField);
+  LOAD_DLL_FN (library, TIFFReadRGBAImage);
+  LOAD_DLL_FN (library, TIFFClose);
+  LOAD_DLL_FN (library, TIFFSetDirectory);
   return 1;
 }
 
-#else
+#  undef TIFFClientOpen
+#  undef TIFFClose
+#  undef TIFFGetField
+#  undef TIFFOpen
+#  undef TIFFReadRGBAImage
+#  undef TIFFSetDirectory
+#  undef TIFFSetErrorHandler
+#  undef TIFFSetWarningHandler
 
-#define fn_TIFFSetErrorHandler          TIFFSetErrorHandler
-#define fn_TIFFSetWarningHandler        TIFFSetWarningHandler
-#define fn_TIFFOpen                     TIFFOpen
-#define fn_TIFFClientOpen               TIFFClientOpen
-#define fn_TIFFGetField                 TIFFGetField
-#define fn_TIFFReadRGBAImage            TIFFReadRGBAImage
-#define fn_TIFFClose                    TIFFClose
-#define fn_TIFFSetDirectory             TIFFSetDirectory
-#endif /* WINDOWSNT */
+#  define TIFFClientOpen fn_TIFFClientOpen
+#  define TIFFClose fn_TIFFClose
+#  define TIFFGetField fn_TIFFGetField
+#  define TIFFOpen fn_TIFFOpen
+#  define TIFFReadRGBAImage fn_TIFFReadRGBAImage
+#  define TIFFSetDirectory fn_TIFFSetDirectory
+#  define TIFFSetErrorHandler fn_TIFFSetErrorHandler
+#  define TIFFSetWarningHandler fn_TIFFSetWarningHandler
+
+# endif /* WINDOWSNT */
 
 
 /* Reading from a memory buffer for TIFF images Based on the PNG
@@ -6904,11 +6933,11 @@ tiff_size_of_memory (thandle_t data)
    compiler error compiling tiff_handler, see Bugzilla bug #17406
    (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=17406).  Declaring
    this function as external works around that problem.  */
-#if defined (__MINGW32__) && __GNUC__ == 3
-# define MINGW_STATIC
-#else
-# define MINGW_STATIC static
-#endif
+# if defined (__MINGW32__) && __GNUC__ == 3
+#  define MINGW_STATIC
+# else
+#  define MINGW_STATIC static
+# endif
 
 MINGW_STATIC void
 tiff_handler (const char *, const char *, const char *, va_list)
@@ -6927,7 +6956,7 @@ tiff_handler (const char *log_format, const char *title,
   add_to_log (log_format, build_string (title),
               make_string (buf, max (0, min (len, sizeof buf - 1))));
 }
-#undef MINGW_STATIC
+# undef MINGW_STATIC
 
 static void tiff_error_handler (const char *, const char *, va_list)
   ATTRIBUTE_FORMAT_PRINTF (2, 0);
@@ -6966,8 +6995,8 @@ tiff_load (struct frame *f, struct image *img)
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
 
-  fn_TIFFSetErrorHandler ((TIFFErrorHandler) tiff_error_handler);
-  fn_TIFFSetWarningHandler ((TIFFErrorHandler) tiff_warning_handler);
+  TIFFSetErrorHandler ((TIFFErrorHandler) tiff_error_handler);
+  TIFFSetWarningHandler ((TIFFErrorHandler) tiff_warning_handler);
 
   if (NILP (specified_data))
     {
@@ -6978,12 +7007,12 @@ tiff_load (struct frame *f, struct image *img)
           image_error ("Cannot find image file `%s'", specified_file, Qnil);
           return 0;
         }
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
       file = ansi_encode_filename (file);
-#endif
+# endif
 
       /* Try to open the image file.  */
-      tiff = fn_TIFFOpen (SSDATA (file), "r");
+      tiff = TIFFOpen (SSDATA (file), "r");
       if (tiff == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
@@ -7003,14 +7032,14 @@ tiff_load (struct frame *f, struct image *img)
       memsrc.len = SBYTES (specified_data);
       memsrc.index = 0;
 
-      tiff = fn_TIFFClientOpen ("memory_source", "r", (thandle_t)&memsrc,
-                                tiff_read_from_memory,
-                                tiff_write_from_memory,
-                                tiff_seek_in_memory,
-                                tiff_close_memory,
-                                tiff_size_of_memory,
-                                tiff_mmap_memory,
-                                tiff_unmap_memory);
+      tiff = TIFFClientOpen ("memory_source", "r", (thandle_t)&memsrc,
+                             tiff_read_from_memory,
+                             tiff_write_from_memory,
+                             tiff_seek_in_memory,
+                             tiff_close_memory,
+                             tiff_size_of_memory,
+                             tiff_mmap_memory,
+                             tiff_unmap_memory);
 
       if (!tiff)
         {
@@ -7024,24 +7053,24 @@ tiff_load (struct frame *f, struct image *img)
     {
       EMACS_INT ino = XFASTINT (image);
       if (! (TYPE_MINIMUM (tdir_t) <= ino && ino <= TYPE_MAXIMUM (tdir_t)
-             && fn_TIFFSetDirectory (tiff, ino)))
+             && TIFFSetDirectory (tiff, ino)))
         {
           image_error ("Invalid image number `%s' in image `%s'",
                        image, img->spec);
-          fn_TIFFClose (tiff);
+          TIFFClose (tiff);
           return 0;
         }
     }
 
   /* Get width and height of the image, and allocate a raster buffer
      of width x height 32-bit values.  */
-  fn_TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
-  fn_TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
+  TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
+  TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
 
   if (!check_image_size (f, width, height))
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
-      fn_TIFFClose (tiff);
+      TIFFClose (tiff);
       return 0;
     }
 
@@ -7050,16 +7079,16 @@ tiff_load (struct frame *f, struct image *img)
          && image_create_x_image_and_pixmap (f, img, width, height, 0,
                                              &ximg, 0)))
     {
-      fn_TIFFClose (tiff);
+      TIFFClose (tiff);
       return 0;
     }
 
   buf = xmalloc (sizeof *buf * width * height);
 
-  rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
+  rc = TIFFReadRGBAImage (tiff, width, height, buf, 0);
 
   /* Count the number of images in the file.  */
-  for (count = 1; fn_TIFFSetDirectory (tiff, count); count++)
+  for (count = 1; TIFFSetDirectory (tiff, count); count++)
     continue;
 
   if (count > 1)
@@ -7067,7 +7096,7 @@ tiff_load (struct frame *f, struct image *img)
                             Fcons (make_number (count),
                                    img->lisp_data));
 
-  fn_TIFFClose (tiff);
+  TIFFClose (tiff);
   if (!rc)
     {
       image_error ("Error reading TIFF image `%s'", img->spec, Qnil);
@@ -7093,11 +7122,11 @@ tiff_load (struct frame *f, struct image *img)
         }
     }
 
-#ifdef COLOR_TABLE_SUPPORT
+# ifdef COLOR_TABLE_SUPPORT
   /* Remember the colors allocated for the image.  Free the color table.  */
   img->colors = colors_in_color_table (&img->ncolors);
   free_color_table ();
-#endif /* COLOR_TABLE_SUPPORT */
+# endif /* COLOR_TABLE_SUPPORT */
 
   img->width = width;
   img->height = height;
@@ -7114,9 +7143,8 @@ tiff_load (struct frame *f, struct image *img)
   return 1;
 }
 
-#else /* HAVE_TIFF */
+#elif defined HAVE_NS
 
-#ifdef HAVE_NS
 static bool
 tiff_load (struct frame *f, struct image *img)
 {
@@ -7124,9 +7152,8 @@ tiff_load (struct frame *f, struct image *img)
                         image_spec_value (img->spec, QCfile, NULL),
                         image_spec_value (img->spec, QCdata, NULL));
 }
-#endif  /* HAVE_NS */
 
-#endif /* !HAVE_TIFF */
+#endif
 
 
 
@@ -7226,54 +7253,54 @@ gif_image_p (Lisp_Object object)
 
 #ifdef HAVE_GIF
 
-#if defined (HAVE_NTGUI)
+# ifdef HAVE_NTGUI
 
 /* winuser.h might define DrawText to DrawTextA or DrawTextW.
    Undefine before redefining to avoid a preprocessor warning.  */
-#ifdef DrawText
-#undef DrawText
-#endif
+#  ifdef DrawText
+#   undef DrawText
+#  endif
 /* avoid conflict with QuickdrawText.h */
-#define DrawText gif_DrawText
-#include <gif_lib.h>
-#undef DrawText
+#  define DrawText gif_DrawText
+#  include <gif_lib.h>
+#  undef DrawText
 
 /* Giflib before 5.0 didn't define these macros (used only if HAVE_NTGUI).  */
-#ifndef GIFLIB_MINOR
-#define GIFLIB_MINOR 0
-#endif
-#ifndef GIFLIB_RELEASE
-#define GIFLIB_RELEASE 0
-#endif
+#  ifndef GIFLIB_MINOR
+#   define GIFLIB_MINOR 0
+#  endif
+#  ifndef GIFLIB_RELEASE
+#   define GIFLIB_RELEASE 0
+#  endif
 
-#else /* HAVE_NTGUI */
+# else /* HAVE_NTGUI */
 
-#include <gif_lib.h>
+#  include <gif_lib.h>
 
-#endif /* HAVE_NTGUI */
+# endif /* HAVE_NTGUI */
 
 /* Giflib before 5.0 didn't define these macros.  */
-#ifndef GIFLIB_MAJOR
-#define GIFLIB_MAJOR 4
-#endif
+# ifndef GIFLIB_MAJOR
+#  define GIFLIB_MAJOR 4
+# endif
 
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
 
 /* GIF library details.  */
-#if 5 < GIFLIB_MAJOR + (1 <= GIFLIB_MINOR)
-DEF_IMGLIB_FN (int, DGifCloseFile, (GifFileType *, int *));
-#else
-DEF_IMGLIB_FN (int, DGifCloseFile, (GifFileType *));
-#endif
-DEF_IMGLIB_FN (int, DGifSlurp, (GifFileType *));
-#if GIFLIB_MAJOR < 5
-DEF_IMGLIB_FN (GifFileType *, DGifOpen, (void *, InputFunc));
-DEF_IMGLIB_FN (GifFileType *, DGifOpenFileName, (const char *));
-#else
-DEF_IMGLIB_FN (GifFileType *, DGifOpen, (void *, InputFunc, int *));
-DEF_IMGLIB_FN (GifFileType *, DGifOpenFileName, (const char *, int *));
-DEF_IMGLIB_FN (char *, GifErrorString, (int));
-#endif
+#  if 5 < GIFLIB_MAJOR + (1 <= GIFLIB_MINOR)
+DEF_DLL_FN (int, DGifCloseFile, (GifFileType *, int *));
+#   else
+DEF_DLL_FN (int, DGifCloseFile, (GifFileType *));
+#  endif
+DEF_DLL_FN (int, DGifSlurp, (GifFileType *));
+#  if GIFLIB_MAJOR < 5
+DEF_DLL_FN (GifFileType *, DGifOpen, (void *, InputFunc));
+DEF_DLL_FN (GifFileType *, DGifOpenFileName, (const char *));
+#  else
+DEF_DLL_FN (GifFileType *, DGifOpen, (void *, InputFunc, int *));
+DEF_DLL_FN (GifFileType *, DGifOpenFileName, (const char *, int *));
+DEF_DLL_FN (char *, GifErrorString, (int));
+#  endif
 
 static bool
 init_gif_functions (void)
@@ -7283,27 +7310,29 @@ init_gif_functions (void)
   if (!(library = w32_delayed_load (Qgif)))
     return 0;
 
-  LOAD_IMGLIB_FN (library, DGifCloseFile);
-  LOAD_IMGLIB_FN (library, DGifSlurp);
-  LOAD_IMGLIB_FN (library, DGifOpen);
-  LOAD_IMGLIB_FN (library, DGifOpenFileName);
-#if GIFLIB_MAJOR >= 5
-  LOAD_IMGLIB_FN (library, GifErrorString);
-#endif
+  LOAD_DLL_FN (library, DGifCloseFile);
+  LOAD_DLL_FN (library, DGifSlurp);
+  LOAD_DLL_FN (library, DGifOpen);
+  LOAD_DLL_FN (library, DGifOpenFileName);
+#  if GIFLIB_MAJOR >= 5
+  LOAD_DLL_FN (library, GifErrorString);
+#  endif
   return 1;
 }
 
-#else
+#  undef DGifCloseFile
+#  undef DGifOpen
+#  undef DGifOpenFileName
+#  undef DGifSlurp
+#  undef GifErrorString
 
-#define fn_DGifCloseFile        DGifCloseFile
-#define fn_DGifSlurp            DGifSlurp
-#define fn_DGifOpen             DGifOpen
-#define fn_DGifOpenFileName     DGifOpenFileName
-#if 5 <= GIFLIB_MAJOR
-# define fn_GifErrorString      GifErrorString
-#endif
+#  define DGifCloseFile fn_DGifCloseFile
+#  define DGifOpen fn_DGifOpen
+#  define DGifOpenFileName fn_DGifOpenFileName
+#  define DGifSlurp fn_DGifSlurp
+#  define GifErrorString fn_GifErrorString
 
-#endif /* WINDOWSNT */
+# endif /* WINDOWSNT */
 
 /* Reading a GIF image from memory
    Based on the PNG memory stuff to a certain extent. */
@@ -7340,9 +7369,9 @@ gif_close (GifFileType *gif, int *err)
   int retval;
 
 #if 5 < GIFLIB_MAJOR + (1 <= GIFLIB_MINOR)
-  retval = fn_DGifCloseFile (gif, err);
+  retval = DGifCloseFile (gif, err);
 #else
-  retval = fn_DGifCloseFile (gif);
+  retval = DGifCloseFile (gif);
 #if GIFLIB_MAJOR >= 5
   if (err)
     *err = gif->Error;
@@ -7390,18 +7419,18 @@ gif_load (struct frame *f, struct image *img)
 
       /* Open the GIF file.  */
 #if GIFLIB_MAJOR < 5
-      gif = fn_DGifOpenFileName (SSDATA (file));
+      gif = DGifOpenFileName (SSDATA (file));
       if (gif == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
           return 0;
         }
 #else
-      gif = fn_DGifOpenFileName (SSDATA (file), &gif_err);
+      gif = DGifOpenFileName (SSDATA (file), &gif_err);
       if (gif == NULL)
         {
           image_error ("Cannot open `%s': %s",
-                       file, build_string (fn_GifErrorString (gif_err)));
+                       file, build_string (GifErrorString (gif_err)));
           return 0;
         }
 #endif
@@ -7421,18 +7450,18 @@ gif_load (struct frame *f, struct image *img)
       memsrc.index = 0;
 
 #if GIFLIB_MAJOR < 5
-      gif = fn_DGifOpen (&memsrc, gif_read_from_memory);
+      gif = DGifOpen (&memsrc, gif_read_from_memory);
       if (!gif)
         {
           image_error ("Cannot open memory source `%s'", img->spec, Qnil);
           return 0;
         }
 #else
-      gif = fn_DGifOpen (&memsrc, gif_read_from_memory, &gif_err);
+      gif = DGifOpen (&memsrc, gif_read_from_memory, &gif_err);
       if (!gif)
         {
           image_error ("Cannot open memory source `%s': %s",
-                       img->spec, build_string (fn_GifErrorString (gif_err)));
+                       img->spec, build_string (GifErrorString (gif_err)));
           return 0;
         }
 #endif
@@ -7447,7 +7476,7 @@ gif_load (struct frame *f, struct image *img)
     }
 
   /* Read entire contents.  */
-  rc = fn_DGifSlurp (gif);
+  rc = DGifSlurp (gif);
   if (rc == GIF_ERROR || gif->ImageCount <= 0)
     {
       image_error ("Error reading `%s'", img->spec, Qnil);
@@ -7681,7 +7710,7 @@ gif_load (struct frame *f, struct image *img)
   if (gif_close (gif, &gif_err) == GIF_ERROR)
     {
 #if 5 <= GIFLIB_MAJOR
-      char *error_text = fn_GifErrorString (gif_err);
+      char *error_text = GifErrorString (gif_err);
 
       if (error_text)
         image_error ("Error closing `%s': %s",
@@ -8593,7 +8622,7 @@ and `imagemagick-types-inhibit'.  */)
                                  SVG
  ***********************************************************************/
 
-#if defined (HAVE_RSVG)
+#ifdef HAVE_RSVG
 
 /* Function prototypes.  */
 
@@ -8641,11 +8670,11 @@ static const struct image_keyword svg_format[SVG_LAST] =
   {":background",       IMAGE_STRING_OR_NIL_VALUE,              0}
 };
 
-#if defined HAVE_NTGUI && defined WINDOWSNT
+# if defined HAVE_NTGUI && defined WINDOWSNT
 static bool init_svg_functions (void);
-#else
+# else
 #define init_svg_functions NULL
-#endif
+# endif
 
 /* Structure describing the image type `svg'.  Its the same type of
    structure defined for all image formats, handled by emacs image
@@ -8679,32 +8708,34 @@ svg_image_p (Lisp_Object object)
   return fmt[SVG_FILE].count + fmt[SVG_DATA].count == 1;
 }
 
-#include <librsvg/rsvg.h>
+# include <librsvg/rsvg.h>
 
-#ifdef WINDOWSNT
+# ifdef WINDOWSNT
 
 /* SVG library functions.  */
-DEF_IMGLIB_FN (RsvgHandle *, rsvg_handle_new, (void));
-DEF_IMGLIB_FN (void, rsvg_handle_get_dimensions, (RsvgHandle *, RsvgDimensionData *));
-DEF_IMGLIB_FN (gboolean, rsvg_handle_write, (RsvgHandle *, const guchar *, gsize, GError **));
-DEF_IMGLIB_FN (gboolean, rsvg_handle_close, (RsvgHandle *, GError **));
-DEF_IMGLIB_FN (GdkPixbuf *, rsvg_handle_get_pixbuf, (RsvgHandle *));
-DEF_IMGLIB_FN (void, rsvg_handle_set_base_uri, (RsvgHandle *, const char *));
-
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_width, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_height, (const GdkPixbuf *));
-DEF_IMGLIB_FN (guchar *, gdk_pixbuf_get_pixels, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_rowstride, (const GdkPixbuf *));
-DEF_IMGLIB_FN (GdkColorspace, gdk_pixbuf_get_colorspace, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_n_channels, (const GdkPixbuf *));
-DEF_IMGLIB_FN (gboolean, gdk_pixbuf_get_has_alpha, (const GdkPixbuf *));
-DEF_IMGLIB_FN (int, gdk_pixbuf_get_bits_per_sample, (const GdkPixbuf *));
-
-#if ! GLIB_CHECK_VERSION (2, 36, 0)
-DEF_IMGLIB_FN (void, g_type_init, (void));
-#endif
-DEF_IMGLIB_FN (void, g_object_unref, (gpointer));
-DEF_IMGLIB_FN (void, g_error_free, (GError *));
+DEF_DLL_FN (RsvgHandle *, rsvg_handle_new, (void));
+DEF_DLL_FN (void, rsvg_handle_get_dimensions,
+            (RsvgHandle *, RsvgDimensionData *));
+DEF_DLL_FN (gboolean, rsvg_handle_write,
+            (RsvgHandle *, const guchar *, gsize, GError **));
+DEF_DLL_FN (gboolean, rsvg_handle_close, (RsvgHandle *, GError **));
+DEF_DLL_FN (GdkPixbuf *, rsvg_handle_get_pixbuf, (RsvgHandle *));
+DEF_DLL_FN (void, rsvg_handle_set_base_uri, (RsvgHandle *, const char *));
+
+DEF_DLL_FN (int, gdk_pixbuf_get_width, (const GdkPixbuf *));
+DEF_DLL_FN (int, gdk_pixbuf_get_height, (const GdkPixbuf *));
+DEF_DLL_FN (guchar *, gdk_pixbuf_get_pixels, (const GdkPixbuf *));
+DEF_DLL_FN (int, gdk_pixbuf_get_rowstride, (const GdkPixbuf *));
+DEF_DLL_FN (GdkColorspace, gdk_pixbuf_get_colorspace, (const GdkPixbuf *));
+DEF_DLL_FN (int, gdk_pixbuf_get_n_channels, (const GdkPixbuf *));
+DEF_DLL_FN (gboolean, gdk_pixbuf_get_has_alpha, (const GdkPixbuf *));
+DEF_DLL_FN (int, gdk_pixbuf_get_bits_per_sample, (const GdkPixbuf *));
+
+#  if ! GLIB_CHECK_VERSION (2, 36, 0)
+DEF_DLL_FN (void, g_type_init, (void));
+#  endif
+DEF_DLL_FN (void, g_object_unref, (gpointer));
+DEF_DLL_FN (void, g_error_free, (GError *));
 
 Lisp_Object Qgdk_pixbuf, Qglib, Qgobject;
 
@@ -8724,56 +8755,71 @@ init_svg_functions (void)
       return 0;
     }
 
-  LOAD_IMGLIB_FN (library, rsvg_handle_new);
-  LOAD_IMGLIB_FN (library, rsvg_handle_get_dimensions);
-  LOAD_IMGLIB_FN (library, rsvg_handle_write);
-  LOAD_IMGLIB_FN (library, rsvg_handle_close);
-  LOAD_IMGLIB_FN (library, rsvg_handle_get_pixbuf);
-  LOAD_IMGLIB_FN (library, rsvg_handle_set_base_uri);
-
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_width);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_height);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_pixels);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_rowstride);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_colorspace);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_n_channels);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_has_alpha);
-  LOAD_IMGLIB_FN (gdklib, gdk_pixbuf_get_bits_per_sample);
-
-#if ! GLIB_CHECK_VERSION (2, 36, 0)
-  LOAD_IMGLIB_FN (gobject, g_type_init);
-#endif
-  LOAD_IMGLIB_FN (gobject, g_object_unref);
-  LOAD_IMGLIB_FN (glib, g_error_free);
+  LOAD_DLL_FN (library, rsvg_handle_new);
+  LOAD_DLL_FN (library, rsvg_handle_get_dimensions);
+  LOAD_DLL_FN (library, rsvg_handle_write);
+  LOAD_DLL_FN (library, rsvg_handle_close);
+  LOAD_DLL_FN (library, rsvg_handle_get_pixbuf);
+  LOAD_DLL_FN (library, rsvg_handle_set_base_uri);
+
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_width);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_height);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_pixels);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_rowstride);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_colorspace);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_n_channels);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_has_alpha);
+  LOAD_DLL_FN (gdklib, gdk_pixbuf_get_bits_per_sample);
+
+#  if ! GLIB_CHECK_VERSION (2, 36, 0)
+  LOAD_DLL_FN (gobject, g_type_init);
+#  endif
+  LOAD_DLL_FN (gobject, g_object_unref);
+  LOAD_DLL_FN (glib, g_error_free);
 
   return 1;
 }
 
-#else
 /* The following aliases for library functions allow dynamic loading
    to be used on some platforms.  */
-#define fn_rsvg_handle_new              rsvg_handle_new
-#define fn_rsvg_handle_get_dimensions   rsvg_handle_get_dimensions
-#define fn_rsvg_handle_write            rsvg_handle_write
-#define fn_rsvg_handle_close            rsvg_handle_close
-#define fn_rsvg_handle_get_pixbuf       rsvg_handle_get_pixbuf
-#define fn_rsvg_handle_set_base_uri     rsvg_handle_set_base_uri
-
-#define fn_gdk_pixbuf_get_width           gdk_pixbuf_get_width
-#define fn_gdk_pixbuf_get_height          gdk_pixbuf_get_height
-#define fn_gdk_pixbuf_get_pixels          gdk_pixbuf_get_pixels
-#define fn_gdk_pixbuf_get_rowstride       gdk_pixbuf_get_rowstride
-#define fn_gdk_pixbuf_get_colorspace      gdk_pixbuf_get_colorspace
-#define fn_gdk_pixbuf_get_n_channels      gdk_pixbuf_get_n_channels
-#define fn_gdk_pixbuf_get_has_alpha       gdk_pixbuf_get_has_alpha
-#define fn_gdk_pixbuf_get_bits_per_sample gdk_pixbuf_get_bits_per_sample
 
-#if ! GLIB_CHECK_VERSION (2, 36, 0)
-#define fn_g_type_init                    g_type_init
-#endif
-#define fn_g_object_unref                 g_object_unref
-#define fn_g_error_free                   g_error_free
-#endif /* !WINDOWSNT  */
+#  undef gdk_pixbuf_get_bits_per_sample
+#  undef gdk_pixbuf_get_colorspace
+#  undef gdk_pixbuf_get_has_alpha
+#  undef gdk_pixbuf_get_height
+#  undef gdk_pixbuf_get_n_channels
+#  undef gdk_pixbuf_get_pixels
+#  undef gdk_pixbuf_get_rowstride
+#  undef gdk_pixbuf_get_width
+#  undef g_error_free
+#  undef g_object_unref
+#  undef g_type_init
+#  undef rsvg_handle_close
+#  undef rsvg_handle_get_dimensions
+#  undef rsvg_handle_get_pixbuf
+#  undef rsvg_handle_new
+#  undef rsvg_handle_set_base_uri
+#  undef rsvg_handle_write
+
+#  define gdk_pixbuf_get_bits_per_sample fn_gdk_pixbuf_get_bits_per_sample
+#  define gdk_pixbuf_get_colorspace fn_gdk_pixbuf_get_colorspace
+#  define gdk_pixbuf_get_has_alpha fn_gdk_pixbuf_get_has_alpha
+#  define gdk_pixbuf_get_height fn_gdk_pixbuf_get_height
+#  define gdk_pixbuf_get_n_channels fn_gdk_pixbuf_get_n_channels
+#  define gdk_pixbuf_get_pixels fn_gdk_pixbuf_get_pixels
+#  define gdk_pixbuf_get_rowstride fn_gdk_pixbuf_get_rowstride
+#  define gdk_pixbuf_get_width fn_gdk_pixbuf_get_width
+#  define g_error_free fn_g_error_free
+#  define g_object_unref fn_g_object_unref
+#  define g_type_init fn_g_type_init
+#  define rsvg_handle_close fn_rsvg_handle_close
+#  define rsvg_handle_get_dimensions fn_rsvg_handle_get_dimensions
+#  define rsvg_handle_get_pixbuf fn_rsvg_handle_get_pixbuf
+#  define rsvg_handle_new fn_rsvg_handle_new
+#  define rsvg_handle_set_base_uri fn_rsvg_handle_set_base_uri
+#  define rsvg_handle_write fn_rsvg_handle_write
+
+# endif /* !WINDOWSNT  */
 
 /* Load SVG image IMG for use on frame F.  Value is true if
    successful.  */
@@ -8862,28 +8908,28 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
 #if ! GLIB_CHECK_VERSION (2, 36, 0)
   /* g_type_init is a glib function that must be called prior to
      using gnome type library functions (obsolete since 2.36.0).  */
-  fn_g_type_init ();
+  g_type_init ();
 #endif
 
   /* Make a handle to a new rsvg object.  */
-  rsvg_handle = fn_rsvg_handle_new ();
+  rsvg_handle = rsvg_handle_new ();
 
   /* Set base_uri for properly handling referenced images (via 'href').
      See rsvg bug 596114 - "image refs are relative to curdir, not .svg file"
      (https://bugzilla.gnome.org/show_bug.cgi?id=596114). */
   if (filename)
-    fn_rsvg_handle_set_base_uri(rsvg_handle, filename);
+    rsvg_handle_set_base_uri(rsvg_handle, filename);
 
   /* Parse the contents argument and fill in the rsvg_handle.  */
-  fn_rsvg_handle_write (rsvg_handle, contents, size, &err);
+  rsvg_handle_write (rsvg_handle, contents, size, &err);
   if (err) goto rsvg_error;
 
   /* The parsing is complete, rsvg_handle is ready to used, close it
      for further writes.  */
-  fn_rsvg_handle_close (rsvg_handle, &err);
+  rsvg_handle_close (rsvg_handle, &err);
   if (err) goto rsvg_error;
 
-  fn_rsvg_handle_get_dimensions (rsvg_handle, &dimension_data);
+  rsvg_handle_get_dimensions (rsvg_handle, &dimension_data);
   if (! check_image_size (f, dimension_data.width, dimension_data.height))
     {
       image_error ("Invalid image size (see `max-image-size')", Qnil, Qnil);
@@ -8892,26 +8938,26 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
 
   /* We can now get a valid pixel buffer from the svg file, if all
      went ok.  */
-  pixbuf = fn_rsvg_handle_get_pixbuf (rsvg_handle);
+  pixbuf = rsvg_handle_get_pixbuf (rsvg_handle);
   if (!pixbuf) goto rsvg_error;
-  fn_g_object_unref (rsvg_handle);
+  g_object_unref (rsvg_handle);
 
   /* Extract some meta data from the svg handle.  */
-  width     = fn_gdk_pixbuf_get_width (pixbuf);
-  height    = fn_gdk_pixbuf_get_height (pixbuf);
-  pixels    = fn_gdk_pixbuf_get_pixels (pixbuf);
-  rowstride = fn_gdk_pixbuf_get_rowstride (pixbuf);
+  width     = gdk_pixbuf_get_width (pixbuf);
+  height    = gdk_pixbuf_get_height (pixbuf);
+  pixels    = gdk_pixbuf_get_pixels (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
 
   /* Validate the svg meta data.  */
-  eassert (fn_gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
-  eassert (fn_gdk_pixbuf_get_n_channels (pixbuf) == 4);
-  eassert (fn_gdk_pixbuf_get_has_alpha (pixbuf));
-  eassert (fn_gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
+  eassert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
+  eassert (gdk_pixbuf_get_n_channels (pixbuf) == 4);
+  eassert (gdk_pixbuf_get_has_alpha (pixbuf));
+  eassert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 
   /* Try to create a x pixmap to hold the svg pixmap.  */
   if (!image_create_x_image_and_pixmap (f, img, width, height, 0, &ximg, 0))
     {
-      fn_g_object_unref (pixbuf);
+      g_object_unref (pixbuf);
       return 0;
     }
 
@@ -8968,7 +9014,7 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
   free_color_table ();
 #endif /* COLOR_TABLE_SUPPORT */
 
-  fn_g_object_unref (pixbuf);
+  g_object_unref (pixbuf);
 
   img->width  = width;
   img->height = height;
@@ -8983,11 +9029,11 @@ svg_load_image (struct frame *f,         /* Pointer to emacs frame structure.  *
   return 1;
 
  rsvg_error:
-  fn_g_object_unref (rsvg_handle);
+  g_object_unref (rsvg_handle);
   /* FIXME: Use error->message so the user knows what is the actual
      problem with the image.  */
   image_error ("Error parsing SVG image `%s'", img->spec, Qnil);
-  fn_g_error_free (err);
+  g_error_free (err);
   return 0;
 }
 
diff --git a/src/keyboard.c b/src/keyboard.c
index d76a8fcb783..5b66050aa92 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -276,7 +276,7 @@ bool input_pending;
 /* True if more input was available last time we read an event.
 
    Since redisplay can take a significant amount of time and is not
-   indispensible to perform the user's commands, when input arrives
+   indispensable to perform the user's commands, when input arrives
    "too fast", Emacs skips redisplay.  More specifically, if the next
    command has already been input when we finish the previous command,
    we skip the intermediate redisplay.
diff --git a/src/nsimage.m b/src/nsimage.m
index 640dfcbc113..d5c06477f8b 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -351,15 +351,15 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
     {
       if ([rep respondsToSelector: @selector (getBitmapDataPlanes:)])
         {
-          NSBitmapImageRep *bmRep = (NSBitmapImageRep *) rep;
+          NSBitmapImageRep *bmr = (NSBitmapImageRep *) rep;
 
-          if ([bmRep numberOfPlanes] >= 3)
-              [bmRep getBitmapDataPlanes: pixmapData];
+          if ([bmr numberOfPlanes] >= 3)
+              [bmr getBitmapDataPlanes: pixmapData];
 
           /* The next two lines cause the DPI of the image to be ignored.
              This seems to be the behavior users expect. */
           [self setScalesWhenResized: YES];
-          [self setSize: NSMakeSize([bmRep pixelsWide], [bmRep pixelsHigh])];
+          [self setSize: NSMakeSize([bmr pixelsWide], [bmr pixelsHigh])];
 
           break;
         }
diff --git a/src/tparam.c b/src/tparam.c
index e02cea3689e..b0cd0047ba2 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -255,9 +255,9 @@ tparam1 (const char *string, char *outstring, int len,
     }
   *op = 0;
   while (doup-- > 0)
-    strcat (op, up);
+    op = stpcpy (op, up);
   while (doleft-- > 0)
-    strcat (op, left);
+    op = stpcpy (op, left);
   return outstring;
 }
 
diff --git a/src/w32.c b/src/w32.c
index 8d8f536ca40..6dea0c2a811 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -3405,10 +3405,10 @@ sys_readdir (DIR *dirp)
       int ln;
 
       strcpy (filename, dir_pathname);
-      ln = strlen (filename) - 1;
-      if (!IS_DIRECTORY_SEP (filename[ln]))
-        strcat (filename, "\\");
-      strcat (filename, "*");
+      ln = strlen (filename);
+      if (!IS_DIRECTORY_SEP (filename[ln - 1]))
+        filename[ln++] = '\\';
+      strcpy (filename + ln, "*");
 
       /* Note: No need to resolve symlinks in FILENAME, because
          FindFirst opens the directory that is the target of a
@@ -4969,7 +4969,7 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
         {
           /* Make sure root directories end in a slash.  */
           if (!IS_DIRECTORY_SEP (name[len-1]))
-            strcat (name, "\\");
+            strcpy (name + len, "\\");
           if (GetDriveType (name) < 2)
             {
               errno = ENOENT;
@@ -5438,8 +5438,7 @@ symlink (char const *filename, char const *linkname)
         p--;
       if (p > linkfn)
         strncpy (tem, linkfn, p - linkfn);
-      tem[p - linkfn] = '\0';
-      strcat (tem, filename);
+      strcpy (tem + (p - linkfn), filename);
       dir_access = faccessat (AT_FDCWD, tem, D_OK, AT_EACCESS);
     }
   else
diff --git a/src/w32.h b/src/w32.h
index e0aedcbffa2..18e12b2458c 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -225,4 +225,17 @@ extern ssize_t emacs_gnutls_push (gnutls_transport_ptr_t p,
                                   const void* buf, size_t sz);
 #endif /* HAVE_GNUTLS */
 
+/* Definine a function that will be loaded from a DLL.  */
+#define DEF_DLL_FN(type, func, args) static type (FAR CDECL *fn_##func) args
+
+/* Load a function from the DLL.  */
+#define LOAD_DLL_FN(lib, func)                                          \
+  do                                                                    \
+    {                                                                   \
+      fn_##func = (void *) GetProcAddress (lib, #func);                 \
+      if (!fn_##func)                                                   \
+        return false;                                                   \
+    }                                                                   \
+  while (false)
+
 #endif /* EMACS_W32_H */
diff --git a/src/w32menu.c b/src/w32menu.c
index 6633ffddbcf..287062c702c 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1256,9 +1256,9 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
       if (wv->key != NULL)
         {
           out_string = SAFE_ALLOCA (strlen (wv->name) + strlen (wv->key) + 2);
-          strcpy (out_string, wv->name);
-          strcat (out_string, "\t");
-          strcat (out_string, wv->key);
+          p = stpcpy (out_string, wv->name);
+          p = stpcpy (p, "\t");
+          strcpy (p, wv->key);
         }
       else
         out_string = (char *)wv->name;
diff --git a/src/w32proc.c b/src/w32proc.c
index 09e0c0530a4..c571726d70f 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1665,10 +1665,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
       if (egetenv ("CMDPROXY"))
         strcpy (cmdname, egetenv ("CMDPROXY"));
       else
-        {
-          lispstpcpy (cmdname, Vinvocation_directory);
-          strcat (cmdname, "cmdproxy.exe");
-        }
+        strcpy (lispstpcpy (cmdname, Vinvocation_directory), "cmdproxy.exe");
 
       /* Can't use unixtodos_filename here, since that needs its file
          name argument encoded in UTF-8.  */
@@ -3183,18 +3180,20 @@ get_lcid_callback (LPTSTR locale_num_str)
   if (GetLocaleInfo (try_lcid, LOCALE_SABBREVLANGNAME,
                      locval, LOCALE_NAME_MAX_LENGTH))
     {
+      size_t locval_len;
+
       /* This is for when they only specify the language, as in "ENU".  */
       if (stricmp (locval, lname) == 0)
         {
           found_lcid = try_lcid;
           return FALSE;
         }
-      strcat (locval, "_");
+      locval_len = strlen (locval);
+      strcpy (locval + locval_len, "_");
       if (GetLocaleInfo (try_lcid, LOCALE_SABBREVCTRYNAME,
-                         locval + strlen (locval), LOCALE_NAME_MAX_LENGTH))
+                         locval + locval_len + 1, LOCALE_NAME_MAX_LENGTH))
         {
-          size_t locval_len = strlen (locval);
-
+          locval_len = strlen (locval);
           if (strnicmp (locval, lname, locval_len) == 0
               && (lname[locval_len] == '.'
                   || lname[locval_len] == '\0'))
diff --git a/src/xdisp.c b/src/xdisp.c
index 0e3e1a2bb69..e6bbd859fe7 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -7332,27 +7332,15 @@ set_iterator_to_next (struct it *it, int reseat_p)
       else if (it->cmp_it.id >= 0)
         {
           /* We are currently getting glyphs from a composition.  */
-          int i;
-
           if (! it->bidi_p)
             {
               IT_CHARPOS (*it) += it->cmp_it.nchars;
               IT_BYTEPOS (*it) += it->cmp_it.nbytes;
-              if (it->cmp_it.to < it->cmp_it.nglyphs)
-                {
-                  it->cmp_it.from = it->cmp_it.to;
-                }
-              else
-                {
-                  it->cmp_it.id = -1;
-                  composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
-                                                IT_BYTEPOS (*it),
-                                                it->end_charpos, Qnil);
-                }
             }
-          else if (! it->cmp_it.reversed_p)
+          else
             {
-              /* Composition created while scanning forward.  */
+              int i;
+
               /* Update IT's char/byte positions to point to the first
                  character of the next grapheme cluster, or to the
                  character visually after the current composition.  */
@@ -7360,52 +7348,34 @@ set_iterator_to_next (struct it *it, int reseat_p)
                 bidi_move_to_visually_next (&it->bidi_it);
               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
               IT_CHARPOS (*it) = it->bidi_it.charpos;
+            }
 
-              if (it->cmp_it.to < it->cmp_it.nglyphs)
-                {
-                  /* Proceed to the next grapheme cluster.  */
-                  it->cmp_it.from = it->cmp_it.to;
-                }
-              else
-                {
-                  /* No more grapheme clusters in this composition.
-                     Find the next stop position.  */
-                  ptrdiff_t stop = it->end_charpos;
-                  if (it->bidi_it.scan_dir < 0)
-                    /* Now we are scanning backward and don't know
-                       where to stop.  */
-                    stop = -1;
-                  composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
-                                                IT_BYTEPOS (*it), stop, Qnil);
-                }
+          if ((! it->bidi_p || ! it->cmp_it.reversed_p)
+              && it->cmp_it.to < it->cmp_it.nglyphs)
+            {
+              /* Composition created while scanning forward.  Proceed
+                 to the next grapheme cluster.  */
+              it->cmp_it.from = it->cmp_it.to;
+            }
+          else if ((it->bidi_p && it->cmp_it.reversed_p)
+                   && it->cmp_it.from > 0)
+            {
+              /* Composition created while scanning backward.  Proceed
+                 to the previous grapheme cluster.  */
+              it->cmp_it.to = it->cmp_it.from;
             }
           else
             {
-              /* Composition created while scanning backward.  */
-              /* Update IT's char/byte positions to point to the last
-                 character of the previous grapheme cluster, or the
-                 character visually after the current composition.  */
-              for (i = 0; i < it->cmp_it.nchars; i++)
-                bidi_move_to_visually_next (&it->bidi_it);
-              IT_BYTEPOS (*it) = it->bidi_it.bytepos;
-              IT_CHARPOS (*it) = it->bidi_it.charpos;
-              if (it->cmp_it.from > 0)
-                {
-                  /* Proceed to the previous grapheme cluster.  */
-                  it->cmp_it.to = it->cmp_it.from;
-                }
-              else
-                {
-                  /* No more grapheme clusters in this composition.
-                     Find the next stop position.  */
-                  ptrdiff_t stop = it->end_charpos;
-                  if (it->bidi_it.scan_dir < 0)
-                    /* Now we are scanning backward and don't know
-                       where to stop.  */
-                    stop = -1;
-                  composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
-                                                IT_BYTEPOS (*it), stop, Qnil);
-                }
+              /* No more grapheme clusters in this composition.
+                 Find the next stop position.  */
+              ptrdiff_t stop = it->end_charpos;
+
+              if (it->bidi_it.scan_dir < 0)
+                /* Now we are scanning backward and don't know
+                   where to stop.  */
+                stop = -1;
+              composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
+                                            IT_BYTEPOS (*it), stop, Qnil);
             }
         }
       else
@@ -7534,61 +7504,63 @@ set_iterator_to_next (struct it *it, int reseat_p)
         }
       if (it->cmp_it.id >= 0)
         {
-          int i;
-
+          /* We are delivering display elements from a composition.
+             Update the string position past the grapheme cluster
+             we've just processed.  */
           if (! it->bidi_p)
             {
               IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
               IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
-              if (it->cmp_it.to < it->cmp_it.nglyphs)
-                it->cmp_it.from = it->cmp_it.to;
-              else
-                {
-                  it->cmp_it.id = -1;
-                  composition_compute_stop_pos (&it->cmp_it,
-                                                IT_STRING_CHARPOS (*it),
-                                                IT_STRING_BYTEPOS (*it),
-                                                it->end_charpos, it->string);
-                }
             }
-          else if (! it->cmp_it.reversed_p)
+          else
             {
+              int i;
+
               for (i = 0; i < it->cmp_it.nchars; i++)
                 bidi_move_to_visually_next (&it->bidi_it);
               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+            }
 
-              if (it->cmp_it.to < it->cmp_it.nglyphs)
-                it->cmp_it.from = it->cmp_it.to;
-              else
-                {
-                  ptrdiff_t stop = it->end_charpos;
-                  if (it->bidi_it.scan_dir < 0)
-                    stop = -1;
-                  composition_compute_stop_pos (&it->cmp_it,
-                                                IT_STRING_CHARPOS (*it),
-                                                IT_STRING_BYTEPOS (*it), stop,
-                                                it->string);
-                }
+          /* Did we exhaust all the grapheme clusters of this
+             composition?  */
+          if ((! it->bidi_p || ! it->cmp_it.reversed_p)
+              && (it->cmp_it.to < it->cmp_it.nglyphs))
+            {
+              /* Not all the grapheme clusters were processed yet;
+                 advance to the next cluster.  */
+              it->cmp_it.from = it->cmp_it.to;
+            }
+          else if ((it->bidi_p && it->cmp_it.reversed_p)
+                   && it->cmp_it.from > 0)
+            {
+              /* Likewise: advance to the next cluster, but going in
+                 the reverse direction.  */
+              it->cmp_it.to = it->cmp_it.from;
             }
           else
             {
-              for (i = 0; i < it->cmp_it.nchars; i++)
-                bidi_move_to_visually_next (&it->bidi_it);
-              IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
-              IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
-              if (it->cmp_it.from > 0)
-                it->cmp_it.to = it->cmp_it.from;
-              else
+              /* This composition was fully processed; find the next
+                 candidate place for checking for composed
+                 characters.  */
+              /* Always limit string searches to the string length;
+                 any padding spaces are not part of the string, and
+                 there cannot be any compositions in that padding.  */
+              ptrdiff_t stop = SCHARS (it->string);
+
+              if (it->bidi_p && it->bidi_it.scan_dir < 0)
+                stop = -1;
+              else if (it->end_charpos < stop)
                 {
-                  ptrdiff_t stop = it->end_charpos;
-                  if (it->bidi_it.scan_dir < 0)
-                    stop = -1;
-                  composition_compute_stop_pos (&it->cmp_it,
-                                                IT_STRING_CHARPOS (*it),
-                                                IT_STRING_BYTEPOS (*it), stop,
-                                                it->string);
+                  /* Cf. PRECISION in reseat_to_string: we might be
+                     limited in how many of the string characters we
+                     need to deliver.  */
+                  stop = it->end_charpos;
                 }
+              composition_compute_stop_pos (&it->cmp_it,
+                                            IT_STRING_CHARPOS (*it),
+                                            IT_STRING_BYTEPOS (*it), stop,
+                                            it->string);
             }
         }
       else
@@ -7611,12 +7583,17 @@ set_iterator_to_next (struct it *it, int reseat_p)
               bidi_move_to_visually_next (&it->bidi_it);
               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
+              /* If the scan direction changes, we may need to update
+                 the place where to check for composed characters.  */
               if (prev_scan_dir != it->bidi_it.scan_dir)
                 {
-                  ptrdiff_t stop = it->end_charpos;
+                  ptrdiff_t stop = SCHARS (it->string);
 
                   if (it->bidi_it.scan_dir < 0)
                     stop = -1;
+                  else if (it->end_charpos < stop)
+                    stop = it->end_charpos;
+
                   composition_compute_stop_pos (&it->cmp_it,
                                                 IT_STRING_CHARPOS (*it),
                                                 IT_STRING_BYTEPOS (*it), stop,
diff --git a/src/xfns.c b/src/xfns.c
index 1b17311f99c..ba2601daca4 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1710,13 +1710,14 @@ xic_create_fontsetname (const char *base_fontname, int motif)
 {
   const char *sep = motif ? ";" : ",";
   char *fontsetname;
+  char *z;
 
   /* Make a fontset name from the base font name.  */
   if (xic_default_fontset == base_fontname)
     {
       /* There is no base font name, use the default.  */
       fontsetname = xmalloc (strlen (base_fontname) + 2);
-      strcpy (fontsetname, base_fontname);
+      z = stpcpy (fontsetname, base_fontname);
     }
   else
     {
@@ -1737,9 +1738,9 @@ xic_create_fontsetname (const char *base_fontname, int motif)
              Use the specified font plus the default.  */
           fontsetname = xmalloc (strlen (base_fontname)
                                  + strlen (xic_default_fontset) + 3);
-          strcpy (fontsetname, base_fontname);
-          strcat (fontsetname, sep);
-          strcat (fontsetname, xic_default_fontset);
+          z = stpcpy (fontsetname, base_fontname);
+          z = stpcpy (z, sep);
+          z = stpcpy (z, xic_default_fontset);
         }
       else
         {
@@ -1800,27 +1801,26 @@ xic_create_fontsetname (const char *base_fontname, int motif)
           /* Build the font spec that matches all.  */
           len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
           font_all = alloca (len);
-          strcpy (font_all, allfamilies);
-          strcat (font_all, all);
-          memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
-          strcpy (font_all + strlen (all) + strlen (allfamilies) + (p - p2),
-                  allcs);
+          z = stpcpy (font_all, allfamilies);
+          z = stpcpy (z, all);
+          memcpy (z, p2, p - p2);
+          strcpy (z + (p - p2), allcs);
 
           /* Build the actual font set name.  */
           len = strlen (base_fontname) + strlen (font_allcs)
             + strlen (font_allfamilies) + strlen (font_all) + 5;
           fontsetname = xmalloc (len);
-          strcpy (fontsetname, base_fontname);
-          strcat (fontsetname, sep);
-          strcat (fontsetname, font_allcs);
-          strcat (fontsetname, sep);
-          strcat (fontsetname, font_allfamilies);
-          strcat (fontsetname, sep);
-          strcat (fontsetname, font_all);
+          z = stpcpy (fontsetname, base_fontname);
+          z = stpcpy (z, sep);
+          z = stpcpy (z, font_allcs);
+          z = stpcpy (z, sep);
+          z = stpcpy (z, font_allfamilies);
+          z = stpcpy (z, sep);
+          z = stpcpy (z, font_all);
         }
     }
   if (motif)
-    return strcat (fontsetname, ":");
+    strcpy (z, ":");
   return fontsetname;
 }
 #endif /* HAVE_X_WINDOWS && USE_X_TOOLKIT */
diff --git a/src/xml.c b/src/xml.c
index d418202182b..6be3bc74e97 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -33,26 +33,17 @@ static Lisp_Object Qlibxml2_dll;
 
 #ifdef WINDOWSNT
 
-#include <windows.h>
-#include "w32.h"
+# include <windows.h>
+# include "w32.h"
 
-/* Macro for defining functions that will be loaded from the libxml2 DLL.  */
-#define DEF_XML2_FN(rettype,func,args) static rettype (FAR CDECL *fn_##func)args
-
-/* Macro for loading libxml2 functions from the library.  */
-#define LOAD_XML2_FN(lib,func) {                                        \
-    fn_##func = (void *) GetProcAddress (lib, #func);                   \
-    if (!fn_##func) goto bad_library;                                   \
-  }
-
-DEF_XML2_FN (htmlDocPtr, htmlReadMemory,
+DEF_DLL_FN (htmlDocPtr, htmlReadMemory,
              (const char *, int, const char *, const char *, int));
-DEF_XML2_FN (xmlDocPtr, xmlReadMemory,
+DEF_DLL_FN (xmlDocPtr, xmlReadMemory,
              (const char *, int, const char *, const char *, int));
-DEF_XML2_FN (xmlNodePtr, xmlDocGetRootElement, (xmlDocPtr));
-DEF_XML2_FN (void, xmlFreeDoc, (xmlDocPtr));
-DEF_XML2_FN (void, xmlCleanupParser, (void));
-DEF_XML2_FN (void, xmlCheckVersion, (int));
+DEF_DLL_FN (xmlNodePtr, xmlDocGetRootElement, (xmlDocPtr));
+DEF_DLL_FN (void, xmlFreeDoc, (xmlDocPtr));
+DEF_DLL_FN (void, xmlCleanupParser, (void));
+DEF_DLL_FN (void, xmlCheckVersion, (int));
 
 static int
 libxml2_loaded_p (void)
@@ -64,14 +55,33 @@ libxml2_loaded_p (void)
   return 0;
 }
 
-#else  /* !WINDOWSNT */
+# undef htmlReadMemory
+# undef xmlCheckVersion
+# undef xmlCleanupParser
+# undef xmlDocGetRootElement
+# undef xmlFreeDoc
+# undef xmlReadMemory
+
+# define htmlReadMemory fn_htmlReadMemory
+# define xmlCheckVersion fn_xmlCheckVersion
+# define xmlCleanupParser fn_xmlCleanupParser
+# define xmlDocGetRootElement fn_xmlDocGetRootElement
+# define xmlFreeDoc fn_xmlFreeDoc
+# define xmlReadMemory fn_xmlReadMemory
+
+static bool
+load_dll_functions (HMODULE library)
+{
+  LOAD_DLL_FN (library, htmlReadMemory);
+  LOAD_DLL_FN (library, xmlReadMemory);
+  LOAD_DLL_FN (library, xmlDocGetRootElement);
+  LOAD_DLL_FN (library, xmlFreeDoc);
+  LOAD_DLL_FN (library, xmlCleanupParser);
+  LOAD_DLL_FN (library, xmlCheckVersion);
+  return true;
+}
 
-#define fn_htmlReadMemory       htmlReadMemory
-#define fn_xmlReadMemory        xmlReadMemory
-#define fn_xmlDocGetRootElement xmlDocGetRootElement
-#define fn_xmlFreeDoc           xmlFreeDoc
-#define fn_xmlCleanupParser     xmlCleanupParser
-#define fn_xmlCheckVersion      xmlCheckVersion
+#else  /* !WINDOWSNT */
 
 static int
 libxml2_loaded_p (void)
@@ -97,14 +107,8 @@ init_libxml2_functions (void)
           return 0;
         }
 
-      /* LOAD_XML2_FN jumps to bad_library if it fails to find the
-         named function.  */
-      LOAD_XML2_FN (library, htmlReadMemory);
-      LOAD_XML2_FN (library, xmlReadMemory);
-      LOAD_XML2_FN (library, xmlDocGetRootElement);
-      LOAD_XML2_FN (library, xmlFreeDoc);
-      LOAD_XML2_FN (library, xmlCleanupParser);
-      LOAD_XML2_FN (library, xmlCheckVersion);
+      if (! load_dll_functions (library))
+        goto bad_library;
 
       Vlibrary_cache = Fcons (Fcons (Qlibxml2_dll, Qt), Vlibrary_cache);
       return 1;
@@ -182,7 +186,7 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, Lisp_Obj
   const char *burl = "";
   ptrdiff_t istart, iend, istart_byte, iend_byte;
 
-  fn_xmlCheckVersion (LIBXML_VERSION);
+  xmlCheckVersion (LIBXML_VERSION);
 
   validate_region (&start, &end);
 
@@ -201,16 +205,16 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, Lisp_Obj
     }
 
   if (htmlp)
-    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
-                             iend_byte - istart_byte, burl, "utf-8",
-                             HTML_PARSE_RECOVER|HTML_PARSE_NONET|
-                             HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
-                             HTML_PARSE_NOBLANKS);
+    doc = htmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                          iend_byte - istart_byte, burl, "utf-8",
+                          HTML_PARSE_RECOVER|HTML_PARSE_NONET|
+                          HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
+                          HTML_PARSE_NOBLANKS);
   else
-    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
-                            iend_byte - istart_byte, burl, "utf-8",
-                            XML_PARSE_NONET|XML_PARSE_NOWARNING|
-                            XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
+    doc = xmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                         iend_byte - istart_byte, burl, "utf-8",
+                         XML_PARSE_NONET|XML_PARSE_NOWARNING|
+                         XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
 
   if (doc != NULL)
     {
@@ -232,14 +236,14 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, Lisp_Obj
       if (NILP (result)) {
         /* The document doesn't have toplevel comments or we discarded
            them.  Get the tree the proper way. */
-        xmlNode *node = fn_xmlDocGetRootElement (doc);
+        xmlNode *node = xmlDocGetRootElement (doc);
         if (node != NULL)
           result = make_dom (node);
       } else
         result = Fcons (intern ("top"),
                         Fcons (Qnil, Fnreverse (Fcons (r, result))));
 
-      fn_xmlFreeDoc (doc);
+      xmlFreeDoc (doc);
     }
 
   return result;
@@ -249,7 +253,7 @@ void
 xml_cleanup_parser (void)
 {
   if (libxml2_loaded_p ())
-    fn_xmlCleanupParser ();
+    xmlCleanupParser ();
 }
 
 DEFUN ("libxml-parse-html-region", Flibxml_parse_html_region,
diff --git a/src/xrdb.c b/src/xrdb.c
index 32ad3c7f01e..e21206d0800 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -232,9 +232,10 @@ gethomedir (void)
   if (ptr == NULL)
     return xstrdup ("/");
 
-  copy = xmalloc (strlen (ptr) + 2);
-  strcpy (copy, ptr);
-  return strcat (copy, "/");
+  ptrdiff_t len = strlen (ptr);
+  copy = xmalloc (len + 2);
+  strcpy (copy + len, "/");
+  return memcpy (copy, ptr, len);
 }
 
 
@@ -334,6 +335,7 @@ get_user_app (const char *class)
   return db;
 }
 
+static char const xdefaults[] = ".Xdefaults";
 
 static XrmDatabase
 get_user_db (Display *display)
@@ -351,16 +353,12 @@ get_user_db (Display *display)
     db = XrmGetStringDatabase (xdefs);
   else
     {
-      char *home;
-      char *xdefault;
-
-      home = gethomedir ();
-      xdefault = xmalloc (strlen (home) + sizeof ".Xdefaults");
-      strcpy (xdefault, home);
-      strcat (xdefault, ".Xdefaults");
-      db = XrmGetFileDatabase (xdefault);
-      xfree (home);
-      xfree (xdefault);
+      char *home = gethomedir ();
+      ptrdiff_t homelen = strlen (home);
+      char *filename = xrealloc (home, homelen + sizeof xdefaults);
+      strcpy (filename + homelen, xdefaults);
+      db = XrmGetFileDatabase (filename);
+      xfree (filename);
     }
 
 #ifdef HAVE_XSCREENRESOURCESTRING
@@ -380,24 +378,22 @@ static XrmDatabase
 get_environ_db (void)
 {
   XrmDatabase db;
-  char *p;
-  char *path = 0;
+  char *p = getenv ("XENVIRONMENT");
+  char *filename = 0;
 
-  if ((p = getenv ("XENVIRONMENT")) == NULL)
+  if (!p)
     {
-      static char const xdefaults[] = ".Xdefaults-";
       char *home = gethomedir ();
-      char const *host = SSDATA (Vsystem_name);
-      ptrdiff_t pathsize = (strlen (home) + sizeof xdefaults
-                            + SBYTES (Vsystem_name));
-      path = xrealloc (home, pathsize);
-      strcat (strcat (path, xdefaults), host);
-      p = path;
+      ptrdiff_t homelen = strlen (home);
+      ptrdiff_t filenamesize = (homelen + sizeof xdefaults
+                                + SBYTES (Vsystem_name));
+      p = filename = xrealloc (home, filenamesize);
+      lispstpcpy (stpcpy (filename + homelen, xdefaults), Vsystem_name);
     }
 
   db = XrmGetFileDatabase (p);
 
-  xfree (path);
+  xfree (filename);
 
   return db;
 }
diff --git a/src/xselect.c b/src/xselect.c
index 92e89822293..3f8a1321954 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -46,9 +46,10 @@ struct prop_location;
 struct selection_data;
 
 static void x_decline_selection_request (struct input_event *);
-static int x_convert_selection (struct input_event *, Lisp_Object, Lisp_Object,
-                                Atom, int, struct x_display_info *);
-static int waiting_for_other_props_on_window (Display *, Window);
+static bool x_convert_selection (struct input_event *, Lisp_Object,
+                                 Lisp_Object, Atom, bool,
+                                 struct x_display_info *);
+static bool waiting_for_other_props_on_window (Display *, Window);
 static struct prop_location *expect_property_change (Display *, Window,
                                                      Atom, int);
 static void unexpect_property_change (struct prop_location *);
@@ -360,7 +361,7 @@ x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
 
 static Lisp_Object
 x_get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
-                       int local_request, struct x_display_info *dpyinfo)
+                       bool local_request, struct x_display_info *dpyinfo)
 {
   Lisp_Object local_value;
   Lisp_Object handler_fn, value, check;
@@ -470,7 +471,7 @@ struct selection_data
   ptrdiff_t size;
   int format;
   Atom type;
-  int nofree;
+  bool nofree;
   Atom property;
   /* This can be set to non-NULL during x_reply_selection_request, if
      the selection is waiting for an INCR transfer to complete.  Don't
@@ -498,7 +499,7 @@ x_selection_request_lisp_error (void)
   for (cs = converted_selections; cs; cs = next)
     {
       next = cs->next;
-      if (cs->nofree == 0 && cs->data)
+      if (! cs->nofree && cs->data)
         xfree (cs->data);
       xfree (cs);
     }
@@ -531,7 +532,7 @@ struct prop_location
   Window window;
   Atom property;
   int desired_state;
-  int arrived;
+  bool arrived;
   struct prop_location *next;
 };
 
@@ -747,7 +748,7 @@ x_handle_selection_request (struct input_event *event)
   Lisp_Object target_symbol = x_atom_to_symbol (dpyinfo, target);
   Atom property = SELECTION_EVENT_PROPERTY (event);
   Lisp_Object local_selection_data;
-  int success = 0;
+  bool success = false;
   ptrdiff_t count = SPECPDL_INDEX ();
   GCPRO2 (local_selection_data, target_symbol);
 
@@ -805,9 +806,9 @@ x_handle_selection_request (struct input_event *event)
 
           if (subproperty != None)
             x_convert_selection (event, selection_symbol, subtarget,
-                                 subproperty, 1, dpyinfo);
+                                 subproperty, true, dpyinfo);
         }
-      success = 1;
+      success = true;
     }
   else
     {
@@ -815,7 +816,7 @@ x_handle_selection_request (struct input_event *event)
         property = SELECTION_EVENT_TARGET (event);
       success = x_convert_selection (event, selection_symbol,
                                      target_symbol, property,
-                                     0, dpyinfo);
+                                     false, dpyinfo);
     }
 
  DONE:
@@ -844,15 +845,15 @@ x_handle_selection_request (struct input_event *event)
 
 /* Perform the requested selection conversion, and write the data to
    the converted_selections linked list, where it can be accessed by
-   x_reply_selection_request.  If FOR_MULTIPLE is non-zero, write out
+   x_reply_selection_request.  If FOR_MULTIPLE, write out
    the data even if conversion fails, using conversion_fail_tag.
 
-   Return 0 if the selection failed to convert, 1 otherwise.  */
+   Return true iff successful.  */
 
-static int
+static bool
 x_convert_selection (struct input_event *event, Lisp_Object selection_symbol,
                      Lisp_Object target_symbol, Atom property,
-                     int for_multiple, struct x_display_info *dpyinfo)
+                     bool for_multiple, struct x_display_info *dpyinfo)
 {
   struct gcpro gcpro1;
   Lisp_Object lisp_selection;
@@ -861,7 +862,7 @@ x_convert_selection (struct input_event *event, Lisp_Object selection_symbol,
 
   lisp_selection
     = x_get_local_selection (selection_symbol, target_symbol,
-                             0, dpyinfo);
+                             false, dpyinfo);
 
   /* A nil return value means we can't perform the conversion.  */
   if (NILP (lisp_selection)
@@ -874,7 +875,7 @@ x_convert_selection (struct input_event *event, Lisp_Object selection_symbol,
           cs->size = 1;
           cs->format = 32;
           cs->type = XA_ATOM;
-          cs->nofree = 1;
+          cs->nofree = true;
           cs->property = property;
           cs->wait_object = NULL;
           cs->next = converted_selections;
@@ -882,20 +883,20 @@ x_convert_selection (struct input_event *event, Lisp_Object selection_symbol,
         }
 
       UNGCPRO;
-      return 0;
+      return false;
     }
 
   /* Otherwise, record the converted selection to binary.  */
   cs = xmalloc (sizeof *cs);
   cs->data = NULL;
-  cs->nofree = 1;
+  cs->nofree = true;
   cs->property = property;
   cs->wait_object = NULL;
   cs->next = converted_selections;
   converted_selections = cs;
   lisp_data_to_selection_data (dpyinfo, lisp_selection, cs);
   UNGCPRO;
-  return 1;
+  return true;
 }
 
 /* Handle a SelectionClear event EVENT, which indicates that some
@@ -1012,19 +1013,16 @@ x_clear_frame_selections (struct frame *f)
       }
 }
 
-/* Nonzero if any properties for DISPLAY and WINDOW
+/* True if any properties for DISPLAY and WINDOW
    are on the list of what we are waiting for.  */
 
-static int
+static bool
 waiting_for_other_props_on_window (Display *display, Window window)
 {
-  struct prop_location *rest = property_change_wait_list;
-  while (rest)
-    if (rest->display == display && rest->window == window)
-      return 1;
-    else
-      rest = rest->next;
-  return 0;
+  for (struct prop_location *p = property_change_wait_list; p; p = p->next)
+    if (p->display == display && p->window == window)
+      return true;
+  return false;
 }
 
 /* Add an entry to the list of property changes we are waiting for.
@@ -1043,7 +1041,7 @@ expect_property_change (Display *display, Window window,
   pl->property = property;
   pl->desired_state = state;
   pl->next = property_change_wait_list;
-  pl->arrived = 0;
+  pl->arrived = false;
   property_change_wait_list = pl;
   return pl;
 }
@@ -1106,7 +1104,7 @@ wait_for_property_change (struct prop_location *location)
       EMACS_INT secs = timeout / 1000;
       int nsecs = (timeout % 1000) * 1000000;
       TRACE2 ("  Waiting %"pI"d secs, %d nsecs", secs, nsecs);
-      wait_reading_process_output (secs, nsecs, 0, 0,
+      wait_reading_process_output (secs, nsecs, 0, false,
                                    property_change_reply, NULL, 0);
 
       if (NILP (XCAR (property_change_reply)))
@@ -1138,7 +1136,7 @@ x_handle_property_notify (const XPropertyEvent *event)
                   (event->state == PropertyDelete ? "deletion" : "change"),
                   XGetAtomName (event->display, event->atom));
 
-          rest->arrived = 1;
+          rest->arrived = true;
 
           /* If this is the one wait_for_property_change is waiting for,
              tell it to wake up.  */
@@ -1204,7 +1202,7 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
      during this time.  In fact, the SAVE_TARGETS mechanism requires
      us to handle a clipboard manager's requests before it returns
      SelectionNotify. */
-#if 0
+#if false
   x_start_queuing_selection_requests ();
   record_unwind_protect_void (x_stop_queuing_selection_requests);
 #endif
@@ -1216,7 +1214,7 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
   secs = timeout / 1000;
   nsecs = (timeout % 1000) * 1000000;
   TRACE1 ("  Start waiting %"pI"d secs for SelectionNotify", secs);
-  wait_reading_process_output (secs, nsecs, 0, 0,
+  wait_reading_process_output (secs, nsecs, 0, false,
                                reading_selection_reply, NULL, 0);
   TRACE1 ("  Got event = %d", !NILP (XCAR (reading_selection_reply)));
 
@@ -1240,7 +1238,7 @@ static void
 x_get_window_property (Display *display, Window window, Atom property,
                        unsigned char **data_ret, ptrdiff_t *bytes_ret,
                        Atom *actual_type_ret, int *actual_format_ret,
-                       unsigned long *actual_size_ret, int delete_p)
+                       unsigned long *actual_size_ret)
 {
   ptrdiff_t total_size;
   unsigned long bytes_remaining;
@@ -1413,7 +1411,7 @@ receive_incremental_selection (struct x_display_info *dpyinfo,
   XFlush (display);
   unblock_input ();
 
-  while (1)
+  while (true)
     {
       unsigned char *tmp_data;
       ptrdiff_t tmp_size_bytes;
@@ -1427,7 +1425,7 @@ receive_incremental_selection (struct x_display_info *dpyinfo,
       TRACE0 ("  Get property value");
       x_get_window_property (display, window, property,
                              &tmp_data, &tmp_size_bytes,
-                             type_ret, format_ret, size_ret, 1);
+                             type_ret, format_ret, size_ret);
 
       TRACE1 ("  Read increment of %"pD"d bytes", tmp_size_bytes);
 
@@ -1488,13 +1486,12 @@ x_get_window_property_as_lisp_data (struct x_display_info *dpyinfo,
   TRACE0 ("Reading selection data");
 
   x_get_window_property (display, window, property, &data, &bytes,
-                         &actual_type, &actual_format, &actual_size, 1);
+                         &actual_type, &actual_format, &actual_size);
   if (! data)
     {
-      int there_is_a_selection_owner;
       block_input ();
-      there_is_a_selection_owner
-        = XGetSelectionOwner (display, selection_atom);
+      bool there_is_a_selection_owner
+        = XGetSelectionOwner (display, selection_atom) != 0;
       unblock_input ();
       if (there_is_a_selection_owner)
         signal_error ("Selection owner couldn't convert",
@@ -1687,7 +1684,7 @@ lisp_data_to_selection_data (struct x_display_info *dpyinfo,
   Lisp_Object type = Qnil;
 
   eassert (cs != NULL);
-  cs->nofree = 0;
+  cs->nofree = false;
 
   if (CONSP (obj) && SYMBOLP (XCAR (obj)))
     {
@@ -1714,7 +1711,7 @@ lisp_data_to_selection_data (struct x_display_info *dpyinfo,
       cs->format = 8;
       cs->size = SBYTES (obj);
       cs->data = SDATA (obj);
-      cs->nofree = 1;
+      cs->nofree = true;
     }
   else if (SYMBOLP (obj))
     {
@@ -1981,7 +1978,7 @@ On Nextstep, TIME-STAMP and TERMINAL are unused.  */)
   if (!f)
     error ("X selection unavailable for this frame");
 
-  val = x_get_local_selection (selection_symbol, target_type, 1,
+  val = x_get_local_selection (selection_symbol, target_type, true,
                                FRAME_DISPLAY_INFO (f));
 
   if (NILP (val) && FRAME_LIVE_P (f))
@@ -2432,7 +2429,7 @@ FRAME is on.  If FRAME is nil, the selected frame is used.  */)
 
 /* Convert an XClientMessageEvent to a Lisp event of type DRAG_N_DROP_EVENT.  */
 
-int
+bool
 x_handle_dnd_message (struct frame *f, const XClientMessageEvent *event,
                       struct x_display_info *dpyinfo, struct input_event *bufp)
 {
@@ -2448,7 +2445,7 @@ x_handle_dnd_message (struct frame *f, const XClientMessageEvent *event,
   for (i = 0; i < dpyinfo->x_dnd_atoms_length; ++i)
     if (dpyinfo->x_dnd_atoms[i] == event->message_type) break;
 
-  if (i == dpyinfo->x_dnd_atoms_length) return 0;
+  if (i == dpyinfo->x_dnd_atoms_length) return false;
 
   XSETFRAME (frame, f);
 
@@ -2484,7 +2481,7 @@ x_handle_dnd_message (struct frame *f, const XClientMessageEvent *event,
   bufp->arg = vec;
   bufp->modifiers = 0;
 
-  return 1;
+  return true;
 }
 
 DEFUN ("x-send-client-message", Fx_send_client_message,
@@ -2535,7 +2532,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
   Window wdest;
   XEvent event;
   struct frame *f = decode_window_system_frame (from);
-  int to_root;
+  bool to_root;
 
   CHECK_NUMBER (format);
   CHECK_CONS (values);
@@ -2592,7 +2589,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
      event then goes to clients selecting for events on the root window.  */
   x_catch_errors (dpyinfo->display);
   {
-    int propagate = to_root ? False : True;
+    bool propagate = !to_root;
     long mask = to_root ? 0xffffff : 0;
 
     XSendEvent (dpyinfo->display, wdest, propagate, mask, &event);
diff --git a/src/xsettings.c b/src/xsettings.c
index 5f4275df545..066f426d241 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -68,11 +68,11 @@ store_config_changed_event (Lisp_Object arg, Lisp_Object display_name)
   kbd_buffer_store_event (&event);
 }
 
-/* Return non-zero if DPYINFO is still valid.  */
-static int
+/* Return true if DPYINFO is still valid.  */
+static bool
 dpyinfo_valid (struct x_display_info *dpyinfo)
 {
-  int found = 0;
+  bool found = false;
   if (dpyinfo != NULL)
     {
       struct x_display_info *d;
@@ -404,7 +404,7 @@ parse_settings (unsigned char *prop,
 
   /* First 4 bytes is a serial number, skip that.  */
 
-  if (bytes < 12) return BadLength;
+  if (bytes < 12) return settings_seen;
   memcpy (&n_settings, prop+8, 4);
   if (my_bo != that_bo) n_settings = bswap_32 (n_settings);
   bytes_parsed = 12;
@@ -419,7 +419,7 @@ parse_settings (unsigned char *prop,
       CARD32 vlen, ival = 0;
       char name[128]; /* The names we are looking for are not this long.  */
       char sval[128]; /* The values we are looking for are not this long.  */
-      int want_this;
+      bool want_this;
       int to_cpy;
 
       sval[0] = '\0';
@@ -429,8 +429,8 @@ parse_settings (unsigned char *prop,
       memcpy (&nlen, prop+bytes_parsed, 2);
       bytes_parsed += 2;
       if (my_bo != that_bo) nlen = bswap_16 (nlen);
-      if (bytes_parsed+nlen > bytes) return BadLength;
-      to_cpy = nlen > 127 ? 127 : nlen;
+      if (bytes_parsed + nlen > bytes) return settings_seen;
+      to_cpy = min (nlen, sizeof name - 1);
       memcpy (name, prop+bytes_parsed, to_cpy);
       name[to_cpy] = '\0';
 
@@ -438,20 +438,19 @@ parse_settings (unsigned char *prop,
       bytes_parsed = PAD (bytes_parsed);
 
       bytes_parsed += 4; /* Skip serial for this value */
-      if (bytes_parsed > bytes) return BadLength;
+      if (bytes_parsed > bytes) return settings_seen;
 
-      want_this =
+      want_this = strcmp (XSETTINGS_TOOL_BAR_STYLE, name) == 0;
 #ifdef HAVE_XFT
-        (nlen > 6 && strncmp (name, "Xft/", 4) == 0)
-        || strcmp (XSETTINGS_FONT_NAME, name) == 0
-        ||
+      if ((nlen > 6 && memcmp (name, "Xft/", 4) == 0)
+          || strcmp (XSETTINGS_FONT_NAME, name) == 0)
+        want_this = true;
 #endif
-        strcmp (XSETTINGS_TOOL_BAR_STYLE, name) == 0;
 
       switch (type)
         {
         case 0: /* Integer */
-          if (bytes_parsed+4 > bytes) return BadLength;
+          if (bytes_parsed + 4 > bytes) return settings_seen;
           if (want_this)
             {
               memcpy (&ival, prop+bytes_parsed, 4);
@@ -461,13 +460,13 @@ parse_settings (unsigned char *prop,
           break;
 
         case 1: /* String */
-          if (bytes_parsed+4 > bytes) return BadLength;
+          if (bytes_parsed + 4 > bytes) return settings_seen;
           memcpy (&vlen, prop+bytes_parsed, 4);
           bytes_parsed += 4;
           if (my_bo != that_bo) vlen = bswap_32 (vlen);
           if (want_this)
             {
-              to_cpy = vlen > 127 ? 127 : vlen;
+              to_cpy = min (vlen, sizeof sval - 1);
               memcpy (sval, prop+bytes_parsed, to_cpy);
               sval[to_cpy] = '\0';
             }
@@ -477,17 +476,16 @@ parse_settings (unsigned char *prop,
 
         case 2: /* RGB value */
           /* No need to parse this */
-          if (bytes_parsed+8 > bytes) return BadLength;
+          if (bytes_parsed + 8 > bytes) return settings_seen;
           bytes_parsed += 8; /* 4 values (r, b, g, alpha), 2 bytes each.  */
           break;
 
         default: /* Parse Error */
-          return BadValue;
+          return settings_seen;
         }
 
       if (want_this)
         {
-          ++settings_seen;
           if (strcmp (name, XSETTINGS_TOOL_BAR_STYLE) == 0)
             {
               dupstring (&settings->tb_style, sval);
@@ -557,6 +555,9 @@ parse_settings (unsigned char *prop,
                 settings->seen &= ~SEEN_LCDFILTER;
             }
 #endif /* HAVE_XFT */
+          else
+            want_this = false;
+          settings_seen += want_this;
         }
     }
 
@@ -565,9 +566,9 @@ parse_settings (unsigned char *prop,
 
 /* Read settings from the XSettings property window on display for DPYINFO.
    Store settings read in SETTINGS.
-   Return non-zero if successful, zero if not.  */
+   Return true iff successful.  */
 
-static int
+static bool
 read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
 {
   Atom act_type;
@@ -576,6 +577,7 @@ read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
   unsigned char *prop = NULL;
   Display *dpy = dpyinfo->display;
   int rc;
+  bool got_settings = false;
 
   x_catch_errors (dpy);
   rc = XGetWindowProperty (dpy,
@@ -587,27 +589,26 @@ read_settings (struct x_display_info *dpyinfo, struct xsettings *settings)
 
   if (rc == Success && prop != NULL && act_form == 8 && nitems > 0
       && act_type == dpyinfo->Xatom_xsettings_prop)
-    rc = parse_settings (prop, nitems, settings);
+    got_settings = parse_settings (prop, nitems, settings) != 0;
 
   XFree (prop);
 
   x_uncatch_errors ();
 
-  return rc != 0;
+  return got_settings;
 }
 
 /* Apply Xft settings in SETTINGS to the Xft library.
-   If SEND_EVENT_P is non-zero store a Lisp event that Xft settings changed.  */
+   Store a Lisp event that Xft settings changed.  */
 
 static void
 apply_xft_settings (struct x_display_info *dpyinfo,
-                    int send_event_p,
                     struct xsettings *settings)
 {
 #ifdef HAVE_XFT
   FcPattern *pat;
   struct xsettings oldsettings;
-  int changed = 0;
+  bool changed = false;
 
   memset (&oldsettings, 0, sizeof (oldsettings));
   pat = FcPatternCreate ();
@@ -627,7 +628,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
     {
       FcPatternDel (pat, FC_ANTIALIAS);
       FcPatternAddBool (pat, FC_ANTIALIAS, settings->aa);
-      ++changed;
+      changed = true;
       oldsettings.aa = settings->aa;
     }
 
@@ -636,7 +637,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
     {
       FcPatternDel (pat, FC_HINTING);
       FcPatternAddBool (pat, FC_HINTING, settings->hinting);
-      ++changed;
+      changed = true;
       oldsettings.hinting = settings->hinting;
     }
   if ((settings->seen & SEEN_RGBA) != 0 && oldsettings.rgba != settings->rgba)
@@ -644,7 +645,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
       FcPatternDel (pat, FC_RGBA);
       FcPatternAddInteger (pat, FC_RGBA, settings->rgba);
       oldsettings.rgba = settings->rgba;
-      ++changed;
+      changed = true;
     }
 
   /* Older fontconfig versions don't have FC_LCD_FILTER. */
@@ -653,7 +654,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
     {
       FcPatternDel (pat, FC_LCD_FILTER);
       FcPatternAddInteger (pat, FC_LCD_FILTER, settings->lcdfilter);
-      ++changed;
+      changed = true;
       oldsettings.lcdfilter = settings->lcdfilter;
     }
 
@@ -663,7 +664,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
     {
       FcPatternDel (pat, FC_HINT_STYLE);
       FcPatternAddInteger (pat, FC_HINT_STYLE, settings->hintstyle);
-      ++changed;
+      changed = true;
       oldsettings.hintstyle = settings->hintstyle;
     }
 #endif
@@ -673,7 +674,7 @@ apply_xft_settings (struct x_display_info *dpyinfo,
     {
       FcPatternDel (pat, FC_DPI);
       FcPatternAddDouble (pat, FC_DPI, settings->dpi);
-      ++changed;
+      changed = true;
       oldsettings.dpi = settings->dpi;
 
       /* Changing the DPI on this display affects all frames on it.
@@ -699,9 +700,8 @@ apply_xft_settings (struct x_display_info *dpyinfo,
       char buf[sizeof format + d_formats * d_growth + lf_formats * lf_growth];
 
       XftDefaultSet (dpyinfo->display, pat);
-      if (send_event_p)
-        store_config_changed_event (Qfont_render,
-                                    XCAR (dpyinfo->name_list_element));
+      store_config_changed_event (Qfont_render,
+                                  XCAR (dpyinfo->name_list_element));
       Vxft_settings
         = make_formatted_string (buf, format,
                                  oldsettings.aa, oldsettings.hinting,
@@ -715,17 +715,17 @@ apply_xft_settings (struct x_display_info *dpyinfo,
 }
 
 /* Read XSettings from the display for DPYINFO.
-   If SEND_EVENT_P is non-zero store a Lisp event settings that changed.  */
+   If SEND_EVENT_P store a Lisp event settings that changed.  */
 
 static void
-read_and_apply_settings (struct x_display_info *dpyinfo, int send_event_p)
+read_and_apply_settings (struct x_display_info *dpyinfo, bool send_event_p)
 {
   struct xsettings settings;
 
   if (!read_settings (dpyinfo, &settings))
     return;
 
-  apply_xft_settings (dpyinfo, True, &settings);
+  apply_xft_settings (dpyinfo, &settings);
   if (settings.seen & SEEN_TB_STYLE)
     {
       if (send_event_p)
@@ -751,27 +751,27 @@ read_and_apply_settings (struct x_display_info *dpyinfo, int send_event_p)
 void
 xft_settings_event (struct x_display_info *dpyinfo, const XEvent *event)
 {
-  bool check_window_p = 0, apply_settings_p = 0;
+  bool check_window_p = false, apply_settings_p = false;
 
   switch (event->type)
     {
     case DestroyNotify:
       if (dpyinfo->xsettings_window == event->xany.window)
-        check_window_p = 1;
+        check_window_p = true;
       break;
 
     case ClientMessage:
       if (event->xclient.message_type == dpyinfo->Xatom_xsettings_mgr
           && event->xclient.data.l[1] == dpyinfo->Xatom_xsettings_sel
           && event->xclient.window == dpyinfo->root_window)
-        check_window_p = 1;
+        check_window_p = true;
       break;
 
     case PropertyNotify:
       if (event->xproperty.window == dpyinfo->xsettings_window
           && event->xproperty.state == PropertyNewValue
           && event->xproperty.atom == dpyinfo->Xatom_xsettings_prop)
-        apply_settings_p = 1;
+        apply_settings_p = true;
       break;
     }
 
@@ -781,11 +781,11 @@ xft_settings_event (struct x_display_info *dpyinfo, const XEvent *event)
       dpyinfo->xsettings_window = None;
       get_prop_window (dpyinfo);
       if (dpyinfo->xsettings_window != None)
-        apply_settings_p = 1;
+        apply_settings_p = true;
     }
 
   if (apply_settings_p)
-    read_and_apply_settings (dpyinfo, True);
+    read_and_apply_settings (dpyinfo, true);
 }
 
 /* Initialize GSettings and read startup values.  */
@@ -795,7 +795,7 @@ init_gsettings (void)
 {
 #ifdef HAVE_GSETTINGS
   GVariant *val;
-  int schema_found = 0;
+  bool schema_found = false;
 
 #if ! GLIB_CHECK_VERSION (2, 36, 0)
   g_type_init ();
@@ -937,7 +937,7 @@ init_xsettings (struct x_display_info *dpyinfo)
 
   get_prop_window (dpyinfo);
   if (dpyinfo->xsettings_window != None)
-    read_and_apply_settings (dpyinfo, False);
+    read_and_apply_settings (dpyinfo, false);
 
   unblock_input ();
 }
@@ -1030,7 +1030,7 @@ syms_of_xsettings (void)
 When this is non-nil and the system defined fixed width font changes, we
 update frames dynamically.
 If this variable is nil, Emacs ignores system font changes.  */);
-  use_system_font = 0;
+  use_system_font = false;
 
   DEFVAR_LISP ("xft-settings", Vxft_settings,
                doc: /* Font settings applied to Xft.  */);
diff --git a/src/xsmfns.c b/src/xsmfns.c
index cd4f9ce57fa..a6c69855390 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -53,7 +53,7 @@ static int ice_fd = -1;
 
 /* A flag that says if we are in shutdown interactions or not.  */
 
-static int doing_interact;
+static bool doing_interact;
 
 /* The session manager object for the session manager connection.  */
 
@@ -123,9 +123,9 @@ x_session_check_input (int fd, void *data)
     kbd_buffer_store_event (&emacs_event);
 }
 
-/* Return non-zero if we have a connection to a session manager.  */
+/* Return true if we have a connection to a session manager.  */
 
-int
+bool
 x_session_have_connection (void)
 {
   return ice_fd != -1;
@@ -138,7 +138,7 @@ x_session_have_connection (void)
 static void
 smc_interact_CB (SmcConn smcConn, SmPointer clientData)
 {
-  doing_interact = True;
+  doing_interact = true;
   emacs_event.kind = SAVE_SESSION_EVENT;
   emacs_event.arg = Qnil;
 }
@@ -230,8 +230,7 @@ smc_save_yourself_CB (SmcConn smcConn,
   props[props_idx]->vals[vp_idx++].value = emacs_program;
 
   smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
-  strcpy (smid_opt, SMID_OPT);
-  strcat (smid_opt, client_id);
+  strcpy (stpcpy (smid_opt, SMID_OPT), client_id);
 
   props[props_idx]->vals[vp_idx].length = strlen (smid_opt);
   props[props_idx]->vals[vp_idx++].value = smid_opt;
@@ -242,8 +241,7 @@ smc_save_yourself_CB (SmcConn smcConn,
   if (cwd)
     {
       chdir_opt = xmalloc (strlen (CHDIR_OPT) + strlen (cwd) + 1);
-      strcpy (chdir_opt, CHDIR_OPT);
-      strcat (chdir_opt, cwd);
+      strcpy (stpcpy (chdir_opt, CHDIR_OPT), cwd);
 
       props[props_idx]->vals[vp_idx].length = strlen (chdir_opt);
       props[props_idx]->vals[vp_idx++].value = chdir_opt;
@@ -400,15 +398,15 @@ x_session_initialize (struct x_display_info *dpyinfo)
   ptrdiff_t name_len = 0;
 
   ice_fd = -1;
-  doing_interact = False;
+  doing_interact = false;
 
   /* Check if we where started by the session manager.  If so, we will
      have a previous id.  */
-  if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
+  if (! NILP (Vx_session_previous_id) && STRINGP (Vx_session_previous_id))
     previous_id = SSDATA (Vx_session_previous_id);
 
   /* Construct the path to the Emacs program.  */
-  if (! EQ (Vinvocation_directory, Qnil))
+  if (! NILP (Vinvocation_directory))
     name_len += SBYTES (Vinvocation_directory);
   name_len += SBYTES (Vinvocation_name);
 
@@ -417,7 +415,7 @@ x_session_initialize (struct x_display_info *dpyinfo)
   emacs_program = xmalloc (name_len + 1);
   char *z = emacs_program;
 
-  if (! EQ (Vinvocation_directory, Qnil))
+  if (! NILP (Vinvocation_directory))
     z = lispstpcpy (z, Vinvocation_directory);
   lispstpcpy (z, Vinvocation_name);
 
@@ -491,21 +489,19 @@ is told to abort the window system shutdown.
 Do not call this function yourself. */)
   (Lisp_Object event)
 {
-  int kill_emacs = CONSP (event) && CONSP (XCDR (event))
-    && EQ (Qt, XCAR (XCDR (event)));
+  bool kill_emacs = (CONSP (event) && CONSP (XCDR (event))
+                     && EQ (Qt, XCAR (XCDR (event))));
 
   /* Check doing_interact so that we don't do anything if someone called
      this at the wrong time. */
   if (doing_interact && ! kill_emacs)
     {
-      Bool cancel_shutdown = False;
-
-      cancel_shutdown = ! EQ (call0 (intern ("emacs-session-save")), Qnil);
+      bool cancel_shutdown = ! NILP (call0 (intern ("emacs-session-save")));
 
       SmcInteractDone (smc_conn, cancel_shutdown);
       SmcSaveYourselfDone (smc_conn, True);
 
-      doing_interact = False;
+      doing_interact = false;
     }
   else if (kill_emacs)
     {
@@ -513,7 +509,7 @@ Do not call this function yourself. */)
          prevent.  Fix this in next version.  */
       Fkill_emacs (Qnil);
 
-#if 0
+#if false
       /* This will not be reached, but we want kill-emacs-hook to be run.  */
       SmcCloseConnection (smc_conn, 0, 0);
       ice_connection_closed ();
diff --git a/src/xterm.c b/src/xterm.c
index 0640208ca14..130174dff19 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -9230,13 +9230,9 @@ do_ewmh_fullscreen (struct frame *f)
       switch (f->want_fullscreen)
         {
         case FULLSCREEN_BOTH:
-          if (cur == FULLSCREEN_WIDTH || cur == FULLSCREEN_MAXIMIZED
-              || cur == FULLSCREEN_HEIGHT)
-            set_wm_state (frame, false,
-                          dpyinfo->Xatom_net_wm_state_maximized_horz,
-                          dpyinfo->Xatom_net_wm_state_maximized_vert);
-          set_wm_state (frame, true,
-                        dpyinfo->Xatom_net_wm_state_fullscreen, None);
+          if (cur != FULLSCREEN_BOTH)
+            set_wm_state (frame, true, dpyinfo->Xatom_net_wm_state_fullscreen,
+                          None);
           break;
         case FULLSCREEN_WIDTH:
           if (cur == FULLSCREEN_BOTH || cur == FULLSCREEN_HEIGHT
diff --git a/src/xterm.h b/src/xterm.h
index 31c3261e3b9..13877d33935 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -1049,10 +1049,10 @@ extern void x_send_client_event (Lisp_Object display,
                                  Lisp_Object format,
                                  Lisp_Object values);
 
-extern int x_handle_dnd_message (struct frame *,
-                                 const XClientMessageEvent *,
-                                 struct x_display_info *,
-                                 struct input_event *);
+extern bool x_handle_dnd_message (struct frame *,
+                                  const XClientMessageEvent *,
+                                  struct x_display_info *,
+                                  struct input_event *);
 extern int x_check_property_data (Lisp_Object);
 extern void x_fill_property_data (Display *,
                                   Lisp_Object,
@@ -1107,7 +1107,7 @@ extern void initialize_frame_menubar (struct frame *);
 /* Defined in xsmfns.c */
 #ifdef HAVE_X_SM
 extern void x_session_initialize (struct x_display_info *dpyinfo);
-extern int x_session_have_connection (void);
+extern bool x_session_have_connection (void);
 extern void x_session_close (void);
 #endif