6671721.patch revision 1422
30N/Adiff --git a/configure.ac b/configure.ac
30N/Aindex d15b326..28185fe 100644
30N/A--- a/configure.ac
30N/A+++ b/configure.ac
30N/A@@ -72,6 +72,7 @@ AC_SUBST(LDFLAGS_FOR_BUILD)
30N/A
30N/A # Map function checks to old Imake #defines
30N/A case $host_os in
30N/A+ solaris*) ;; # our changes to NextEvent.c break if poll() is used
30N/A # darwin through Snow Leopard has poll() but can't be used to poll character devices.
30N/A darwin@<:@789@:>@*|darwin10*) ;;
30N/A darwin*)
30N/Adiff --git a/include/X11/Intrinsic.h b/include/X11/Intrinsic.h
30N/Aindex d09acad..d30e01f 100644
30N/A--- a/include/X11/Intrinsic.h
30N/A+++ b/include/X11/Intrinsic.h
30N/A@@ -125,6 +125,7 @@ typedef int XtCacheType;
30N/A #define XtCacheAll 0x002
30N/A #define XtCacheByDisplay 0x003
30N/A #define XtCacheRefCount 0x100
30N/A+#define XtCacheXmRefCount 0x200
30N/A
30N/A /****************************************************************
30N/A *
30N/A@@ -253,6 +254,8 @@ typedef void (*XtDestructor)(
58N/A Cardinal* /* num_args */
58N/A );
58N/A
58N/A+typedef XtPointer (*XtReplicator)(XtPointer);
99N/A+
30N/A typedef Opaque XtCacheRef;
58N/A
58N/A typedef Opaque XtActionHookId;
30N/A@@ -656,6 +659,17 @@ extern void XtSetTypeConverter(
99N/A XtDestructor /* destructor */
58N/A );
58N/A
58N/A+extern void _XtSetTypeConverter(
58N/A+ _Xconst _XtString /* from_type */,
58N/A+ _Xconst _XtString /* to_type */,
58N/A+ XtTypeConverter /* converter */,
58N/A+ XtConvertArgList /* convert_args */,
58N/A+ Cardinal /* num_args */,
58N/A+ XtCacheType /* cache_type */,
112N/A+ XtDestructor /* destructor */,
30N/A+ XtReplicator /* replicator */
30N/A+);
30N/A+
58N/A extern void XtAppSetTypeConverter(
30N/A XtAppContext /* app_context */,
30N/A _Xconst _XtString /* from_type */,
58N/Adiff --git a/src/Convert.c b/src/Convert.c
145N/Aindex cea8fd3..265b162 100644
30N/A--- a/src/Convert.c
30N/A+++ b/src/Convert.c
30N/A@@ -87,6 +87,7 @@ typedef struct _ConverterRec {
77N/A XrmRepresentation from, to;
77N/A XtTypeConverter converter;
77N/A XtDestructor destructor;
77N/A+ XtReplicator replicator;
30N/A unsigned short num_args;
30N/A unsigned int do_ref_count:1;
30N/A unsigned int new_style:1;
30N/A@@ -94,11 +95,25 @@ typedef struct _ConverterRec {
30N/A char cache_type;
77N/A } ConverterRec;
77N/A
30N/A-#define ConvertArgs(p) ((XtConvertArgList)((p)+1))
30N/A+#define ConvertArgs(p) ((XtConvertArgList)((p)+(ptrdiff_t)1))
58N/A
145N/A /* used for old-style type converter cache only */
145N/A static Heap globalHeap = {NULL, NULL, 0};
145N/A
145N/A+static
145N/A+void TableAddConverter(
58N/A+ ConverterTable table,
77N/A+ XrmRepresentation from_type,
77N/A+ XrmRepresentation to_type,
77N/A+ XtTypeConverter converter,
77N/A+ XtConvertArgList convert_args,
77N/A+ Cardinal num_args,
58N/A+ _XtBoolean new_style,
145N/A+ XtCacheType cache_type,
58N/A+ XtDestructor destructor,
58N/A+ XtReplicator replicator,
77N/A+ _XtBoolean global);
77N/A+
77N/A void _XtSetDefaultConverterTable(
77N/A ConverterTable *table)
30N/A {
58N/A@@ -117,13 +132,11 @@ void _XtSetDefaultConverterTable(
58N/A XtCacheType cache_type;
58N/A for (i = CONVERTHASHSIZE; --i >= 0; ) {
58N/A for (rec = *globalConverterTable++; rec; rec = rec->next) {
58N/A- cache_type = rec->cache_type;
58N/A- if (rec->do_ref_count)
58N/A- cache_type |= XtCacheRefCount;
30N/A- _XtTableAddConverter(*table, rec->from, rec->to, rec->converter,
58N/A+ cache_type = rec->cache_type | (rec->do_ref_count & 0xff00);
77N/A+ TableAddConverter(*table, rec->from, rec->to, rec->converter,
77N/A ConvertArgs(rec), rec->num_args,
77N/A rec->new_style, cache_type,
77N/A- rec->destructor, True);
77N/A+ rec->destructor, rec->replicator, True);
77N/A }
145N/A }
77N/A }
77N/A@@ -155,10 +168,14 @@ typedef struct _CacheRec {
77N/A XtPointer tag;
77N/A int hash;
77N/A XtTypeConverter converter;
77N/A+ XtDestructor destructor;
77N/A+ XtReplicator replicator;
145N/A+ XtPointer closure;
77N/A unsigned short num_args;
77N/A unsigned int conversion_succeeded:1;
77N/A unsigned int has_ext:1;
77N/A unsigned int is_refcounted:1;
77N/A+ unsigned int ref_count;
77N/A unsigned int must_be_freed:1;
77N/A unsigned int from_is_value:1;
145N/A unsigned int to_is_value:1;
77N/A@@ -166,15 +183,7 @@ typedef struct _CacheRec {
77N/A XrmValue to;
77N/A } CacheRec;
77N/A
77N/A-typedef struct _CacheRecExt {
77N/A- CachePtr *prev;
30N/A- XtDestructor destructor;
58N/A- XtPointer closure;
58N/A- long ref_count;
58N/A-} CacheRecExt;
58N/A-
58N/A-#define CEXT(p) ((CacheRecExt *)((p)+1))
58N/A-#define CARGS(p) ((p)->has_ext ? (XrmValue *)(CEXT(p)+1) : (XrmValue *)((p)+1))
58N/A+#define CARGS(p) (XrmValue *)((p)+(ptrdiff_t)1)
58N/A
58N/A #define CACHEHASHSIZE 256
77N/A #define CACHEHASHMASK 255
77N/A@@ -183,6 +192,28 @@ typedef CachePtr CacheHashTable[CACHEHASHSIZE];
77N/A static CacheHashTable cacheHashTable;
77N/A
77N/A void _XtTableAddConverter(
125N/A+ ConverterTable table,
145N/A+ XrmRepresentation from_type,
58N/A+ XrmRepresentation to_type,
58N/A+ XtTypeConverter converter,
77N/A+ XtConvertArgList convert_args,
77N/A+ Cardinal num_args,
77N/A+ _XtBoolean new_style,
77N/A+ XtCacheType cache_type,
58N/A+ XtDestructor destructor,
145N/A+ _XtBoolean global)
58N/A+{
58N/A+
77N/A+ unsigned short cache_flags;
77N/A+
77N/A+ cache_flags = cache_type & (XtCacheNone | XtCacheAll |
77N/A+ XtCacheByDisplay | XtCacheRefCount);
58N/A+
58N/A+ TableAddConverter(table, from_type, to_type, converter, convert_args, num_args,
58N/A+ new_style, cache_type, destructor, 0, global);
58N/A+}
58N/A+
77N/A+void TableAddConverter(
77N/A ConverterTable table,
77N/A XrmRepresentation from_type,
77N/A XrmRepresentation to_type,
58N/A@@ -192,6 +223,7 @@ void _XtTableAddConverter(
145N/A _XtBoolean new_style,
58N/A XtCacheType cache_type,
58N/A XtDestructor destructor,
77N/A+ XtReplicator replicator,
77N/A _XtBoolean global)
77N/A {
77N/A register ConverterPtr *pp;
58N/A@@ -215,6 +247,7 @@ void _XtTableAddConverter(
145N/A p->to = to_type;
58N/A p->converter = converter;
58N/A p->destructor = destructor;
77N/A+ p->replicator = replicator;
77N/A p->num_args = num_args;
77N/A p->global = global;
77N/A args = ConvertArgs(p);
77N/A@@ -224,21 +257,21 @@ void _XtTableAddConverter(
58N/A p->do_ref_count = False;
145N/A if (destructor || (cache_type & 0xff)) {
58N/A p->cache_type = cache_type & 0xff;
58N/A- if (cache_type & XtCacheRefCount)
77N/A- p->do_ref_count = True;
77N/A+ p->do_ref_count = cache_type & 0xff00;
77N/A } else {
77N/A p->cache_type = XtCacheNone;
58N/A }
145N/A }
58N/A
58N/A-void XtSetTypeConverter(
77N/A+void _XtSetTypeConverter(
77N/A register _Xconst char* from_type,
77N/A register _Xconst char* to_type,
77N/A- XtTypeConverter converter,
58N/A+ XtTypeConverter converter,
145N/A XtConvertArgList convert_args,
58N/A- Cardinal num_args,
58N/A- XtCacheType cache_type,
77N/A- XtDestructor destructor
77N/A+ Cardinal num_args,
77N/A+ XtCacheType cache_type,
77N/A+ XtDestructor destructor,
58N/A+ XtReplicator replicator
145N/A )
58N/A {
58N/A ProcessContext process;
77N/A@@ -253,21 +286,41 @@ void XtSetTypeConverter(
77N/A to = XrmStringToRepresentation(to_type);
77N/A
77N/A if (!process->globalConverterTable) {
58N/A- process->globalConverterTable = (ConverterTable)
145N/A- __XtCalloc(CONVERTHASHSIZE, (unsigned)sizeof(ConverterPtr));
58N/A+ process->globalConverterTable = (ConverterTable)
99N/A+ __XtCalloc(CONVERTHASHSIZE, (unsigned)sizeof(ConverterPtr));
99N/A }
99N/A- _XtTableAddConverter(process->globalConverterTable, from, to,
99N/A- converter, convert_args,
99N/A- num_args, True, cache_type, destructor, True);
99N/A+
99N/A+ TableAddConverter(process->globalConverterTable, from, to, converter,
99N/A+ convert_args, num_args, True, cache_type, destructor,
99N/A+ replicator, True);
99N/A while (app) {
99N/A- _XtTableAddConverter(app->converterTable, from, to,
99N/A- converter, convert_args,
99N/A- num_args, True, cache_type, destructor, True);
99N/A+ TableAddConverter(app->converterTable, from, to, converter,
99N/A+ convert_args, num_args, True, cache_type,
99N/A+ destructor, replicator, True);
99N/A app = app->next;
99N/A }
99N/A UNLOCK_PROCESS;
99N/A }
99N/A
99N/A+void XtSetTypeConverter(
99N/A+ register _Xconst char* from_type,
99N/A+ register _Xconst char* to_type,
99N/A+ XtTypeConverter converter,
99N/A+ XtConvertArgList convert_args,
99N/A+ Cardinal num_args,
99N/A+ XtCacheType cache_type,
99N/A+ XtDestructor destructor
99N/A+ )
99N/A+{
99N/A+ unsigned short cache_flags;
99N/A+
99N/A+ cache_flags = cache_type & (XtCacheNone | XtCacheAll |
99N/A+ XtCacheByDisplay | XtCacheRefCount);
99N/A+
99N/A+ _XtSetTypeConverter(from_type, to_type, converter, convert_args, num_args,
99N/A+ cache_flags, destructor, 0);
99N/A+}
99N/A+
99N/A void XtAppSetTypeConverter(
99N/A XtAppContext app,
99N/A register _Xconst char* from_type,
99N/A@@ -357,6 +410,7 @@ CacheEnter(
77N/A Boolean do_ref,
77N/A Boolean do_free,
77N/A XtDestructor destructor,
77N/A+ XtReplicator replicator,
58N/A XtPointer closure)
145N/A {
58N/A register CachePtr *pHashEntry;
58N/A@@ -366,34 +420,22 @@ CacheEnter(
77N/A LOCK_PROCESS;
77N/A pHashEntry = &cacheHashTable[hash & CACHEHASHMASK];
77N/A
77N/A- if ((succeeded && destructor) || do_ref) {
77N/A- p = (CachePtr) _XtHeapAlloc(heap, (sizeof(CacheRec) +
58N/A- sizeof(CacheRecExt) +
145N/A- num_args * sizeof(XrmValue)));
30N/A- CEXT(p)->prev = pHashEntry;
58N/A- CEXT(p)->destructor = succeeded ? destructor : NULL;
77N/A- CEXT(p)->closure = closure;
77N/A- CEXT(p)->ref_count = 1;
77N/A- p->has_ext = True;
77N/A- }
58N/A- else {
145N/A- p = (CachePtr)_XtHeapAlloc(heap, (sizeof(CacheRec) +
58N/A- num_args * sizeof(XrmValue)));
58N/A- p->has_ext = False;
77N/A- }
77N/A+ p = (CachePtr)_XtHeapAlloc(heap,
77N/A+ (sizeof(CacheRec) + num_args * sizeof(XrmValue)));
77N/A+
58N/A if (!to->addr)
145N/A succeeded = False;
58N/A p->conversion_succeeded = succeeded;
77N/A p->is_refcounted = do_ref;
77N/A p->must_be_freed = do_free;
77N/A p->next = *pHashEntry;
77N/A- if (p->next && p->next->has_ext)
77N/A- CEXT(p->next)->prev = &p->next;
65N/A-
145N/A *pHashEntry = p;
65N/A p->tag = (XtPointer)heap;
65N/A p->hash = hash;
77N/A p->converter = converter;
77N/A+ p->destructor = destructor;
77N/A+ p->replicator = replicator;
77N/A+ p->closure = closure;
65N/A p->from.size = from->size;
145N/A if (from->size <= sizeof(p->from.addr)) {
65N/A p->from_is_value = True;
58N/A@@ -416,14 +458,31 @@ CacheEnter(
106N/A if (!succeeded) {
145N/A p->to_is_value = False;
106N/A p->to.addr = NULL;
106N/A- } else if (to->size <= sizeof(p->to.addr)) {
106N/A- p->to_is_value = True;
145N/A- XtMemmove(&p->to.addr, to->addr, to->size);
106N/A } else {
106N/A- p->to_is_value = False;
77N/A- p->to.addr = (XPointer)_XtHeapAlloc(heap, to->size);
77N/A- (void) memmove((char *)p->to.addr, (char *)to->addr, to->size);
77N/A+ XPointer src_ptr, dest_ptr, gptr;
77N/A+
58N/A+ if ((size_t)to->size <= sizeof(p->to.addr)) {
145N/A+ p->to_is_value = True;
58N/A+ dest_ptr = (XPointer)&p->to.addr;
58N/A+ } else {
77N/A+ p->to_is_value = False;
77N/A+ dest_ptr = p->to.addr = (XPointer)_XtHeapAlloc(heap, to->size);
77N/A+ }
77N/A+
58N/A+ if (do_ref & XtCacheXmRefCount) {
145N/A+ gptr = (*(p->replicator))(*(XtPointer *)(to->addr));
58N/A+ src_ptr = (XtPointer)&gptr;
58N/A+ } else {
77N/A+ src_ptr = to->addr;
77N/A+ }
77N/A+
77N/A+ memmove(dest_ptr, src_ptr, to->size);
77N/A+ }
77N/A+
77N/A+ if ((succeeded && destructor) || do_ref) {
145N/A+ p->ref_count = 1;
58N/A }
58N/A+
77N/A UNLOCK_PROCESS;
77N/A return p;
77N/A }
77N/A@@ -431,32 +490,39 @@ CacheEnter(
77N/A static void FreeCacheRec(
77N/A XtAppContext app,
77N/A CachePtr p,
145N/A- CachePtr *prev)
77N/A+ Boolean clean_table)
77N/A {
77N/A LOCK_PROCESS;
99N/A- if (p->has_ext) {
99N/A- if (CEXT(p)->destructor) {
99N/A- Cardinal num_args = p->num_args;
99N/A- XrmValue *args = NULL;
99N/A- XrmValue toc;
99N/A- if (num_args)
99N/A- args = CARGS(p);
99N/A- toc.size = p->to.size;
99N/A- if (p->to_is_value)
99N/A- toc.addr = (XPointer)&p->to.addr;
99N/A- else
145N/A- toc.addr = p->to.addr;
99N/A- (*CEXT(p)->destructor) (app, &toc, CEXT(p)->closure, args,
99N/A- &num_args);
124N/A- }
124N/A- *(CEXT(p)->prev) = p->next;
124N/A- if (p->next && p->next->has_ext)
124N/A- CEXT(p->next)->prev = CEXT(p)->prev;
124N/A- } else {
99N/A- *prev = p->next;
145N/A- if (p->next && p->next->has_ext)
99N/A- CEXT(p->next)->prev = prev;
99N/A+ if (clean_table) {
124N/A+ CachePtr cachep, *cachepp;
124N/A+
124N/A+ cachepp = &cacheHashTable[p->hash & CACHEHASHMASK];
124N/A+ while (cachep = *cachepp) {
99N/A+ if (p == cachep) {
145N/A+ *cachepp = cachep->next;
99N/A+ break;
124N/A+ }
124N/A+ cachepp = &cachep->next;
124N/A+ }
124N/A+ }
124N/A+
99N/A+ if (p->destructor) {
145N/A+ Cardinal num_args=p->num_args;
99N/A+ XrmValue *args=NULL;
124N/A+ XrmValue toc;
125N/A+
125N/A+ if (num_args) {
125N/A+ args = CARGS(p);
125N/A+ }
125N/A+ toc.size = p->to.size;
125N/A+ if (p->to_is_value) {
125N/A+ toc.addr = (XPointer)&p->to.addr;
145N/A+ } else {
125N/A+ toc.addr = p->to.addr;
125N/A+ }
125N/A+ (*p->destructor)(app, &toc, p->closure, args, &num_args);
125N/A }
125N/A+
125N/A if (p->must_be_freed) {
125N/A register int i;
145N/A if (!p->from_is_value)
125N/A@@ -480,18 +546,18 @@ void _XtCacheFlushTag(
124N/A XtPointer tag)
112N/A {
145N/A int i;
112N/A- register CachePtr *prev;
112N/A register CachePtr rec;
112N/A+ register CachePtr *next_link;
145N/A
112N/A LOCK_PROCESS;
129N/A for (i = CACHEHASHSIZE; --i >= 0;) {
129N/A- prev = &cacheHashTable[i];
129N/A- while ((rec = *prev)) {
129N/A+ next_link = &cacheHashTable[i];
129N/A+ while ((rec = *next_link)) {
129N/A+ next_link = &rec->next;
145N/A if (rec->tag == tag)
129N/A- FreeCacheRec(app, rec, prev);
129N/A- else
129N/A- prev = &rec->next;
129N/A+ FreeCacheRec(app, rec, False);
129N/A }
129N/A+ cacheHashTable[i] = 0;
129N/A }
145N/A UNLOCK_PROCESS;
129N/A }
129N/A@@ -641,7 +707,12 @@ void XtDirectConvert(
129N/A LOCK_PROCESS;
129N/A /* Try to find cache entry for conversion */
129N/A hash = ((long) converter >> 2) + from->size + *((char *) from->addr);
129N/A- if (from->size > 1) hash += ((char *) from->addr)[1];
129N/A+ if (from->size > 1) {
145N/A+ if (sizeof(long) == 4)
129N/A+ hash += ((char *) from->addr)[1];
129N/A+ else
129N/A+ hash += ((char *) from->addr)[6];
129N/A+ }
129N/A
129N/A for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next) {
129N/A if ((p->hash == hash)
145N/A@@ -685,7 +756,7 @@ void XtDirectConvert(
129N/A {
129N/A CacheEnter(&globalHeap, (XtTypeConverter)converter, args, num_args,
129N/A from, to, (to->addr != NULL), hash, False, False,
129N/A- (XtDestructor)NULL, NULL);
129N/A+ (XtDestructor)NULL, NULL, 0);
129N/A }
129N/A UNLOCK_PROCESS;
145N/A }
129N/A@@ -726,6 +797,7 @@ CallConverter(
129N/A int hash;
129N/A Cardinal i;
129N/A Boolean retval;
129N/A+ XPointer from_addr, gptr;
129N/A
129N/A if (!cP || ((cP->cache_type == XtCacheNone) && !cP->destructor)) {
145N/A XtPointer closure;
129N/A@@ -738,7 +810,12 @@ CallConverter(
99N/A LOCK_PROCESS;
144N/A /* Try to find cache entry for conversion */
145N/A hash = ((long)(converter) >> 2) + from->size + *((char *) from->addr);
144N/A- if (from->size > 1) hash += ((char *) from->addr)[1];
144N/A+ if (from->size > 1) {
144N/A+ if (sizeof(long) == 4)
145N/A+ hash += ((char *) from->addr)[1];
144N/A+ else
99N/A+ hash += ((char *) from->addr)[6];
77N/A+ }
77N/A
77N/A if (cP->cache_type != XtCacheNone) {
77N/A for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next){
58N/A@@ -770,14 +847,18 @@ CallConverter(
58N/A UNLOCK_PROCESS;
58N/A return False;
58N/A }
58N/A- to->size = p->to.size;
58N/A- if (p->to_is_value) {
58N/A- XtMemmove(to->addr, &p->to.addr,
58N/A- to->size);
58N/A+ if (cP->do_ref_count & XtCacheXmRefCount) {
58N/A+ gptr = (*(p->replicator))(p->to.addr);
58N/A+ from_addr = (XPointer)&gptr;
58N/A+ } else if (p->to_is_value) {
58N/A+ from_addr = (XPointer)&p->to.addr;
58N/A } else {
77N/A- (void) memmove((char *)to->addr,
77N/A- (char *)p->to.addr, to->size);
77N/A+ from_addr = p->to.addr;
77N/A }
77N/A+
58N/A+ to->size = p->to.size;
58N/A+ memmove((char *)to->addr, from_addr,
58N/A+ to->size);
145N/A } else { /* old-style call */
58N/A to->size = p->to.size;
58N/A if (p->to_is_value)
58N/A@@ -787,7 +868,7 @@ CallConverter(
77N/A }
77N/A }
77N/A if (p->is_refcounted) {
77N/A- CEXT(p)->ref_count++;
77N/A+ p->ref_count++;
77N/A if (cache_ref_return)
58N/A *cache_ref_return = (XtCacheRef)p;
58N/A else
58N/A@@ -810,7 +891,7 @@ CallConverter(
145N/A Heap *heap;
58N/A XtPointer closure = NULL;
58N/A unsigned int supplied_size = to->size;
58N/A- Boolean do_ref = cP->do_ref_count && cache_ref_return;
58N/A+ unsigned short do_ref;
58N/A Boolean do_free = False;
58N/A Boolean retval =
58N/A (*(XtTypeConverter)converter)(dpy, args, &num_args, from, to, &closure);
58N/A@@ -823,6 +904,8 @@ CallConverter(
58N/A return False;
58N/A }
77N/A
77N/A+ do_ref = cache_ref_return ? cP->do_ref_count : 0;
77N/A+
58N/A if ((cP->cache_type == XtCacheNone) || do_ref) {
58N/A heap = NULL;
58N/A do_free = True;
77N/A@@ -834,8 +917,12 @@ CallConverter(
30N/A else
77N/A heap = &XtDisplayToApplicationContext(dpy)->heap;
77N/A
77N/A- p = CacheEnter(heap, converter, args, num_args, from, to, retval,
77N/A- hash, do_ref, do_free, cP->destructor, closure);
77N/A+ if (do_ref || !(cP->do_ref_count & XtCacheXmRefCount)) {
77N/A+ p = CacheEnter(heap, converter, args, num_args, from, to, retval,
77N/A+ hash, do_ref, do_free, cP->destructor,
58N/A+ cP->replicator, closure);
58N/A+ }
58N/A+
58N/A if (do_ref)
58N/A *cache_ref_return = (XtCacheRef)p;
58N/A else if (cache_ref_return)
58N/A@@ -1061,8 +1148,8 @@ void XtAppReleaseCacheRefs(
58N/A LOCK_APP(app);
58N/A LOCK_PROCESS;
58N/A for (r = (CachePtr*)refs; (p = *r); r++) {
58N/A- if (p->is_refcounted && --(CEXT(p)->ref_count) == 0) {
58N/A- FreeCacheRec(app, p, NULL);
58N/A+ if (p->is_refcounted && (--p->ref_count) == 0) {
58N/A+ FreeCacheRec(app, p, True);
58N/A }
58N/A }
58N/A UNLOCK_PROCESS;
58N/A@@ -1078,7 +1165,6 @@ void XtCallbackReleaseCacheRefList(
58N/A {
58N/A XtAppReleaseCacheRefs( XtWidgetToApplicationContext(widget),
58N/A (XtCacheRef*)closure );
58N/A- XtFree(closure);
58N/A }
58N/A
58N/A
58N/Adiff --git a/src/Create.c b/src/Create.c
58N/Aindex da00192..b756223 100644
58N/A--- a/src/Create.c
58N/A+++ b/src/Create.c
58N/A@@ -405,8 +405,7 @@ xtCreate(
58N/A CompileCallbacks(widget);
58N/A
58N/A if (cache_refs != NULL) {
58N/A- XtAddCallback(widget, XtNdestroyCallback,
58N/A- XtCallbackReleaseCacheRefList, (XtPointer)cache_refs );
58N/A+ XtFree(cache_refs);
58N/A }
58N/A
58N/A wsize = widget_class->core_class.widget_size;
58N/Adiff --git a/src/Display.c b/src/Display.c
58N/Aindex 4ccf079..72ed668 100644
58N/A--- a/src/Display.c
58N/A+++ b/src/Display.c
58N/A@@ -323,12 +323,15 @@ _XtAppInit(
58N/A * Save away argv and argc so we can set the properties later
58N/A */
58N/A
58N/A- saved_argv = (String *)
58N/A- __XtMalloc( (Cardinal)((*argc_in_out + 1) * sizeof(String)) );
58N/A-
58N/A- for (i = 0 ; i < *argc_in_out ; i++) saved_argv[i] = (*argv_in_out)[i];
58N/A- saved_argv[i] = NULL; /* NULL terminate that sucker. */
30N/A-
30N/A+ if(*argv_in_out != NULL) {
+ saved_argv = (String *)
+ __XtMalloc( (Cardinal)((*argc_in_out + 1) * sizeof(String)) );
+
+ for (i = 0 ; i < *argc_in_out ; i++) saved_argv[i] = (*argv_in_out)[i];
+ saved_argv[i] = NULL; /* NULL terminate that sucker. */
+ } else {
+ saved_argv = NULL;
+ }
*app_context_return = XtCreateApplicationContext();
diff --git a/src/Event.c b/src/Event.c
index 11823d6..7c15e83 100644
--- a/src/Event.c
+++ b/src/Event.c
@@ -563,6 +563,14 @@ void XtRegisterDrawable(
UNLOCK_APP(app);
}
+/* need this for backward compatability */
+void _XtRegisterWindow(window, widget)
+ Window window;
+ Widget widget;
+{
+ XtRegisterDrawable(XtDisplay(widget), (Drawable)window, widget);
+}
+
void XtUnregisterDrawable(
Display* display,
Drawable drawable)
@@ -613,6 +621,14 @@ void XtUnregisterDrawable(
UNLOCK_APP(app);
}
+/* need this for backward compatability */
+void _XtUnregisterWindow(window, widget)
+ register Window window;
+ register Widget widget;
+{
+ XtUnregisterDrawable(XtDisplay(widget), (Drawable)window);
+}
+
static void ExpandWWTable(
register WWTable tab)
{
diff --git a/src/Geometry.c b/src/Geometry.c
index d64c8e2..c8ddbd6 100644
--- a/src/Geometry.c
+++ b/src/Geometry.c
@@ -330,6 +330,12 @@ _XtMakeGeometryRequest (
} else {
returnCode = (*manager)(widget, request, reply);
}
+
+ /* leob fix for bug 4153816 */
+ if (returnCode == XtGeometryDone && XtIsRealized(widget) &&
+ (widget->core.width != request->width ||
+ widget->core.height != request->height) )
+ return XtGeometryYes;
}
/*
diff --git a/src/Initialize.c b/src/Initialize.c
index 9783deb..2a5a8a8 100644
--- a/src/Initialize.c
+++ b/src/Initialize.c
@@ -473,7 +473,7 @@ static String _XtDefaultLanguageProc(
if (! XSetLocaleModifiers(""))
XtWarning("X locale modifiers not supported, using default");
- return setlocale(LC_ALL, NULL); /* re-query in case overwritten */
+ return setlocale(LC_CTYPE, NULL); /* re-query in case overwritten */
}
XtLanguageProc XtSetLanguageProc(
@@ -994,8 +994,13 @@ Widget XtOpenApplication(XtAppContext *app_context_return,
LOCK_APP(app_con);
XtSetArg(args[num], XtNscreen, DefaultScreenOfDisplay(dpy)); num++;
- XtSetArg(args[num], XtNargc, saved_argc); num++;
- XtSetArg(args[num], XtNargv, argv_in_out); num++;
+ /* only set argc and argv if argv_in_out[0] is not NULL */
+ if (argv_in_out && argv_in_out[0]) {
+ XtSetArg(args[num], XtNargc, saved_argc);
+ num++;
+ XtSetArg(args[num], XtNargv, argv_in_out);
+ num++;
+ }
merged_args = XtMergeArgLists(args_in, num_args_in, args, num);
num += num_args_in;
diff --git a/src/Makefile.am b/src/Makefile.am
index cf54a5c..a786d94 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -74,7 +74,8 @@ DISTCLEANFILES = StringDefs.c
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 -lc
#
# The util directory contains a program that builds some of the sources.
diff --git a/src/NextEvent.c b/src/NextEvent.c
index b1f7bc7..c9b53db 100644
--- a/src/NextEvent.c
+++ b/src/NextEvent.c
@@ -347,6 +347,51 @@ static void AdjustTimes (
#endif
}
+static void CheckAndTrimTimes(XtAppContext app, wait_times_ptr_t wt)
+{
+ struct timeval tv;
+ String pptrs[8];
+ Cardinal nbr_parms;
+
+ pptrs[0] = (String)zero_time.tv_sec;
+ pptrs[1] = (String)zero_time.tv_usec;
+ pptrs[2] = (String)wt->wait_time.tv_sec;
+ pptrs[3] = (String)wt->wait_time.tv_usec;
+ pptrs[4] = (String)wt->max_wait_time.tv_sec;
+ pptrs[5] = (String)wt->max_wait_time.tv_usec;
+ pptrs[6] = (String)wt->cur_time.tv_sec;
+ pptrs[7] = (String)wt->cur_time.tv_usec;
+ nbr_parms = 8;
+ XtAppErrorMsg(app, "communicationError", "select",
+ XtCXtToolkitError, "Resetting timer values: zero_time=%lu:%lu, "
+ "wait_time=%lu:%lu, max_wait_time=%lu:%lu, cur_time=%lu:%lu",
+ pptrs, &nbr_parms);
+
+ memset(&zero_time, 0, sizeof(zero_time)); /* Ensure the integrity of */
+ /* zero_time. */
+ if (wt->max_wait_time.tv_sec > 99999999) /* Bring max_wait_time back into */
+ { /* acceptable range if nec. */
+ wt->max_wait_time.tv_sec &= 0xFFFFF;
+ wt->max_wait_time.tv_usec = 0; /* (Fractions of a sec are in- */
+ /* significant at this level.) */
+ }
+ if (app->timerQueue != NULL) /* Do the same for the head of */
+ { /* the timer queue if necessary. */
+ TIMEDELTA(tv, app->timerQueue->te_timer_value, wt->cur_time);
+ if (tv.tv_sec > 99999999)
+ {
+ pptrs[0] = (String)app->timerQueue->te_timer_value.tv_sec;
+ pptrs[1] = (String)app->timerQueue->te_timer_value.tv_usec;
+ nbr_parms = 2;
+ XtAppErrorMsg(app, "selectError", "timerQueue",
+ XtCXtToolkitError, "timerQueue value %lu:%lu is invalid",
+ pptrs, &nbr_parms);
+ tv.tv_sec &= 0xFFFFF;
+ tv.tv_usec = 0;
+ ADD_TIME(app->timerQueue->te_timer_value, wt->cur_time, tv);
+ }
+ }
+}
static int IoWait (
wait_times_ptr_t wt,
@@ -629,20 +674,56 @@ WaitLoop:
/*
* interrupt occured recalculate time value and wait again.
*/
- if (errno == EINTR || errno == EAGAIN) {
- if (errno == EAGAIN) {
- errno = 0; /* errno is not self reseting */
- continue;
- }
- errno = 0; /* errno is not self reseting */
-
- /* was it interrupted by a signal that we care about? */
- if (!ignoreSignals && app->signalQueue != NULL) {
- SignalEventRec *se_ptr = app->signalQueue;
- while (se_ptr != NULL) {
- if (se_ptr->se_notice) {
- if (block && howlong != NULL)
- AdjustHowLong (howlong, &wt.start_time);
+ if (errno == EAGAIN) {
+ errno = 0; /* errno is not self reseting */
+ continue;
+ } else if (errno == EBADF) {
+ /* Bug 4482749 - If we have a bad FD stop monitoring it */
+ int i;
+ struct timeval tv={0};
+ for (i = 0; i < wf.nfds; i++) {
+ if (FD_ISSET(i, &wf.rmask) || FD_ISSET(i, &wf.wmask) ||
+ FD_ISSET(i, &wf.emask)) {
+ if (select(i + 1, &wf.rmask, &wf.wmask, &wf.emask, &tv)
+ == -1) {
+ char bad_fd[55];
+ String param = bad_fd;
+ Cardinal param_count = 1;
+
+ /*
+ * Get rid of any input procedures on the bad FD
+ * and regenerate the list of FDs we listen to.
+ */
+ while (app->input_list[i] != NULL) {
+ XtRemoveInput((XtInputId)app->input_list[i]);
+ }
+ InitFds (app, ignoreEvents, ignoreInputs, &wf);
+
+ sprintf(bad_fd, "%d", errno);
+ XtAppWarningMsg(app, "communicationError", "select",
+ XtCXtToolkitError,
+ "Select failed; error code %s",
+ &param, &param_count);
+
+ sprintf(bad_fd, "EBADF error in select() call for file descriptor %d", i);
+ XtAppWarning(app, param);
+
+ }
+ }
+ }
+
+ return -1;
+
+ } else if (errno == EINTR) {
+ errno = 0;
+
+ /* was it interrupted by a signal that we care about? */
+ if (!ignoreSignals && app->signalQueue != NULL) {
+ SignalEventRec *se_ptr = app->signalQueue;
+ while (se_ptr != NULL) {
+ if (se_ptr->se_notice) {
+ if (block && howlong != NULL)
+ AdjustHowLong (howlong, &wt.start_time);
#ifdef USE_POLL
XtStackFree ((XtPointer) wf.fdlist, fdlist);
#endif
@@ -687,17 +768,33 @@ WaitLoop:
#endif
nfds = 0;
}
- } else {
- char Errno[12];
- String param = Errno;
- Cardinal param_count = 1;
-
- sprintf( Errno, "%d", errno);
- XtAppWarningMsg(app, "communicationError","select",
- XtCXtToolkitError,"Select failed; error code %s",
- &param, &param_count);
- continue;
- }
+ } else if (errno == EINVAL) { /* (Can be recovered from if */
+ struct timeval tv={0};
+
+ nfds = Select(wf.nfds, &wf.rmask, &wf.wmask, &wf.emask, &tv);
+ /* Do a non-blocking select to */
+ /* eliminate any timeout errors.*/
+ if (nfds == -1) { /* Now try to sort out the good */
+ if (errno == EINVAL) { /* and the bad from the ugly. */
+ char Errno[12]; /* (This is ugly). */
+ String param = Errno;
+ Cardinal param_count = 1;
+
+ sprintf(Errno, "%d", errno);
+ XtAppErrorMsg(app, "communicationError", "select",
+ XtCXtToolkitError, "Select failed; error code %s",
+ &param, &param_count);
+ XtAppError(app, "EINVAL error in select() call");
+ } else { /* If the new error is not about */
+ /* an invalid select() parameter,*/
+ continue; /* then simply try again. */
+ }
+ } else { /* (Else the error appears to be */
+ /* in the timeout parameter.) */
+ CheckAndTrimTimes(app, &wt);
+ continue;
+ }
+ }
} /* timed out or input available */
break;
}
@@ -750,6 +847,33 @@ WaitLoop:
#define SeCallProc(ptr) \
(*ptr->se_proc) (ptr->se_closure, (XtSignalId*)&ptr);
+#ifdef sun /*SUNSOFT */
+int _XtwaitForSomething(
+ _XtBoolean ignoreTimers,
+ _XtBoolean ignoreInputs,
+ _XtBoolean ignoreEvents,
+ _XtBoolean block,
+ unsigned long *howlong,
+ XtAppContext app)
+{
+#ifdef XTHREADS
+/* fix for bug 4185875 leob */
+return _XtWaitForSomething(app,
+ ignoreEvents, ignoreTimers, ignoreInputs, TRUE,
+ block,
+ TRUE,
+ howlong);
+#else
+/* fix for bug 4185875 leob */
+return _XtWaitForSomething(app,
+ ignoreEvents, ignoreTimers, ignoreInputs, TRUE,
+ block,
+ howlong);
+#endif
+
+}
+#endif /* SUNSOFT */
+
/*
* Public Routines
*/