--- src/Makefile.am	Tue Mar  4 16:36:48 2008

+++ src/Makefile.am	Wed Mar  5 12:44:16 2008

@@ -74,7 +74,8 @@

 libXt_la_LIBADD = @XT_LIBS@

-libXt_la_LDFLAGS = -version-number 6:0:0 -no-undefined

+libXt_la_LDFLAGS = -version-number 4:0:0 -no-undefined \

+	-M $(top_srcdir)/../../mapfile-vers

 #

 # The util directory contains a program that builds some of the sources. 

--- configure.ac	Wed Mar  5 10:10:39 2008

+++ configure.ac	Wed Mar  5 10:33:20 2008

 AC_CHECK_HEADER([alloca.h], AC_DEFINE(INCLUDE_ALLOCA_H, 1, [Define to 1 if Xalloca.h should include <alloca.h>]))

 # Map function checks to old Imake #defines

-AC_CHECK_FUNC(poll, AC_DEFINE(USE_POLL,1,

 AC_CHECK_FUNC(snprintf, AC_DEFINE(USE_SNPRINTF,1,

         [Define to 1 if you have the `snprintf' function.]))

--- src/Create.c	Tue Mar  4 16:36:48 2008

+++ src/Create.c	Wed Mar  5 09:23:20 2008

@@ -398,8 +398,7 @@

     CompileCallbacks(widget);

     if (cache_refs != NULL) {

-	XtAddCallback(widget, XtNdestroyCallback,

-		XtCallbackReleaseCacheRefList, (XtPointer)cache_refs );

+	XtFree(cache_refs);

     }

     wsize = widget_class->core_class.widget_size;

--- src/Convert.c	Tue Mar  4 14:47:58 2008

+++ src/Convert.c	Tue Mar  4 16:09:36 2008

@@ -73,6 +73,9 @@

 #define CONVERTHASHMASK	255

 #define ProcHash(from_type, to_type) (2 * (from_type) + to_type)

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

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

+

 typedef struct _ConverterRec *ConverterPtr;

 typedef struct _ConverterRec {

     ConverterPtr	next;

@@ -79,6 +82,7 @@

     XrmRepresentation	from, to;

     XtTypeConverter	converter;

     XtDestructor	destructor;

+    XtReplicator        replicator;

     unsigned short	num_args;

     unsigned int	do_ref_count:1;

     unsigned int	new_style:1;

@@ -86,11 +90,23 @@

     char		cache_type;

 } ConverterRec;

-#define ConvertArgs(p) ((XtConvertArgList)((p)+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)

 {

@@ -109,13 +125,11 @@

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

 	    }

   	}

     }

@@ -147,10 +161,14 @@

     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;

@@ -158,16 +176,6 @@

     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 CACHEHASHSIZE	256

 #define CACHEHASHMASK	255

 typedef CachePtr CacheHashTable[CACHEHASHSIZE];

@@ -175,6 +183,28 @@

 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,

@@ -184,6 +214,7 @@

     _XtBoolean		new_style,

     XtCacheType		cache_type,

     XtDestructor	destructor,

+    XtReplicator        replicator,

     _XtBoolean		global)

 {

     register ConverterPtr	*pp;

@@ -207,6 +238,7 @@

     p->to	    = to_type;

     p->converter    = converter;

     p->destructor   = destructor;

+    p->replicator   = replicator;

     p->num_args     = num_args;

     p->global       = global;

     args = ConvertArgs(p);

@@ -216,21 +248,21 @@

     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;

@@ -245,21 +277,41 @@

     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,

@@ -349,6 +401,7 @@

     Boolean		    do_ref,

     Boolean		    do_free,

     XtDestructor	    destructor,

+    XtReplicator	    replicator,

     XtPointer		    closure)

 {

     register	CachePtr *pHashEntry;

@@ -358,21 +411,9 @@

     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;

@@ -379,13 +420,13 @@

     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;

@@ -408,14 +449,31 @@

     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;

 }

@@ -423,32 +481,39 @@

 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)

@@ -472,18 +537,18 @@

     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;

 }

@@ -633,7 +698,12 @@

     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)

@@ -677,7 +747,7 @@

     {

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

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

-		   (XtDestructor)NULL, NULL);

+		   (XtDestructor)NULL, NULL, 0);

     }

     UNLOCK_PROCESS;

 }

@@ -718,6 +788,7 @@

     int	hash;

     Cardinal i;

     Boolean retval;

+    XPointer from_addr, gptr;

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

 	XtPointer closure;

@@ -730,7 +801,12 @@

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

@@ -762,14 +838,18 @@

 				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)

@@ -779,7 +859,7 @@

 			}

 		    }

 		    if (p->is_refcounted) {

-			CEXT(p)->ref_count++;

+			p->ref_count++;

 			if (cache_ref_return)

 			    *cache_ref_return = (XtCacheRef)p;

 			else

@@ -802,7 +882,7 @@

 	Heap *heap;

 	XtPointer closure = NULL;

 	unsigned int supplied_size = to->size;

-	Boolean do_ref = cP->do_ref_count && cache_ref_return;

+	unsigned short do_ref;

 	Boolean do_free = False;

 	Boolean retval =

 	    (*(XtTypeConverter)converter)(dpy, args, &num_args, from, to, &closure);

@@ -815,6 +895,8 @@

 	    return False;

 	}

+	do_ref = cache_ref_return ? cP->do_ref_count : 0;

+

 	if ((cP->cache_type == XtCacheNone) || do_ref) {

 	    heap = NULL;

 	    do_free = True;

@@ -826,8 +908,12 @@