diff -urp -x '*~' -x '*.orig' configure.ac configure.ac

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

 	*)

 		AC_CHECK_FUNC(poll, AC_DEFINE(USE_POLL,1,

 	        	[Define to 1 if you have the "poll" function.]))

diff -urp -x '*~' -x '*.orig' include/X11/Intrinsic.h include/X11/Intrinsic.h

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

 #define			XtCacheAll	  0x002

 #define			XtCacheByDisplay  0x003

 #define			XtCacheRefCount	  0x100

+#define			XtCacheXmRefCount 0x200

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

  *

@@ -256,6 +257,8 @@ typedef void (*XtDestructor)(

     Cardinal*		/* num_args */

 );

+typedef XtPointer (*XtReplicator)(XtPointer);

+

 typedef Opaque XtCacheRef;

 typedef Opaque XtActionHookId;

@@ -659,6 +662,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 */,

diff -urp -x '*~' -x '*.orig' include/X11/IntrinsicI.h include/X11/IntrinsicI.h

@@ -120,6 +120,8 @@ SOFTWARE.

     if ((char *)(dst) != (char *)(src)) {		    \

 	if (size == sizeof(int))			    \

 	    *((int *) (dst)) = *((int *) (src));	    \

+	else if (size == sizeof(long))			    \

+	    *((long *) (dst)) = *((long *) (src));          \

 	else if (size == sizeof(char))			    \

 	    *((char *) (dst)) = *((char *) (src));	    \

 	else if (size == sizeof(short))			    \

@@ -131,15 +133,22 @@ SOFTWARE.

 #define XtBZero(dst, size)				    \

     if (size == sizeof(int))				    \

 	*((int *) (dst)) = 0;				    \

+    else if (size == sizeof(long))			    \

+	*((long *)(dst)) = 0;			    	    \

     else						    \

 	bzero((char *) (dst), (int) (size))

 #define XtMemcmp(b1, b2, size)				    \

-    (size == sizeof(int) ?				    \

+    ((size == sizeof(int)) ?				    \

 	*((int *) (b1)) != *((int *) (b2))		    \

-    :   memcmp((char *) (b1), (char *) (b2), (int) (size))  \

-    )

-

+	:((size == sizeof(short))?  			    \

+	*((short *) (b1)) != *((short *) (b2))		    \

+	:((size == sizeof(long))?			    \ 

+	*((long *) (b1)) != *((long *) (b2))                \

+	:((size == sizeof(BYTE))?			    \

+	*((BYTE *)(b1)) != *((BYTE *)(b2))		    \

+	:memcmp((char *) (b1), (char *) (b2), (int) (size)) \

+	))))

 #else

 #define XtMemmove(dst, src, size)	\

diff -urp -x '*~' -x '*.orig' src/Convert.c src/Convert.c

     XrmRepresentation	from, to;

     XtTypeConverter	converter;

     XtDestructor	destructor;

+    XtReplicator	replicator;

     unsigned short	num_args;

     unsigned int	do_ref_count:1;

     unsigned int	new_style:1;

     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)

 {

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

 	    }

   	}

     }

     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;

     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,

     _XtBoolean		new_style,

     XtCacheType		cache_type,

     XtDestructor	destructor,

+    XtReplicator        replicator,

     _XtBoolean		global)

 {

     register ConverterPtr	*pp;

     p->to	    = to_type;

     p->converter    = converter;

     p->destructor   = destructor;

+    p->replicator   = replicator;

     p->num_args     = num_args;

     p->global       = global;

     args = ConvertArgs(p);

     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;

     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,

     Boolean		    do_ref,

     Boolean		    do_free,

     XtDestructor	    destructor,

+    XtReplicator	    replicator,

     XtPointer		    closure)

 {

     register	CachePtr *pHashEntry;

     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;

     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;

 }

 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)

     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;

 }

     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)

     {

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

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

-		   (XtDestructor)NULL, NULL);

+		   (XtDestructor)NULL, NULL, 0);

     }

     UNLOCK_PROCESS;

 }

     int	hash;

     Cardinal i;

     Boolean retval;

+    XPointer from_addr, gptr;

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

 	XtPointer closure;

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

+    }