diff --git a/src/cache/ftcbasic.c b/src/cache/ftcbasic.c
index f9c75f3..f462be0 100644
--- a/src/cache/ftcbasic.c
+++ b/src/cache/ftcbasic.c
@@ -316,11 +316,16 @@
                          FTC_Node       *anode )
   {
     FTC_BasicQueryRec  query;
-    FTC_INode          node = 0;  /* make compiler happy */
     FT_Error           error;
     FT_UInt32          hash;
+    union
+    {
+      FTC_Node   node;
+      FTC_INode  inode;
+    } ftc_unode;
 
 
+    ftc_unode.inode = 0; /* XXX: make compiler happy */
     /* some argument checks are delayed to FTC_Cache_Lookup */
     if ( !aglyph )
     {
@@ -377,22 +382,22 @@
                            FTC_GNode_Compare,
                            hash, gindex,
                            &query,
-                           node,
+                           ftc_unode.node,
                            error );
 #else
     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                                hash, gindex,
                                FTC_GQUERY( &query ),
-                               (FTC_Node*) &node );
+                               &(ftc_unode.node) );
 #endif
     if ( !error )
     {
-      *aglyph = FTC_INODE( node )->glyph;
+      *aglyph = FTC_INODE( ftc_unode.inode )->glyph;
 
       if ( anode )
       {
-        *anode = FTC_NODE( node );
-        FTC_NODE( node )->ref_count++;
+        *anode = FTC_NODE( ftc_unode.inode );
+        FTC_NODE( ftc_unode.inode )->ref_count++;
       }
     }
 
@@ -412,11 +417,16 @@
                                FTC_Node       *anode )
   {
     FTC_BasicQueryRec  query;
-    FTC_INode          node = 0;  /* make compiler happy */
     FT_Error           error;
     FT_UInt32          hash;
+    union
+    {
+      FTC_Node   node;
+      FTC_INode  inode;
+    } ftc_unode;
 
 
+    ftc_unode.inode = 0;  /* XXX: make compiler happy */
     /* some argument checks are delayed to FTC_Cache_Lookup */
     if ( !aglyph || !scaler )
     {
@@ -445,16 +455,16 @@
                            FTC_GNode_Compare,
                            hash, gindex,
                            &query,
-                           node,
+                           ftc_unode.node,
                            error );
     if ( !error )
     {
-      *aglyph = FTC_INODE( node )->glyph;
+      *aglyph = FTC_INODE( ftc_unode.inode )->glyph;
 
       if ( anode )
       {
-        *anode = FTC_NODE( node );
-        FTC_NODE( node )->ref_count++;
+        *anode = FTC_NODE( ftc_unode.node );
+        FTC_NODE( ftc_unode.node )->ref_count++;
       }
     }
 
@@ -655,10 +665,15 @@
   {
     FT_Error           error;
     FTC_BasicQueryRec  query;
-    FTC_SNode          node = 0; /* make compiler happy */
     FT_UInt32          hash;
+    union
+    {
+      FTC_Node   node;
+      FTC_SNode  snode;
+    } ftc_unode;
 
 
+    ftc_unode.snode = 0; /* XXX: make compiler happy */
     if ( anode )
       *anode = NULL;
 
@@ -714,24 +729,24 @@
                            FTC_SNode_Compare,
                            hash, gindex,
                            &query,
-                           node,
+                           ftc_unode.node,
                            error );
 #else
     error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                                hash,
                                gindex,
                                FTC_GQUERY( &query ),
-                               (FTC_Node*)&node );
+                               &(ftc_unode.node) );
 #endif
     if ( error )
       goto Exit;
 
-    *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
+    *ansbit = ftc_unode.snode->sbits + ( gindex - FTC_GNODE( ftc_unode.snode )->gindex );
 
     if ( anode )
     {
-      *anode = FTC_NODE( node );
-      FTC_NODE( node )->ref_count++;
+      *anode = FTC_NODE( ftc_unode.node );
+      FTC_NODE( ftc_unode.node )->ref_count++;
     }
 
   Exit:
@@ -751,10 +766,15 @@
   {
     FT_Error           error;
     FTC_BasicQueryRec  query;
-    FTC_SNode          node = 0; /* make compiler happy */
     FT_UInt32          hash;
+    union
+    {
+      FTC_Node   node;
+      FTC_SNode  snode;
+    } ftc_unode;
 
 
+    ftc_unode.snode = 0; /* XXX: make compiler happy */
     if ( anode )
         *anode = NULL;
 
@@ -783,17 +803,17 @@
                            FTC_SNode_Compare,
                            hash, gindex,
                            &query,
-                           node,
+                           ftc_unode.node,
                            error );
     if ( error )
       goto Exit;
 
-    *ansbit = node->sbits + ( gindex - FTC_GNODE( node )->gindex );
+    *ansbit = ftc_unode.snode->sbits + ( gindex - FTC_GNODE( ftc_unode.snode )->gindex );
 
     if ( anode )
     {
-      *anode = FTC_NODE( node );
-      FTC_NODE( node )->ref_count++;
+      *anode = FTC_NODE( ftc_unode.node );
+      FTC_NODE( ftc_unode.node )->ref_count++;
     }
 
   Exit:
diff --git a/src/cache/ftccmap.c b/src/cache/ftccmap.c
index 50a6189..8fb3387 100644
--- a/src/cache/ftccmap.c
+++ b/src/cache/ftccmap.c
@@ -283,11 +283,15 @@
   {
     FTC_Cache         cache = FTC_CACHE( cmap_cache );
     FTC_CMapQueryRec  query;
-    FTC_CMapNode      node;
     FT_Error          error;
     FT_UInt           gindex = 0;
     FT_UInt32         hash;
     FT_Int            no_cmap_change = 0;
+    union
+    {
+      FTC_Node      node;
+      FTC_CMapNode  cmap;
+    } ftc_unode;
 
 
     if ( cmap_index < 0 )
@@ -371,20 +375,20 @@
 
 #if 1
     FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
-                          node, error );
+                          ftc_unode.node, error );
 #else
-    error = FTC_Cache_Lookup( cache, hash, &query, (FTC_Node*) &node );
+    error = FTC_Cache_Lookup( cache, hash, &query, &(ftc_unode.node) );
 #endif
     if ( error )
       goto Exit;
 
-    FT_ASSERT( (FT_UInt)( char_code - node->first ) < FTC_CMAP_INDICES_MAX );
+    FT_ASSERT( (FT_UInt)( char_code - ftc_unode.cmap->first ) < FTC_CMAP_INDICES_MAX );
 
     /* something rotten can happen with rogue clients */
-    if ( (FT_UInt)( char_code - node->first >= FTC_CMAP_INDICES_MAX ) )
+    if ( (FT_UInt)( char_code - ftc_unode.cmap->first >= FTC_CMAP_INDICES_MAX ) )
       return 0;
 
-    gindex = node->indices[char_code - node->first];
+    gindex = ftc_unode.cmap->indices[char_code - ftc_unode.cmap->first];
     if ( gindex == FTC_CMAP_UNKNOWN )
     {
       FT_Face  face;
@@ -392,7 +396,7 @@
 
       gindex = 0;
 
-      error = FTC_Manager_LookupFace( cache->manager, node->face_id, &face );
+      error = FTC_Manager_LookupFace( cache->manager, ftc_unode.cmap->face_id, &face );
       if ( error )
         goto Exit;
 
@@ -413,7 +417,7 @@
           FT_Set_Charmap( face, old );
       }
 
-      node->indices[char_code - node->first] = (FT_UShort)gindex;
+      ftc_unode.cmap->indices[char_code - ftc_unode.cmap->first] = (FT_UShort)gindex;
     }
 
   Exit:
diff --git a/src/cache/ftcglyph.h b/src/cache/ftcglyph.h
index 87a4199..7ef6eac 100644
--- a/src/cache/ftcglyph.h
+++ b/src/cache/ftcglyph.h
@@ -277,12 +277,21 @@ FT_BEGIN_HEADER
     FTC_GCache               _gcache   = FTC_GCACHE( cache );               \
     FTC_GQuery               _gquery   = (FTC_GQuery)( query );             \
     FTC_MruNode_CompareFunc  _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \
+    union                                                                   \
+    {                                                                       \
+      FTC_MruNode  mrunode;                                                 \
+      FTC_Family   family;                                                  \
+    } _ftc_unode;                                                           \
                                                                             \
                                                                             \
-    _gquery->gindex = (gindex);                                             \
+    _gquery->gindex  = (gindex);                                            \
+    _ftc_unode.family = _gquery->family;                                    \
                                                                             \
     FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare,         \
-                            _gquery->family, error );                       \
+                            _ftc_unode.mrunode, error );                    \
+                                                                            \
+    _gquery->family = _ftc_unode.family;                                    \
+                                                                            \
     if ( !error )                                                           \
     {                                                                       \
       FTC_Family  _gqfamily = _gquery->family;                              \
diff --git a/src/cache/ftcmanag.c b/src/cache/ftcmanag.c
index 8436bd0..843f145 100644
--- a/src/cache/ftcmanag.c
+++ b/src/cache/ftcmanag.c
@@ -181,7 +181,11 @@
                           FT_Size     *asize )
   {
     FT_Error      error;
-    FTC_SizeNode  node;
+    union
+    {
+      FTC_MruNode   mrunode;
+      FTC_SizeNode  sizenode;
+    } ftc_unode;
 
 
     if ( asize == NULL )
@@ -195,14 +199,14 @@
 #ifdef FTC_INLINE
 
     FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
-                            node, error );
+                            ftc_unode.mrunode, error );
 
 #else
-    error = FTC_MruList_Lookup( &manager->sizes, scaler, (FTC_MruNode*)&node );
+    error = FTC_MruList_Lookup( &manager->sizes, scaler, &(ftc_unode.mrunode) );
 #endif
 
     if ( !error )
-      *asize = node->size;
+      *asize = ftc_unode.sizenode->size;
 
     return error;
   }
@@ -306,7 +310,11 @@
                           FT_Face     *aface )
   {
     FT_Error      error;
-    FTC_FaceNode  node;
+    union
+    {
+      FTC_MruNode   mrunode;
+      FTC_FaceNode  facenode;
+    } ftc_unode;
 
 
     if ( aface == NULL )
@@ -321,14 +329,14 @@
 #ifdef FTC_INLINE
 
     FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
-                            node, error );
+                            ftc_unode.mrunode, error );
 
 #else
-    error = FTC_MruList_Lookup( &manager->faces, face_id, (FTC_MruNode*)&node );
+    error = FTC_MruList_Lookup( &manager->faces, face_id, &(ftc_unode.mrunode) );
 #endif
 
     if ( !error )
-      *aface = node->face;
+      *aface = ftc_unode.facenode->face;
 
     return error;
   }
diff --git a/src/cache/ftcmru.h b/src/cache/ftcmru.h
index 0cda76e..5739439 100644
--- a/src/cache/ftcmru.h
+++ b/src/cache/ftcmru.h
@@ -163,7 +163,7 @@ FT_BEGIN_HEADER
   FT_BEGIN_STMNT                                                            \
     FTC_MruNode*             _pfirst  = &(list)->nodes;                     \
     FTC_MruNode_CompareFunc  _compare = (FTC_MruNode_CompareFunc)(compare); \
-    FTC_MruNode              _first, _node, *_pnode;                        \
+    FTC_MruNode              _first, _node;                                 \
                                                                             \
                                                                             \
     error  = 0;                                                             \
@@ -180,8 +180,7 @@ FT_BEGIN_HEADER
           if ( _node != _first )                                            \
             FTC_MruNode_Up( _pfirst, _node );                               \
                                                                             \
-          _pnode = (FTC_MruNode*)(void*)&(node);                            \
-          *_pnode = _node;                                                  \
+          node = _node;                                                     \
           goto _MruOk;                                                      \
         }                                                                   \
         _node = _node->next;                                                \
