case $host_os in

+	solaris*) ;; # our changes to NextEvent.c break if poll() is used

@@ -125,6 +125,7 @@ typedef int		XtCacheType;

 #define			XtCacheAll	  0x002

 #define			XtCacheByDisplay  0x003

 #define			XtCacheRefCount	  0x100

+#define			XtCacheXmRefCount 0x200

 /****************************************************************

  *

@@ -253,6 +254,8 @@ typedef void (*XtDestructor)(

     Cardinal*		/* num_args */

 );

+typedef XtPointer (*XtReplicator)(XtPointer);

+

 typedef Opaque XtCacheRef;

 typedef Opaque XtActionHookId;

@@ -656,6 +659,17 @@ extern void XtSetTypeConverter(

     XtDestructor 	/* destructor */

 );

+extern void _XtSetTypeConverter(

+    _Xconst _XtString   /* from_type */,

+    _Xconst _XtString   /* to_type */,

+    XtTypeConverter     /* converter */,

+    XtConvertArgList    /* convert_args */,

+    Cardinal            /* num_args */,

+    XtCacheType         /* cache_type */,

+    XtDestructor        /* destructor */,

+    XtReplicator        /* replicator */

+);

+

 extern void XtAppSetTypeConverter(

     XtAppContext 	/* app_context */,

     _Xconst _XtString 	/* from_type */,

@@ -87,6 +87,7 @@ typedef struct _ConverterRec {

     XrmRepresentation	from, to;

     XtTypeConverter	converter;

     XtDestructor	destructor;

+    XtReplicator	replicator;

     unsigned short	num_args;

     unsigned int	do_ref_count:1;

     unsigned int	new_style:1;

@@ -94,11 +95,25 @@ typedef struct _ConverterRec {

     char		cache_type;

 } ConverterRec;

-#define ConvertArgs(p) ((XtConvertArgList)((p)+1))

+#define ConvertArgs(p) ((XtConvertArgList)((p)+(ptrdiff_t)1))

 /* used for old-style type converter cache only */

 static Heap globalHeap = {NULL, NULL, 0};

+static

+void TableAddConverter(

+    ConverterTable      table,

+    XrmRepresentation   from_type,

+    XrmRepresentation   to_type,

+    XtTypeConverter     converter,

+    XtConvertArgList    convert_args,

+    Cardinal            num_args,

+    _XtBoolean          new_style,

+    XtCacheType         cache_type,

+    XtDestructor        destructor,

+    XtReplicator        replicator,

+    _XtBoolean          global);

+

 void _XtSetDefaultConverterTable(

 	ConverterTable *table)

 {

@@ -117,13 +132,11 @@ void _XtSetDefaultConverterTable(

 	XtCacheType cache_type;

 	for (i = CONVERTHASHSIZE; --i >= 0; ) {

 	    for (rec = *globalConverterTable++; rec; rec = rec->next) {

-		cache_type = rec->cache_type;

-		if (rec->do_ref_count)

-		    cache_type |= XtCacheRefCount;

-	       _XtTableAddConverter(*table, rec->from, rec->to, rec->converter,

+		cache_type = rec->cache_type | (rec->do_ref_count & 0xff00);

+	        TableAddConverter(*table, rec->from, rec->to, rec->converter,

 				    ConvertArgs(rec), rec->num_args,

 				    rec->new_style, cache_type,

-				    rec->destructor, True);

+				    rec->destructor, rec->replicator, True);

 	    }

   	}

     }

@@ -155,10 +168,14 @@ typedef struct _CacheRec {

     XtPointer	tag;

     int		hash;

     XtTypeConverter converter;

+    XtDestructor destructor;

+    XtReplicator replicator;

+    XtPointer closure;

     unsigned short num_args;

     unsigned int conversion_succeeded:1;

     unsigned int has_ext:1;

     unsigned int is_refcounted:1;

+    unsigned int ref_count;

     unsigned int must_be_freed:1;

     unsigned int from_is_value:1;

     unsigned int to_is_value:1;

@@ -166,15 +183,7 @@ typedef struct _CacheRec {

     XrmValue	to;

 } CacheRec;

-typedef struct _CacheRecExt {

-    CachePtr	*prev;

-    XtDestructor destructor;

-    XtPointer	 closure;

-    long	 ref_count;

-} CacheRecExt;

-

-#define CEXT(p) ((CacheRecExt *)((p)+1))

-#define CARGS(p) ((p)->has_ext ? (XrmValue *)(CEXT(p)+1) : (XrmValue *)((p)+1))

+#define CARGS(p) (XrmValue *)((p)+(ptrdiff_t)1)

 #define CACHEHASHSIZE	256

 #define CACHEHASHMASK	255

 static CacheHashTable	cacheHashTable;

 void _XtTableAddConverter(

+    ConverterTable      table,

+    XrmRepresentation   from_type,

+    XrmRepresentation   to_type,

+    XtTypeConverter     converter,

+    XtConvertArgList    convert_args,

+    Cardinal            num_args,

+    _XtBoolean          new_style,

+    XtCacheType         cache_type,

+    XtDestructor        destructor,

+    _XtBoolean          global)

+{

+

+    unsigned short	cache_flags;

+

+    cache_flags = cache_type & (XtCacheNone | XtCacheAll |

+				XtCacheByDisplay | XtCacheRefCount);

+

+    TableAddConverter(table, from_type, to_type, converter, convert_args, num_args,

+			new_style, cache_type, destructor, 0, global);

+}

+

+void TableAddConverter(

     ConverterTable	table,

     XrmRepresentation   from_type,

     XrmRepresentation   to_type,

@@ -192,6 +223,7 @@ void _XtTableAddConverter(

     _XtBoolean		new_style,

     XtCacheType		cache_type,

     XtDestructor	destructor,

+    XtReplicator        replicator,

     _XtBoolean		global)

 {

     register ConverterPtr	*pp;

@@ -215,6 +247,7 @@ void _XtTableAddConverter(

     p->to	    = to_type;

     p->converter    = converter;

     p->destructor   = destructor;

+    p->replicator   = replicator;

     p->num_args     = num_args;

     p->global       = global;

     args = ConvertArgs(p);

@@ -224,21 +257,21 @@ void _XtTableAddConverter(

     p->do_ref_count = False;

     if (destructor || (cache_type & 0xff)) {

 	p->cache_type = cache_type & 0xff;

-	if (cache_type & XtCacheRefCount)

-	    p->do_ref_count = True;

+        p->do_ref_count = cache_type & 0xff00;

     } else {

 	p->cache_type = XtCacheNone;

     }

 }

-void XtSetTypeConverter(

+void _XtSetTypeConverter(

     register _Xconst char* from_type,

     register _Xconst char* to_type,

-    XtTypeConverter	converter,

+    XtTypeConverter     converter,

     XtConvertArgList    convert_args,

-    Cardinal		num_args,

-    XtCacheType		cache_type,

-    XtDestructor	destructor

+    Cardinal            num_args,

+    XtCacheType         cache_type,

+    XtDestructor        destructor,

+    XtReplicator	replicator

     )

 {

     ProcessContext process;

@@ -253,21 +286,41 @@ void XtSetTypeConverter(

     to = XrmStringToRepresentation(to_type);

     if (!process->globalConverterTable) {

-	process->globalConverterTable = (ConverterTable)

-	    __XtCalloc(CONVERTHASHSIZE, (unsigned)sizeof(ConverterPtr));

+        process->globalConverterTable = (ConverterTable)

+            __XtCalloc(CONVERTHASHSIZE, (unsigned)sizeof(ConverterPtr));

     }

-    _XtTableAddConverter(process->globalConverterTable, from, to,

-			 converter, convert_args,

-			 num_args, True, cache_type, destructor, True);

+

+    TableAddConverter(process->globalConverterTable, from, to, converter,

+		      	convert_args, num_args, True, cache_type, destructor,

+			replicator, True);	

     while (app) {

-	_XtTableAddConverter(app->converterTable, from, to,

-			     converter, convert_args,

-			     num_args, True, cache_type, destructor, True);

+	TableAddConverter(app->converterTable, from, to, converter, 

+			  convert_args, num_args, True, cache_type,

+			  destructor, replicator, True);

 	app = app->next;

     }

     UNLOCK_PROCESS;

 }

+void XtSetTypeConverter(

+    register _Xconst char* from_type,

+    register _Xconst char* to_type,

+    XtTypeConverter	converter,

+    XtConvertArgList    convert_args,

+    Cardinal		num_args,

+    XtCacheType		cache_type,

+    XtDestructor	destructor

+    )

+{

+    unsigned short	cache_flags;

+  

+    cache_flags = cache_type & (XtCacheNone | XtCacheAll |

+				XtCacheByDisplay | XtCacheRefCount);

+

+    _XtSetTypeConverter(from_type, to_type, converter, convert_args, num_args,

+			cache_flags, destructor, 0);

+}

+

 void XtAppSetTypeConverter(

     XtAppContext	app,

     register _Xconst char* from_type,

@@ -357,6 +410,7 @@ CacheEnter(

     Boolean		    do_ref,

     Boolean		    do_free,

     XtDestructor	    destructor,

+    XtReplicator	    replicator,

     XtPointer		    closure)

 {

     register	CachePtr *pHashEntry;

@@ -366,34 +420,22 @@ CacheEnter(

     LOCK_PROCESS;

     pHashEntry = &cacheHashTable[hash & CACHEHASHMASK];

-    if ((succeeded && destructor) || do_ref) {

-	p = (CachePtr) _XtHeapAlloc(heap, (sizeof(CacheRec) +

-					   sizeof(CacheRecExt) +

-					   num_args * sizeof(XrmValue)));

-	CEXT(p)->prev = pHashEntry;

-	CEXT(p)->destructor = succeeded ? destructor : NULL;

-	CEXT(p)->closure = closure;

-	CEXT(p)->ref_count = 1;

-	p->has_ext = True;

-    }

-    else {

-	p = (CachePtr)_XtHeapAlloc(heap, (sizeof(CacheRec) +

-					  num_args * sizeof(XrmValue)));

-	p->has_ext = False;

-    }

+    p = (CachePtr)_XtHeapAlloc(heap, 

+			(sizeof(CacheRec) + num_args * sizeof(XrmValue)));

+

     if (!to->addr)

 	succeeded = False;

     p->conversion_succeeded = succeeded;

     p->is_refcounted = do_ref;

     p->must_be_freed = do_free;

     p->next	    = *pHashEntry;

-    if (p->next && p->next->has_ext)

-	CEXT(p->next)->prev = &p->next;

-

     *pHashEntry     = p;

     p->tag	    = (XtPointer)heap;

     p->hash	    = hash;

     p->converter    = converter;

+    p->destructor = destructor;

+    p->replicator = replicator;

+    p->closure = closure;

     p->from.size    = from->size;

     if (from->size <= sizeof(p->from.addr)) {

 	p->from_is_value = True;

@@ -416,14 +458,31 @@ CacheEnter(

     if (!succeeded) {

 	p->to_is_value = False;

 	p->to.addr = NULL;

-    } else if (to->size <= sizeof(p->to.addr)) {

-	p->to_is_value = True;

-	XtMemmove(&p->to.addr, to->addr, to->size);

     } else {

-	p->to_is_value = False;

-	p->to.addr = (XPointer)_XtHeapAlloc(heap, to->size);

-	(void) memmove((char *)p->to.addr, (char *)to->addr, to->size);

+        XPointer src_ptr, dest_ptr, gptr;

+

+        if ((size_t)to->size <= sizeof(p->to.addr)) {

+        	p->to_is_value = True;

+                dest_ptr = (XPointer)&p->to.addr;

+        } else {

+                p->to_is_value = False;

+                dest_ptr = p->to.addr = (XPointer)_XtHeapAlloc(heap, to->size);

+        }

+

+        if (do_ref & XtCacheXmRefCount) {

+                gptr = (*(p->replicator))(*(XtPointer *)(to->addr));

+                src_ptr = (XtPointer)&gptr;

+        } else {

+                src_ptr = to->addr;

+        }

+

+        memmove(dest_ptr, src_ptr, to->size);

+

+    if ((succeeded && destructor) || do_ref) {

+	p->ref_count = 1;

+

     UNLOCK_PROCESS;

     return p;

 }

@@ -431,32 +490,39 @@ CacheEnter(

 static void FreeCacheRec(

     XtAppContext app,

     CachePtr p,

-    CachePtr *prev)

+    Boolean clean_table)

 {

     LOCK_PROCESS;

-    if (p->has_ext) {

-	if (CEXT(p)->destructor) {

-	    Cardinal num_args = p->num_args;

-	    XrmValue *args = NULL;

-	    XrmValue toc;

-	    if (num_args)

-		args = CARGS(p);

-	    toc.size = p->to.size;

-	    if (p->to_is_value)

-		toc.addr = (XPointer)&p->to.addr;

-	    else

-		toc.addr = p->to.addr;

-	    (*CEXT(p)->destructor) (app, &toc, CEXT(p)->closure, args,

-				    &num_args);

-	}

-	*(CEXT(p)->prev) = p->next;

-	if (p->next && p->next->has_ext)

-	    CEXT(p->next)->prev = CEXT(p)->prev;

-    } else {

-	*prev = p->next;

-	if (p->next && p->next->has_ext)

-	    CEXT(p->next)->prev = prev;

+    if (clean_table) {

+    	CachePtr cachep, *cachepp;

+

+        cachepp = &cacheHashTable[p->hash & CACHEHASHMASK];

+        while (cachep = *cachepp) {

+            if (p == cachep) {

+            	*cachepp = cachep->next;

+                break;

+            }

+           cachepp = &cachep->next;

+        }      

+    }

+

+    if (p->destructor) {

+        Cardinal num_args=p->num_args;

+        XrmValue *args=NULL;

+        XrmValue toc;

+

+        if (num_args) {

+        	args = CARGS(p);

+        }

+        toc.size = p->to.size;

+        if (p->to_is_value) {

+                toc.addr = (XPointer)&p->to.addr;

+        } else {

+                toc.addr = p->to.addr;

+        }

+        (*p->destructor)(app, &toc, p->closure, args, &num_args);

     }

+

     if (p->must_be_freed) {

 	register int i;

 	if (!p->from_is_value)

@@ -480,18 +546,18 @@ void _XtCacheFlushTag(

     XtPointer	tag)

 {

     int i;

-    register CachePtr *prev;

     register CachePtr rec;

+    register CachePtr *next_link;

     LOCK_PROCESS;

     for (i = CACHEHASHSIZE; --i >= 0;) {

-	prev = &cacheHashTable[i];

-	while ((rec = *prev)) {

+	next_link = &cacheHashTable[i];

+	while ((rec = *next_link)) {

+	    next_link = &rec->next;

 	    if (rec->tag == tag)

-		FreeCacheRec(app, rec, prev);

-	    else

-		prev = &rec->next;

+		FreeCacheRec(app, rec, False);

 	}

+	cacheHashTable[i] = 0;

     }

     UNLOCK_PROCESS;

 }

@@ -641,7 +707,12 @@ void XtDirectConvert(

     LOCK_PROCESS;

     /* Try to find cache entry for conversion */

     hash = ((long) converter >> 2) + from->size + *((char *) from->addr);

-    if (from->size > 1) hash += ((char *) from->addr)[1];

+    if (from->size > 1) {

+	if (sizeof(long) == 4)

+            hash += ((char *) from->addr)[1];

+        else

+            hash += ((char *) from->addr)[6];

+    }

     for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next) {

 	if ((p->hash == hash)

@@ -685,7 +756,7 @@ void XtDirectConvert(

     {

 	CacheEnter(&globalHeap, (XtTypeConverter)converter, args, num_args,

 		   from, to, (to->addr != NULL), hash, False, False,

-		   (XtDestructor)NULL, NULL);

+		   (XtDestructor)NULL, NULL, 0);

     }

     UNLOCK_PROCESS;

 }

@@ -726,6 +797,7 @@ CallConverter(

     int	hash;

     Cardinal i;

     Boolean retval;

+    XPointer from_addr, gptr;

     if (!cP || ((cP->cache_type == XtCacheNone) && !cP->destructor)) {

 	XtPointer closure;

@@ -738,7 +810,12 @@ CallConverter(

     LOCK_PROCESS;

     /* Try to find cache entry for conversion */

     hash = ((long)(converter) >> 2) + from->size + *((char *) from->addr);

-    if (from->size > 1) hash += ((char *) from->addr)[1];

+    if (from->size > 1) {

+	if (sizeof(long) == 4)

+	    hash += ((char *) from->addr)[1];

+	else

+	    hash += ((char *) from->addr)[6];

+    }

     if (cP->cache_type != XtCacheNone) {

 	for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next){

@@ -770,14 +847,18 @@ CallConverter(

 				UNLOCK_PROCESS;

 				return False;

 			    }

-			    to->size = p->to.size;

-			    if (p->to_is_value) {

-				XtMemmove(to->addr, &p->to.addr,

-					  to->size);

+			    if (cP->do_ref_count & XtCacheXmRefCount) {

+				gptr = (*(p->replicator))(p->to.addr);

+				from_addr = (XPointer)&gptr; 

+			    } else if (p->to_is_value) {

+				from_addr = (XPointer)&p->to.addr;

 			    } else {

-				(void) memmove((char *)to->addr,

-					       (char *)p->to.addr, to->size);

+				from_addr = p->to.addr;

 			    }

+				

+			    to->size = p->to.size;

+			    memmove((char *)to->addr, from_addr,

+					  to->size);

 			} else {	/* old-style call */

 			    to->size = p->to.size;

 			    if (p->to_is_value)

@@ -787,7 +868,7 @@ CallConverter(

 			}

 		    }

 		    if (p->is_refcounted) {

-			CEXT(p)->ref_count++;

+			p->ref_count++;

 			if (cache_ref_return)

 			    *cache_ref_return = (XtCacheRef)p;

 			else

@@ -810,7 +891,7 @@ CallConverter(