Style fixes for indenting etc. in module code

This is mostly indenting and spacing changes.  Also, remove
some unnecessary static decls instead of bothering to reindent them.
* src/module.h (EMACS_EXTERN_C_BEGIN): Remove, and do this inline,
as most other Emacs files do for this sort of thing.

9 files changed, 629 insertions, 684 deletions

diff --git a/configure.ac b/configure.ac
index 7c9061029e2..4d34c1ad25e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3322,7 +3322,8 @@ fi
 if test "${HAVE_MODULES}" = yes; then
    MODULES_OBJ="dynlib.o module.o"
    AC_DEFINE(HAVE_MODULES, 1, [Define to 1 if dynamic modules are enabled])
-   AC_DEFINE_UNQUOTED(MODULES_SUFFIX, "$MODULES_SUFFIX", [System extension for dynamic libraries])
+   AC_DEFINE_UNQUOTED(MODULES_SUFFIX, "$MODULES_SUFFIX",
+     [System extension for dynamic libraries])
 fi
 AC_SUBST(MODULES_OBJ)
 AC_SUBST(LIBMODULES)
diff --git a/modules/mod-test/mod-test.c b/modules/mod-test/mod-test.c
index 04b6122cafb..b58b86c9047 100644
--- a/modules/mod-test/mod-test.c
+++ b/modules/mod-test/mod-test.c
@@ -23,24 +23,21 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 int plugin_is_GPL_compatible;
 
-/*
- * Always return symbol 't'
- */
-static emacs_value Fmod_test_return_t (emacs_env *env, int nargs, emacs_value args[], void *data)
+/* Always return symbol 't'.  */
+static emacs_value
+Fmod_test_return_t (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   return env->intern (env, "t");
 }
 
-
-/*
- * Expose simple sum function
- */
+/* Expose simple sum function.  */
 static int64_t sum (int64_t a, int64_t b)
 {
   return a + b;
 }
 
-static emacs_value Fmod_test_sum (emacs_env *env, int nargs, emacs_value args[], void* data)
+static emacs_value
+Fmod_test_sum (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   int64_t a = env->extract_integer (env, args[0]);
   int64_t b = env->extract_integer (env, args[1]);
@@ -51,38 +48,40 @@ static emacs_value Fmod_test_sum (emacs_env *env, int nargs, emacs_value args[],
 }
 
 
-/*
- * Signal '(error 56)
- */
-static emacs_value Fmod_test_signal (emacs_env *env, int nargs, emacs_value args[], void* data)
+/* Signal '(error 56).  */
+static emacs_value
+Fmod_test_signal (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   assert (env->non_local_exit_check (env) == emacs_funcall_exit_return);
-  env->non_local_exit_signal (env, env->intern (env, "error"), env->make_integer (env, 56));
+  env->non_local_exit_signal (env, env->intern (env, "error"),
+			      env->make_integer (env, 56));
   return NULL;
 }
 
 
-/*
- * Throw '(tag 65)
- */
-static emacs_value Fmod_test_throw (emacs_env *env, int nargs, emacs_value args[], void* data)
+/* Throw '(tag 65).  */
+static emacs_value
+Fmod_test_throw (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   assert (env->non_local_exit_check (env) == emacs_funcall_exit_return);
-  env->non_local_exit_throw (env, env->intern (env, "tag"), env->make_integer (env, 65));
+  env->non_local_exit_throw (env, env->intern (env, "tag"),
+			     env->make_integer (env, 65));
   return NULL;
 }
 
 
-/*
- * Call argument function, catch all non-local exists and return
- * either normal result or a list describing the non-local exit.
- */
-static emacs_value Fmod_test_non_local_exit_funcall (emacs_env *env, int nargs, emacs_value args[], void* data)
+/* Call argument function, catch all non-local exists and return
+   either normal result or a list describing the non-local exit.  */
+static emacs_value
+Fmod_test_non_local_exit_funcall (emacs_env *env, int nargs, emacs_value args[],
+				  void *data)
 {
   assert (nargs == 1);
   const emacs_value result = env->funcall (env, args[0], 0, NULL);
   emacs_value non_local_exit_symbol, non_local_exit_data;
-  enum emacs_funcall_exit code = env->non_local_exit_get (env, &non_local_exit_symbol, &non_local_exit_data);
+  enum emacs_funcall_exit code
+    = env->non_local_exit_get (env, &non_local_exit_symbol,
+			       &non_local_exit_data);
   switch (code)
     {
     case emacs_funcall_exit_return:
@@ -91,141 +90,133 @@ static emacs_value Fmod_test_non_local_exit_funcall (emacs_env *env, int nargs,
       {
         env->non_local_exit_clear (env);
         const emacs_value Flist = env->intern (env, "list");
-        emacs_value list_args[] = {env->intern (env, "signal"), non_local_exit_symbol, non_local_exit_data};
+        emacs_value list_args[] = {env->intern (env, "signal"),
+				   non_local_exit_symbol, non_local_exit_data};
         return env->funcall (env, Flist, 3, list_args);
       }
     case emacs_funcall_exit_throw:
       {
         env->non_local_exit_clear (env);
         const emacs_value Flist = env->intern (env, "list");
-        emacs_value list_args[] = {env->intern (env, "throw"), non_local_exit_symbol, non_local_exit_data};
+        emacs_value list_args[] = {env->intern (env, "throw"),
+				   non_local_exit_symbol, non_local_exit_data};
         return env->funcall (env, Flist, 3, list_args);
       }
     }
-  /* never reached */
+
+  /* Never reached.  */
   return env->intern (env, "nil");;
 }
 
 
-/*
- * Return a global referrence
- */
-static emacs_value Fmod_test_globref_make (emacs_env *env, int nargs, emacs_value args[], void* data)
+/* Return a global referrence.  */
+static emacs_value
+Fmod_test_globref_make (emacs_env *env, int nargs, emacs_value args[],
+			void *data)
 {
-  /* make a big string and make it global */
-  size_t i;
-  char str[26*100];
-
-  for (i = 0; i < sizeof (str); i++)
-    {
-      str[i] = 'a' + (i % 26);
-    }
+  /* Make a big string and make it global.  */
+  char str[26 * 100];
+  for (size_t i = 0; i < sizeof str; i++)
+    str[i] = 'a' + (i % 26);
 
-  /* we don't need to null-terminate str */
-  emacs_value lisp_str = env->make_string (env, str, sizeof (str));
+  /* We don't need to null-terminate str.  */
+  emacs_value lisp_str = env->make_string (env, str, sizeof str);
   return env->make_global_ref (env, lisp_str);
 }
 
 
-/*
- * Return a copy of the argument string where every 'a' is replaced with 'b'.
- */
-static emacs_value Fmod_test_string_a_to_b (emacs_env *env, int nargs, emacs_value args[], void* data)
+/* Return a copy of the argument string where every 'a' is replaced
+   with 'b'.  */
+static emacs_value
+Fmod_test_string_a_to_b (emacs_env *env, int nargs, emacs_value args[],
+			 void *data)
 {
   emacs_value lisp_str = args[0];
   size_t size = 0;
   char * buf = NULL;
-  size_t i;
 
   env->copy_string_contents (env, lisp_str, buf, &size);
   buf = malloc (size);
   env->copy_string_contents (env, lisp_str, buf, &size);
 
-  for (i = 0; i+1 < size; i++) {
+  for (size_t i = 0; i + 1 < size; i++)
     if (buf[i] == 'a')
       buf[i] = 'b';
-  }
 
-  return env->make_string (env, buf, size-1);
+  return env->make_string (env, buf, size - 1);
 }
 
 
-/*
- * Embedded pointers in lisp objects.
- */
+/* Embedded pointers in lisp objects.  */
 
-/* C struct (pointer to) that will be embedded */
+/* C struct (pointer to) that will be embedded.  */
 struct super_struct
 {
   int amazing_int;
   char large_unused_buffer[512];
 };
 
-/* Associated finalizer */
-static void finalizer (void *p)
+/* Associated finalizer.  */
+static void
+finalizer (void *p)
 {
   if (p)
     free (p);
 }
 
-/*
- * Return a new user-pointer to a super_struct, with amazing_int set
- * to the passed parameter.
- */
-static emacs_value Fmod_test_userptr_make (emacs_env *env, int nargs, emacs_value args[], void *data)
+/* Return a new user-pointer to a super_struct, with amazing_int set
+   to the passed parameter.  */
+static emacs_value
+Fmod_test_userptr_make (emacs_env *env, int nargs, emacs_value args[],
+			void *data)
 {
-  struct super_struct *p = calloc (1, sizeof(*p));
+  struct super_struct *p = calloc (1, sizeof *p);
   p->amazing_int = env->extract_integer (env, args[0]);
-  return env->make_user_ptr (env, finalizer, p);
+  return env->make_user_ptr (env, free, p);
 }
 
-/*
- * Return the amazing_int of a passed 'user-pointer to a super_struct'.
- */
-static emacs_value Fmod_test_userptr_get (emacs_env *env, int nargs, emacs_value args[], void *data)
+/* Return the amazing_int of a passed 'user-pointer to a super_struct'.  */
+static emacs_value
+Fmod_test_userptr_get (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   struct super_struct *p = env->get_user_ptr (env, args[0]);
   return env->make_integer (env, p->amazing_int);
 }
 
 
-/*
- * Fill vector in args[0] with value in args[1]
- */
-static emacs_value Fmod_test_vector_fill (emacs_env *env, int nargs, emacs_value args[], void *data)
+/* Fill vector in args[0] with value in args[1].  */
+static emacs_value
+Fmod_test_vector_fill (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
-  size_t i;
   emacs_value vec = args[0];
   emacs_value val = args[1];
   const size_t size = env->vec_size (env, vec);
-  for (i = 0; i < size; i++)
+  for (size_t i = 0; i < size; i++)
     env->vec_set (env, vec, i, val);
   return env->intern (env, "t");
 }
 
 
-/*
- * Return whether all elements of vector in args[0] are 'eq' to value in args[1]
- */
-static emacs_value Fmod_test_vector_eq (emacs_env *env, int nargs, emacs_value args[], void *data)
+/* Return whether all elements of vector in args[0] are 'eq' to value
+   in args[1].  */
+static emacs_value
+Fmod_test_vector_eq (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
-  size_t i;
   emacs_value vec = args[0];
   emacs_value val = args[1];
   const size_t size = env->vec_size (env, vec);
-  for (i = 0; i < size; i++)
+  for (size_t i = 0; i < size; i++)
     if (!env->eq (env, env->vec_get (env, vec, i), val))
         return env->intern (env, "nil");
   return env->intern (env, "t");
 }
 
 
-/*
- * Lisp utilities for easier readability (simple wrappers)
- */
+/* Lisp utilities for easier readability (simple wrappers).  */
 
-/* Provide FEATURE to Emacs */
-static void provide (emacs_env *env, const char *feature)
+/* Provide FEATURE to Emacs.  */
+static void
+provide (emacs_env *env, const char *feature)
 {
   emacs_value Qfeat = env->intern (env, feature);
   emacs_value Qprovide = env->intern (env, "provide");
@@ -234,8 +225,9 @@ static void provide (emacs_env *env, const char *feature)
   env->funcall (env, Qprovide, 1, args);
 }
 
-/* Binds NAME to FUN */
-static void bind_function (emacs_env *env, const char *name, emacs_value Sfun)
+/* Bind NAME to FUN.  */
+static void
+bind_function (emacs_env *env, const char *name, emacs_value Sfun)
 {
   emacs_value Qfset = env->intern (env, "fset");
   emacs_value Qsym = env->intern (env, name);
@@ -244,21 +236,22 @@ static void bind_function (emacs_env *env, const char *name, emacs_value Sfun)
   env->funcall (env, Qfset, 2, args);
 }
 
-/*
- * Module init function.
- */
-int emacs_module_init (struct emacs_runtime *ert)
+/* Module init function.  */
+int
+emacs_module_init (struct emacs_runtime *ert)
 {
   emacs_env *env = ert->get_environment (ert);
 
 #define DEFUN(lsym, csym, amin, amax, doc, data) \
-  bind_function (env, lsym, env->make_function (env, amin, amax, csym, doc, data))
+  bind_function (env, lsym, \
+		 env->make_function (env, amin, amax, csym, doc, data))
 
   DEFUN ("mod-test-return-t", Fmod_test_return_t, 1, 1, NULL, NULL);
   DEFUN ("mod-test-sum", Fmod_test_sum, 2, 2, "Return A + B", NULL);
   DEFUN ("mod-test-signal", Fmod_test_signal, 0, 0, NULL, NULL);
   DEFUN ("mod-test-throw", Fmod_test_throw, 0, 0, NULL, NULL);
-  DEFUN ("mod-test-non-local-exit-funcall", Fmod_test_non_local_exit_funcall, 1, 1, NULL, NULL);
+  DEFUN ("mod-test-non-local-exit-funcall", Fmod_test_non_local_exit_funcall,
+	 1, 1, NULL, NULL);
   DEFUN ("mod-test-globref-make", Fmod_test_globref_make, 0, 0, NULL, NULL);
   DEFUN ("mod-test-string-a-to-b", Fmod_test_string_a_to_b, 1, 1, NULL, NULL);
   DEFUN ("mod-test-userptr-make", Fmod_test_userptr_make, 1, 1, NULL, NULL);
diff --git a/modules/mod-test/test.el b/modules/mod-test/test.el
index ed584ebb95e..98ce46411bd 100644
--- a/modules/mod-test/test.el
+++ b/modules/mod-test/test.el
@@ -19,11 +19,12 @@
 
 (require 'ert)
 
-(add-to-list 'load-path (file-name-directory (or #$ (expand-file-name (buffer-file-name)))))
+(add-to-list 'load-path
+             (file-name-directory (or #$ (expand-file-name (buffer-file-name)))))
 (require 'mod-test)
 
 ;;
-;; basic tests
+;; Basic tests.
 ;;
 
 (ert-deftest mod-test-sum-test ()
@@ -33,7 +34,7 @@
   (should (string= (documentation 'mod-test-sum) "Return A + B")))
 
 ;;
-;; non-local exists (throw, signal)
+;; Non-local exists (throw, signal).
 ;;
 
 (ert-deftest mod-test-non-local-exit-signal-test ()
@@ -51,7 +52,8 @@
                  23)))
 
 (ert-deftest mod-test-non-local-exit-funcall-signal ()
-  (should (equal (mod-test-non-local-exit-funcall (lambda () (signal 'error '(32))))
+  (should (equal (mod-test-non-local-exit-funcall
+                  (lambda () (signal 'error '(32))))
                  '(signal error (32)))))
 
 (ert-deftest mod-test-non-local-exit-funcall-throw ()
@@ -59,7 +61,7 @@
                  '(throw tag 32))))
 
 ;;
-;; string
+;; String tests.
 ;;
 
 (defun multiply-string (s n)
@@ -77,7 +79,7 @@
   (should (string= (mod-test-string-a-to-b "aaa") "bbb")))
 
 ;;
-;; user-pointer
+;; User-pointer tests.
 ;;
 
 (ert-deftest mod-test-userptr-fun-test ()
@@ -92,7 +94,7 @@
 ;; TODO: try to test finalizer
 
 ;;
-;; vectors
+;; Vector tests.
 ;;
 
 (ert-deftest mod-test-vector-test ()
diff --git a/modules/modhelp.py b/modules/modhelp.py
index 5afe8f24e95..45b849ee747 100755
--- a/modules/modhelp.py
+++ b/modules/modhelp.py
@@ -56,7 +56,8 @@ def cmd_test(args):
         print '[*] %s: running test' % m
         testpath = os.path.join(m, 'test.el')
         if os.path.isfile(testpath):
-            emacs_cmd = [EMACS, '-batch', '-L', '.', '-l', 'ert', '-l', testpath, '-f', 'ert-run-tests-batch-and-exit']
+            emacs_cmd = [EMACS, '-batch', '-L', '.', '-l', 'ert',
+                         '-l', testpath, '-f', 'ert-run-tests-batch-and-exit']
             print ' '.join(emacs_cmd)
             r = sp.call(emacs_cmd)
             if r != 0:
@@ -111,13 +112,16 @@ def main():
     subp = mainp.add_subparsers()
 
     testp = subp.add_parser('test', help='run tests')
-    testp.add_argument('-f', '--force', action='store_true', help='force regeneration (make -B)')
-    testp.add_argument('module', nargs='*', help='path to module to test (default all)')
+    testp.add_argument('-f', '--force', action='store_true',
+                       help='force regeneration (make -B)')
+    testp.add_argument('module', nargs='*',
+                       help='path to module to test (default all)')
     testp.set_defaults(func=cmd_test)
 
     initp = subp.add_parser('init', help='create a test module from a template')
     initp.add_argument('module', help='name of the new module')
-    initp.add_argument('-f', '--fun', default='fun', help='overide name of the default function')
+    initp.add_argument('-f', '--fun', default='fun',
+                       help='overide name of the default function')
     initp.set_defaults(func=cmd_init)
 
     args = mainp.parse_args()
@@ -149,13 +153,15 @@ all: ${module}.so ${module}.doc
 
 int plugin_is_GPL_compatible;
 
-static emacs_value ${c_func} (emacs_env *env, int nargs, emacs_value args[], void *data)
+static emacs_value
+${c_func} (emacs_env *env, int nargs, emacs_value args[], void *data)
 {
   return env->intern (env, "t");
 }
 
-/* Binds NAME to FUN */
-static void bind_function (emacs_env *env, const char *name, emacs_value Sfun)
+/* Bind NAME to FUN.  */
+static void
+bind_function (emacs_env *env, const char *name, emacs_value Sfun)
 {
   emacs_value Qfset = env->intern (env, "fset");
   emacs_value Qsym = env->intern (env, name);
@@ -164,8 +170,9 @@ static void bind_function (emacs_env *env, const char *name, emacs_value Sfun)
   env->funcall (env, Qfset, 2, args);
 }
 
-/* Provide FEATURE to Emacs */
-static void provide (emacs_env *env, const char *feature)
+/* Provide FEATURE to Emacs.  */
+static void
+provide (emacs_env *env, const char *feature)
 {
   emacs_value Qfeat = env->intern (env, feature);
   emacs_value Qprovide = env->intern (env, "provide");
@@ -174,10 +181,12 @@ static void provide (emacs_env *env, const char *feature)
   env->funcall (env, Qprovide, 1, args);
 }
 
-int emacs_module_init (struct emacs_runtime *ert)
+int
+emacs_module_init (struct emacs_runtime *ert)
 {
   emacs_env *env = ert->get_environment (ert);
-  bind_function (env, "${lisp_func}", env->make_function (env, 1, 1, ${c_func}, "doc", NULL));
+  bind_function (env, "${lisp_func}",
+                 env->make_function (env, 1, 1, ${c_func}, "doc", NULL));
   provide (env, "${module}");
   return 0;
 }
diff --git a/src/dynlib.c b/src/dynlib.c
index fbc5f9b873b..491a08e0787 100644
--- a/src/dynlib.c
+++ b/src/dynlib.c
@@ -26,63 +26,68 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "dynlib.h"
 
-/*
- *  Windows systems
- */
-#if defined(_WIN32)
+#if defined _WIN32
+
+/* MS-Windows systems.  */
 
 #include <windows.h>
 
-dynlib_handle_ptr dynlib_open (const char * path)
+dynlib_handle_ptr
+dynlib_open (const char *path)
 {
 
   return (dynlib_handle_ptr) LoadLibrary (path);
 }
 
-void * dynlib_sym (dynlib_handle_ptr h, const char * sym)
+void *
+dynlib_sym (dynlib_handle_ptr h, const char *sym)
 {
   return GetProcAddress ((HMODULE) h, sym);
 }
 
-bool dynlib_addr (void *ptr, const char **path, const char **sym)
+bool
+dynlib_addr (void *ptr, const char **path, const char **sym)
 {
   return false;  /* not implemented */
 }
 
-const char * dynlib_error (void)
+const char *
+dynlib_error (void)
 {
   /* TODO: use GetLastError(), FormatMessage(), ... */
   return "Can't load DLL";
 }
 
-int dynlib_close (dynlib_handle_ptr h)
+int
+dynlib_close (dynlib_handle_ptr h)
 {
   return FreeLibrary ((HMODULE) h) != 0;
 }
 
+#elif defined HAVE_UNISTD_H
 
-/*
- *  POSIX systems
- */
-#elif defined(HAVE_UNISTD_H)
+/* POSIX systems.  */
 
 #include <dlfcn.h>
 
-dynlib_handle_ptr dynlib_open (const char * path)
+dynlib_handle_ptr
+dynlib_open (const char *path)
 {
   return dlopen (path, RTLD_LAZY);
 }
 
-void * dynlib_sym (dynlib_handle_ptr h, const char * sym)
+void *
+dynlib_sym (dynlib_handle_ptr h, const char *sym)
 {
   return dlsym (h, sym);
 }
 
-bool dynlib_addr (void *ptr, const char **path, const char **sym)
+bool
+dynlib_addr (void *ptr, const char **path, const char **sym)
 {
 #ifdef HAVE_DLADDR
   Dl_info info;
-  if (dladdr (ptr, &info) != 0 && info.dli_fname != NULL && info.dli_sname != NULL)
+  if (dladdr (ptr, &info) && info.dli_fname && info.dli_sname)
     {
       *path = info.dli_fname;
       *sym = info.dli_sname;
@@ -92,12 +97,14 @@ bool dynlib_addr (void *ptr, const char **path, const char **sym)
   return false;
 }
 
-const char * dynlib_error (void)
+const char *
+dynlib_error (void)
 {
   return dlerror ();
 }
 
-int dynlib_close (dynlib_handle_ptr h)
+int
+dynlib_close (dynlib_handle_ptr h)
 {
   return dlclose (h) == 0;
 }
diff --git a/src/dynlib.h b/src/dynlib.h
index 852842df478..bd03666b860 100644
--- a/src/dynlib.h
+++ b/src/dynlib.h
@@ -23,11 +23,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include <stdbool.h>
 
-typedef void* dynlib_handle_ptr;
-dynlib_handle_ptr dynlib_open (const char * path);
-void * dynlib_sym (dynlib_handle_ptr h, const char * sym);
+typedef void *dynlib_handle_ptr;
+dynlib_handle_ptr dynlib_open (const char *path);
+void *dynlib_sym (dynlib_handle_ptr h, const char *sym);
 bool dynlib_addr (void *ptr, const char **path, const char **sym);
-const char * dynlib_error (void);
+const char *dynlib_error (void);
 int dynlib_close (dynlib_handle_ptr h);
 
 #endif /* DYNLIB_H */
diff --git a/src/lisp.h b/src/lisp.h
index 3b6ea76943d..ce5a6d2aea8 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2246,7 +2246,7 @@ struct Lisp_User_Ptr
   bool_bf gcmarkbit : 1;
   unsigned spacer : 15;
 
-  void (*finalizer) (void*);
+  void (*finalizer) (void *);
   void *p;
 };
 #endif
@@ -2347,7 +2347,6 @@ XUSER_PTR (Lisp_Object a)
 }
 #endif
 
-
 
 /* Forwarding pointer to an int variable.
    This is allowed only in the value cell of a symbol,
diff --git a/src/module.c b/src/module.c
index 4069b881394..35a9f48eb12 100644
--- a/src/module.c
+++ b/src/module.c
@@ -30,285 +30,193 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "verify.h"
 
 
-/* Feature tests */
+/* Feature tests.  */
 
-enum {
-  /* 1 if we have __attribute__((cleanup(...))), 0 otherwise */
-  module_has_cleanup =
+/* True if __attribute__ ((cleanup (...))) works, false otherwise.  */
 #ifdef HAVE_VAR_ATTRIBUTE_CLEANUP
-  1
+enum { module_has_cleanup = true };
 #else
-  0
+enum { module_has_cleanup = false };
 #endif
-};
 
 /* Handle to the main thread.  Used to verify that modules call us in
-   the right thread. */
-#if defined(HAVE_THREADS_H)
-#include <threads.h>
+   the right thread.  */
+#ifdef HAVE_THREADS_H
+# include <threads.h>
 static thrd_t main_thread;
-#elif defined(HAVE_PTHREAD)
-#include <pthread.h>
+#elif defined HAVE_PTHREAD
+# include <pthread.h>
 static pthread_t main_thread;
-#elif defined(WINDOWSNT)
-#include <windows.h>
-/* On Windows, we store both a handle to the main thread and the
+#elif defined WINDOWSNT
+# include <windows.h>
+/* On Windows, store both a handle to the main thread and the
    thread ID because the latter can be reused when a thread
-   terminates. */
+   terminates.  */
 static HANDLE main_thread;
 static DWORD main_thread_id;
 #endif
 
 
-/* Implementation of runtime and environment functions */
-
-static emacs_env* module_get_environment (struct emacs_runtime *ert);
-
-static emacs_value module_make_global_ref (emacs_env *env,
-                                           emacs_value ref);
-static void module_free_global_ref (emacs_env *env,
-                                    emacs_value ref);
-static enum emacs_funcall_exit module_non_local_exit_check (emacs_env *env);
-static void module_non_local_exit_clear (emacs_env *env);
-static enum emacs_funcall_exit module_non_local_exit_get (emacs_env *env, emacs_value *sym, emacs_value *data);
-static void module_non_local_exit_signal (emacs_env *env, emacs_value sym, emacs_value data);
-static void module_non_local_exit_throw (emacs_env *env, emacs_value tag, emacs_value value);
-static emacs_value module_make_function (emacs_env *env,
-                                         int min_arity,
-                                         int max_arity,
-                                         emacs_subr subr,
-                                         const char *documentation,
-                                         void *data);
-static emacs_value module_funcall (emacs_env *env,
-                                   emacs_value fun,
-                                   int nargs,
-                                   emacs_value args[]);
-static emacs_value module_intern (emacs_env *env, const char *name);
-static emacs_value module_type_of (emacs_env *env, emacs_value value);
-static bool module_is_not_nil (emacs_env *env, emacs_value value);
-static bool module_eq (emacs_env *env, emacs_value a, emacs_value b);
-static int64_t module_extract_integer (emacs_env *env, emacs_value n);
-static emacs_value module_make_integer (emacs_env *env, int64_t n);
-static emacs_value module_make_float (emacs_env *env, double d);
-static double module_extract_float (emacs_env *env, emacs_value f);
-static bool module_copy_string_contents (emacs_env *env,
-                                         emacs_value value,
-                                         char *buffer,
-                                         size_t* length);
-static emacs_value module_make_string (emacs_env *env, const char *str, size_t lenght);
-static emacs_value module_make_user_ptr (emacs_env *env,
-                                         emacs_finalizer_function fin,
-                                         void *ptr);
-static void* module_get_user_ptr (emacs_env *env, emacs_value uptr);
-static void module_set_user_ptr (emacs_env *env, emacs_value uptr, void *ptr);
-static emacs_finalizer_function module_get_user_finalizer (emacs_env *env, emacs_value uptr);
-static void module_set_user_finalizer (emacs_env *env,
-                                       emacs_value uptr,
-                                       emacs_finalizer_function fin);
-
-
-/* Helper functions */
-
-/* If checking is enabled, abort if the current thread is not the
-   Emacs main thread. */
-static void check_main_thread (void);
-
-/* Internal versions of `module_non_local_exit_signal' and `module_non_local_exit_throw'. */
-static void module_non_local_exit_signal_1 (emacs_env *env, Lisp_Object sym, Lisp_Object data);
-static void module_non_local_exit_throw_1 (emacs_env *env, Lisp_Object tag, Lisp_Object value);
-
-/* Module version of `wrong_type_argument'. */
-static void module_wrong_type (emacs_env *env, Lisp_Object predicate, Lisp_Object value);
-
-/* Signal an out-of-memory condition to the caller. */
-static void module_out_of_memory (emacs_env *env);
-
-/* Signal arguments are out of range. */
-static void module_args_out_of_range (emacs_env *env, Lisp_Object a1, Lisp_Object a2);
-
-
-/* Value conversion */
-
-/* Converts an `emacs_value' to the corresponding internal object.
-   Never fails. */
-static Lisp_Object value_to_lisp (emacs_value v);
-
-/* Converts an internal object to an `emacs_value'.  Allocates storage
-   from the environment; returns NULL if allocation fails. */
-static emacs_value lisp_to_value (emacs_env *env, Lisp_Object o);
-
-
-/* Memory management */
+/* Memory management.  */
 
 /* An `emacs_value' is just a pointer to a structure holding an
-   internal Lisp object. */
+   internal Lisp object.  */
 struct emacs_value_tag { Lisp_Object v; };
 
 /* Local value objects use a simple fixed-sized block allocation
    scheme without explicit deallocation.  All local values are
-   deallocated when the lifetime of their environment ends.  We keep
+   deallocated when the lifetime of their environment ends.  Keep
    track of a current frame from which new values are allocated,
-   appending further dynamically-allocated frames if necessary. */
+   appending further dynamically-allocated frames if necessary.  */
 
 enum { value_frame_size = 512 };
 
-/* A block from which `emacs_value' object can be allocated. */
-struct emacs_value_frame {
-  /* Storage for values */
+/* A block from which `emacs_value' object can be allocated.  */
+struct emacs_value_frame
+{
+  /* Storage for values.  */
   struct emacs_value_tag objects[value_frame_size];
 
-  /* Index of the next free value in `objects' */
+  /* Index of the next free value in `objects'.  */
   size_t offset;
 
-  /* Pointer to next frame, if any */
+  /* Pointer to next frame, if any.  */
   struct emacs_value_frame *next;
 };
 
-/* Must be called for each frame before it can be used for
-   allocation. */
-static void initialize_frame (struct emacs_value_frame *frame);
-
 /* A structure that holds an initial frame (so that the first local
    values require no dynamic allocation) and keeps track of the
-   current frame. */
-static struct emacs_value_storage {
+   current frame.  */
+static struct emacs_value_storage
+{
   struct emacs_value_frame initial;
   struct emacs_value_frame *current;
 } global_storage;
 
-/* Must be called for any storage object before it can be used for
-   allocation. */
-static void initialize_storage (struct emacs_value_storage *storage);
-
-/* Must be called for any initialized storage object before its
-   lifetime ends.  Frees all dynamically-allocated frames. */
-static void finalize_storage (struct emacs_value_storage *storage);
-
-/* Allocates a new value from STORAGE and stores OBJ in it.  Returns
-   NULL if allocations fails and uses ENV for non local exit reporting. */
-static emacs_value allocate_emacs_value (emacs_env *env, struct emacs_value_storage *storage,
-                                         Lisp_Object obj);
-
 
-/* Private runtime and environment members */
+/* Private runtime and environment members.  */
 
 /* The private part of an environment stores the current non local exit state
    and holds the `emacs_value' objects allocated during the lifetime
-   of the environment. */
-struct emacs_env_private {
+   of the environment.  */
+struct emacs_env_private
+{
   enum emacs_funcall_exit pending_non_local_exit;
 
-  /* Dedicated storage for non-local exit symbol and data so that we always
-     have storage available for them, even in an out-of-memory
-     situation. */
+  /* Dedicated storage for non-local exit symbol and data so that
+     storage is always available for them, even in an out-of-memory
+     situation.  */
   struct emacs_value_tag non_local_exit_symbol, non_local_exit_data;
 
   struct emacs_value_storage storage;
 };
 
-/* Combines public and private parts in one structure.  This structure
-   is used whenever an environment is created. */
-struct env_storage {
+/* Combine public and private parts in one structure.  This structure
+   is used whenever an environment is created.  */
+struct env_storage
+{
   emacs_env pub;
   struct emacs_env_private priv;
 };
 
-/* Must be called before the environment can be used. */
-static void initialize_environment (struct env_storage *env);
-
-/* Must be called before the lifetime of the environment object
-   ends. */
-static void finalize_environment (struct env_storage *env);
-
 /* The private parts of an `emacs_runtime' object contain the initial
-   environment. */
-struct emacs_runtime_private {
+   environment.  */
+struct emacs_runtime_private
+{
   struct env_storage environment;
 };
 
 
-/* Convenience macros for non-local exit handling */
 
-/* Emacs uses setjmp(3) and longjmp(3) for non-local exits, but we
-   can't allow module frames to be skipped because they are in general
-   not prepared for long jumps (e.g. the behavior in C++ is undefined
-   if objects with nontrivial destructors would be skipped).
-   Therefore we catch all non-local exits.  There are two kinds of
-   non-local exits: `signal' and `throw'.  The macros in this section
-   can be used to catch both.  We use macros so that we don't have to
-   write lots of additional variants of `internal_condition_case'
-   etc. and don't have to worry about passing information to the
-   handler functions. */
+/* Forward declarations.  */
 
-/* Called on `signal'.  ERR will be a cons cell (SYMBOL . DATA), which
-   gets stored in the environment.  Sets the pending non-local exit flag. */
-static void module_handle_signal (emacs_env *env, Lisp_Object err);
+struct module_fun_env;
 
-/* Called on `throw'.  TAG_VAL will be a cons cell (TAG . VALUE),
-   which gets stored in the environment.  Sets the pending non-local exit
-   flag. */
-static void module_handle_throw (emacs_env *env, Lisp_Object tag_val);
+static Lisp_Object module_format_fun_env (const struct module_fun_env *);
+static Lisp_Object value_to_lisp (emacs_value);
+static emacs_value allocate_emacs_value (emacs_env *, struct emacs_value_storage *, Lisp_Object);
+static emacs_value lisp_to_value (emacs_env *, Lisp_Object);
+static enum emacs_funcall_exit module_non_local_exit_check (emacs_env *);
+static void check_main_thread (void);
+static void finalize_environment (struct env_storage *);
+static void initialize_environment (struct env_storage *);
+static void module_args_out_of_range (emacs_env *, Lisp_Object, Lisp_Object);
+static void module_handle_signal (emacs_env *, const Lisp_Object);
+static void module_handle_throw (emacs_env *, Lisp_Object);
+static void module_non_local_exit_signal_1 (emacs_env *, Lisp_Object, Lisp_Object);
+static void module_non_local_exit_throw_1 (emacs_env *, Lisp_Object, Lisp_Object);
+static void module_out_of_memory (emacs_env *);
+static void module_reset_handlerlist (const int *);
+static void module_wrong_type (emacs_env *, Lisp_Object, Lisp_Object);
 
-/* Must be called after setting up a handler immediately before
-   returning from the function.  See the comments in lisp.h and the
-   code in eval.c for details.  The macros below arrange for this
-   function to be called automatically.  DUMMY is ignored. */
-static void module_reset_handlerlist (const int *dummy);
+
+/* Convenience macros for non-local exit handling.  */
+
+/* Emacs uses setjmp and longjmp for non-local exits, but
+   module frames cannot be skipped because they are in general
+   not prepared for long jumps (e.g., the behavior in C++ is undefined
+   if objects with nontrivial destructors would be skipped).
+   Therefore, catch all non-local exits.  There are two kinds of
+   non-local exits: `signal' and `throw'.  The macros in this section
+   can be used to catch both.  Use macros to avoid additional variants
+   of `internal_condition_case' etc., and to avoid worrying about
+   passing information to the handler functions.  */
 
 /* Place this macro at the beginning of a function returning a number
    or a pointer to handle signals.  The function must have an ENV
    parameter.  The function will return 0 (or NULL) if a signal is
-   caught. */
-#define MODULE_HANDLE_SIGNALS MODULE_HANDLE_SIGNALS_RETURN(0)
+   caught.  */
+#define MODULE_HANDLE_SIGNALS MODULE_HANDLE_SIGNALS_RETURN (0)
 
 /* Place this macro at the beginning of a function returning void to
-   handle signals.  The function must have an ENV parameter. */
-#define MODULE_HANDLE_SIGNALS_VOID MODULE_HANDLE_SIGNALS_RETURN()
+   handle signals.  The function must have an ENV parameter.  */
+#define MODULE_HANDLE_SIGNALS_VOID MODULE_HANDLE_SIGNALS_RETURN ()
 
 #define MODULE_HANDLE_SIGNALS_RETURN(retval)                                   \
-  MODULE_SETJMP(CONDITION_CASE, module_handle_signal, retval)
+  MODULE_SETJMP (CONDITION_CASE, module_handle_signal, retval)
 
 /* Place this macro at the beginning of a function returning a pointer
    to handle non-local exits via `throw'.  The function must have an
    ENV parameter.  The function will return NULL if a `throw' is
-   caught. */
+   caught.  */
 #define MODULE_HANDLE_THROW                                                    \
-  MODULE_SETJMP(CATCHER_ALL, module_handle_throw, NULL)
-
-#define MODULE_SETJMP(handlertype, handlerfunc, retval)                        \
-  MODULE_SETJMP_1(handlertype, handlerfunc, retval,                            \
-                  internal_handler_##handlertype,                              \
-                  internal_cleanup_##handlertype)
-
-#define MODULE_SETJMP_1(handlertype, handlerfunc, retval, c, dummy)            \
-  eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);    \
-  struct handler *c;                                                           \
-  /* It is very important that pushing the handler doesn't itself raise a      \
-     signal. */                                                                \
-  if (!push_handler_nosignal(&c, Qt, handlertype)) {                           \
-    module_out_of_memory(env);                                                 \
-    return retval;                                                             \
-  }                                                                            \
-  verify(module_has_cleanup);                                                  \
-  /* We can install the cleanup only after the handler has been pushed.  Use   \
-     __attribute__((cleanup)) to avoid non-local-exit-prone manual cleanup. */ \
-  const int dummy __attribute__((cleanup(module_reset_handlerlist)));          \
-  if (sys_setjmp(c->jmp)) {                                                    \
-    (handlerfunc)(env, c->val);                                                \
-    return retval;                                                             \
-  }                                                                            \
-  /* Force the macro to be followed by a semicolon. */                         \
-  do {                                                                         \
-  } while (0)
+  MODULE_SETJMP (CATCHER_ALL, module_handle_throw, NULL)
+
+#define MODULE_SETJMP(handlertype, handlerfunc, retval)			       \
+  MODULE_SETJMP_1 (handlertype, handlerfunc, retval,			       \
+		   internal_handler_##handlertype,			       \
+		   internal_cleanup_##handlertype)
+
+/* It is very important that pushing the handler doesn't itself raise
+   a signal.  Install the cleanup only after the handler has been
+   pushed.  Use __attribute__ ((cleanup)) to avoid
+   non-local-exit-prone manual cleanup.  */
+#define MODULE_SETJMP_1(handlertype, handlerfunc, retval, c, dummy)	\
+  do {									\
+    eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return); \
+    struct handler *c;							\
+    if (!push_handler_nosignal (&c, Qt, handlertype))			\
+      {									\
+	module_out_of_memory (env);					\
+	return retval;							\
+      }									\
+    verify (module_has_cleanup);					\
+    const int dummy __attribute__ ((cleanup (module_reset_handlerlist))); \
+    if (sys_setjmp (c->jmp))						\
+      {									\
+	(handlerfunc) (env, c->val);					\
+	return retval;							\
+      }									\
+  } while (false)
 
 
-/* Function environments */
+/* Function environments.  */
 
 /* A function environment is an auxiliary structure used by
    `module_make_function' to store information about a module
    function.  It is stored in a save pointer and retrieved by
    `module-call'.  Its members correspond to the arguments given to
-   `module_make_function'. */
+   `module_make_function'.  */
 
 struct module_fun_env
 {
@@ -317,34 +225,30 @@ struct module_fun_env
   void *data;
 };
 
-/* Returns a string object that contains a user-friendly
-   representation of the function environment. */
-static Lisp_Object module_format_fun_env (const struct module_fun_env *env);
-
-/* Holds the function definition of `module-call'.  `module-call' is
-   uninterned because user code couldn't meaningfully use it, so we
-   have to keep its definition around somewhere else. */
+/* The function definition of `module-call'.  `module-call' is
+   uninterned because user code couldn't meaningfully use it, so keep
+   its definition around somewhere else.  */
 static Lisp_Object module_call_func;
 
 
-/* Implementation of runtime and environment functions */
+/* Implementation of runtime and environment functions.  */
 
-/* We catch signals and throws only if the code can actually signal or
-   throw. */
+/* Catch signals and throws only if the code can actually signal or
+   throw.  If checking is enabled, abort if the current thread is not
+   the Emacs main thread.  */
 
-static emacs_env* module_get_environment (struct emacs_runtime *ert)
+static emacs_env *
+module_get_environment (struct emacs_runtime *ert)
 {
   check_main_thread ();
   return &ert->private_members->environment.pub;
 }
 
-/*
- * To make global refs (GC-protected global values) we keep a hash
- * that maps global Lisp objects to reference counts.
- */
+/* To make global refs (GC-protected global values) keep a hash that
+   maps global Lisp objects to reference counts.  */
 
-static emacs_value module_make_global_ref (emacs_env *env,
-                                           emacs_value ref)
+static emacs_value
+module_make_global_ref (emacs_env *env, emacs_value ref)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -376,12 +280,12 @@ static emacs_value module_make_global_ref (emacs_env *env,
   return allocate_emacs_value (env, &global_storage, new_obj);
 }
 
-static void module_free_global_ref (emacs_env *env,
-                                    emacs_value ref)
+static void
+module_free_global_ref (emacs_env *env, emacs_value ref)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
-  /* TODO: This probably never signals. */
+  /* TODO: This probably never signals.  */
   MODULE_HANDLE_SIGNALS_VOID;
   eassert (HASH_TABLE_P (Vmodule_refs_hash));
   struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
@@ -407,19 +311,22 @@ static void module_free_global_ref (emacs_env *env,
     }
 }
 
-static enum emacs_funcall_exit module_non_local_exit_check (emacs_env *env)
+static enum emacs_funcall_exit
+module_non_local_exit_check (emacs_env *env)
 {
   check_main_thread ();
   return env->private_members->pending_non_local_exit;
 }
 
-static void module_non_local_exit_clear (emacs_env *env)
+static void
+module_non_local_exit_clear (emacs_env *env)
 {
   check_main_thread ();
   env->private_members->pending_non_local_exit = emacs_funcall_exit_return;
 }
 
-static enum emacs_funcall_exit module_non_local_exit_get (emacs_env *env, emacs_value *sym, emacs_value *data)
+static enum emacs_funcall_exit
+module_non_local_exit_get (emacs_env *env, emacs_value *sym, emacs_value *data)
 {
   check_main_thread ();
   struct emacs_env_private *const p = env->private_members;
@@ -431,42 +338,36 @@ static enum emacs_funcall_exit module_non_local_exit_get (emacs_env *env, emacs_
   return p->pending_non_local_exit;
 }
 
-/*
- * Like for `signal', DATA must be a list
- */
-static void module_non_local_exit_signal (emacs_env *env, emacs_value sym, emacs_value data)
+/* Like for `signal', DATA must be a list.  */
+static void
+module_non_local_exit_signal (emacs_env *env, emacs_value sym, emacs_value data)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
-  module_non_local_exit_signal_1 (env, value_to_lisp (sym), value_to_lisp (data));
+  module_non_local_exit_signal_1 (env, value_to_lisp (sym),
+				  value_to_lisp (data));
 }
 
-static void module_non_local_exit_throw (emacs_env *env, emacs_value tag, emacs_value value)
+static void
+module_non_local_exit_throw (emacs_env *env, emacs_value tag, emacs_value value)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
-  module_non_local_exit_throw_1 (env, value_to_lisp (tag), value_to_lisp (value));
+  module_non_local_exit_throw_1 (env, value_to_lisp (tag),
+				 value_to_lisp (value));
 }
 
-/*
- * A module function is lambda function that calls `module-call',
- * passing the function pointer of the module function along with the
- * module emacs_env pointer as arguments.
- *
- *   (function
- *    (lambda
- *     (&rest arglist)
- *     (module-call
- *      envobj
- *      arglist)))
- *
- */
-static emacs_value module_make_function (emacs_env *env,
-                                         int min_arity,
-                                         int max_arity,
-                                         emacs_subr subr,
-                                         const char *const documentation,
-                                         void *data)
+/* A module function is lambda function that calls `module-call',
+   passing the function pointer of the module function along with the
+   module emacs_env pointer as arguments.
+
+	(function (lambda (&rest arglist)
+		    (module-call envobj arglist)))  */
+
+static emacs_value
+module_make_function (emacs_env *env, int min_arity, int max_arity,
+		      emacs_subr subr, const char *const documentation,
+		      void *data)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -475,15 +376,15 @@ static emacs_value module_make_function (emacs_env *env,
   if (min_arity > MOST_POSITIVE_FIXNUM || max_arity > MOST_POSITIVE_FIXNUM)
     xsignal0 (Qoverflow_error);
 
-  if (min_arity < 0 ||
-      (max_arity >= 0 && max_arity < min_arity) ||
-      (max_arity < 0 && max_arity != emacs_variadic_function))
+  if (min_arity < 0
+      || (max_arity >= 0 && max_arity < min_arity)
+      || (max_arity < 0 && max_arity != emacs_variadic_function))
     xsignal2 (Qinvalid_arity, make_number (min_arity), make_number (max_arity));
 
   Lisp_Object envobj;
 
-  /* XXX: This should need to be freed when envobj is GC'd */
-  struct module_fun_env *envptr = xzalloc (sizeof (*envptr));
+  /* XXX: This should need to be freed when envobj is GC'd.  */
+  struct module_fun_env *envptr = xzalloc (sizeof *envptr);
   envptr->min_arity = min_arity;
   envptr->max_arity = max_arity;
   envptr->subr = subr;
@@ -500,20 +401,16 @@ static emacs_value module_make_function (emacs_env *env,
   return lisp_to_value (env, ret);
 }
 
-static emacs_value module_funcall (emacs_env *env,
-                                   emacs_value fun,
-                                   int nargs,
-                                   emacs_value args[])
+static emacs_value
+module_funcall (emacs_env *env, emacs_value fun, int nargs, emacs_value args[])
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
   MODULE_HANDLE_SIGNALS;
   MODULE_HANDLE_THROW;
 
-  /*
-   *  Make a new Lisp_Object array starting with the function as the
-   *  first arg, because that's what Ffuncall takes
-   */
+  /* Make a new Lisp_Object array starting with the function as the
+     first arg, because that's what Ffuncall takes.  */
   Lisp_Object newargs[nargs + 1];
   newargs[0] = value_to_lisp (fun);
   for (int i = 0; i < nargs; i++)
@@ -521,7 +418,8 @@ static emacs_value module_funcall (emacs_env *env,
   return lisp_to_value (env, Ffuncall (nargs + 1, newargs));
 }
 
-static emacs_value module_intern (emacs_env *env, const char *name)
+static emacs_value
+module_intern (emacs_env *env, const char *name)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -529,28 +427,32 @@ static emacs_value module_intern (emacs_env *env, const char *name)
   return lisp_to_value (env, intern (name));
 }
 
-static emacs_value module_type_of (emacs_env *env, emacs_value value)
+static emacs_value
+module_type_of (emacs_env *env, emacs_value value)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
   return lisp_to_value (env, Ftype_of (value_to_lisp (value)));
 }
 
-static bool module_is_not_nil (emacs_env *env, emacs_value value)
+static bool
+module_is_not_nil (emacs_env *env, emacs_value value)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
   return ! NILP (value_to_lisp (value));
 }
 
-static bool module_eq (emacs_env *env, emacs_value a, emacs_value b)
+static bool
+module_eq (emacs_env *env, emacs_value a, emacs_value b)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
   return EQ (value_to_lisp (a), value_to_lisp (b));
 }
 
-static int64_t module_extract_integer (emacs_env *env, emacs_value n)
+static int64_t
+module_extract_integer (emacs_env *env, emacs_value n)
 {
   verify (INT64_MIN <= MOST_NEGATIVE_FIXNUM);
   verify (INT64_MAX >= MOST_POSITIVE_FIXNUM);
@@ -565,7 +467,8 @@ static int64_t module_extract_integer (emacs_env *env, emacs_value n)
   return XINT (l);
 }
 
-static emacs_value module_make_integer (emacs_env *env, int64_t n)
+static emacs_value
+module_make_integer (emacs_env *env, int64_t n)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -582,7 +485,8 @@ static emacs_value module_make_integer (emacs_env *env, int64_t n)
   return lisp_to_value (env, make_number (n));
 }
 
-static double module_extract_float (emacs_env *env, emacs_value f)
+static double
+module_extract_float (emacs_env *env, emacs_value f)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -595,7 +499,8 @@ static double module_extract_float (emacs_env *env, emacs_value f)
   return XFLOAT_DATA (lisp);
 }
 
-static emacs_value module_make_float (emacs_env *env, double d)
+static emacs_value
+module_make_float (emacs_env *env, double d)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -603,10 +508,9 @@ static emacs_value module_make_float (emacs_env *env, double d)
   return lisp_to_value (env, make_float (d));
 }
 
-static bool module_copy_string_contents (emacs_env *env,
-                                         emacs_value value,
-                                         char *buffer,
-                                         size_t* length)
+static bool
+module_copy_string_contents (emacs_env *env, emacs_value value, char *buffer,
+			     size_t *length)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -620,10 +524,8 @@ static bool module_copy_string_contents (emacs_env *env,
 
   size_t raw_size = SBYTES (lisp_str);
 
-  /*
-   * Emacs internal encoding is more-or-less UTF8, let's assume utf8
-   * encoded emacs string are the same byte size.
-   */
+  /* Emacs internal encoding is more-or-less UTF8, let's assume utf8
+     encoded emacs string are the same byte size.  */
 
   if (!buffer || length == 0 || *length-1 < raw_size)
     {
@@ -640,7 +542,8 @@ static bool module_copy_string_contents (emacs_env *env,
   return true;
 }
 
-static emacs_value module_make_string (emacs_env *env, const char *str, size_t length)
+static emacs_value
+module_make_string (emacs_env *env, const char *str, size_t length)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -650,19 +553,19 @@ static emacs_value module_make_string (emacs_env *env, const char *str, size_t l
       module_non_local_exit_signal_1 (env, Qoverflow_error, Qnil);
       return NULL;
     }
-  /* Assume STR is utf8 encoded */
+  /* Assume STR is utf8 encoded.  */
   return lisp_to_value (env, make_string (str, length));
 }
 
-static emacs_value module_make_user_ptr (emacs_env *env,
-                                         emacs_finalizer_function fin,
-                                         void *ptr)
+static emacs_value
+module_make_user_ptr (emacs_env *env, emacs_finalizer_function fin, void *ptr)
 {
   check_main_thread ();
   return lisp_to_value (env, make_user_ptr (fin, ptr));
 }
 
-static void* module_get_user_ptr (emacs_env *env, emacs_value uptr)
+static void *
+module_get_user_ptr (emacs_env *env, emacs_value uptr)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -675,7 +578,8 @@ static void* module_get_user_ptr (emacs_env *env, emacs_value uptr)
   return XUSER_PTR (lisp)->p;
 }
 
-static void module_set_user_ptr (emacs_env *env, emacs_value uptr, void *ptr)
+static void
+module_set_user_ptr (emacs_env *env, emacs_value uptr, void *ptr)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -684,7 +588,8 @@ static void module_set_user_ptr (emacs_env *env, emacs_value uptr, void *ptr)
   XUSER_PTR (lisp)->p = ptr;
 }
 
-static emacs_finalizer_function module_get_user_finalizer (emacs_env *env, emacs_value uptr)
+static emacs_finalizer_function
+module_get_user_finalizer (emacs_env *env, emacs_value uptr)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -697,9 +602,9 @@ static emacs_finalizer_function module_get_user_finalizer (emacs_env *env, emacs
   return XUSER_PTR (lisp)->finalizer;
 }
 
-static void module_set_user_finalizer (emacs_env *env,
-                                           emacs_value uptr,
-                                           emacs_finalizer_function fin)
+static void
+module_set_user_finalizer (emacs_env *env, emacs_value uptr,
+			   emacs_finalizer_function fin)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -708,10 +613,8 @@ static void module_set_user_finalizer (emacs_env *env,
   XUSER_PTR (lisp)->finalizer = fin;
 }
 
-static void module_vec_set (emacs_env *env,
-			    emacs_value vec,
-			    size_t i,
-			    emacs_value val)
+static void
+module_vec_set (emacs_env *env, emacs_value vec, size_t i, emacs_value val)
 {
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -734,11 +637,10 @@ static void module_vec_set (emacs_env *env,
   ASET (lvec, i, value_to_lisp (val));
 }
 
-static emacs_value module_vec_get (emacs_env *env,
-                                   emacs_value vec,
-                                   size_t i)
+static emacs_value
+module_vec_get (emacs_env *env, emacs_value vec, size_t i)
 {
-  /* Type of ASIZE (lvec) is ptrdiff_t, make sure it fits */
+  /* Type of ASIZE (lvec) is ptrdiff_t, make sure it fits.  */
   verify (PTRDIFF_MAX <= SIZE_MAX);
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -753,7 +655,7 @@ static emacs_value module_vec_get (emacs_env *env,
       module_wrong_type (env, Qvectorp, lvec);
       return NULL;
     }
-  /* Prevent error-prone comparison between types of different signedness. */
+  /* Prevent error-prone comparison between types of different signedness.  */
   const size_t size = ASIZE (lvec);
   eassert (size >= 0);
   if (i >= size)
@@ -766,10 +668,10 @@ static emacs_value module_vec_get (emacs_env *env,
   return lisp_to_value (env, AREF (lvec, i));
 }
 
-static size_t module_vec_size (emacs_env *env,
-                               emacs_value vec)
+static size_t
+module_vec_size (emacs_env *env, emacs_value vec)
 {
-  /* Type of ASIZE (lvec) is ptrdiff_t, make sure it fits */
+  /* Type of ASIZE (lvec) is ptrdiff_t, make sure it fits.  */
   verify (PTRDIFF_MAX <= SIZE_MAX);
   check_main_thread ();
   eassert (module_non_local_exit_check (env) == emacs_funcall_exit_return);
@@ -784,7 +686,7 @@ static size_t module_vec_size (emacs_env *env,
 }
 
 
-/* Subroutines */
+/* Subroutines.  */
 
 DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
        doc: /* Load module FILE.  */)
@@ -836,28 +738,30 @@ DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
 DEFUN ("module-call", Fmodule_call, Smodule_call, 2, 2, 0,
        doc: /* Internal function to call a module function.
 ENVOBJ is a save pointer to a module_fun_env structure.
-ARGLIST is a list of arguments passed to SUBRPTR. */)
+ARGLIST is a list of arguments passed to SUBRPTR.  */)
   (Lisp_Object envobj, Lisp_Object arglist)
 {
-  const struct module_fun_env *const envptr =
-    (const struct module_fun_env *) XSAVE_POINTER (envobj, 0);
+  const struct module_fun_env *const envptr = XSAVE_POINTER (envobj, 0);
   const EMACS_INT len = XINT (Flength (arglist));
   eassert (len >= 0);
   if (len > MOST_POSITIVE_FIXNUM)
     xsignal0 (Qoverflow_error);
-  if (len > INT_MAX || len < envptr->min_arity || (envptr->max_arity >= 0 && len > envptr->max_arity))
-    xsignal2 (Qwrong_number_of_arguments, module_format_fun_env (envptr), make_number (len));
+  if (len > INT_MAX || len < envptr->min_arity
+      || (envptr->max_arity >= 0 && len > envptr->max_arity))
+    xsignal2 (Qwrong_number_of_arguments, module_format_fun_env (envptr),
+	      make_number (len));
 
   struct env_storage env;
   initialize_environment (&env);
 
-  emacs_value *args = xzalloc (len * sizeof (*args));
+  emacs_value *args = xzalloc (len * sizeof *args);
   int i;
 
   for (i = 0; i < len; i++)
     {
       args[i] = lisp_to_value (&env.pub, XCAR (arglist));
-      if (! args[i]) memory_full (sizeof *args[i]);
+      if (! args[i])
+	memory_full (sizeof *args[i]);
       arglist = XCDR (arglist);
     }
 
@@ -868,11 +772,12 @@ ARGLIST is a list of arguments passed to SUBRPTR. */)
     {
     case emacs_funcall_exit_return:
       finalize_environment (&env);
-      if (ret == NULL) xsignal1 (Qinvalid_module_call, module_format_fun_env (envptr));
+      if (ret == NULL)
+	xsignal1 (Qinvalid_module_call, module_format_fun_env (envptr));
       return value_to_lisp (ret);
     case emacs_funcall_exit_signal:
       {
-        const Lisp_Object symbol = value_to_lisp (&env.priv.non_local_exit_symbol);
+        Lisp_Object symbol = value_to_lisp (&env.priv.non_local_exit_symbol);
         const Lisp_Object data = value_to_lisp (&env.priv.non_local_exit_data);
         finalize_environment (&env);
         xsignal (symbol, data);
@@ -888,24 +793,27 @@ ARGLIST is a list of arguments passed to SUBRPTR. */)
 }
 
 
-/* Helper functions */
+/* Helper functions.  */
 
-static void check_main_thread (void)
+static void
+check_main_thread (void)
 {
-#if defined(HAVE_THREADS_H)
-  eassert (thrd_equal (thdr_current (), main_thread);
-#elif defined(HAVE_PTHREAD)
+#ifdef HAVE_THREADS_H
+  eassert (thrd_equal (thdr_current (), main_thread));
+#elif defined HAVE_PTHREAD
   eassert (pthread_equal (pthread_self (), main_thread));
-#elif defined(WINDOWSNT)
+#elif defined WINDOWSNT
   /* CompareObjectHandles would be perfect, but is only available in
      Windows 10.  Also check whether the thread is still running to
-     protect against thread identifier reuse. */
+     protect against thread identifier reuse.  */
   eassert (GetCurrentThreadId () == main_thread_id
 	   && WaitForSingleObject (main_thread, 0) == WAIT_TIMEOUT);
 #endif
 }
 
-static void module_non_local_exit_signal_1 (emacs_env *env, Lisp_Object sym, Lisp_Object data)
+static void
+module_non_local_exit_signal_1 (emacs_env *env, Lisp_Object sym,
+				Lisp_Object data)
 {
   struct emacs_env_private *const p = env->private_members;
   eassert (p->pending_non_local_exit == emacs_funcall_exit_return);
@@ -914,7 +822,9 @@ static void module_non_local_exit_signal_1 (emacs_env *env, Lisp_Object sym, Lis
   p->non_local_exit_data.v = data;
 }
 
-static void module_non_local_exit_throw_1 (emacs_env *env, Lisp_Object tag, Lisp_Object value)
+static void
+module_non_local_exit_throw_1 (emacs_env *env, Lisp_Object tag,
+			       Lisp_Object value)
 {
   struct emacs_env_private *const p = env->private_members;
   eassert (p->pending_non_local_exit == emacs_funcall_exit_return);
@@ -923,53 +833,77 @@ static void module_non_local_exit_throw_1 (emacs_env *env, Lisp_Object tag, Lisp
   p->non_local_exit_data.v = value;
 }
 
-static void module_wrong_type (emacs_env *env, Lisp_Object predicate, Lisp_Object value)
+/* Module version of `wrong_type_argument'.  */
+static void
+module_wrong_type (emacs_env *env, Lisp_Object predicate, Lisp_Object value)
 {
-  module_non_local_exit_signal_1 (env, Qwrong_type_argument, list2 (predicate, value));
+  module_non_local_exit_signal_1 (env, Qwrong_type_argument,
+				  list2 (predicate, value));
 }
 
-static void module_out_of_memory (emacs_env *env)
+/* Signal an out-of-memory condition to the caller.  */
+static void
+module_out_of_memory (emacs_env *env)
 {
-  // TODO: Reimplement this so it works even if memory-signal-data has been modified.
-  module_non_local_exit_signal_1 (env, XCAR (Vmemory_signal_data), XCDR (Vmemory_signal_data));
+  /* TODO: Reimplement this so it works even if memory-signal-data has
+     been modified.  */
+  module_non_local_exit_signal_1 (env, XCAR (Vmemory_signal_data),
+				  XCDR (Vmemory_signal_data));
 }
 
-static void module_args_out_of_range (emacs_env *env, Lisp_Object a1, Lisp_Object a2)
+/* Signal arguments are out of range.  */
+static void
+module_args_out_of_range (emacs_env *env, Lisp_Object a1, Lisp_Object a2)
 {
   module_non_local_exit_signal_1 (env, Qargs_out_of_range, list2 (a1, a2));
 }
 
 
-/* Value conversion */
+/* Value conversion.  */
 
-static Lisp_Object value_to_lisp (emacs_value v)
+/* Convert an `emacs_value' to the corresponding internal object.
+   Never fails.  */
+static Lisp_Object
+value_to_lisp (emacs_value v)
 {
   return v->v;
 }
 
-static emacs_value lisp_to_value (emacs_env *env, Lisp_Object o)
+/* Convert an internal object to an `emacs_value'.  Allocate storage
+   from the environment; return NULL if allocation fails.  */
+static emacs_value
+lisp_to_value (emacs_env *env, Lisp_Object o)
 {
   struct emacs_env_private *const p = env->private_members;
-  if (p->pending_non_local_exit != emacs_funcall_exit_return) return NULL;
+  if (p->pending_non_local_exit != emacs_funcall_exit_return)
+    return NULL;
   return allocate_emacs_value (env, &p->storage, o);
 }
 
 
-/* Memory management */
+/* Memory management.  */
 
-static void initialize_frame (struct emacs_value_frame *frame)
+/* Must be called for each frame before it can be used for allocation.  */
+static void
+initialize_frame (struct emacs_value_frame *frame)
 {
   frame->offset = 0;
   frame->next = NULL;
 }
 
-static void initialize_storage (struct emacs_value_storage *storage)
+/* Must be called for any storage object before it can be used for
+   allocation.  */
+static void
+initialize_storage (struct emacs_value_storage *storage)
 {
   initialize_frame (&storage->initial);
   storage->current = &storage->initial;
 }
 
-static void finalize_storage (struct emacs_value_storage *storage)
+/* Must be called for any initialized storage object before its
+   lifetime ends.  Free all dynamically-allocated frames.  */
+static void
+finalize_storage (struct emacs_value_storage *storage)
 {
   struct emacs_value_frame *next = storage->initial.next;
   while (next != NULL)
@@ -980,8 +914,11 @@ static void finalize_storage (struct emacs_value_storage *storage)
     }
 }
 
-static emacs_value allocate_emacs_value (emacs_env *env, struct emacs_value_storage *storage,
-                                         Lisp_Object obj)
+/* Allocate a new value from STORAGE and stores OBJ in it.  Return
+   NULL if allocations fails and use ENV for non local exit reporting.  */
+static emacs_value
+allocate_emacs_value (emacs_env *env, struct emacs_value_storage *storage,
+		      Lisp_Object obj)
 {
   eassert (storage->current);
   eassert (storage->current->offset < value_frame_size);
@@ -1004,46 +941,50 @@ static emacs_value allocate_emacs_value (emacs_env *env, struct emacs_value_stor
 }
 
 /* Mark all objects allocated from local environments so that they
-   don't get garbage-collected. */
+   don't get garbage-collected.  */
 void mark_modules (void)
 {
   for (Lisp_Object tem = Vmodule_environments; CONSP (tem); tem = XCDR (tem))
     {
       const struct env_storage *const env = XSAVE_POINTER (tem, 0);
-      for (const struct emacs_value_frame *frame = &env->priv.storage.initial; frame != NULL; frame = frame->next)
+      for (const struct emacs_value_frame *frame = &env->priv.storage.initial;
+	   frame != NULL;
+	   frame = frame->next)
         for (size_t i = 0; i < frame->offset; ++i)
           mark_object (frame->objects[i].v);
     }
 }
 
 
-/* Environment lifetime management */
+/* Environment lifetime management.  */
 
-static void initialize_environment (struct env_storage *env)
+/* Must be called before the environment can be used.  */
+static void
+initialize_environment (struct env_storage *env)
 {
   env->priv.pending_non_local_exit = emacs_funcall_exit_return;
   initialize_storage (&env->priv.storage);
-  env->pub.size            = sizeof env->pub;
+  env->pub.size = sizeof env->pub;
   env->pub.private_members = &env->priv;
   env->pub.make_global_ref = module_make_global_ref;
   env->pub.free_global_ref = module_free_global_ref;
-  env->pub.non_local_exit_check     = module_non_local_exit_check;
-  env->pub.non_local_exit_clear     = module_non_local_exit_clear;
-  env->pub.non_local_exit_get       = module_non_local_exit_get;
-  env->pub.non_local_exit_signal    = module_non_local_exit_signal;
-  env->pub.non_local_exit_throw     = module_non_local_exit_throw;
-  env->pub.make_function   = module_make_function;
-  env->pub.funcall         = module_funcall;
-  env->pub.intern          = module_intern;
-  env->pub.type_of         = module_type_of;
-  env->pub.is_not_nil      = module_is_not_nil;
-  env->pub.eq              = module_eq;
-  env->pub.extract_integer   = module_extract_integer;
-  env->pub.make_integer     = module_make_integer;
+  env->pub.non_local_exit_check = module_non_local_exit_check;
+  env->pub.non_local_exit_clear = module_non_local_exit_clear;
+  env->pub.non_local_exit_get = module_non_local_exit_get;
+  env->pub.non_local_exit_signal = module_non_local_exit_signal;
+  env->pub.non_local_exit_throw = module_non_local_exit_throw;
+  env->pub.make_function = module_make_function;
+  env->pub.funcall = module_funcall;
+  env->pub.intern = module_intern;
+  env->pub.type_of = module_type_of;
+  env->pub.is_not_nil = module_is_not_nil;
+  env->pub.eq = module_eq;
+  env->pub.extract_integer = module_extract_integer;
+  env->pub.make_integer = module_make_integer;
   env->pub.extract_float = module_extract_float;
-  env->pub.make_float      = module_make_float;
+  env->pub.make_float = module_make_float;
   env->pub.copy_string_contents = module_copy_string_contents;
-  env->pub.make_string     = module_make_string;
+  env->pub.make_string = module_make_string;
   env->pub.make_user_ptr = module_make_user_ptr;
   env->pub.get_user_ptr = module_get_user_ptr;
   env->pub.set_user_ptr = module_set_user_ptr;
@@ -1055,36 +996,53 @@ static void initialize_environment (struct env_storage *env)
   Vmodule_environments = Fcons (make_save_ptr (env), Vmodule_environments);
 }
 
-static void finalize_environment (struct env_storage *env)
+/* Must be called before the lifetime of the environment object
+   ends.  */
+static void
+finalize_environment (struct env_storage *env)
 {
   finalize_storage (&env->priv.storage);
   Vmodule_environments = XCDR (Vmodule_environments);
 }
 
 
-/* Non-local exit handling */
+/* Non-local exit handling.  */
 
-static void module_reset_handlerlist(const int *dummy)
+/* Must be called after setting up a handler immediately before
+   returning from the function.  See the comments in lisp.h and the
+   code in eval.c for details.  The macros below arrange for this
+   function to be called automatically.  DUMMY is ignored.  */
+static void
+module_reset_handlerlist (const int *dummy)
 {
   handlerlist = handlerlist->next;
 }
 
-static void module_handle_signal (emacs_env *const env, const Lisp_Object err)
+/* Called on `signal'.  ERR is a pair (SYMBOL . DATA), which gets
+   stored in the environment.  Set the pending non-local exit flag.  */
+static void
+module_handle_signal (emacs_env *const env, const Lisp_Object err)
 {
   module_non_local_exit_signal_1 (env, XCAR (err), XCDR (err));
 }
 
-static void module_handle_throw (emacs_env *const env, const Lisp_Object tag_val)
+/* Called on `throw'.  TAG_VAL is a pair (TAG . VALUE), which gets
+   stored in the environment.  Set the pending non-local exit flag.  */
+static void
+module_handle_throw (emacs_env *const env, const Lisp_Object tag_val)
 {
   module_non_local_exit_throw_1 (env, XCAR (tag_val), XCDR (tag_val));
 }
 
 
-/* Function environments */
+/* Function environments.  */
 
-static Lisp_Object module_format_fun_env (const struct module_fun_env *const env)
+/* Return a string object that contains a user-friendly
+   representation of the function environment.  */
+static Lisp_Object
+module_format_fun_env (const struct module_fun_env *const env)
 {
-  /* Try to print a function name if possible. */
+  /* Try to print a function name if possible.  */
   const char *path, *sym;
   if (dynlib_addr (env->subr, &path, &sym))
     {
@@ -1108,26 +1066,28 @@ static Lisp_Object module_format_fun_env (const struct module_fun_env *const env
 }
 
 
-/* Segment initializer */
+/* Segment initializer.  */
 
-void syms_of_module (void)
+void
+syms_of_module (void)
 {
   DEFSYM (Qmodule_refs_hash, "module-refs-hash");
   DEFVAR_LISP ("module-refs-hash", Vmodule_refs_hash,
 	       doc: /* Module global referrence table.  */);
 
-  Vmodule_refs_hash = make_hash_table (hashtest_eq, make_number (DEFAULT_HASH_SIZE),
-                                       make_float (DEFAULT_REHASH_SIZE),
-                                       make_float (DEFAULT_REHASH_THRESHOLD),
-                                       Qnil);
+  Vmodule_refs_hash
+    = make_hash_table (hashtest_eq, make_number (DEFAULT_HASH_SIZE),
+		       make_float (DEFAULT_REHASH_SIZE),
+		       make_float (DEFAULT_REHASH_THRESHOLD),
+		       Qnil);
   Funintern (Qmodule_refs_hash, Qnil);
 
   DEFSYM (Qmodule_environments, "module-environments");
   DEFVAR_LISP ("module-environments", Vmodule_environments,
-               doc: /* List of active module environments. */);
+               doc: /* List of active module environments.  */);
   Vmodule_environments = Qnil;
   /* Unintern `module-environments' because it is only used
-     internally. */
+     internally.  */
   Funintern (Qmodule_environments, Qnil);
 
   DEFSYM (Qmodule_load_failed, "module-load-failed");
@@ -1151,7 +1111,7 @@ void syms_of_module (void)
   initialize_storage (&global_storage);
 
   /* Unintern `module-refs-hash' because it is internal-only and Lisp
-     code or modules should not access it. */
+     code or modules should not access it.  */
   Funintern (Qmodule_refs_hash, Qnil);
 
   defsubr (&Smodule_load);
@@ -1159,39 +1119,40 @@ void syms_of_module (void)
   /* Don't call defsubr on `module-call' because that would intern it,
      but `module-call' is an internal function that users cannot
      meaningfully use.  Instead, assign its definition to a private
-     variable. */
+     variable.  */
   XSETPVECTYPE (&Smodule_call, PVEC_SUBR);
   XSETSUBR (module_call_func, &Smodule_call);
 }
 
 /* Unlike syms_of_module, this initializer is called even from an
- * initialized (dumped) Emacs. */
+   initialized (dumped) Emacs.  */
 
-void module_init (void)
+void
+module_init (void)
 {
   /* It is not guaranteed that dynamic initializers run in the main thread,
-     therefore we detect the main thread here. */
-#if defined(HAVE_THREADS_H)
+     therefore detect the main thread here.  */
+#ifdef HAVE_THREADS_H
   main_thread = thrd_current ();
-#elif defined(HAVE_PTHREAD)
+#elif defined HAVE_PTHREAD
   main_thread = pthread_self ();
-#elif defined(WINDOWSNT)
+#elif defined WINDOWSNT
   /* This calls APIs that are only available on Vista and later.  */
-#if 0
-  /* GetCurrentProcess returns a pseudohandle, which we have to duplicate. */
-  if (! DuplicateHandle (GetCurrentProcess(), GetCurrentThread(),
-                         GetCurrentProcess(), &main_thread,
+# if false
+  /* GetCurrentProcess returns a pseudohandle, which must be duplicated.  */
+  if (! DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+                         GetCurrentProcess (), &main_thread,
                          SYNCHRONIZE | THREAD_QUERY_INFORMATION,
                          FALSE, 0))
     emacs_abort ();
-#else
-  /* GetCurrentThread returns a pseudohandle, which we have to duplicate. */
+# else
+  /* GetCurrentThread returns a pseudohandle, which must be duplicated.  */
   HANDLE th = GetCurrentThread ();
   if (!DuplicateHandle (GetCurrentProcess (), th,
                         GetCurrentProcess (), &main_thread, 0, FALSE,
                         DUPLICATE_SAME_ACCESS))
     emacs_abort ();
   main_thread_id = GetCurrentThreadId ();
-#endif
+# endif
 #endif
 }
diff --git a/src/module.h b/src/module.h
index 9f43c898af4..d4fad9d32a0 100644
--- a/src/module.h
+++ b/src/module.h
@@ -24,206 +24,179 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <stdlib.h>
 #include <stdbool.h>
 
-#ifdef __cplusplus
-#define EMACS_EXTERN_C_BEGIN extern "C" {
-#define EMACS_EXTERN_C_END }
+#if defined __cplusplus && __cplusplus >= 201103L
+# define EMACS_NOEXCEPT noexcept
 #else
-#define EMACS_EXTERN_C_BEGIN
-#define EMACS_EXTERN_C_END
+# define EMACS_NOEXCEPT
 #endif
 
-#if defined(__cplusplus) && __cplusplus >= 201103L
-#define EMACS_NOEXCEPT noexcept
-#else
-#define EMACS_NOEXCEPT
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-EMACS_EXTERN_C_BEGIN
-
-/* Current environement */
+/* Current environment.  */
 typedef struct emacs_env_25 emacs_env;
 
-/* Opaque structure pointer representing an Emacs Lisp value */
-typedef struct emacs_value_tag* emacs_value;
+/* Opaque structure pointer representing an Emacs Lisp value.  */
+typedef struct emacs_value_tag *emacs_value;
 
-enum emacs_arity {
-  emacs_variadic_function = -2
-};
+enum emacs_arity { emacs_variadic_function = -2 };
 
-/* Struct passed to a module init function (emacs_module_init) */
-struct emacs_runtime {
-  /* Structure size (for version checking) */
+/* Struct passed to a module init function (emacs_module_init).  */
+struct emacs_runtime
+{
+  /* Structure size (for version checking).  */
   size_t size;
 
-  /* Private data; users should not touch this */
+  /* Private data; users should not touch this.  */
   struct emacs_runtime_private *private_members;
 
-  /* Returns an environment pointer. */
-  emacs_env* (*get_environment)(struct emacs_runtime *ert);
+  /* Return an environment pointer.  */
+  emacs_env *(*get_environment) (struct emacs_runtime *ert);
 };
 
 
-/* Function prototype for the module init function */
-typedef int (*emacs_init_function)(struct emacs_runtime *ert);
+/* Function prototype for the module init function.  */
+typedef int (*emacs_init_function) (struct emacs_runtime *ert);
 
-/* Function prototype for the module Lisp functions */
-typedef emacs_value (*emacs_subr)(emacs_env *env,
-                                  int nargs,
-                                  emacs_value args[],
-                                  void *data);
+/* Function prototype for the module Lisp functions.  */
+typedef emacs_value (*emacs_subr) (emacs_env *env, int nargs, emacs_value args[],
+				   void *data);
 
-/* Function prototype for module user-pointer finalizers */
-typedef void (*emacs_finalizer_function)(void*);
+/* Function prototype for module user-pointer finalizers.  */
+typedef void (*emacs_finalizer_function) (void *);
 
-/* Possible Emacs function call outcomes. */
-enum emacs_funcall_exit {
-  /* Function has returned normally. */
+/* Possible Emacs function call outcomes.  */
+enum emacs_funcall_exit
+{
+  /* Function has returned normally.  */
   emacs_funcall_exit_return = 0,
-  /* Function has signaled an error using `signal'. */
+
+  /* Function has signaled an error using `signal'.  */
   emacs_funcall_exit_signal = 1,
-  /* Function has exit using `throw'. */
+
+  /* Function has exit using `throw'.  */
   emacs_funcall_exit_throw = 2,
 };
 
-struct emacs_env_25 {
-  /*
-   * Structure size (for version checking)
-   */
-
+struct emacs_env_25
+{
+  /* Structure size (for version checking).  */
   size_t size;
 
-  /* Private data; users should not touch this */
+  /* Private data; users should not touch this.  */
   struct emacs_env_private *private_members;
 
-  /*
-   * Memory management
-   */
+  /* Memory management.  */
+
+  emacs_value (*make_global_ref) (emacs_env *env,
+				  emacs_value any_reference);
+
+  void (*free_global_ref) (emacs_env *env,
+			   emacs_value global_reference);
+
+  /* Non-local exit handling.  */
+
+  enum emacs_funcall_exit (*non_local_exit_check) (emacs_env *env);
+
+  void (*non_local_exit_clear) (emacs_env *env);
+
+  enum emacs_funcall_exit (*non_local_exit_get)
+    (emacs_env *env,
+     emacs_value *non_local_exit_symbol_out,
+     emacs_value *non_local_exit_data_out);
+
+  void (*non_local_exit_signal) (emacs_env *env,
+				 emacs_value non_local_exit_symbol,
+				 emacs_value non_local_exit_data);
+
+  void (*non_local_exit_throw) (emacs_env *env,
+				emacs_value tag,
+				emacs_value value);
+
+  /* Function registration.  */
+
+  emacs_value (*make_function) (emacs_env *env,
+				int min_arity,
+				int max_arity,
+				emacs_value (*function) (emacs_env *, int,
+							 emacs_value *, void *)
+				  EMACS_NOEXCEPT,
+				const char *documentation,
+				void *data);
 
+  emacs_value (*funcall) (emacs_env *env,
+                          emacs_value function,
+                          int nargs,
+                          emacs_value args[]);
 
-  emacs_value (*make_global_ref)(emacs_env *env,
-                                 emacs_value any_reference);
+  emacs_value (*intern) (emacs_env *env,
+                         const char *symbol_name);
 
-  void (*free_global_ref)(emacs_env *env,
-                          emacs_value global_reference);
+  /* Type conversion.  */
 
-  /*
-   * Non-local exit handling
-   */
+  emacs_value (*type_of) (emacs_env *env,
+			  emacs_value value);
 
-  enum emacs_funcall_exit (*non_local_exit_check)(emacs_env *env);
+  bool (*is_not_nil) (emacs_env *env, emacs_value value);
 
-  void (*non_local_exit_clear)(emacs_env *env);
-
-  enum emacs_funcall_exit (*non_local_exit_get)(emacs_env *env,
-                                       emacs_value *non_local_exit_symbol_out,
-                                       emacs_value *non_local_exit_data_out);
-
-  void (*non_local_exit_signal)(emacs_env *env,
-                       emacs_value non_local_exit_symbol,
-                       emacs_value non_local_exit_data);
-
-  void (*non_local_exit_throw)(emacs_env *env,
-                      emacs_value tag,
-                      emacs_value value);
-
-  /*
-   * Function registration
-   */
-
-  emacs_value (*make_function)(emacs_env *env,
-                               int min_arity,
-                               int max_arity,
-                               emacs_value (*function)(emacs_env*, int, emacs_value*, void*) EMACS_NOEXCEPT,
-                               const char *documentation,
-                               void *data);
-
-  emacs_value (*funcall)(emacs_env *env,
-                         emacs_value function,
-                         int nargs,
-                         emacs_value args[]);
-
-  emacs_value (*intern)(emacs_env *env,
-                        const char *symbol_name);
-
-  /*
-   * Type conversion
-   */
-
-  emacs_value (*type_of)(emacs_env *env,
-                         emacs_value value);
-
-  bool (*is_not_nil)(emacs_env *env, emacs_value value);
-
-  bool (*eq)(emacs_env *env, emacs_value a, emacs_value b);
-
-  int64_t (*extract_integer)(emacs_env *env,
-                             emacs_value value);
-
-  emacs_value (*make_integer)(emacs_env *env,
-                              int64_t value);
-
-  double (*extract_float)(emacs_env *env,
-                          emacs_value value);
-
-  emacs_value (*make_float)(emacs_env *env,
-                            double value);
-
-  /*
-   * Copy the content of the lisp string VALUE to BUFFER as an utf8
-   * null-terminated string.
-   *
-   * SIZE must point to the total size of the buffer.  If BUFFER is
-   * NULL or if SIZE is not big enough, write the required buffer size
-   * to SIZE and return false.
-   *
-   * Note that SIZE must include the last null byte (e.g. "abc" needs
-   * a buffer of size 4).
-   *
-   * Returns true if the string was successfully copied.
-   */
-
-  bool (*copy_string_contents)(emacs_env *env,
-                               emacs_value value,
-                               char *buffer,
-                               size_t *size_inout);
-
-  /*
-   * Create a lisp string from a utf8 encoded string.
-   */
-  emacs_value (*make_string)(emacs_env *env,
-                             const char *contents, size_t length);
-
-  /*
-   * Embedded pointer type
-   */
-  emacs_value (*make_user_ptr)(emacs_env *env,
-                               void (*fin)(void *) EMACS_NOEXCEPT,
-                               void *ptr);
-
-  void* (*get_user_ptr)(emacs_env *env, emacs_value uptr);
-  void (*set_user_ptr)(emacs_env *env, emacs_value uptr, void *ptr);
-
-  void (*(*get_user_finalizer)(emacs_env *env, emacs_value uptr))(void *) EMACS_NOEXCEPT;
-  void (*set_user_finalizer)(emacs_env *env,
-                             emacs_value uptr,
-                             void (*fin)(void *) EMACS_NOEXCEPT);
-
-  /*
-   * Vector functions
-   */
-  emacs_value (*vec_get) (emacs_env *env,
-			  emacs_value vec,
-			  size_t i);
-
-  void (*vec_set) (emacs_env *env,
-		   emacs_value vec,
-		   size_t i,
+  bool (*eq) (emacs_env *env, emacs_value a, emacs_value b);
+
+  int_fast64_t (*extract_integer) (emacs_env *env,
+				   emacs_value value);
+
+  emacs_value (*make_integer) (emacs_env *env, int_fast64_t value);
+
+  double (*extract_float) (emacs_env *env, emacs_value value);
+
+  emacs_value (*make_float) (emacs_env *env, double value);
+
+  /* Copy the content of the Lisp string VALUE to BUFFER as an utf8
+     null-terminated string.
+
+     SIZE must point to the total size of the buffer.  If BUFFER is
+     NULL or if SIZE is not big enough, write the required buffer size
+     to SIZE and return false.
+
+     Note that SIZE must include the last null byte (e.g. "abc" needs
+     a buffer of size 4).
+
+     Return true if the string was successfully copied.  */
+
+  bool (*copy_string_contents) (emacs_env *env,
+                                emacs_value value,
+                                char *buffer,
+                                size_t *size_inout);
+
+  /* Create a Lisp string from a utf8 encoded string.  */
+  emacs_value (*make_string) (emacs_env *env,
+			      const char *contents, size_t length);
+
+  /* Embedded pointer type.  */
+  emacs_value (*make_user_ptr) (emacs_env *env,
+				void (*fin) (void *) EMACS_NOEXCEPT,
+				void *ptr);
+
+  void *(*get_user_ptr) (emacs_env *env, emacs_value uptr);
+  void (*set_user_ptr) (emacs_env *env, emacs_value uptr, void *ptr);
+
+  void (*(*get_user_finalizer) (emacs_env *env, emacs_value uptr))
+    (void *) EMACS_NOEXCEPT;
+  void (*set_user_finalizer) (emacs_env *env,
+			      emacs_value uptr,
+			      void (*fin) (void *) EMACS_NOEXCEPT);
+
+  /* Vector functions.  */
+  emacs_value (*vec_get) (emacs_env *env, emacs_value vec, size_t i);
+
+  void (*vec_set) (emacs_env *env, emacs_value vec, size_t i,
 		   emacs_value val);
 
-  size_t (*vec_size) (emacs_env *env,
-		      emacs_value vec);
+  size_t (*vec_size) (emacs_env *env, emacs_value vec);
 };
 
-EMACS_EXTERN_C_END
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* EMACS_MODULE_H */