Changes to m4/m4/module.c,v

[Gary V. Vaughan]

CVSROOT:        /sources/m4
Module name:    m4
Changes by:     Gary V. Vaughan <gary>  07/09/12 01:14:49

Index: m4/module.c
===================================================================
RCS file: /sources/m4/m4/m4/module.c,v
retrieving revision 1.54
retrieving revision 1.55
diff -u -b -r1.54 -r1.55
--- m4/module.c 7 Sep 2007 22:37:47 -0000       1.54
+++ m4/module.c 12 Sep 2007 01:14:48 -0000      1.55
@@ -82,7 +82,7 @@
 #define MODULE_SELF_NAME       "!myself!"
 
 static const char*  module_dlerror (void);
-static int         module_remove  (m4 *context, m4_module *handle,
+static int         module_remove  (m4 *context, m4_module *module,
                                    m4_obstack *obs);
 
 static void        install_builtin_table (m4*, m4_module *);
@@ -94,13 +94,13 @@
 static lt_dlinterface_id iface_id = NULL;
 
 const char *
-m4_get_module_name (const m4_module *m4_handle)
+m4_get_module_name (const m4_module *module)
 {
   const lt_dlinfo *info;
 
-  assert (m4_handle && m4_handle->handle);
+  assert (module && module->handle);
 
-  info = lt_dlgetinfo (m4_handle->handle);
+  info = lt_dlgetinfo (module->handle);
 
   return info ? info->name : NULL;
 }
@@ -109,19 +109,19 @@
 m4_module_import (m4 *context, const char *module_name,
                  const char *symbol_name, m4_obstack *obs)
 {
-  m4_module *  handle          = m4__module_find (module_name);
+  m4_module *  module          = m4__module_find (module_name);
   void *       symbol_address  = NULL;
 
   /* Try to load the module if it is not yet available (errors are
      diagnosed by m4_module_load).  */
   /* FIXME - should this use m4__module_open instead, to avoid
      polluting the symbol table when importing a function?  */
-  if (!handle)
-    handle = m4_module_load (context, module_name, obs);
+  if (!module)
+    module = m4_module_load (context, module_name, obs);
 
-  if (handle)
+  if (module)
     {
-      symbol_address = lt_dlsym (handle->handle, symbol_name);
+      symbol_address = lt_dlsym (module->handle, symbol_name);
 
       if (!symbol_address)
        m4_error (context, 0, 0, _("cannot load symbol `%s' from module `%s'"),
@@ -132,14 +132,14 @@
 }
 
 static void
-install_builtin_table (m4 *context, m4_module *handle)
+install_builtin_table (m4 *context, m4_module *module)
 {
   const m4_builtin *bp;
 
   assert (context);
-  assert (handle);
+  assert (module);
 
-  bp = (m4_builtin *) lt_dlsym (handle->handle, BUILTIN_SYMBOL);
+  bp = (m4_builtin *) lt_dlsym (module->handle, BUILTIN_SYMBOL);
   if (bp)
     {
       for (; bp->name != NULL; bp++)
@@ -155,7 +155,7 @@
          assert ((bp->flags & ~M4_BUILTIN_FLAGS_MASK) == 0);
 
          m4_set_symbol_value_builtin (value, bp);
-         VALUE_HANDLE   (value)        = handle;
+         VALUE_MODULE   (value)        = module;
          VALUE_FLAGS    (value)        = bp->flags;
          VALUE_MIN_ARGS (value)        = bp->min_args;
          VALUE_MAX_ARGS (value)        = bp->max_args;
@@ -173,19 +173,19 @@
 
       m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                        _("module %s: builtins loaded"),
-                       m4_get_module_name (handle));
+                       m4_get_module_name (module));
     }
 }
 
 static void
-install_macro_table (m4 *context, m4_module *handle)
+install_macro_table (m4 *context, m4_module *module)
 {
   const m4_macro *mp;
 
   assert (context);
-  assert (handle);
+  assert (module);
 
-  mp = (const m4_macro *) lt_dlsym (handle->handle, MACRO_SYMBOL);
+  mp = (const m4_macro *) lt_dlsym (module->handle, MACRO_SYMBOL);
 
   if (mp)
     {
@@ -194,53 +194,53 @@
          m4_symbol_value *value = m4_symbol_value_create ();
 
          m4_set_symbol_value_text (value, xstrdup (mp->value));
-         VALUE_HANDLE (value) = handle;
+         VALUE_MODULE (value) = module;
 
          m4_symbol_pushdef (M4SYMTAB, mp->name, value);
        }
 
       m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                        _("module %s: macros loaded"),
-                       m4_get_module_name (handle));
+                       m4_get_module_name (module));
     }
 }
 
 m4_module *
 m4_module_load (m4 *context, const char *name, m4_obstack *obs)
 {
-  m4_module *handle = m4__module_open (context, name, obs);
+  m4_module *module = m4__module_open (context, name, obs);
 
-  if (handle && handle->refcount == 1)
+  if (module && module->refcount == 1)
     {
-      install_builtin_table (context, handle);
-      install_macro_table (context, handle);
+      install_builtin_table (context, module);
+      install_macro_table (context, module);
     }
 
-  return handle;
+  return module;
 }
 
-/* Make the module HANDLE resident.  Return NULL on success, or a
+/* Make the module MODULE resident.  Return NULL on success, or a
    pre-translated error string on failure.  */
 const char *
-m4_module_makeresident (m4_module *m4_handle)
+m4_module_makeresident (m4_module *module)
 {
-  assert (m4_handle);
-  return lt_dlmakeresident (m4_handle->handle) ? module_dlerror () : NULL;
+  assert (module);
+  return lt_dlmakeresident (module->handle) ? module_dlerror () : NULL;
 }
 
 /* Unload a module.  */
 void
 m4_module_unload (m4 *context, const char *name, m4_obstack *obs)
 {
-  m4_module *  handle  = NULL;
+  m4_module *  module  = NULL;
   int          errors  = 0;
 
   assert (context);
 
   if (name)
-    handle = m4__module_find (name);
+    module = m4__module_find (name);
 
-  if (!handle)
+  if (!module)
     {
       const char *error_msg = _("module not loaded");
 
@@ -248,7 +248,7 @@
       ++errors;
     }
   else
-    errors = module_remove (context, handle, obs);
+    errors = module_remove (context, module, obs);
 
   if (errors)
     {
@@ -266,8 +266,8 @@
   /* Shortcut.  If we've already associated our wrapper with this
      handle, then we've validated the handle in the past, and don't
      need to waste any time on additional lt_dlsym calls.  */
-  m4_module *m4_handle = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
-  if (m4_handle)
+  m4_module *module = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
+  if (module)
     return 0;
 
   /* A valid m4 module must provide at least one of these symbols.  */
@@ -281,9 +281,9 @@
 /* Return successive loaded modules that pass the interface test registered
    with the interface id.  */
 m4_module *
-m4__module_next (m4_module *m4_handle)
+m4__module_next (m4_module *module)
 {
-  lt_dlhandle handle = m4_handle ? m4_handle->handle : NULL;
+  lt_dlhandle handle = module ? module->handle : NULL;
   assert (iface_id);
 
   /* Resident modules still show up in the lt_dlhandle_iterate loop
@@ -293,11 +293,11 @@
       handle = lt_dlhandle_iterate (iface_id, handle);
       if (!handle)
        return NULL;
-      m4_handle = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
+      module = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
     }
-  while (!m4_handle);
-  assert (m4_handle->handle == handle);
-  return m4_handle;
+  while (!module);
+  assert (module->handle == handle);
+  return module;
 }
 
 /* Return the first loaded module that passes the registered interface test
@@ -306,16 +306,16 @@
 m4__module_find (const char *name)
 {
   lt_dlhandle handle;
-  m4_module *m4_handle;
+  m4_module *module;
   assert (iface_id);
 
   handle = lt_dlhandle_fetch (iface_id, name);
   if (!handle)
     return NULL;
-  m4_handle = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
-  if (m4_handle)
-    assert (m4_handle->handle == handle);
-  return m4_handle;
+  module = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
+  if (module)
+    assert (module->handle == handle);
+  return module;
 }
 
 
@@ -389,7 +389,7 @@
 m4__module_open (m4 *context, const char *name, m4_obstack *obs)
 {
   lt_dlhandle          handle          = lt_dlopenext (name);
-  m4_module *          m4_handle       = NULL;
+  m4_module *          module          = NULL;
   m4_module_init_func *        init_func       = NULL;
 
   assert (context);
@@ -414,22 +414,22 @@
                        _("module %s: opening file `%s'"),
                        name ? name : MODULE_SELF_NAME, info->filename);
 
-      /* Provide the m4_module correpsonding to the lt_dlhandle, if
+      /* Provide the m4_module corresponding to the lt_dlhandle, if
         not yet created.  */
-      m4_handle = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
-      if (!m4_handle)
+      module = (m4_module *) lt_dlcaller_get_data (iface_id, handle);
+      if (!module)
        {
          void *old;
          const char *err;
 
-         m4_handle = (m4_module *) xzalloc (sizeof *m4_handle);
-         m4_handle->handle = handle;
+         module = (m4_module *) xzalloc (sizeof *module);
+         module->handle = handle;
 
          /* clear out any stale errors, since we have to use
             lt_dlerror to distinguish between success and
             failure.  */
          lt_dlerror ();
-         old = lt_dlcaller_set_data (iface_id, handle, m4_handle);
+         old = lt_dlcaller_set_data (iface_id, handle, module);
          assert (!old);
          err = lt_dlerror ();
          if (err)
@@ -439,11 +439,11 @@
 
       /* Find and run any initializing function in the opened module,
         each time the module is opened.  */
-      m4_handle->refcount++;
+      module->refcount++;
       init_func = (m4_module_init_func *) lt_dlsym (handle, INIT_SYMBOL);
       if (init_func)
        {
-         init_func (context, m4_handle, obs);
+         init_func (context, module, obs);
 
          m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                            _("module %s: init hook called"), name);
@@ -466,23 +466,23 @@
                name, module_dlerror ());
     }
 
-  return m4_handle;
+  return module;
 }
 
 void
 m4__module_exit (m4 *context)
 {
-  m4_module *  handle  = m4__module_next (NULL);
+  m4_module *  module  = m4__module_next (NULL);
   int          errors  = 0;
 
-  while (handle && !errors)
+  while (module && !errors)
     {
-      m4_module *      pending = handle;
+      m4_module *      pending = module;
 
       /* If we are about to unload the final reference, move on to the
-        next handle before we unload the current one.  */
+        next module before we unload the current one.  */
       if (pending->refcount <= 1)
-       handle = m4__module_next (handle);
+       module = m4__module_next (module);
 
       errors = module_remove (context, pending, NULL);
     }
@@ -515,12 +515,12 @@
   return dlerror;
 }
 
-/* Close one reference to the module M4_HANDLE, and output to OBS any
+/* Close one reference to the module MODULE, and output to OBS any
    information from the finish hook of the module.  If no references
-   to M4_HANDLE remain, also remove all symbols and other memory
+   to MODULE remain, also remove all symbols and other memory
    associated with the module.  */
 static int
-module_remove (m4 *context, m4_module *m4_handle, m4_obstack *obs)
+module_remove (m4 *context, m4_module *module, m4_obstack *obs)
 {
   const lt_dlinfo *            info;
   int                          errors  = 0;
@@ -530,11 +530,11 @@
   bool                         resident = false;
   m4_module_finish_func *      finish_func;
 
-  assert (m4_handle && m4_handle->handle);
+  assert (module && module->handle);
 
   /* Be careful when closing myself.  */
-  handle = m4_handle->handle;
-  name = m4_get_module_name (m4_handle);
+  handle = module->handle;
+  name = m4_get_module_name (module);
   name = xstrdup (name ? name : MODULE_SELF_NAME);
 
   info = lt_dlgetinfo (handle);
@@ -550,13 +550,13 @@
     }
 #endif /* DEBUG_MODULES */
 
-  if (m4_handle->refcount-- == 1)
+  if (module->refcount-- == 1)
     {
       /* Remove the table references only when ref_count is *exactly*
         equal to 1.  If module_close is called again on a
         resident module after the references have already been
         removed, we needn't try to remove them again!  */
-      m4__symtab_remove_module_references (M4SYMTAB, m4_handle);
+      m4__symtab_remove_module_references (M4SYMTAB, module);
 
       m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                        _("module %s: symbols unloaded"), name);
@@ -566,7 +566,7 @@
   finish_func = (m4_module_finish_func *) lt_dlsym (handle, FINISH_SYMBOL);
   if (finish_func)
     {
-      finish_func (context, m4_handle, obs);
+      finish_func (context, module, obs);
 
       m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                        _("module %s: finish hook called"), name);
@@ -585,7 +585,7 @@
        m4_error (context, EXIT_FAILURE, 0,
                  _("unable to close module `%s': %s"), name,
                  module_dlerror());
-      assert (old == m4_handle);
+      assert (old == module);
       lt_dlclose (handle);
       m4_debug_message (context, M4_DEBUG_TRACE_MODULE,
                        _("module %s: resident module not closed"), name);
@@ -607,7 +607,7 @@
     m4_error (context, EXIT_FAILURE, 0, _("cannot close module `%s': %s"),
              name, module_dlerror ());
   if (last_reference)
-    free (m4_handle);
+    free (module);
 
   DELETE (name);
 
@@ -618,16 +618,16 @@
 /* Below here are the accessor functions behind fast macros.  Declare
    them last, so the rest of the file can use the macros.  */
 
-/* Return the current refcount, or times that module HANDLE has been
+/* Return the current refcount, or times that module MODULE has been
    opened.  */
 #undef m4_module_refcount
 int
-m4_module_refcount (const m4_module *handle)
+m4_module_refcount (const m4_module *module)
 {
   const lt_dlinfo *info;
-  assert (handle);
-  info = lt_dlgetinfo (handle->handle);
+  assert (module);
+  info = lt_dlgetinfo (module->handle);
   assert (info);
-  assert (handle->refcount <= info->ref_count);
-  return handle->refcount;
+  assert (module->refcount <= info->ref_count);
+  return module->refcount;
 }