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.

3 files changed, 114 insertions, 110 deletions

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;
 }