[5927] use union in KEYMAP_ENTRY

[Gavin D. Smith]

Revision: 5927
          http://svn.sv.gnu.org/viewvc/?view=rev&root=texinfo&revision=5927
Author:   gavin
Date:     2014-11-14 13:32:00 +0000 (Fri, 14 Nov 2014)
Log Message:
-----------
use union in KEYMAP_ENTRY

Modified Paths:
--------------
    trunk/ChangeLog
    trunk/info/infodoc.c
    trunk/info/infokey.c
    trunk/info/infomap.c
    trunk/info/infomap.h
    trunk/info/session.c

Modified: trunk/ChangeLog
===================================================================
--- trunk/ChangeLog     2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/ChangeLog     2014-11-14 13:32:00 UTC (rev 5927)
@@ -1,3 +1,8 @@
+2014-11-14  Gavin Smith  <address@hidden>
+
+       * info/infomap.h (KEYMAP_ENTRY) <function>: Replace with a union 
+       to avoid casts on accessing it as a Keymap.  All uses updated.
+
 2014-11-13  Gavin Smith  <address@hidden>
 
        * info/echo-area.c (ea_delete, ea_transpose_chars): Handle 

Modified: trunk/info/infodoc.c
===================================================================
--- trunk/info/infodoc.c        2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/info/infodoc.c        2014-11-14 13:32:00 UTC (rev 5927)
@@ -103,21 +103,21 @@
       if (map[i].type == ISKMAP)
         {
           dump_map_to_text_buffer (tb, new_prefix, prefix_len + 1,
-                                   (Keymap)map[i].function);
+                                   map[i].value.keymap);
         }
-      else if (map[i].function)
+      else if (map[i].value.function)
         {
           long start_of_line = tb->off;
           register int last;
           char *doc, *name;
 
           /* Hide some key mappings. */
-          if (map[i].function
-              && (map[i].function->func == info_do_lowercase_version))
+          if (map[i].value.function
+              && (map[i].value.function->func == info_do_lowercase_version))
             continue;
 
-          doc = function_documentation (map[i].function);
-          name = function_name (map[i].function);
+          doc = function_documentation (map[i].value.function);
+          name = function_name (map[i].value.function);
 
           if (!*doc)
             continue;
@@ -126,7 +126,7 @@
              add-digit-to-numeric-arg. */
           for (last = i + 1; last < KEYMAP_SIZE; last++)
             if ((map[last].type != ISFUNC) ||
-                (map[last].function != map[i].function))
+                (map[last].value.function != map[i].value.function))
               break;
 
           if (last - 1 != i)
@@ -451,14 +451,14 @@
       *k++ = keystroke;
       *k = '\0';
 
-      if (map[keystroke].function == NULL)
+      if (map[keystroke].value.function == NULL)
         {
           message_in_echo_area (_("%s is undefined."), pretty_keyseq (keys));
           return;
         }
       else if (map[keystroke].type == ISKMAP)
         {
-          map = (Keymap)map[keystroke].function;
+          map = map[keystroke].value.keymap;
           continue;
         }
       else
@@ -471,8 +471,9 @@
              edit keys that emit an escape sequence: it's terribly
              confusing to see a message "Home (do-lowercase-version)"
              or some such when Home is unbound.  */
-          if (map[keystroke].function
-              && map[keystroke].function->func == info_do_lowercase_version)
+          if (map[keystroke].value.function
+              && map[keystroke].value.function->func
+                 == info_do_lowercase_version)
             {
               int lowerkey;
 
@@ -486,7 +487,7 @@
               else
                 lowerkey = tolower (keystroke);
 
-              if (map[lowerkey].function == NULL)
+              if (map[lowerkey].value.function == NULL)
                 {
                   message_in_echo_area (_("%s is undefined."),
                                        pretty_keyseq (keys));
@@ -496,9 +497,9 @@
 
           keyname = pretty_keyseq (keys);
 
-          funname = function_name (map[keystroke].function);
+          funname = function_name (map[keystroke].value.function);
 
-          fundoc = function_documentation (map[keystroke].function);
+          fundoc = function_documentation (map[keystroke].value.function);
 
           message = xmalloc
             (10 + strlen (keyname) + strlen (fundoc) + strlen (funname));

Modified: trunk/info/infokey.c
===================================================================
--- trunk/info/infokey.c        2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/info/infokey.c        2014-11-14 13:32:00 UTC (rev 5927)
@@ -465,7 +465,7 @@
                       KEYMAP_ENTRY ke;
                       
                       ke.type = ISFUNC;
-                      ke.function = &function_doc_array[a];
+                      ke.value.function = &function_doc_array[a];
                       To_seq (0);
 
                       if (section == info)

Modified: trunk/info/infomap.c
===================================================================
--- trunk/info/infomap.c        2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/info/infomap.c        2014-11-14 13:32:00 UTC (rev 5927)
@@ -40,7 +40,7 @@
   for (i = 0; i < KEYMAP_SIZE; i++)
     {
       keymap[i].type = ISFUNC;
-      keymap[i].function = NULL;
+      keymap[i].value.function = NULL;
     }
 
   return keymap;
@@ -91,13 +91,13 @@
       switch (m[c].type)
         {
         case ISFUNC:
-          if (m[c].function)
+          if (m[c].value.function)
             return; /* There is a function here already. */
 
           if (*s != '\0')
             {
               m[c].type = ISKMAP;
-              m[c].function = (InfoCommand *)keymap_make_keymap ();
+              m[c].value.keymap = keymap_make_keymap ();
             }
           break;
 
@@ -109,11 +109,11 @@
         }
       if (*s != '\0')
         {
-          m = (Keymap)m[c].function;
+          m = m[c].value.keymap;
         }
       else
         {
-          add_function_keyseq (keyentry->function, keyseq, map);
+          add_function_keyseq (keyentry->value.function, keyseq, map);
           m[c] = *keyentry;
         }
     }
@@ -641,7 +641,7 @@
            state = getseq;
 
             ke.type = ISFUNC;
-            ke.function = action < A_NCOMMANDS ?
+            ke.value.function = action < A_NCOMMANDS ?
                                 &function_doc_array[action]
                                 : NULL;
             keymap_bind_keyseq (map, seq, &ke);
@@ -654,23 +654,23 @@
 
   /* Go through map and bind ESC x to the same function as M-x if it is not 
      bound already. */
-  if (!map[ESC].function)
+  if (!map[ESC].value.function)
     {
       map[ESC].type = ISKMAP;
-      map[ESC].function = (InfoCommand *)keymap_make_keymap ();
+      map[ESC].value.keymap = keymap_make_keymap ();
     }
 
   if (map[ESC].type != ISKMAP)
     return; /* ESC is bound to a command. */
 
-  esc_map = (Keymap) map[ESC].function;
+  esc_map = map[ESC].value.keymap;
   for (k = 1; k < KEYMAP_META_BASE; k++)
     {
       if (map[k + KEYMAP_META_BASE].type == ISFUNC
-          && esc_map[k].function == 0)
+          && esc_map[k].value.function == 0)
         {
           esc_map[k].type = ISFUNC;
-          esc_map[k].function = map[k + KEYMAP_META_BASE].function;
+          esc_map[k].value.function = map[k + KEYMAP_META_BASE].value.function;
         }
     }
   return;
@@ -725,16 +725,16 @@
 
   for (i = 'A'; i < ('Z' + 1); i++)
     {
-      if (!info_keymap[i].function)
+      if (!info_keymap[i].value.function)
         {
           info_keymap[i].type = ISFUNC;
-          info_keymap[i].function = InfoCmd (info_do_lowercase_version);
+          info_keymap[i].value.function = InfoCmd (info_do_lowercase_version);
         }
 
-      if (!info_keymap[KEYMAP_META(i)].function)
+      if (!info_keymap[KEYMAP_META(i)].value.function)
         {
           info_keymap[KEYMAP_META(i)].type = ISFUNC;
-          info_keymap[KEYMAP_META(i)].function
+          info_keymap[KEYMAP_META(i)].value.function
             = InfoCmd (info_do_lowercase_version);
         }
     }

Modified: trunk/info/infomap.h
===================================================================
--- trunk/info/infomap.h        2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/info/infomap.h        2014-11-14 13:32:00 UTC (rev 5927)
@@ -63,13 +63,18 @@
 typedef struct keymap_entry
 {
   char type;
-  InfoCommand *function;  /* The address of a function or another keymap. */
+  union
+  {
+    InfoCommand *function;         /* The address of a function. */
+    struct keymap_entry *keymap;   /* The address of another Keymap */
+  } value;
 } KEYMAP_ENTRY;
 
 /* The values that TYPE can have in a keymap entry. */
 #define ISFUNC 0
 #define ISKMAP 1
 
+/* We use Keymap for a pointer to a block of KEYMAP_SIZE KEYMAP_ENTRY's. */
 typedef KEYMAP_ENTRY *Keymap;
 
 extern Keymap info_keymap;

Modified: trunk/info/session.c
===================================================================
--- trunk/info/session.c        2014-11-13 17:47:21 UTC (rev 5926)
+++ trunk/info/session.c        2014-11-14 13:32:00 UTC (rev 5927)
@@ -4538,8 +4538,8 @@
              if any. */
           KEYMAP_ENTRY k = info_keymap[key];
           type = k.type;
-          func = type == ISFUNC && k.function
-            ? k.function->func
+          func = type == ISFUNC && k.value.function
+            ? k.value.function->func
             : NULL;
         }
 
@@ -5010,7 +5010,7 @@
 
       if (!dash_typed && !digit_typed && map[key].type == ISFUNC)
         {
-          func = map[key].function ? map[key].function->func : 0;
+          func = map[key].value.function ? map[key].value.function->func : 0;
           if (!func)
             {
               dispatch_error (info_keyseq);
@@ -5104,8 +5104,8 @@
         }
       else if (map[key].type == ISKMAP)
         {
-          if (map[key].function != NULL)
-            map = (Keymap)map[key].function;
+          if (map[key].value.keymap != NULL)
+            map = map[key].value.keymap;
           else
             {
               dispatch_error (info_keyseq);