Merge branch 'master' of ssh://gitlab.freedesktop.org/xorg/lib/libxt

59 files changed, 22521 insertions, 21814 deletions

diff --git a/.gitignore b/.gitignore
index 95f781e..a839d84 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 #
 #		X.Org module default exclusion patterns
-#		The next section if for module specific patterns
+#		The next section is for module specific patterns
 #
 #	Do not edit the following section
 # 	GNU Build System (Autotools)
diff --git a/configure.ac b/configure.ac
index ada63ee..ca462cd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -23,7 +23,7 @@
 
 # Initialize Autoconf
 AC_PREREQ([2.60])
-AC_INIT([libXt], [1.1.5.2],
+AC_INIT([libXt], [1.2.0.2],
 	[https://gitlab.freedesktop.org/xorg/lib/libXt/issues], [libXt])
 AC_CONFIG_SRCDIR([Makefile.am])
 AC_CONFIG_HEADERS([config.h])
diff --git a/include/X11/ConvertI.h b/include/X11/ConvertI.h
index e7a9636..8fdfe18 100644
--- a/include/X11/ConvertI.h
+++ b/include/X11/ConvertI.h
@@ -74,7 +74,7 @@ extern void _XtTableAddConverter(
     XrmRepresentation    	/* from_type */,
     XrmRepresentation    	/* to_type */,
     XtTypeConverter      	/* converter */,
-    XtConvertArgList     	/* convert_args */,
+    XtConvertArgRec const *     /* convert_args */,
     Cardinal             	/* num_args */,
     _XtBoolean              	/* new_style */,
     XtCacheType	    		/* cache_type */,
diff --git a/src/ActionHook.c b/src/ActionHook.c
index ade4e70..1d7a56a 100644
--- a/src/ActionHook.c
+++ b/src/ActionHook.c
@@ -1,5 +1,3 @@
-/*LINTLIBRARY*/
-
 /***********************************************************
 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
 
@@ -43,7 +41,6 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ******************************************************************/
-
 /*
 
 Copyright 1987, 1988, 1998  The Open Group
@@ -69,75 +66,69 @@ used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
 */
-
 /*
  * Contains XtAppAddActionHook, XtRemoveActionHook
  */
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
 
-
-/*ARGSUSED*/
-static void FreeActionHookList(
-    Widget widget,		/* unused (and invalid) */
-    XtPointer closure,		/* ActionHook* */
-    XtPointer call_data)	/* unused */
+static void
+FreeActionHookList(Widget widget _X_UNUSED,
+		   XtPointer closure,  /* ActionHook* */
+                   XtPointer call_data _X_UNUSED)
 {
-    ActionHook list = *(ActionHook*)closure;
+    ActionHook list = *(ActionHook *) closure;
+
     while (list != NULL) {
-	ActionHook next = list->next;
-	XtFree( (XtPointer)list );
-	list = next;
+        ActionHook next = list->next;
+
+        XtFree((XtPointer) list);
+        list = next;
     }
 }
 
-
-XtActionHookId XtAppAddActionHook(
-    XtAppContext app,
-    XtActionHookProc proc,
-    XtPointer closure)
+XtActionHookId
+XtAppAddActionHook(XtAppContext app, XtActionHookProc proc, XtPointer closure)
 {
     ActionHook hook = XtNew(ActionHookRec);
+
     LOCK_APP(app);
     hook->next = app->action_hook_list;
     hook->app = app;
     hook->proc = proc;
     hook->closure = closure;
     if (app->action_hook_list == NULL) {
-	_XtAddCallback( &app->destroy_callbacks,
-		        FreeActionHookList,
-		        (XtPointer)&app->action_hook_list
-		      );
+        _XtAddCallback(&app->destroy_callbacks,
+                       FreeActionHookList, (XtPointer) &app->action_hook_list);
     }
     app->action_hook_list = hook;
     UNLOCK_APP(app);
-    return (XtActionHookId)hook;
+    return (XtActionHookId) hook;
 }
 
-
-void XtRemoveActionHook(
-    XtActionHookId id)
+void
+XtRemoveActionHook(XtActionHookId id)
 {
-    ActionHook *p, hook = (ActionHook)id;
+    ActionHook *p, hook = (ActionHook) id;
     XtAppContext app = hook->app;
+
     LOCK_APP(app);
     for (p = &app->action_hook_list; p != NULL && *p != hook; p = &(*p)->next);
     if (p) {
-	*p = hook->next;
-	XtFree( (XtPointer)hook );
-	if (app->action_hook_list == NULL)
-	    _XtRemoveCallback(&app->destroy_callbacks, FreeActionHookList,
-			      (XtPointer) &app->action_hook_list);
+        *p = hook->next;
+        XtFree((XtPointer) hook);
+        if (app->action_hook_list == NULL)
+            _XtRemoveCallback(&app->destroy_callbacks, FreeActionHookList,
+                              (XtPointer) &app->action_hook_list);
     }
 #ifdef DEBUG
     else {
-	XtAppWarningMsg(app, "badId", "xtRemoveActionHook", XtCXtToolkitError,
-			"XtRemoveActionHook called with bad or old hook id",
-			NULL, NULL);
+        XtAppWarningMsg(app, "badId", "xtRemoveActionHook", XtCXtToolkitError,
+                        "XtRemoveActionHook called with bad or old hook id",
+                        NULL, NULL);
     }
 #endif /*DEBUG*/
-    UNLOCK_APP(app);
+        UNLOCK_APP(app);
 }
diff --git a/src/Alloc.c b/src/Alloc.c
index dd2f616..8cd3f5b 100644
--- a/src/Alloc.c
+++ b/src/Alloc.c
@@ -91,33 +91,35 @@ in this Software without prior written authorization from The Open Group.
 #define Xfree(ptr) free(ptr)
 
 #ifdef _XNEEDBCOPYFUNC
-void _XtBcopy(
-    char *src, char *dst,
-    int length)
+void
+_XtBcopy(char *src, char *dst, int length)
 {
     if (src < dst) {
-	dst += length;
-	src += length;
-	while (length--)
-	    *--dst = *--src;
-    } else {
-	while (length--)
-	    *dst++ = *src++;
+        dst += length;
+        src += length;
+        while (length--)
+            *--dst = *--src;
+    }
+    else {
+        while (length--)
+            *dst++ = *src++;
     }
 }
 #endif
 
-void _XtAllocError(
-    String type)
+void
+_XtAllocError(String type)
 {
     Cardinal num_params = 1;
-    if (type == NULL) type = "local memory allocation";
+
+    if (type == NULL)
+        type = "local memory allocation";
     XtErrorMsg("allocError", type, XtCXtToolkitError,
-	       "Cannot perform %s", &type, &num_params);
+               "Cannot perform %s", &type, &num_params);
 }
 
-void _XtHeapInit(
-    Heap*	heap)
+void
+_XtHeapInit(Heap *heap)
 {
     heap->start = NULL;
     heap->bytes_remaining = 0;
@@ -127,10 +129,8 @@ void _XtHeapInit(
  * Not currently available in XTTRACEMEMORY version, since that would
  * require varargs macros everywhere, which are only standard in C99 & later.
  */
-Cardinal XtAsprintf(
-    _XtString *new_string,
-    _Xconst char * _X_RESTRICT_KYWD format,
-    ...)
+Cardinal
+XtAsprintf(_XtString *new_string, _Xconst char *_X_RESTRICT_KYWD format, ...)
 {
     char buf[256];
     int len;
@@ -141,96 +141,98 @@ Cardinal XtAsprintf(
     va_end(ap);
 
     if (len < 0)
-	_XtAllocError("vsnprintf");
+        _XtAllocError("vsnprintf");
 
     *new_string = XtMalloc((Cardinal) len + 1); /* snprintf doesn't count trailing '\0' */
-    if (len < sizeof(buf))
-    {
-	strncpy(*new_string, buf, (size_t) len);
-	(*new_string)[len] = '\0';
+    if ((size_t) len < sizeof(buf)) {
+        strncpy(*new_string, buf, (size_t) len);
+        (*new_string)[len] = '\0';
     }
-    else
-    {
-	va_start(ap, format);
-	if (vsnprintf(*new_string, (size_t) (len + 1), format, ap) < 0)
-	    _XtAllocError("vsnprintf");
-	va_end(ap);
+    else {
+        va_start(ap, format);
+        if (vsnprintf(*new_string, (size_t) (len + 1), format, ap) < 0)
+            _XtAllocError("vsnprintf");
+        va_end(ap);
     }
     return (Cardinal) len;
 }
 
-
 #ifndef XTTRACEMEMORY
 
-char *XtMalloc(
-    unsigned size)
+char *
+XtMalloc(unsigned size)
 {
     char *ptr;
 
 #if defined(MALLOC_0_RETURNS_NULL) && defined(XTMALLOC_BC)
     /* preserve this (broken) behavior until everyone fixes their apps */
-    if (!size) size = 1;
+    if (!size)
+        size = 1;
 #endif
     if ((ptr = Xmalloc(size)) == NULL)
         _XtAllocError("malloc");
 
-    return(ptr);
+    return (ptr);
 }
 
-char *XtRealloc(
-    char     *ptr,
-    unsigned size)
+char *
+XtRealloc(char *ptr, unsigned size)
 {
-   if (ptr == NULL) {
+    if (ptr == NULL) {
 #ifdef MALLOC_0_RETURNS_NULL
-	if (!size) size = 1;
+        if (!size)
+            size = 1;
 #endif
-	return(XtMalloc(size));
-   } else if ((ptr = Xrealloc(ptr, size)) == NULL
+        return (XtMalloc(size));
+    }
+    else if ((ptr = Xrealloc(ptr, size)) == NULL
 #ifdef MALLOC_0_RETURNS_NULL
-		&& size
+             && size
 #endif
-	)
-	_XtAllocError("realloc");
+        )
+        _XtAllocError("realloc");
 
-   return(ptr);
+    return (ptr);
 }
 
-char *XtCalloc(
-    unsigned num, unsigned size)
+char *
+XtCalloc(unsigned num, unsigned size)
 {
     char *ptr;
 
 #if defined(MALLOC_0_RETURNS_NULL) && defined(XTMALLOC_BC)
     /* preserve this (broken) behavior until everyone fixes their apps */
-    if (!size) num = size = 1;
+    if (!size)
+        num = size = 1;
 #endif
     if ((ptr = Xcalloc(num, size)) == NULL)
-	_XtAllocError("calloc");
+        _XtAllocError("calloc");
 
-    return(ptr);
+    return (ptr);
 }
 
-void XtFree(
-    char *ptr)
+void
+XtFree(char *ptr)
 {
     free(ptr);
 }
 
-char* __XtMalloc(
-    unsigned size)
+char *
+__XtMalloc(unsigned size)
 {
 #ifdef MALLOC_0_RETURNS_NULL
-    if (!size) size = 1;
+    if (!size)
+        size = 1;
 #endif
-    return XtMalloc (size);
+    return XtMalloc(size);
 }
 
-char* __XtCalloc(
-    unsigned num, unsigned size)
+char *
+__XtCalloc(unsigned num, unsigned size)
 {
 #ifdef MALLOC_0_RETURNS_NULL
-    if (!size) num = size = 1;
+    if (!size)
+        num = size = 1;
 #endif
     return XtCalloc(num, size);
 }
@@ -239,55 +241,58 @@ char* __XtCalloc(
 #define HEAP_SEGMENT_SIZE 1492
 #endif
 
-char* _XtHeapAlloc(
-    Heap*	heap,
-    Cardinal	bytes)
+char *
+_XtHeapAlloc(Heap *heap, Cardinal bytes)
 {
-    register char* heap_loc;
-    if (heap == NULL) return XtMalloc(bytes);
-    if (heap->bytes_remaining < (int)bytes) {
-	if ((bytes + sizeof(char*)) >= (HEAP_SEGMENT_SIZE>>1)) {
-	    /* preserve current segment; insert this one in front */
+    register char *heap_loc;
+
+    if (heap == NULL)
+        return XtMalloc(bytes);
+    if (heap->bytes_remaining < (int) bytes) {
+        if ((bytes + sizeof(char *)) >= (HEAP_SEGMENT_SIZE >> 1)) {
+            /* preserve current segment; insert this one in front */
 #ifdef _TRACE_HEAP
-	    printf( "allocating large segment (%d bytes) on heap %p\n",
-		    bytes, heap );
+            printf("allocating large segment (%d bytes) on heap %p\n",
+                   bytes, heap);
 #endif
-	    heap_loc = XtMalloc(bytes + (Cardinal) sizeof(char*));
-	    if (heap->start) {
-		*(char**)heap_loc = *(char**)heap->start;
-		*(char**)heap->start = heap_loc;
-	    }
-	    else {
-		*(char**)heap_loc = NULL;
-		heap->start = heap_loc;
-	    }
-	    return heap_loc + sizeof(char*);
-	}
-	/* else discard remainder of this segment */
+            heap_loc = XtMalloc(bytes + (Cardinal) sizeof(char *));
+            if (heap->start) {
+                *(char **) heap_loc = *(char **) heap->start;
+                *(char **) heap->start = heap_loc;
+            }
+            else {
+                *(char **) heap_loc = NULL;
+                heap->start = heap_loc;
+            }
+            return heap_loc + sizeof(char *);
+        }
+        /* else discard remainder of this segment */
 #ifdef _TRACE_HEAP
-	printf( "allocating new segment on heap %p\n", heap );
+        printf("allocating new segment on heap %p\n", heap);
 #endif
-	heap_loc = XtMalloc((unsigned)HEAP_SEGMENT_SIZE);
-	*(char**)heap_loc = heap->start;
-	heap->start = heap_loc;
-	heap->current = heap_loc + sizeof(char*);
-	heap->bytes_remaining = HEAP_SEGMENT_SIZE - sizeof(char*);
+        heap_loc = XtMalloc((unsigned) HEAP_SEGMENT_SIZE);
+        *(char **) heap_loc = heap->start;
+        heap->start = heap_loc;
+        heap->current = heap_loc + sizeof(char *);
+        heap->bytes_remaining = HEAP_SEGMENT_SIZE - sizeof(char *);
     }
     bytes = (Cardinal) ((bytes + (sizeof(long) - 1)) & (~(sizeof(long) - 1)));
     heap_loc = heap->current;
     heap->current += bytes;
-    heap->bytes_remaining = (heap->bytes_remaining - (int) bytes); /* can be negative, if rounded */
+    heap->bytes_remaining = (heap->bytes_remaining - (int) bytes);      /* can be negative, if rounded */
     return heap_loc;
 }
 
-void _XtHeapFree(
-    Heap*	heap)
+void
+_XtHeapFree(Heap *heap)
 {
-    char* segment = heap->start;
+    char *segment = heap->start;
+
     while (segment != NULL) {
-	char* next_segment = *(char**)segment;
-	XtFree(segment);
-	segment = next_segment;
+        char *next_segment = *(char **) segment;
+
+        XtFree(segment);
+        segment = next_segment;
     }
     heap->start = NULL;
     heap->bytes_remaining = 0;
@@ -314,10 +319,10 @@ typedef struct _Stats {
     XtPointer heap;
 } Stats;
 
-static StatsPtr XtMemory = (StatsPtr)NULL;
+static StatsPtr XtMemory = (StatsPtr) NULL;
 static unsigned long ActiveXtMemory = 0;
 static unsigned long XtSeqId = 0;
-static unsigned long XtSeqBreakpoint = (unsigned long)(~0UL);
+static unsigned long XtSeqBreakpoint = (unsigned long) (~0UL);
 
 #define StatsSize(n) (unsigned)((((n) + (sizeof(long) - 1)) & ~(sizeof(long) - 1)) + sizeof(Stats))
 #define ToStats(ptr) ((StatsPtr)(ptr - sizeof(Stats)))
@@ -334,31 +339,29 @@ static unsigned long XtSeqBreakpoint = (unsigned long)(~0UL);
     ptr->size = len; \
     ptr->heap = hp; \
     if (file) \
-	ActiveXtMemory += len; \
+        ActiveXtMemory += len; \
     ptr->seq = XtSeqId; \
     if (XtSeqId == XtSeqBreakpoint) \
-	_XtBreakpoint(ptr); \
+        _XtBreakpoint(ptr); \
     XtSeqId++
 
 /*ARGUSED*/
-static void _XtBreakpoint(
-    StatsPtr mem)
+static void
+_XtBreakpoint(StatsPtr mem)
 {
-    mem->seq = XtSeqId; /* avoid being optimized out of existence */
+    mem->seq = XtSeqId;         /* avoid being optimized out of existence */
 }
 
-char *_XtMalloc(
-    unsigned size,
-    const char *file,
-    int line)
+char *
+_XtMalloc(unsigned size, const char *file, int line)
 {
     StatsPtr ptr;
     unsigned newsize;
-    char* retval = NULL;
+    char *retval = NULL;
 
     LOCK_PROCESS;
     newsize = StatsSize(size);
-    if ((ptr = (StatsPtr)Xmalloc(newsize)) == NULL)
+    if ((ptr = (StatsPtr) Xmalloc(newsize)) == NULL)
         _XtAllocError("malloc");
     CHAIN(ptr, size, NULL);
     retval = (ToMem(ptr));
@@ -366,52 +369,48 @@ char *_XtMalloc(
     return retval;
 }
 
-char *XtMalloc(
-    unsigned size)
+char *
+XtMalloc(unsigned size)
 {
-    return _XtMalloc(size, (char *)NULL, 0);
+    return _XtMalloc(size, (char *) NULL, 0);
 }
 
-char *_XtRealloc(
-    char     *ptr,
-    unsigned size,
-    const char *file,
-    int line)
+char *
+_XtRealloc(char *ptr, unsigned size, const char *file, int line)
 {
-   char *newptr;
-
-   LOCK_PROCESS;
-   newptr = _XtMalloc(size, file, line);
-   if (ptr) {
-       unsigned copysize = ToStats(ptr)->size;
-       if (copysize > size) copysize = size;
-       memmove(newptr, ptr, copysize);
-       _XtFree(ptr);
-   }
-   UNLOCK_PROCESS;
-   return(newptr);
+    char *newptr;
+
+    LOCK_PROCESS;
+    newptr = _XtMalloc(size, file, line);
+    if (ptr) {
+        unsigned copysize = ToStats(ptr)->size;
+
+        if (copysize > size)
+            copysize = size;
+        memmove(newptr, ptr, copysize);
+        _XtFree(ptr);
+    }
+    UNLOCK_PROCESS;
+    return (newptr);
 }
 
-char *XtRealloc(
-    char     *ptr,
-    unsigned size)
+char *
+XtRealloc(char *ptr, unsigned size)
 {
-    return _XtRealloc(ptr, size, (char *)NULL, 0);
+    return _XtRealloc(ptr, size, (char *) NULL, 0);
 }
 
-char *_XtCalloc(
-    unsigned num, unsigned size,
-    const char *file,
-    int line)
+char *
+_XtCalloc(unsigned num, unsigned size, const char *file, int line)
 {
     StatsPtr ptr;
     unsigned total, newsize;
-    char* retval = NULL;
+    char *retval = NULL;
 
     LOCK_PROCESS;
     total = num * size;
     newsize = StatsSize(total);
-    if ((ptr = (StatsPtr)Xcalloc(newsize, 1)) == NULL)
+    if ((ptr = (StatsPtr) Xcalloc(newsize, 1)) == NULL)
         _XtAllocError("calloc");
     CHAIN(ptr, total, NULL);
     retval = (ToMem(ptr));
@@ -419,24 +418,24 @@ char *_XtCalloc(
     return retval;
 }
 
-char *XtCalloc(
-    unsigned num, unsigned size)
+char *
+XtCalloc(unsigned num, unsigned size)
 {
-    return _XtCalloc(num, size, (char *)NULL, 0);
+    return _XtCalloc(num, size, (char *) NULL, 0);
 }
 
-Boolean _XtIsValidPointer(
-    char *ptr)
+Boolean
+_XtIsValidPointer(char *ptr)
 {
     register StatsPtr mem;
     register StatsPtr stp = ToStats(ptr);
 
     LOCK_PROCESS;
     for (mem = XtMemory; mem; mem = mem->next) {
-	if (mem == stp) {
-	    UNLOCK_PROCESS;
-	    return True;
-	}
+        if (mem == stp) {
+            UNLOCK_PROCESS;
+            return True;
+        }
     }
     UNLOCK_PROCESS;
     return False;
@@ -444,48 +443,46 @@ Boolean _XtIsValidPointer(
 
 Boolean _XtValidateMemory = False;
 
-void _XtFree(
-    char *ptr)
+void
+_XtFree(char *ptr)
 {
-   register StatsPtr stp;
-
-   LOCK_PROCESS;
-   if (ptr) {
-       if (_XtValidateMemory && !_XtIsValidPointer(ptr))
-	   abort();
-       stp = ToStats(ptr);
-       if (stp->file)
-	   ActiveXtMemory -= stp->size;
-       if (stp->prev)
-	   stp->prev->next = stp->next;
-       else
-	   XtMemory = stp->next;
-       if (stp->next)
-	   stp->next->prev = stp->prev;
-       Xfree((char *)stp);
-   }
-   UNLOCK_PROCESS;
+    register StatsPtr stp;
+
+    LOCK_PROCESS;
+    if (ptr) {
+        if (_XtValidateMemory && !_XtIsValidPointer(ptr))
+            abort();
+        stp = ToStats(ptr);
+        if (stp->file)
+            ActiveXtMemory -= stp->size;
+        if (stp->prev)
+            stp->prev->next = stp->next;
+        else
+            XtMemory = stp->next;
+        if (stp->next)
+            stp->next->prev = stp->prev;
+        Xfree((char *) stp);
+    }
+    UNLOCK_PROCESS;
 }
 
-void XtFree(char *ptr)
+void
+XtFree(char *ptr)
 {
-   _XtFree(ptr);
+    _XtFree(ptr);
 }
 
-char *_XtHeapMalloc(
-    Heap *heap,
-    Cardinal size,
-    const char *file,
-    int line)
+char *
+_XtHeapMalloc(Heap *heap, Cardinal size, const char *file, int line)
 {
     StatsPtr ptr;
     unsigned newsize;
     XtPointer hp = (XtPointer) heap;
-    char* retval = NULL;
+    char *retval = NULL;
 
     LOCK_PROCESS;
     newsize = StatsSize(size);
-    if ((ptr = (StatsPtr)Xmalloc(newsize)) == NULL)
+    if ((ptr = (StatsPtr) Xmalloc(newsize)) == NULL)
         _XtAllocError("malloc");
     CHAIN(ptr, size, hp);
     retval = (ToMem(ptr));
@@ -493,49 +490,52 @@ char *_XtHeapMalloc(
     return retval;
 }
 
-void _XtHeapFree(Heap* heap)
+void
+_XtHeapFree(Heap *heap)
 {
     register StatsPtr mem, next;
 
     LOCK_PROCESS;
     for (mem = XtMemory; mem; mem = next) {
-	next = mem->next;
-	if (mem->heap == heap) {
-	    if (mem->file)
-		ActiveXtMemory -= mem->size;
-	    if (mem->prev)
-		mem->prev->next = next;
-	    else
-		XtMemory = next;
-	    if (next)
-		next->prev = mem->prev;
-	    Xfree((char *)mem);
-	}
+        next = mem->next;
+        if (mem->heap == heap) {
+            if (mem->file)
+                ActiveXtMemory -= mem->size;
+            if (mem->prev)
+                mem->prev->next = next;
+            else
+                XtMemory = next;
+            if (next)
+                next->prev = mem->prev;
+            Xfree((char *) mem);
+        }
     }
     UNLOCK_PROCESS;
 }
 
 #include <stdio.h>
 
-void _XtPrintMemory(const char * filename)
+void
+_XtPrintMemory(const char *filename)
 {
     register StatsPtr mem;
     FILE *f;
 
     if (filename == NULL)
-	f = stderr;
+        f = stderr;
     else
-	f = fopen(filename, "w");
+        f = fopen(filename, "w");
     LOCK_PROCESS;
     fprintf(f, "total size: %lu\n", ActiveXtMemory);
     for (mem = XtMemory; mem; mem = mem->next) {
-	if (mem->file)
-	    fprintf(f, "size: %6d  seq: %5lu  %12s(%4d)  %s\n",
-		    mem->size, mem->seq,
-		    mem->file, mem->line, mem->heap ? "heap" : "");
+        if (mem->file)
+            fprintf(f, "size: %6d  seq: %5lu  %12s(%4d)  %s\n",
+                    mem->size, mem->seq,
+                    mem->file, mem->line, mem->heap ? "heap" : "");
     }
     UNLOCK_PROCESS;
-    if (filename) fclose(f);
+    if (filename)
+        fclose(f);
 }
 
-#endif  /* XTTRACEMEMORY */
+#endif                          /* XTTRACEMEMORY */
diff --git a/src/ArgList.c b/src/ArgList.c
index a88341c..6fdabf8 100644
--- a/src/ArgList.c
+++ b/src/ArgList.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -48,28 +47,28 @@ SOFTWARE.
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
-#include	"IntrinsicI.h"
-#include	<stdio.h>
+#include        "IntrinsicI.h"
+#include        <stdio.h>
 
 /*
  * This routine merges two arglists. It does NOT check for duplicate entries.
  */
 
-ArgList XtMergeArgLists(
-    ArgList args1,
-    Cardinal num_args1,
-    ArgList args2,
-    Cardinal num_args2)
+ArgList
+XtMergeArgLists(ArgList args1,
+                Cardinal num_args1,
+                ArgList args2,
+                Cardinal num_args2)
 {
     ArgList result, args;
 
     result = (ArgList) __XtCalloc((unsigned) num_args1 + num_args2,
-				(unsigned) sizeof(Arg));
+                                  (unsigned) sizeof(Arg));
 
     for (args = result; num_args1 != 0; num_args1--)
-    	*args++ = *args1++;
-    for (             ; num_args2 != 0; num_args2--)
-    	*args++ = *args2++;
+        *args++ = *args1++;
+    for (; num_args2 != 0; num_args2--)
+        *args++ = *args2++;
 
     return result;
 }
diff --git a/src/Callback.c b/src/Callback.c
index ad2c534..0c4ef5c 100644
--- a/src/Callback.c
+++ b/src/Callback.c
@@ -82,35 +82,34 @@ static _Xconst _XtString XtNxtCallCallback = "xtCallCallback";
 /* However it doesn't contain a final NULL record */
 #define ToList(p) ((XtCallbackList) ((p)+1))
 
-static InternalCallbackList* FetchInternalList(
-    Widget	widget,
-    _Xconst char *name)
+static InternalCallbackList *
+FetchInternalList(Widget widget,
+                  _Xconst char *name)
 {
     XrmQuark quark;
     int n;
     CallbackTable offsets;
-    InternalCallbackList* retval = NULL;
+    InternalCallbackList *retval = NULL;
 
     quark = StringToQuark(name);
     LOCK_PROCESS;
     offsets = (CallbackTable)
-	widget->core.widget_class->core_class.callback_private;
-
-    for (n = (int)(long) *(offsets++); --n >= 0; offsets++)
-	if (quark == (*offsets)->xrm_name) {
-	    retval = (InternalCallbackList *)
-		((char *) widget - (*offsets)->xrm_offset - 1);
-	    break;
-	}
+        widget->core.widget_class->core_class.callback_private;
+
+    for (n = (int) (long) *(offsets++); --n >= 0; offsets++)
+        if (quark == (*offsets)->xrm_name) {
+            retval = (InternalCallbackList *)
+                ((char *) widget - (*offsets)->xrm_offset - 1);
+            break;
+        }
     UNLOCK_PROCESS;
     return retval;
 }
 
-
-void _XtAddCallback(
-    InternalCallbackList*   callbacks,
-    XtCallbackProc	    callback,
-    XtPointer		    closure)
+void
+_XtAddCallback(InternalCallbackList *callbacks,
+               XtCallbackProc callback,
+               XtPointer closure)
 {
     register InternalCallbackList icl;
     register XtCallbackList cl;
@@ -120,16 +119,19 @@ void _XtAddCallback(
     count = icl ? icl->count : 0;
 
     if (icl && icl->call_state) {
-	icl->call_state |= _XtCBFreeAfterCalling;
-	icl = (InternalCallbackList)
-	    __XtMalloc((Cardinal) (sizeof(InternalCallbackRec) +
-		     sizeof(XtCallbackRec) * (size_t) (count + 1)));
-	(void) memmove((char *)ToList(icl), (char *)ToList(*callbacks),
-		       sizeof(XtCallbackRec) * (size_t) count);
-    } else {
-	icl = (InternalCallbackList)
-	    XtRealloc((char *) icl, (Cardinal)(sizeof(InternalCallbackRec) +
-		      sizeof(XtCallbackRec) * (size_t) (count + 1)));
+        icl->call_state |= _XtCBFreeAfterCalling;
+        icl = (InternalCallbackList)
+            __XtMalloc((Cardinal) (sizeof(InternalCallbackRec) +
+                                   sizeof(XtCallbackRec) * (size_t) (count +
+                                                                     1)));
+        (void) memmove((char *) ToList(icl), (char *) ToList(*callbacks),
+                       sizeof(XtCallbackRec) * (size_t) count);
+    }
+    else {
+        icl = (InternalCallbackList)
+            XtRealloc((char *) icl, (Cardinal) (sizeof(InternalCallbackRec) +
+                                                sizeof(XtCallbackRec) *
+                                                (size_t) (count + 1)));
     }
     *callbacks = icl;
     icl->count = (unsigned short) (count + 1);
@@ -138,29 +140,28 @@ void _XtAddCallback(
     cl = ToList(icl) + count;
     cl->callback = callback;
     cl->closure = closure;
-} /* _XtAddCallback */
+}                               /* _XtAddCallback */
 
-void _XtAddCallbackOnce(
-    register InternalCallbackList*callbacks,
-    XtCallbackProc	    callback,
-    XtPointer		    closure)
+void
+_XtAddCallbackOnce(register InternalCallbackList *callbacks,
+                   XtCallbackProc callback,
+                   XtPointer closure)
 {
     register XtCallbackList cl = ToList(*callbacks);
     register int i;
 
-    for (i=(*callbacks)->count; --i >= 0; cl++)
-	if (cl->callback == callback && cl->closure == closure)
-	    return;
+    for (i = (*callbacks)->count; --i >= 0; cl++)
+        if (cl->callback == callback && cl->closure == closure)
+            return;
 
     _XtAddCallback(callbacks, callback, closure);
-} /* _XtAddCallbackOnce */
-
-void XtAddCallback(
-    Widget	    widget,
-    _Xconst char*   name,
-    XtCallbackProc  callback,
-    XtPointer	    closure
-    )
+}                               /* _XtAddCallbackOnce */
+
+void
+XtAddCallback(Widget widget,
+              _Xconst char *name,
+              XtCallbackProc callback,
+              XtPointer closure)
 {
     InternalCallbackList *callbacks;
     XtAppContext app = XtWidgetToApplicationContext(widget);
@@ -168,35 +169,36 @@ void XtAddCallback(
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtAddCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtAddCallback",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtAddCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtAddCallback", NULL,
+                        NULL);
+        UNLOCK_APP(app);
+        return;
     }
     _XtAddCallback(callbacks, callback, closure);
     if (!_XtIsHookObject(widget)) {
         Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
-	if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	    XtChangeHookDataRec call_data;
 
-	    call_data.type = XtHaddCallback;
-	    call_data.widget = widget;
-	    call_data.event_data = (XtPointer) name;
-	    XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
-	}
+        if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
+            XtChangeHookDataRec call_data;
+
+            call_data.type = XtHaddCallback;
+            call_data.widget = widget;
+            call_data.event_data = (XtPointer) name;
+            XtCallCallbackList(hookobj,
+                               ((HookObject) hookobj)->hooks.
+                               changehook_callbacks, (XtPointer) &call_data);
+        }
     }
     UNLOCK_APP(app);
-} /* XtAddCallback */
+}                               /* XtAddCallback */
 
-/* ARGSUSED */
-static void AddCallbacks(
-    Widget		    widget,
-    InternalCallbackList   *callbacks,
-    XtCallbackList	    newcallbacks)
+static void
+AddCallbacks(Widget widget _X_UNUSED,
+             InternalCallbackList *callbacks,
+             XtCallbackList newcallbacks)
 {
     register InternalCallbackList icl;
     register int i, j;
@@ -204,122 +206,135 @@ static void AddCallbacks(
 
     icl = *callbacks;
     i = icl ? icl->count : 0;
-    for (j=0, cl = newcallbacks; cl->callback; cl++, j++);
+    for (j = 0, cl = newcallbacks; cl->callback; cl++, j++);
     if (icl && icl->call_state) {
-	icl->call_state |= _XtCBFreeAfterCalling;
-	icl = (InternalCallbackList) __XtMalloc((Cardinal)(sizeof(InternalCallbackRec) +
-					      sizeof(XtCallbackRec) * (size_t) (i+j)));
-	(void) memmove((char *)ToList(*callbacks), (char *)ToList(icl),
-		       sizeof(XtCallbackRec) * (size_t) i);
-    } else {
-	icl = (InternalCallbackList) XtRealloc((char *) icl,
-					       (Cardinal)(sizeof(InternalCallbackRec) +
-					       sizeof(XtCallbackRec) * (size_t) (i+j)));
+        icl->call_state |= _XtCBFreeAfterCalling;
+        icl = (InternalCallbackList)
+            __XtMalloc((Cardinal)
+                       (sizeof(InternalCallbackRec) +
+                        sizeof(XtCallbackRec) * (size_t) (i + j)));
+        (void) memmove((char *) ToList(*callbacks), (char *) ToList(icl),
+                       sizeof(XtCallbackRec) * (size_t) i);
+    }
+    else {
+        icl = (InternalCallbackList) XtRealloc((char *) icl,
+                                               (Cardinal) (sizeof
+                                                           (InternalCallbackRec)
+                                                           +
+                                                           sizeof(XtCallbackRec)
+                                                           * (size_t) (i + j)));
     }
     *callbacks = icl;
-    icl->count = (unsigned short) (i+j);
+    icl->count = (unsigned short) (i + j);
     icl->is_padded = 0;
     icl->call_state = 0;
-    for (cl = ToList(icl) + i; --j >= 0; )
-	*cl++ = *newcallbacks++;
-} /* AddCallbacks */
-
-void XtAddCallbacks(
-    Widget	    widget,
-    _Xconst char*   name,
-    XtCallbackList  xtcallbacks
-    )
+    for (cl = ToList(icl) + i; --j >= 0;)
+        *cl++ = *newcallbacks++;
+}                               /* AddCallbacks */
+
+void
+XtAddCallbacks(Widget widget,
+               _Xconst char *name,
+               XtCallbackList xtcallbacks)
 {
-    InternalCallbackList* callbacks;
+    InternalCallbackList *callbacks;
     Widget hookobj;
     XtAppContext app = XtWidgetToApplicationContext(widget);
 
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtAddCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtAddCallbacks",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtAddCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtAddCallbacks", NULL,
+                        NULL);
+        UNLOCK_APP(app);
+        return;
     }
     AddCallbacks(widget, callbacks, xtcallbacks);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHaddCallbacks;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) name;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHaddCallbacks;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) name;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtAddCallbacks */
+}                               /* XtAddCallbacks */
 
-void _XtRemoveCallback (
-    InternalCallbackList   *callbacks,
-    XtCallbackProc	    callback,
-    XtPointer		    closure)
+void
+_XtRemoveCallback(InternalCallbackList *callbacks,
+                  XtCallbackProc callback,
+                  XtPointer closure)
 {
     register InternalCallbackList icl;
     register int i, j;
     register XtCallbackList cl, ncl, ocl;
 
     icl = *callbacks;
-    if (!icl) return;
+    if (!icl)
+        return;
 
     cl = ToList(icl);
-    for (i=icl->count; --i >= 0; cl++) {
-	if (cl->callback == callback && cl->closure == closure) {
-	    if (icl->call_state) {
-		icl->call_state |= _XtCBFreeAfterCalling;
-		if (icl->count == 1) {
-		    *callbacks = NULL;
-		} else {
-		    j = icl->count - i - 1;
-		    ocl = ToList(icl);
-		    icl = (InternalCallbackList)
-			__XtMalloc((Cardinal) (sizeof(InternalCallbackRec) +
-				 sizeof(XtCallbackRec) * (size_t) (i + j)));
-		    icl->count = (unsigned short) (i + j);
-		    icl->is_padded = 0;
-		    icl->call_state = 0;
-		    ncl = ToList(icl);
-		    while (--j >= 0)
-			*ncl++ = *ocl++;
-		    while (--i >= 0)
-			*ncl++ = *++cl;
-		    *callbacks = icl;
-		}
-	    } else {
-		if (--icl->count) {
-		    ncl = cl + 1;
-		    while (--i >= 0)
-			*cl++ = *ncl++;
-		    icl = (InternalCallbackList)
-			XtRealloc((char *) icl, (Cardinal) (sizeof(InternalCallbackRec)
-				  + sizeof(XtCallbackRec) * icl->count));
-		    icl->is_padded = 0;
-		    *callbacks = icl;
-		} else {
-		    XtFree((char *) icl);
-		    *callbacks = NULL;
-		}
-	    }
-	    return;
-	}
-    }
-} /* _XtRemoveCallback */
-
-void XtRemoveCallback (
-    Widget	    widget,
-    _Xconst char*   name,
-    XtCallbackProc  callback,
-    XtPointer	    closure
-    )
+    for (i = icl->count; --i >= 0; cl++) {
+        if (cl->callback == callback && cl->closure == closure) {
+            if (icl->call_state) {
+                icl->call_state |= _XtCBFreeAfterCalling;
+                if (icl->count == 1) {
+                    *callbacks = NULL;
+                }
+                else {
+                    j = icl->count - i - 1;
+                    ocl = ToList(icl);
+                    icl = (InternalCallbackList)
+                        __XtMalloc((Cardinal) (sizeof(InternalCallbackRec) +
+                                               sizeof(XtCallbackRec) *
+                                               (size_t) (i + j)));
+                    icl->count = (unsigned short) (i + j);
+                    icl->is_padded = 0;
+                    icl->call_state = 0;
+                    ncl = ToList(icl);
+                    while (--j >= 0)
+                        *ncl++ = *ocl++;
+                    while (--i >= 0)
+                        *ncl++ = *++cl;
+                    *callbacks = icl;
+                }
+            }
+            else {
+                if (--icl->count) {
+                    ncl = cl + 1;
+                    while (--i >= 0)
+                        *cl++ = *ncl++;
+                    icl = (InternalCallbackList)
+                        XtRealloc((char *) icl,
+                                  (Cardinal) (sizeof(InternalCallbackRec)
+                                              +
+                                              sizeof(XtCallbackRec) *
+                                              icl->count));
+                    icl->is_padded = 0;
+                    *callbacks = icl;
+                }
+                else {
+                    XtFree((char *) icl);
+                    *callbacks = NULL;
+                }
+            }
+            return;
+        }
+    }
+}                               /* _XtRemoveCallback */
+
+void
+XtRemoveCallback(Widget widget,
+                 _Xconst char *name,
+                 XtCallbackProc callback,
+                 XtPointer closure)
 {
     InternalCallbackList *callbacks;
     Widget hookobj;
@@ -328,33 +343,33 @@ void XtRemoveCallback (
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtRemoveCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtRemoveCallback",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtRemoveCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtRemoveCallback", NULL,
+                        NULL);
+        UNLOCK_APP(app);
+        return;
     }
     _XtRemoveCallback(callbacks, callback, closure);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHremoveCallback;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) name;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHremoveCallback;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) name;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtRemoveCallback */
-
+}                               /* XtRemoveCallback */
 
-void XtRemoveCallbacks (
-    Widget	    widget,
-    _Xconst char*   name,
-    XtCallbackList  xtcallbacks)
+void
+XtRemoveCallbacks(Widget widget,
+                  _Xconst char *name,
+                  XtCallbackList xtcallbacks)
 {
     InternalCallbackList *callbacks;
     Widget hookobj;
@@ -366,83 +381,87 @@ void XtRemoveCallbacks (
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtRemoveCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtRemoveCallbacks",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtRemoveCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtRemoveCallbacks", NULL,
+                        NULL);
+        UNLOCK_APP(app);
+        return;
     }
 
     icl = *callbacks;
     if (!icl) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
 
     i = icl->count;
     cl = ToList(icl);
     if (icl->call_state) {
-	icl->call_state |= _XtCBFreeAfterCalling;
-	icl = (InternalCallbackList)__XtMalloc((Cardinal)(sizeof(InternalCallbackRec) +
-					     sizeof(XtCallbackRec) * (size_t) i));
-	icl->count = (unsigned short) i;
-	icl->call_state = 0;
+        icl->call_state |= _XtCBFreeAfterCalling;
+        icl =
+            (InternalCallbackList)
+            __XtMalloc((Cardinal)
+                       (sizeof(InternalCallbackRec) +
+                        sizeof(XtCallbackRec) * (size_t) i));
+        icl->count = (unsigned short) i;
+        icl->call_state = 0;
     }
     ccl = ToList(icl);
     while (--i >= 0) {
-	*ccl++ = *cl;
-	for (rcl=xtcallbacks; rcl->callback; rcl++) {
-	    if (cl->callback == rcl->callback && cl->closure == rcl->closure) {
-		ccl--;
-		icl->count--;
-		break;
-	    }
-	}
-	cl++;
+        *ccl++ = *cl;
+        for (rcl = xtcallbacks; rcl->callback; rcl++) {
+            if (cl->callback == rcl->callback && cl->closure == rcl->closure) {
+                ccl--;
+                icl->count--;
+                break;
+            }
+        }
+        cl++;
     }
     if (icl->count) {
-	icl = (InternalCallbackList)
-	    XtRealloc((char *)icl, (Cardinal) (sizeof(InternalCallbackRec) +
-				    sizeof(XtCallbackRec) * icl->count));
-	icl->is_padded = 0;
-	*callbacks = icl;
-    } else {
-	XtFree((char *)icl);
-	*callbacks = NULL;
+        icl = (InternalCallbackList)
+            XtRealloc((char *) icl, (Cardinal) (sizeof(InternalCallbackRec) +
+                                                sizeof(XtCallbackRec) *
+                                                icl->count));
+        icl->is_padded = 0;
+        *callbacks = icl;
+    }
+    else {
+        XtFree((char *) icl);
+        *callbacks = NULL;
     }
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHremoveCallbacks;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) name;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHremoveCallbacks;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) name;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtRemoveCallbacks */
-
+}                               /* XtRemoveCallbacks */
 
-void _XtRemoveAllCallbacks (
-    InternalCallbackList *callbacks)
+void
+_XtRemoveAllCallbacks(InternalCallbackList *callbacks)
 {
     register InternalCallbackList icl = *callbacks;
 
     if (icl) {
-	if (icl->call_state)
-	    icl->call_state |= _XtCBFreeAfterCalling;
-	else
-	    XtFree((char *) icl);
-	*callbacks = NULL;
+        if (icl->call_state)
+            icl->call_state |= _XtCBFreeAfterCalling;
+        else
+            XtFree((char *) icl);
+        *callbacks = NULL;
     }
-} /* _XtRemoveAllCallbacks */
+}                               /* _XtRemoveAllCallbacks */
 
-void XtRemoveAllCallbacks(
-    Widget widget,
-    _Xconst char* name)
+void
+XtRemoveAllCallbacks(Widget widget, _Xconst char *name)
 {
     InternalCallbackList *callbacks;
     Widget hookobj;
@@ -451,52 +470,57 @@ void XtRemoveAllCallbacks(
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtRemoveAllCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtRemoveAllCallbacks",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtRemoveAllCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtRemoveAllCallbacks",
+                        NULL, NULL);
+        UNLOCK_APP(app);
+        return;
     }
     _XtRemoveAllCallbacks(callbacks);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHremoveAllCallbacks;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) name;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHremoveAllCallbacks;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) name;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtRemoveAllCallbacks */
+}                               /* XtRemoveAllCallbacks */
 
-InternalCallbackList _XtCompileCallbackList(
-    XtCallbackList xtcallbacks)
+InternalCallbackList
+_XtCompileCallbackList(XtCallbackList xtcallbacks)
 {
     register int n;
     register XtCallbackList xtcl, cl;
     register InternalCallbackList callbacks;
 
-    for (n=0, xtcl=xtcallbacks; xtcl->callback; n++, xtcl++) {};
-    if (n == 0) return (InternalCallbackList) NULL;
+    for (n = 0, xtcl = xtcallbacks; xtcl->callback; n++, xtcl++) {
+    };
+    if (n == 0)
+        return (InternalCallbackList) NULL;
 
-    callbacks = (InternalCallbackList) __XtMalloc((Cardinal) (sizeof(InternalCallbackRec) +
-						sizeof(XtCallbackRec) * (size_t) n));
+    callbacks =
+        (InternalCallbackList)
+        __XtMalloc((Cardinal)
+                   (sizeof(InternalCallbackRec) +
+                    sizeof(XtCallbackRec) * (size_t) n));
     callbacks->count = (unsigned short) n;
     callbacks->is_padded = 0;
     callbacks->call_state = 0;
     cl = ToList(callbacks);
     while (--n >= 0)
-	*cl++ = *xtcallbacks++;
-    return(callbacks);
-} /* _XtCompileCallbackList */
-
+        *cl++ = *xtcallbacks++;
+    return (callbacks);
+}                               /* _XtCompileCallbackList */
 
-XtCallbackList _XtGetCallbackList(
-    InternalCallbackList *callbacks)
+XtCallbackList
+_XtGetCallbackList(InternalCallbackList *callbacks)
 {
     int i;
     InternalCallbackList icl;
@@ -504,28 +528,33 @@ XtCallbackList _XtGetCallbackList(
 
     icl = *callbacks;
     if (!icl) {
-	static XtCallbackRec emptyList[1] = { {NULL, NULL} };
-	return (XtCallbackList)emptyList;
+        static XtCallbackRec emptyList[1] = { {NULL, NULL} };
+        return (XtCallbackList) emptyList;
     }
     if (icl->is_padded)
-	return ToList(icl);
+        return ToList(icl);
     i = icl->count;
     if (icl->call_state) {
         XtCallbackList ocl;
-	icl->call_state |= _XtCBFreeAfterCalling;
-	ocl = ToList(icl);
-	icl = (InternalCallbackList) __XtMalloc((Cardinal)(sizeof(InternalCallbackRec) +
-					      sizeof(XtCallbackRec) * (size_t) (i+1)));
-	icl->count = (unsigned short) i;
-	icl->call_state = 0;
-	cl = ToList(icl);
-	while (--i >= 0)
-	    *cl++ = *ocl++;
-    } else {
-	icl = (InternalCallbackList) XtRealloc((char *)icl,
-					       (Cardinal)(sizeof(InternalCallbackRec) +
-					       sizeof(XtCallbackRec) * (size_t)(i+1)));
-	cl = ToList(icl) + i;
+
+        icl->call_state |= _XtCBFreeAfterCalling;
+        ocl = ToList(icl);
+        icl = (InternalCallbackList)
+            __XtMalloc((Cardinal)
+                       (sizeof(InternalCallbackRec) +
+                        sizeof(XtCallbackRec) * (size_t) (i + 1)));
+        icl->count = (unsigned short) i;
+        icl->call_state = 0;
+        cl = ToList(icl);
+        while (--i >= 0)
+            *cl++ = *ocl++;
+    }
+    else {
+        icl = (InternalCallbackList)
+            XtRealloc((char *) icl, (Cardinal) (sizeof(InternalCallbackRec)
+                                                + sizeof(XtCallbackRec)
+                                                * (size_t) (i + 1)));
+        cl = ToList(icl) + i;
     }
     icl->is_padded = 1;
     cl->callback = (XtCallbackProc) NULL;
@@ -534,11 +563,10 @@ XtCallbackList _XtGetCallbackList(
     return ToList(icl);
 }
 
-void XtCallCallbacks(
-    Widget   widget,
-    _Xconst char* name,
-    XtPointer call_data
-    )
+void
+XtCallCallbacks(Widget widget,
+                _Xconst char *name,
+                XtPointer call_data)
 {
     InternalCallbackList *callbacks;
     InternalCallbackList icl;
@@ -550,107 +578,107 @@ void XtCallCallbacks(
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, name);
     if (!callbacks) {
-	XtAppWarningMsg(app,
-	       XtNinvalidCallbackList,XtNxtCallCallback,XtCXtToolkitError,
-              "Cannot find callback list in XtCallCallbacks",
-	      NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        XtNinvalidCallbackList, XtNxtCallCallback,
+                        XtCXtToolkitError,
+                        "Cannot find callback list in XtCallCallbacks", NULL,
+                        NULL);
+        UNLOCK_APP(app);
+        return;
     }
 
     icl = *callbacks;
     if (!icl) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
     cl = ToList(icl);
     if (icl->count == 1) {
-	(*cl->callback) (widget, cl->closure, call_data);
-	UNLOCK_APP(app);
-	return;
+        (*cl->callback) (widget, cl->closure, call_data);
+        UNLOCK_APP(app);
+        return;
     }
     ostate = icl->call_state;
     icl->call_state = _XtCBCalling;
     for (i = icl->count; --i >= 0; cl++)
-	(*cl->callback) (widget, cl->closure, call_data);
+        (*cl->callback) (widget, cl->closure, call_data);
     if (ostate)
-	icl->call_state |= ostate;
+        icl->call_state |= ostate;
     else if (icl->call_state & _XtCBFreeAfterCalling)
-	XtFree((char *)icl);
+        XtFree((char *) icl);
     else
-	icl->call_state = ostate;
+        icl->call_state = ostate;
     UNLOCK_APP(app);
-} /* XtCallCallbacks */
-
+}                               /* XtCallCallbacks */
 
-XtCallbackStatus XtHasCallbacks(
-     Widget		widget,
-     _Xconst char*	callback_name
-     )
+XtCallbackStatus
+XtHasCallbacks(Widget widget,
+               _Xconst char *callback_name)
 {
     InternalCallbackList *callbacks;
     XtCallbackStatus retval = XtCallbackHasSome;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     callbacks = FetchInternalList(widget, callback_name);
     if (!callbacks)
-	retval = XtCallbackNoList;
+        retval = XtCallbackNoList;
     else if (!*callbacks)
-	retval = XtCallbackHasNone;
+        retval = XtCallbackHasNone;
     UNLOCK_APP(app);
     return retval;
-} /* XtHasCallbacks */
+}                               /* XtHasCallbacks */
 
-
-void XtCallCallbackList(
-    Widget widget,
-    XtCallbackList callbacks,
-    XtPointer call_data)
+void
+XtCallCallbackList(Widget widget,
+                   XtCallbackList callbacks,
+                   XtPointer call_data)
 {
     register InternalCallbackList icl;
     register XtCallbackList cl;
     register int i;
     char ostate;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (!callbacks) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
-    icl = (InternalCallbackList)callbacks;
+    icl = (InternalCallbackList) callbacks;
     cl = ToList(icl);
     if (icl->count == 1) {
-	(*cl->callback) (widget, cl->closure, call_data);
-	UNLOCK_APP(app);
-	return;
+        (*cl->callback) (widget, cl->closure, call_data);
+        UNLOCK_APP(app);
+        return;
     }
     ostate = icl->call_state;
     icl->call_state = _XtCBCalling;
     for (i = icl->count; --i >= 0; cl++)
-	(*cl->callback) (widget, cl->closure, call_data);
+        (*cl->callback) (widget, cl->closure, call_data);
     if (ostate)
-	icl->call_state |= ostate;
+        icl->call_state |= ostate;
     else if (icl->call_state & _XtCBFreeAfterCalling)
-	XtFree((char *)icl);
+        XtFree((char *) icl);
     else
-	icl->call_state = 0;
+        icl->call_state = 0;
     UNLOCK_APP(app);
-} /* XtCallCallbackList */
+}                               /* XtCallCallbackList */
 
-void _XtPeekCallback(
-    Widget widget,
-    XtCallbackList callbacks,
-    XtCallbackProc *callback,
-    XtPointer *closure)
+void
+_XtPeekCallback(Widget widget _X_UNUSED,
+                XtCallbackList callbacks,
+                XtCallbackProc *callback,
+                XtPointer *closure)
 {
     register InternalCallbackList icl = (InternalCallbackList) callbacks;
     register XtCallbackList cl;
 
     if (!callbacks) {
-	*callback = (XtCallbackProc) NULL;
-	return;
+        *callback = (XtCallbackProc) NULL;
+        return;
     }
     cl = ToList(icl);
     *callback = cl->callback;
@@ -658,43 +686,44 @@ void _XtPeekCallback(
     return;
 }
 
-void _XtCallConditionalCallbackList(
-    Widget widget,
-    XtCallbackList callbacks,
-    XtPointer call_data,
-    _XtConditionProc cond_proc)
+void
+_XtCallConditionalCallbackList(Widget widget,
+                               XtCallbackList callbacks,
+                               XtPointer call_data,
+                               _XtConditionProc cond_proc)
 {
     register InternalCallbackList icl;
     register XtCallbackList cl;
     register int i;
     char ostate;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (!callbacks) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
-    icl = (InternalCallbackList)callbacks;
+    icl = (InternalCallbackList) callbacks;
     cl = ToList(icl);
     if (icl->count == 1) {
-	(*cl->callback) (widget, cl->closure, call_data);
-	(void) (*cond_proc)(call_data);
-	UNLOCK_APP(app);
-	return;
+        (*cl->callback) (widget, cl->closure, call_data);
+        (void) (*cond_proc) (call_data);
+        UNLOCK_APP(app);
+        return;
     }
     ostate = icl->call_state;
     icl->call_state = _XtCBCalling;
     for (i = icl->count; --i >= 0; cl++) {
-	(*cl->callback) (widget, cl->closure, call_data);
-	if (! (*cond_proc)(call_data))
-	    break;
+        (*cl->callback) (widget, cl->closure, call_data);
+        if (!(*cond_proc) (call_data))
+            break;
     }
     if (ostate)
-	icl->call_state |= ostate;
+        icl->call_state |= ostate;
     else if (icl->call_state & _XtCBFreeAfterCalling)
-	XtFree((char *)icl);
+        XtFree((char *) icl);
     else
-	icl->call_state = 0;
+        icl->call_state = 0;
     UNLOCK_APP(app);
 }
diff --git a/src/ClickTime.c b/src/ClickTime.c
index 7a836cc..7841151 100644
--- a/src/ClickTime.c
+++ b/src/ClickTime.c
@@ -77,9 +77,8 @@ in this Software without prior written authorization from The Open Group.
 #endif
 #include "IntrinsicI.h"
 
-void XtSetMultiClickTime(
-    Display *dpy,
-    int time)
+void
+XtSetMultiClickTime(Display *dpy, int time)
 {
     DPY_TO_APPCON(dpy);
 
@@ -88,11 +87,11 @@ void XtSetMultiClickTime(
     UNLOCK_APP(app);
 }
 
-
-int XtGetMultiClickTime(
-    Display *dpy)
+int
+XtGetMultiClickTime(Display *dpy)
 {
     int retval;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
diff --git a/src/Composite.c b/src/Composite.c
index 108645d..469ec09 100644
--- a/src/Composite.c
+++ b/src/Composite.c
@@ -89,197 +89,206 @@ static void CompositeInsertChild(Widget);
 static void CompositeDeleteChild(Widget);
 static void CompositeDestroy(Widget);
 
-externaldef(compositeclassrec) CompositeClassRec compositeClassRec = {
-  { /******* CorePart *******/
-    /* superclass	    */	&widgetClassRec,
-    /* class_name	    */	"Composite",
-    /* widget_size	    */	sizeof(CompositeRec),
-    /* class_initialize     */  NULL,
-    /* class_part_initialize*/	CompositeClassPartInitialize,
-    /* class_inited	    */	FALSE,
-    /* initialize	    */	CompositeInitialize,
-    /* initialize_hook      */	NULL,
-    /* realize		    */	XtInheritRealize,
-    /* actions		    */	NULL,
-    /* num_actions	    */	0,
-    /* resources	    */	resources,
-    /* num_resources	    */	XtNumber(resources),
-    /* xrm_class	    */	NULLQUARK,
-    /* compress_motion      */	FALSE,
-    /* compress_exposure    */	TRUE,
-    /* compress_enterleave  */  FALSE,
-    /* visible_interest     */	FALSE,
-    /* destroy		    */	CompositeDestroy,
-    /* resize		    */	NULL,
-    /* expose		    */	NULL,
-    /* set_values	    */	NULL,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus	    */	NULL,
-    /* version		    */	XtVersion,
-    /* callback_offsets     */  NULL,
-    /* tm_table		    */  NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */	NULL,
-    /* extension	    */  NULL
-  },
-  { /**** CompositePart *****/
-    /* geometry_handler     */  NULL,
-    /* change_managed       */  NULL,
-    /* insert_child	    */  CompositeInsertChild,
-    /* delete_child	    */  CompositeDeleteChild,
-    /* extension	    */  NULL
-    }
+externaldef(compositeclassrec)
+CompositeClassRec compositeClassRec = {
+    {
+    /******* CorePart *******/
+     /* superclass           */ &widgetClassRec,
+     /* class_name           */ "Composite",
+     /* widget_size          */ sizeof(CompositeRec),
+     /* class_initialize     */ NULL,
+     /* class_part_initialize */ CompositeClassPartInitialize,
+     /* class_inited         */ FALSE,
+     /* initialize           */ CompositeInitialize,
+     /* initialize_hook      */ NULL,
+     /* realize              */ XtInheritRealize,
+     /* actions              */ NULL,
+     /* num_actions          */ 0,
+     /* resources            */ resources,
+     /* num_resources        */ XtNumber(resources),
+     /* xrm_class            */ NULLQUARK,
+     /* compress_motion      */ FALSE,
+     /* compress_exposure    */ TRUE,
+     /* compress_enterleave  */ FALSE,
+     /* visible_interest     */ FALSE,
+     /* destroy              */ CompositeDestroy,
+     /* resize               */ NULL,
+     /* expose               */ NULL,
+     /* set_values           */ NULL,
+     /* set_values_hook      */ NULL,
+     /* set_values_almost    */ XtInheritSetValuesAlmost,
+     /* get_values_hook      */ NULL,
+     /* accept_focus         */ NULL,
+     /* version              */ XtVersion,
+     /* callback_offsets     */ NULL,
+     /* tm_table             */ NULL,
+     /* query_geometry       */ NULL,
+     /* display_accelerator  */ NULL,
+     /* extension            */ NULL
+     }
+    ,
+    {
+    /**** CompositePart *****/
+     /* geometry_handler     */ NULL,
+     /* change_managed       */ NULL,
+     /* insert_child         */ CompositeInsertChild,
+     /* delete_child         */ CompositeDeleteChild,
+     /* extension            */ NULL
+     }
 };
 
-externaldef(compositewidgetclass) WidgetClass compositeWidgetClass = (WidgetClass) &compositeClassRec;
+externaldef(compositewidgetclass)
+WidgetClass compositeWidgetClass = (WidgetClass) &compositeClassRec;
 
-static void InheritAllowsChangeManagedSet(
-    WidgetClass widget_class)
+static void
+InheritAllowsChangeManagedSet(WidgetClass widget_class)
 {
     CompositeWidgetClass cc = (CompositeWidgetClass) widget_class;
     CompositeClassExtension ext, super_ext;
 
     ext = (CompositeClassExtension)
-	XtGetClassExtension(widget_class,
-		    XtOffsetOf(CompositeClassRec, composite_class.extension),
-			    NULLQUARK, 1L, 0);
+        XtGetClassExtension(widget_class,
+                            XtOffsetOf(CompositeClassRec,
+                                       composite_class.extension), NULLQUARK,
+                            1L, 0);
 
     if (ext && ext->version == XtCompositeExtensionVersion)
-	return;
+        return;
 
     super_ext = (CompositeClassExtension)
-	XtGetClassExtension(cc->core_class.superclass,
-		    XtOffsetOf(CompositeClassRec, composite_class.extension),
-			    NULLQUARK, 1L, 0);
+        XtGetClassExtension(cc->core_class.superclass,
+                            XtOffsetOf(CompositeClassRec,
+                                       composite_class.extension), NULLQUARK,
+                            1L, 0);
 
     LOCK_PROCESS;
     if (super_ext && super_ext->version == XtCompositeExtensionVersion &&
-	super_ext->record_size == sizeof(CompositeClassExtensionRec) &&
-	super_ext->allows_change_managed_set) {
+        super_ext->record_size == sizeof(CompositeClassExtensionRec) &&
+        super_ext->allows_change_managed_set) {
         CompositeClassExtension new_ext;
 
-	new_ext = (CompositeClassExtension)
-	    __XtCalloc(1, sizeof(CompositeClassExtensionRec));
-
-	/* Be careful to inherit only what is appropriate */
-	new_ext->next_extension = cc->composite_class.extension;
-	new_ext->record_type = NULLQUARK;
-	new_ext->version = XtCompositeExtensionVersion;
-	new_ext->record_size = sizeof(CompositeClassExtensionRec);
-	new_ext->accepts_objects = (ext ? ext->accepts_objects : False);
-	new_ext->allows_change_managed_set = True;
-	cc->composite_class.extension = (XtPointer) new_ext;
+        new_ext = (CompositeClassExtension)
+            __XtCalloc(1, sizeof(CompositeClassExtensionRec));
+
+        /* Be careful to inherit only what is appropriate */
+        new_ext->next_extension = cc->composite_class.extension;
+        new_ext->record_type = NULLQUARK;
+        new_ext->version = XtCompositeExtensionVersion;
+        new_ext->record_size = sizeof(CompositeClassExtensionRec);
+        new_ext->accepts_objects = (ext ? ext->accepts_objects : False);
+        new_ext->allows_change_managed_set = True;
+        cc->composite_class.extension = (XtPointer) new_ext;
     }
     UNLOCK_PROCESS;
 }
 
-static void CompositeClassPartInitialize(
-	WidgetClass myWidgetClass)
+static void
+CompositeClassPartInitialize(WidgetClass myWidgetClass)
 {
     register CompositePartPtr wcPtr;
     register CompositePartPtr superPtr = NULL;
 
     wcPtr = (CompositePartPtr)
-	&(((CompositeWidgetClass)myWidgetClass)->composite_class);
+        &(((CompositeWidgetClass) myWidgetClass)->composite_class);
 
     if (myWidgetClass != compositeWidgetClass) {
-	/* don't compute possible bogus pointer */
-	superPtr = (CompositePartPtr)&(((CompositeWidgetClass)myWidgetClass
-			->core_class.superclass)->composite_class);
-
-	LOCK_PROCESS;
-	if (wcPtr->geometry_manager == XtInheritGeometryManager) {
-	    wcPtr->geometry_manager =
-		    superPtr->geometry_manager;
-	}
-
-	if (wcPtr->change_managed == XtInheritChangeManaged) {
-	    wcPtr->change_managed =
-		    superPtr->change_managed;
-	    InheritAllowsChangeManagedSet(myWidgetClass);
-	}
-
-	if (wcPtr->insert_child == XtInheritInsertChild) {
-	    wcPtr->insert_child = superPtr->insert_child;
-	}
-
-	if (wcPtr->delete_child == XtInheritDeleteChild) {
-	    wcPtr->delete_child = superPtr->delete_child;
-	}
-	UNLOCK_PROCESS;
+        /* don't compute possible bogus pointer */
+        superPtr =
+            (CompositePartPtr) &
+            (((CompositeWidgetClass) myWidgetClass->core_class.superclass)->
+             composite_class);
+
+        LOCK_PROCESS;
+        if (wcPtr->geometry_manager == XtInheritGeometryManager) {
+            wcPtr->geometry_manager = superPtr->geometry_manager;
+        }
+
+        if (wcPtr->change_managed == XtInheritChangeManaged) {
+            wcPtr->change_managed = superPtr->change_managed;
+            InheritAllowsChangeManagedSet(myWidgetClass);
+        }
+
+        if (wcPtr->insert_child == XtInheritInsertChild) {
+            wcPtr->insert_child = superPtr->insert_child;
+        }
+
+        if (wcPtr->delete_child == XtInheritDeleteChild) {
+            wcPtr->delete_child = superPtr->delete_child;
+        }
+        UNLOCK_PROCESS;
     }
 }
 
-static void CompositeDestroy(
-    Widget	w)
+static void
+CompositeDestroy(Widget w)
 {
     register CompositeWidget cw = (CompositeWidget) w;
 
     XtFree((char *) cw->composite.children);
 }
 
-static void CompositeInsertChild(
-    Widget	w)
+static void
+CompositeInsertChild(Widget w)
 {
-    register Cardinal	     position;
-    register Cardinal        i;
+    register Cardinal position;
+    register Cardinal i;
     register CompositeWidget cw;
-    register WidgetList      children;
+    register WidgetList children;
 
     cw = (CompositeWidget) w->core.parent;
     children = cw->composite.children;
 
     if (cw->composite.insert_position != NULL)
-	position = (*(cw->composite.insert_position))(w);
+        position = (*(cw->composite.insert_position)) (w);
     else
-	position = cw->composite.num_children;
+        position = cw->composite.num_children;
 
     if (cw->composite.num_children == cw->composite.num_slots) {
-	/* Allocate more space */
-	cw->composite.num_slots +=  (cw->composite.num_slots / 2) + 2;
-	cw->composite.children = children =
-	    (WidgetList) XtRealloc((XtPointer) children,
-	    (Cardinal)((unsigned) (cw->composite.num_slots) * sizeof(Widget)));
+        /* Allocate more space */
+        cw->composite.num_slots += (cw->composite.num_slots / 2) + 2;
+        cw->composite.children = children =
+            (WidgetList) XtRealloc((XtPointer) children,
+                                   (Cardinal) ((unsigned)
+                                               (cw->composite.num_slots) *
+                                               sizeof(Widget)));
     }
     /* Ripple children up one space from "position" */
     for (i = cw->composite.num_children; i > position; i--) {
-	children[i] = children[i-1];
+        children[i] = children[i - 1];
     }
     children[position] = w;
     cw->composite.num_children++;
 }
 
-static void CompositeDeleteChild(
-    Widget	w)
+static void
+CompositeDeleteChild(Widget w)
 {
-    register Cardinal	     position;
-    register Cardinal	     i;
+    register Cardinal position;
+    register Cardinal i;
     register CompositeWidget cw;
 
     cw = (CompositeWidget) w->core.parent;
 
     for (position = 0; position < cw->composite.num_children; position++) {
         if (cw->composite.children[position] == w) {
-	    break;
-	}
+            break;
+        }
     }
-    if (position == cw->composite.num_children) return;
+    if (position == cw->composite.num_children)
+        return;
 
     /* Ripple children down one space from "position" */
     cw->composite.num_children--;
     for (i = position; i < cw->composite.num_children; i++) {
-        cw->composite.children[i] = cw->composite.children[i+1];
+        cw->composite.children[i] = cw->composite.children[i + 1];
     }
 }
 
-/* ARGSUSED */
-static void CompositeInitialize(
-    Widget   requested_widget,
-    Widget   new_widget,
-    ArgList args,
-    Cardinal *num_args)
+static void
+CompositeInitialize(Widget requested_widget _X_UNUSED,
+                    Widget new_widget,
+                    ArgList args _X_UNUSED,
+                    Cardinal *num_args _X_UNUSED)
 {
     register CompositeWidget cw;
 
diff --git a/src/Constraint.c b/src/Constraint.c
index 92b61b6..45a0b2a 100644
--- a/src/Constraint.c
+++ b/src/Constraint.c
@@ -75,67 +75,75 @@ in this Software without prior written authorization from The Open Group.
 #include "StringDefs.h"
 
 static void ConstraintPartInitialize(WidgetClass wc);
-externaldef(constraintclassrec) ConstraintClassRec constraintClassRec = {
-  { /******* CorePart *******/
-    /* superclass	    */	(WidgetClass) &compositeClassRec,
-    /* class_name	    */	"Constraint",
-    /* widget_size	    */	sizeof(ConstraintRec),
-    /* class_initialize     */  NULL,
-    /* class_part_initialize*/	ConstraintPartInitialize,
-    /* class_inited	    */	FALSE,
-    /* initialize	    */	NULL,
-    /* initialize_hook      */	NULL,
-    /* realize		    */	XtInheritRealize,
-    /* actions		    */	NULL,
-    /* num_actions	    */	0,
-    /* resources	    */	NULL,
-    /* num_resources	    */	0,
-    /* xrm_class	    */	NULLQUARK,
-    /* compress_motion      */	FALSE,
-    /* compress_exposure    */	TRUE,
-    /* compress_enterleave  */  FALSE,
-    /* visible_interest     */	FALSE,
-    /* destroy		    */	NULL,
-    /* resize		    */	NULL,
-    /* expose		    */	NULL,
-    /* set_values	    */	NULL,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus	    */	NULL,
-    /* version		    */	XtVersion,
-    /* callback_offsets     */  NULL,
-    /* tm_table		    */  NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension	    */  NULL
-  },{ /**** CompositePart *****/
-    /* geometry_handler     */  NULL,
-    /* change_managed       */  NULL,
-    /* insert_child	    */  XtInheritInsertChild,
-    /* delete_child	    */  XtInheritDeleteChild,
-    /* extension	    */  NULL
-  },{ /**** ConstraintPart ****/
-    /* resources	    */  NULL,
-    /* num_resources	    */  0,
-    /* constraint_size      */  0,
-    /* initialize	    */  NULL,
-    /* destroy		    */  NULL,
-    /* set_values	    */  NULL,
-    /* extension	    */  NULL
-  }
-};
 
-externaldef(constraintwidgetclass) WidgetClass constraintWidgetClass =
-	(WidgetClass) &constraintClassRec;
+externaldef(constraintclassrec)
+ConstraintClassRec constraintClassRec = {
+    {
+    /******* CorePart *******/
+     /* superclass           */ (WidgetClass) &compositeClassRec,
+     /* class_name           */ "Constraint",
+     /* widget_size          */ sizeof(ConstraintRec),
+     /* class_initialize     */ NULL,
+     /* class_part_initialize */ ConstraintPartInitialize,
+     /* class_inited         */ FALSE,
+     /* initialize           */ NULL,
+     /* initialize_hook      */ NULL,
+     /* realize              */ XtInheritRealize,
+     /* actions              */ NULL,
+     /* num_actions          */ 0,
+     /* resources            */ NULL,
+     /* num_resources        */ 0,
+     /* xrm_class            */ NULLQUARK,
+     /* compress_motion      */ FALSE,
+     /* compress_exposure    */ TRUE,
+     /* compress_enterleave  */ FALSE,
+     /* visible_interest     */ FALSE,
+     /* destroy              */ NULL,
+     /* resize               */ NULL,
+     /* expose               */ NULL,
+     /* set_values           */ NULL,
+     /* set_values_hook      */ NULL,
+     /* set_values_almost    */ XtInheritSetValuesAlmost,
+     /* get_values_hook      */ NULL,
+     /* accept_focus         */ NULL,
+     /* version              */ XtVersion,
+     /* callback_offsets     */ NULL,
+     /* tm_table             */ NULL,
+     /* query_geometry       */ NULL,
+     /* display_accelerator  */ NULL,
+     /* extension            */ NULL
+     }
+    , {
+      /**** CompositePart *****/
+       /* geometry_handler     */ NULL,
+       /* change_managed       */ NULL,
+       /* insert_child         */ XtInheritInsertChild,
+       /* delete_child         */ XtInheritDeleteChild,
+       /* extension            */ NULL
+       }
+    , {
+      /**** ConstraintPart ****/
+       /* resources            */ NULL,
+       /* num_resources        */ 0,
+       /* constraint_size      */ 0,
+       /* initialize           */ NULL,
+       /* destroy              */ NULL,
+       /* set_values           */ NULL,
+       /* extension            */ NULL
+       }
+};
 
+externaldef(constraintwidgetclass)
+WidgetClass constraintWidgetClass = (WidgetClass) &constraintClassRec;
 
-static void ConstraintPartInitialize(WidgetClass wc)
+static void
+ConstraintPartInitialize(WidgetClass wc)
 {
-    ConstraintWidgetClass cwc = (ConstraintWidgetClass)wc;
+    ConstraintWidgetClass cwc = (ConstraintWidgetClass) wc;
+
     if (cwc->constraint_class.resources)
-	_XtCompileResourceList(cwc->constraint_class.resources,
-			       cwc->constraint_class.num_resources);
+        _XtCompileResourceList(cwc->constraint_class.resources,
+                               cwc->constraint_class.num_resources);
 
-    _XtConstraintResDependencies((ConstraintWidgetClass)wc);
+    _XtConstraintResDependencies((ConstraintWidgetClass) wc);
 }
diff --git a/src/Convert.c b/src/Convert.c
index f9f241e..9b2d465 100644
--- a/src/Convert.c
+++ b/src/Convert.c
@@ -71,37 +71,37 @@ in this Software without prior written authorization from The Open Group.
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
-#include	"IntrinsicI.h"
-#include	"StringDefs.h"
-#include	"Intrinsic.h"
+#include        "IntrinsicI.h"
+#include        "StringDefs.h"
+#include        "Intrinsic.h"
 
 /* Conversion procedure hash table */
 
-#define CONVERTHASHSIZE	((unsigned)256)
-#define CONVERTHASHMASK	255
+#define CONVERTHASHSIZE ((unsigned)256)
+#define CONVERTHASHMASK 255
 #define ProcHash(from_type, to_type) (2 * (from_type) + to_type)
 #define HashCode(converter, from) (int)(((long)(converter) >> 2) + from->size + *((char *) from->addr))
 
 typedef struct _ConverterRec *ConverterPtr;
 typedef struct _ConverterRec {
-    ConverterPtr	next;
-    XrmRepresentation	from, to;
-    XtTypeConverter	converter;
-    XtDestructor	destructor;
-    unsigned short	num_args;
-    unsigned int	do_ref_count:1;
-    unsigned int	new_style:1;
-    unsigned int	global:1;
-    char		cache_type;
+    ConverterPtr next;
+    XrmRepresentation from, to;
+    XtTypeConverter converter;
+    XtDestructor destructor;
+    unsigned short num_args;
+    unsigned int do_ref_count:1;
+    unsigned int new_style:1;
+    unsigned int global:1;
+    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 Heap globalHeap = { NULL, NULL, 0 };
 
-void _XtSetDefaultConverterTable(
-	ConverterTable *table)
+void
+_XtSetDefaultConverterTable(ConverterTable *table)
 {
     register ConverterTable globalConverterTable;
 
@@ -109,42 +109,44 @@ void _XtSetDefaultConverterTable(
     globalConverterTable = _XtGetProcessContext()->globalConverterTable;
 
     *table = (ConverterTable)
-	__XtCalloc(CONVERTHASHSIZE, (unsigned)sizeof(ConverterPtr));
+        __XtCalloc(CONVERTHASHSIZE, (unsigned) sizeof(ConverterPtr));
     _XtAddDefaultConverters(*table);
 
     if (globalConverterTable) {
-	ConverterPtr rec;
-	int i;
-	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,
-				    ConvertArgs(rec), rec->num_args,
-				    rec->new_style, cache_type,
-				    rec->destructor, True);
-	    }
-  	}
+        ConverterPtr rec;
+        int i;
+        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,
+                                     ConvertArgs(rec), rec->num_args,
+                                     rec->new_style, cache_type,
+                                     rec->destructor, True);
+            }
+        }
     }
     UNLOCK_PROCESS;
 }
 
-void _XtFreeConverterTable(
-	ConverterTable table)
+void
+_XtFreeConverterTable(ConverterTable table)
 {
-	register Cardinal i;
-	register ConverterPtr p;
-
-	for (i = 0; i < CONVERTHASHSIZE; i++) {
-	    for (p = table[i]; p; ) {
-		register ConverterPtr next = p->next;
-		XtFree((char*)p);
-		p = next;
-	    }
-	}
-	XtFree((char*)table);
+    register Cardinal i;
+    register ConverterPtr p;
+
+    for (i = 0; i < CONVERTHASHSIZE; i++) {
+        for (p = table[i]; p;) {
+            register ConverterPtr next = p->next;
+
+            XtFree((char *) p);
+            p = next;
+        }
+    }
+    XtFree((char *) table);
 }
 
 /* Data cache hash table */
@@ -152,9 +154,9 @@ void _XtFreeConverterTable(
 typedef struct _CacheRec *CachePtr;
 
 typedef struct _CacheRec {
-    CachePtr	next;
-    XtPointer	tag;
-    int		hash;
+    CachePtr next;
+    XtPointer tag;
+    int hash;
     XtTypeConverter converter;
     unsigned short num_args;
     unsigned int conversion_succeeded:1;
@@ -163,84 +165,86 @@ typedef struct _CacheRec {
     unsigned int must_be_freed:1;
     unsigned int from_is_value:1;
     unsigned int to_is_value:1;
-    XrmValue	from;
-    XrmValue	to;
+    XrmValue from;
+    XrmValue to;
 } CacheRec;
 
 typedef struct _CacheRecExt {
-    CachePtr	*prev;
+    CachePtr *prev;
     XtDestructor destructor;
-    XtPointer	 closure;
-    long	 ref_count;
+    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
+#define CACHEHASHSIZE   256
+#define CACHEHASHMASK   255
 typedef CachePtr CacheHashTable[CACHEHASHSIZE];
 
-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)
+static CacheHashTable cacheHashTable;
+
+void
+_XtTableAddConverter(ConverterTable table,
+                     XrmRepresentation from_type,
+                     XrmRepresentation to_type,
+                     XtTypeConverter converter,
+                     XtConvertArgRec const *convert_args,
+                     Cardinal num_args,
+                     _XtBoolean new_style,
+                     XtCacheType cache_type,
+                     XtDestructor destructor,
+                     _XtBoolean global)
 {
-    register ConverterPtr	*pp;
-    register ConverterPtr	p;
+    register ConverterPtr *pp;
+    register ConverterPtr p;
     XtConvertArgList args;
 
-    pp= &table[ProcHash(from_type, to_type) & CONVERTHASHMASK];
+    pp = &table[ProcHash(from_type, to_type) & CONVERTHASHMASK];
     while ((p = *pp) && (p->from != from_type || p->to != to_type))
-	pp = &p->next;
+        pp = &p->next;
 
     if (p) {
-	*pp = p->next;
-	XtFree((char *)p);
+        *pp = p->next;
+        XtFree((char *) p);
     }
 
-    p = (ConverterPtr) __XtMalloc((Cardinal)(sizeof(ConverterRec) +
-				sizeof(XtConvertArgRec) * num_args));
-    p->next	    = *pp;
+    p = (ConverterPtr) __XtMalloc((Cardinal) (sizeof(ConverterRec) +
+                                              sizeof(XtConvertArgRec) *
+                                              num_args));
+    p->next = *pp;
     *pp = p;
-    p->from	    = from_type;
-    p->to	    = to_type;
-    p->converter    = converter;
-    p->destructor   = destructor;
-    p->num_args     = (unsigned short) num_args;
+    p->from = from_type;
+    p->to = to_type;
+    p->converter = converter;
+    p->destructor = destructor;
+    p->num_args = (unsigned short) num_args;
     XtSetBit(p->global, global);
+
     args = ConvertArgs(p);
     while (num_args--)
-	*args++ = *convert_args++;
+        *args++ = *convert_args++;
     XtSetBit(p->new_style, new_style);
     p->do_ref_count = False;
     if (destructor || (cache_type & 0xff)) {
-	p->cache_type = (char) (cache_type & 0xff);
-	if (cache_type & XtCacheRefCount)
-	    p->do_ref_count = True;
-    } else {
-	p->cache_type = XtCacheNone;
+        p->cache_type = (char) (cache_type & 0xff);
+        if (cache_type & XtCacheRefCount)
+            p->do_ref_count = True;
+    }
+    else {
+        p->cache_type = XtCacheNone;
     }
 }
 
-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
-    )
+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)
 {
     ProcessContext process;
     XtAppContext app;
@@ -254,49 +258,46 @@ 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);
+                         converter, convert_args,
+                         num_args, True, cache_type, destructor, True);
     while (app) {
-	_XtTableAddConverter(app->converterTable, from, to,
-			     converter, convert_args,
-			     num_args, True, cache_type, destructor, True);
-	app = app->next;
+        _XtTableAddConverter(app->converterTable, from, to,
+                             converter, convert_args,
+                             num_args, True, cache_type, destructor, True);
+        app = app->next;
     }
     UNLOCK_PROCESS;
 }
 
-void XtAppSetTypeConverter(
-    XtAppContext	app,
-    register _Xconst char* from_type,
-    register _Xconst char* to_type,
-    XtTypeConverter	converter,
-    XtConvertArgList    convert_args,
-    Cardinal		num_args,
-    XtCacheType		cache_type,
-    XtDestructor	destructor
-    )
+void
+XtAppSetTypeConverter(XtAppContext app,
+                      register _Xconst char *from_type,
+                      register _Xconst char *to_type,
+                      XtTypeConverter converter,
+                      XtConvertArgList convert_args,
+                      Cardinal num_args,
+                      XtCacheType cache_type, XtDestructor destructor)
 {
     LOCK_PROCESS;
     _XtTableAddConverter(app->converterTable,
-	XrmStringToRepresentation(from_type),
-        XrmStringToRepresentation(to_type),
-	converter, convert_args, num_args,
-	True, cache_type, destructor, False);
+                         XrmStringToRepresentation(from_type),
+                         XrmStringToRepresentation(to_type),
+                         converter, convert_args, num_args,
+                         True, cache_type, destructor, False);
     UNLOCK_PROCESS;
 }
 
 /* old interface */
-void XtAddConverter(
-    register _Xconst char* from_type,
-    register _Xconst char* to_type,
-    XtConverter		converter,
-    XtConvertArgList    convert_args,
-    Cardinal		num_args
-    )
+void
+XtAddConverter(register _Xconst char *from_type,
+               register _Xconst char *to_type,
+               XtConverter converter,
+               XtConvertArgList convert_args,
+               Cardinal num_args)
 {
     ProcessContext process;
     XtAppContext app;
@@ -310,175 +311,179 @@ void XtAddConverter(
     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,
-			 (XtTypeConverter)converter, convert_args, num_args,
-			 False, XtCacheAll, (XtDestructor)NULL, True);
+                         (XtTypeConverter) converter, convert_args, num_args,
+                         False, XtCacheAll, (XtDestructor) NULL, True);
     while (app) {
-	_XtTableAddConverter(app->converterTable, from, to,
-			     (XtTypeConverter)converter, convert_args,
-			     num_args, False, XtCacheAll, (XtDestructor)NULL,
-			     True);
-	app = app->next;
+        _XtTableAddConverter(app->converterTable, from, to,
+                             (XtTypeConverter) converter, convert_args,
+                             num_args, False, XtCacheAll, (XtDestructor) NULL,
+                             True);
+        app = app->next;
     }
     UNLOCK_PROCESS;
 }
 
 /* old interface */
-void XtAppAddConverter(
-    XtAppContext	app,
-    register _Xconst char* from_type,
-    register _Xconst char* to_type,
-    XtConverter		converter,
-    XtConvertArgList    convert_args,
-    Cardinal		num_args
-    )
+void
+XtAppAddConverter(XtAppContext app,
+                  register _Xconst char *from_type,
+                  register _Xconst char *to_type,
+                  XtConverter converter,
+                  XtConvertArgList convert_args,
+                  Cardinal num_args)
 {
     LOCK_PROCESS;
     _XtTableAddConverter(app->converterTable,
-	XrmStringToRepresentation(from_type),
-        XrmStringToRepresentation(to_type),
-	(XtTypeConverter)converter, convert_args, num_args,
-	False, XtCacheAll, (XtDestructor)NULL, False);
+                         XrmStringToRepresentation(from_type),
+                         XrmStringToRepresentation(to_type),
+                         (XtTypeConverter) converter, convert_args, num_args,
+                         False, XtCacheAll, (XtDestructor) NULL, False);
     UNLOCK_PROCESS;
 }
 
 static CachePtr
-CacheEnter(
-    Heap*		    heap,
-    register XtTypeConverter converter,
-    register XrmValuePtr    args,
-    Cardinal		    num_args,
-    XrmValuePtr		    from,
-    XrmValuePtr		    to,
-    Boolean		    succeeded,
-    register int	    hash,
-    Boolean		    do_ref,
-    Boolean		    do_free,
-    XtDestructor	    destructor,
-    XtPointer		    closure)
+CacheEnter(Heap *heap,
+           register XtTypeConverter converter,
+           register XrmValuePtr args,
+           Cardinal num_args,
+           XrmValuePtr from,
+           XrmValuePtr to,
+           Boolean succeeded,
+           register int hash,
+           Boolean do_ref,
+           Boolean do_free,
+           XtDestructor destructor,
+           XtPointer closure)
 {
-    register	CachePtr *pHashEntry;
-    register	CachePtr p;
+    register CachePtr *pHashEntry;
+    register CachePtr p;
 
     LOCK_PROCESS;
     pHashEntry = &cacheHashTable[hash & CACHEHASHMASK];
 
     if ((succeeded && destructor) || do_ref) {
-	p = (CachePtr) _XtHeapAlloc(heap, (Cardinal) (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;
+        p = (CachePtr) _XtHeapAlloc(heap, (Cardinal) (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, (Cardinal) (sizeof(CacheRec) +
-					  num_args * sizeof(XrmValue)));
-	p->has_ext = False;
+        p = (CachePtr) _XtHeapAlloc(heap, (Cardinal) (sizeof(CacheRec) +
+                                                      num_args *
+                                                      sizeof(XrmValue)));
+        p->has_ext = False;
     }
     if (!to->addr)
-	succeeded = False;
+        succeeded = False;
     XtSetBit(p->conversion_succeeded, succeeded);
     XtSetBit(p->is_refcounted, do_ref);
     XtSetBit(p->must_be_freed, do_free);
-    p->next	    = *pHashEntry;
+    p->next = *pHashEntry;
     if (p->next && p->next->has_ext)
-	CEXT(p->next)->prev = &p->next;
+        CEXT(p->next)->prev = &p->next;
 
-    *pHashEntry     = p;
-    p->tag	    = (XtPointer)heap;
-    p->hash	    = hash;
-    p->converter    = converter;
-    p->from.size    = from->size;
+    *pHashEntry = p;
+    p->tag = (XtPointer) heap;
+    p->hash = hash;
+    p->converter = converter;
+    p->from.size = from->size;
     if (from->size <= sizeof(p->from.addr)) {
-	p->from_is_value = True;
-	XtMemmove(&p->from.addr, from->addr, from->size);
-    } else {
-	p->from_is_value = False;
-	p->from.addr = (XPointer)_XtHeapAlloc(heap, from->size);
-	(void) memmove((char *)p->from.addr, (char *)from->addr, from->size);
+        p->from_is_value = True;
+        XtMemmove(&p->from.addr, from->addr, from->size);
+    }
+    else {
+        p->from_is_value = False;
+        p->from.addr = (XPointer) _XtHeapAlloc(heap, from->size);
+        (void) memmove((char *) p->from.addr, (char *) from->addr, from->size);
     }
     p->num_args = (unsigned short) num_args;
     if (num_args && args) {
-	XrmValue *pargs = CARGS(p);
-        register    Cardinal i;
-	for (i = 0; i < num_args; i++) {
-	    pargs[i].size = args[i].size;
-	    pargs[i].addr = (XPointer)_XtHeapAlloc(heap, args[i].size);
-	    XtMemmove(pargs[i].addr, args[i].addr, args[i].size);
-	}
+        XrmValue *pargs = CARGS(p);
+        register Cardinal i;
+
+        for (i = 0; i < num_args; i++) {
+            pargs[i].size = args[i].size;
+            pargs[i].addr = (XPointer) _XtHeapAlloc(heap, args[i].size);
+            XtMemmove(pargs[i].addr, args[i].addr, args[i].size);
+        }
     }
     p->to.size = to->size;
     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);
+        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);
     }
     UNLOCK_PROCESS;
     return p;
 }
 
-static void FreeCacheRec(
-    XtAppContext app,
-    CachePtr p,
-    CachePtr *prev)
+static void
+FreeCacheRec(XtAppContext app, CachePtr p, CachePtr * prev)
 {
     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 if (prev) {
-	*prev = p->next;
-	if (p->next && p->next->has_ext)
-	    CEXT(p->next)->prev = prev;
+        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 if (prev) {
+        *prev = p->next;
+        if (p->next && p->next->has_ext)
+            CEXT(p->next)->prev = prev;
     }
     if (p->must_be_freed) {
-	register int i;
-	if (!p->from_is_value)
-	    XtFree(p->from.addr);
-	if ((i = p->num_args)) {
-	    XrmValue *pargs = CARGS(p);
-	    while (i--)
-		XtFree(pargs[i].addr);
-	}
-	if (!p->to_is_value)
-	    XtFree(p->to.addr);
-	XtFree((char*)p);
+        register int i;
+
+        if (!p->from_is_value)
+            XtFree(p->from.addr);
+        if ((i = p->num_args)) {
+            XrmValue *pargs = CARGS(p);
+
+            while (i--)
+                XtFree(pargs[i].addr);
+        }
+        if (!p->to_is_value)
+            XtFree(p->to.addr);
+        XtFree((char *) p);
     }
     /* else on private heap; will free entire heap later */
     UNLOCK_PROCESS;
 }
 
-
-void _XtCacheFlushTag(
-    XtAppContext app,
-    XtPointer	tag)
+void
+_XtCacheFlushTag(XtAppContext app, XtPointer tag)
 {
     int i;
     register CachePtr rec;
@@ -486,20 +491,22 @@ void _XtCacheFlushTag(
     LOCK_PROCESS;
     for (i = CACHEHASHSIZE; --i >= 0;) {
         register CachePtr *prev = &cacheHashTable[i];
-	while ((rec = *prev)) {
-	    if (rec->tag == tag)
-		FreeCacheRec(app, rec, prev);
-	    else
-		prev = &rec->next;
-	}
+
+        while ((rec = *prev)) {
+            if (rec->tag == tag)
+                FreeCacheRec(app, rec, prev);
+            else
+                prev = &rec->next;
+        }
     }
     UNLOCK_PROCESS;
 }
 
 #ifdef DEBUG
-#include	<stdio.h>
+#include        <stdio.h>
 
-void _XtConverterCacheStats(void)
+void
+_XtConverterCacheStats(void)
 {
     register Cardinal i;
     register CachePtr p;
@@ -507,193 +514,201 @@ void _XtConverterCacheStats(void)
 
     LOCK_PROCESS;
     for (i = 0; i < CACHEHASHSIZE; i++) {
-	p = cacheHashTable[i];
-	if (p) {
-	    for (entries = 0; p; p = p->next) {
-		entries++;
-	    }
-	    (void) fprintf(stdout, "Index: %4d  Entries: %d\n", i, entries);
-	    for (p = cacheHashTable[i]; p; p = p->next) {
-		(void) fprintf(stdout, "    Size: %3d  Refs: %3ld  '",
-			       p->from.size,
-			       p->has_ext ? CEXT(p)->ref_count : 0);
-		(void) fprintf(stdout, "'\n");
-	    }
-	    (void) fprintf(stdout, "\n");
-	}
+        p = cacheHashTable[i];
+        if (p) {
+            for (entries = 0; p; p = p->next) {
+                entries++;
+            }
+            (void) fprintf(stdout, "Index: %4d  Entries: %d\n", i, entries);
+            for (p = cacheHashTable[i]; p; p = p->next) {
+                (void) fprintf(stdout, "    Size: %3d  Refs: %3ld  '",
+                               p->from.size,
+                               p->has_ext ? CEXT(p)->ref_count : 0);
+                (void) fprintf(stdout, "'\n");
+            }
+            (void) fprintf(stdout, "\n");
+        }
     }
     UNLOCK_PROCESS;
 }
 #endif /*DEBUG*/
 
-static Boolean ResourceQuarkToOffset(
-    WidgetClass widget_class,
-    XrmName     name,
-    Cardinal    *offset)
+static Boolean
+ResourceQuarkToOffset(WidgetClass widget_class,
+                      XrmName name,
+                      Cardinal *offset)
 {
-    WidgetClass     wc;
-    Cardinal        i;
+    WidgetClass wc;
+    Cardinal i;
     XrmResourceList res;
 
     for (wc = widget_class; wc; wc = wc->core_class.superclass) {
-	XrmResourceList *resources = (XrmResourceList*) wc->core_class.resources;
-	for (i = 0; i < wc->core_class.num_resources; i++, resources++) {
-	    res = *resources;
-	    if (res->xrm_name == name) {
-		*offset = (Cardinal) (-res->xrm_offset - 1);
-		return True;
-	    }
-	} /* for i in resources */
-    } /* for wc in widget classes */
+        XrmResourceList *resources =
+            (XrmResourceList *) wc->core_class.resources;
+        for (i = 0; i < wc->core_class.num_resources; i++, resources++) {
+            res = *resources;
+            if (res->xrm_name == name) {
+                *offset = (Cardinal) (-res->xrm_offset - 1);
+                return True;
+            }
+        }                       /* for i in resources */
+    }                           /* for wc in widget classes */
     (*offset) = 0;
     return False;
 }
 
-
-static void ComputeArgs(
-    Widget		widget,
-    XtConvertArgList    convert_args,
-    Cardinal		num_args,
-    XrmValuePtr		args)
+static void
+ComputeArgs(Widget widget,
+            XtConvertArgList convert_args,
+            Cardinal num_args,
+            XrmValuePtr args)
 {
-    register Cardinal   i;
-    Cardinal		offset;
-    String              params[1];
-    Cardinal		num_params = 1;
-    Widget		ancestor = NULL;
+    register Cardinal i;
+    Cardinal offset;
+    String params[1];
+    Cardinal num_params = 1;
+    Widget ancestor = NULL;
 
     for (i = 0; i < num_args; i++) {
-	args[i].size = convert_args[i].size;
-	switch (convert_args[i].address_mode) {
-	case XtAddress:
-	    args[i].addr = convert_args[i].address_id;
-	    break;
-
-	case XtBaseOffset:
-	    args[i].addr =
-		(XPointer)((char *)widget + (long)convert_args[i].address_id);
-	    break;
-
-	case XtWidgetBaseOffset:
-	    if (!ancestor) {
-		if (XtIsWidget(widget))
-		    ancestor = widget;
-		else
-		    ancestor = _XtWindowedAncestor(widget);
-	    }
-
-	    args[i].addr =
-		(XPointer)((char *)ancestor + (long)convert_args[i].address_id);
-	    break;
-
-	case XtImmediate:
-	    args[i].addr = (XPointer) &(convert_args[i].address_id);
-	    break;
-
-	case XtProcedureArg:
-	    (*(XtConvertArgProc)convert_args[i].address_id)
-		(widget, &convert_args[i].size, &args[i]);
-	    break;
-
-	case XtResourceString:
-	    /* Convert in place for next usage */
-	    convert_args[i].address_mode = XtResourceQuark;
-	    convert_args[i].address_id =
-	       (XtPointer)(long)XrmStringToQuark((String)convert_args[i].address_id);
-	    /* Fall through */
-
-	case XtResourceQuark:
-	    if (! ResourceQuarkToOffset(widget->core.widget_class,
-		    (XrmQuark)(long) convert_args[i].address_id, &offset)) {
-		params[0]=
-                  XrmQuarkToString((XrmQuark)(long) convert_args[i].address_id);
-               XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		    "invalidResourceName","computeArgs",XtCXtToolkitError,
-		    "Cannot find resource name %s as argument to conversion",
-                     params,&num_params);
-		offset = 0;
-	    }
-	    args[i].addr = (XPointer)((char *)widget + offset);
-	    break;
-	default:
-	    params[0] = XtName(widget);
-	    XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidAddressMode", "computeArgs", XtCXtToolkitError,
-		"Conversion arguments for widget '%s' contain an unsupported address mode",
-			params,&num_params);
-	    args[i].addr = NULL;
-	    args[i].size = 0;
-	} /* switch */
-    } /* for */
-} /* ComputeArgs */
-
-void XtDirectConvert(
-    XtConverter     converter,
-    XrmValuePtr     args,
-    Cardinal	    num_args,
-    register XrmValuePtr from,
-    XrmValuePtr     to)
+        args[i].size = convert_args[i].size;
+        switch (convert_args[i].address_mode) {
+        case XtAddress:
+            args[i].addr = convert_args[i].address_id;
+            break;
+
+        case XtBaseOffset:
+            args[i].addr =
+                (XPointer) ((char *) widget +
+                            (long) convert_args[i].address_id);
+            break;
+
+        case XtWidgetBaseOffset:
+            if (!ancestor) {
+                if (XtIsWidget(widget))
+                    ancestor = widget;
+                else
+                    ancestor = _XtWindowedAncestor(widget);
+            }
+
+            args[i].addr =
+                (XPointer) ((char *) ancestor +
+                            (long) convert_args[i].address_id);
+            break;
+
+        case XtImmediate:
+            args[i].addr = (XPointer) &(convert_args[i].address_id);
+            break;
+
+        case XtProcedureArg:
+            (*(XtConvertArgProc) convert_args[i].address_id)
+                (widget, &convert_args[i].size, &args[i]);
+            break;
+
+        case XtResourceString:
+            /* Convert in place for next usage */
+            convert_args[i].address_mode = XtResourceQuark;
+            convert_args[i].address_id =
+                (XtPointer) (long) XrmStringToQuark((String) convert_args[i].
+                                                    address_id);
+            /* Fall through */
+
+        case XtResourceQuark:
+            if (!ResourceQuarkToOffset(widget->core.widget_class,
+                                       (XrmQuark) (long) convert_args[i].
+                                       address_id, &offset)) {
+                params[0] =
+                    XrmQuarkToString((XrmQuark) (long) convert_args[i].
+                                     address_id);
+                XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                                "invalidResourceName", "computeArgs",
+                                XtCXtToolkitError,
+                                "Cannot find resource name %s as argument to conversion",
+                                params, &num_params);
+                offset = 0;
+            }
+            args[i].addr = (XPointer) ((char *) widget + offset);
+            break;
+        default:
+            params[0] = XtName(widget);
+            XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                            "invalidAddressMode", "computeArgs",
+                            XtCXtToolkitError,
+                            "Conversion arguments for widget '%s' contain an unsupported address mode",
+                            params, &num_params);
+            args[i].addr = NULL;
+            args[i].size = 0;
+        }                       /* switch */
+    }                           /* for */
+}                               /* ComputeArgs */
+
+void
+XtDirectConvert(XtConverter converter,
+                XrmValuePtr args,
+                Cardinal num_args,
+                register XrmValuePtr from,
+                XrmValuePtr to)
 {
-    register CachePtr   p;
-    register int	hash;
-    register Cardinal   i;
+    register CachePtr p;
+    register int hash;
+    register Cardinal i;
 
     LOCK_PROCESS;
     /* Try to find cache entry for conversion */
     hash = HashCode(converter, from);
-    if (from->size > 1) hash += ((char *) from->addr)[1];
+    if (from->size > 1)
+        hash += ((char *) from->addr)[1];
 
     for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next) {
-	if ((p->hash == hash)
-	 && (p->converter == (XtTypeConverter)converter)
-	 && (p->from.size == from->size)
-	 && !(p->from_is_value ?
-	      XtMemcmp(&p->from.addr, from->addr, from->size) :
-	      memcmp((const void *)p->from.addr, (const void *)from->addr, from->size))
-         && (p->num_args == num_args)) {
-	    if ((i = num_args)) {
-		XrmValue *pargs = CARGS(p);
-		/* Are all args the same data ? */
-		while (i) {
-		    i--; /* do not move to while test, broken compilers */
-		    if (pargs[i].size != args[i].size ||
-			XtMemcmp(pargs[i].addr, args[i].addr, args[i].size)) {
-			i++;
-			break;
-		    }
-		}
-	    }
-	    if (!i) {
-		/* Perfect match */
-		to->size = p->to.size;
-		if (p->to_is_value)
-		    to->addr = (XPointer)&p->to.addr;
-		else
-		    to->addr = p->to.addr;
-		UNLOCK_PROCESS;
-		return;
-	    }
-	}
+        if ((p->hash == hash)
+            && (p->converter == (XtTypeConverter) converter)
+            && (p->from.size == from->size)
+            && !(p->from_is_value ?
+                 XtMemcmp(&p->from.addr, from->addr, from->size) :
+                 memcmp((const void *) p->from.addr, (const void *) from->addr,
+                        from->size))
+            && (p->num_args == num_args)) {
+            if ((i = num_args)) {
+                XrmValue *pargs = CARGS(p);
+
+                /* Are all args the same data ? */
+                while (i) {
+                    i--;        /* do not move to while test, broken compilers */
+                    if (pargs[i].size != args[i].size ||
+                        XtMemcmp(pargs[i].addr, args[i].addr, args[i].size)) {
+                        i++;
+                        break;
+                    }
+                }
+            }
+            if (!i) {
+                /* Perfect match */
+                to->size = p->to.size;
+                if (p->to_is_value)
+                    to->addr = (XPointer) &p->to.addr;
+                else
+                    to->addr = p->to.addr;
+                UNLOCK_PROCESS;
+                return;
+            }
+        }
     }
 
     /* Didn't find it, call converter procedure and entry result in cache */
     (*to).size = 0;
     (*to).addr = NULL;
-    (*converter)(args, &num_args, from, to);
+    (*converter) (args, &num_args, from, to);
     /* This memory can never be freed since we don't know the Display
      * or app context from which to compute the persistance */
     {
-	CacheEnter(&globalHeap, (XtTypeConverter)converter, args, num_args,
-		   from, to, (to->addr != NULL), hash, False, False,
-		   (XtDestructor)NULL, NULL);
+        CacheEnter(&globalHeap, (XtTypeConverter) converter, args, num_args,
+                   from, to, (to->addr != NULL), hash, False, False,
+                   (XtDestructor) NULL, NULL);
     }
     UNLOCK_PROCESS;
 }
 
-
-static ConverterPtr GetConverterEntry(
-    XtAppContext app,
-    XtTypeConverter converter)
+static ConverterPtr
+GetConverterEntry(XtAppContext app, XtTypeConverter converter)
 {
     Cardinal entry;
     register ConverterPtr cP;
@@ -703,157 +718,165 @@ static ConverterPtr GetConverterEntry(
     converterTable = app->converterTable;
     cP = NULL;
     for (entry = 0; (entry < CONVERTHASHSIZE) && !cP; entry++) {
-	cP = converterTable[entry];
-	while (cP && (cP->converter != converter)) cP = cP->next;
+        cP = converterTable[entry];
+        while (cP && (cP->converter != converter))
+            cP = cP->next;
     }
     UNLOCK_PROCESS;
     return cP;
 }
 
-
 static Boolean
-CallConverter(
-    Display*	    dpy,
-    XtTypeConverter converter,
-    XrmValuePtr     args,
-    Cardinal	    num_args,
-    register XrmValuePtr from,
-    XrmValuePtr     to,
-    XtCacheRef	    *cache_ref_return,
-    register ConverterPtr cP)
+CallConverter(Display *dpy,
+              XtTypeConverter converter,
+              XrmValuePtr args,
+              Cardinal num_args,
+              register XrmValuePtr from,
+              XrmValuePtr to,
+              XtCacheRef *cache_ref_return,
+              register ConverterPtr cP)
 {
     CachePtr p;
-    int	hash;
+    int hash;
     Boolean retval;
 
     if (!cP || ((cP->cache_type == XtCacheNone) && !cP->destructor)) {
-	XtPointer closure;
-	if (cache_ref_return) *cache_ref_return = NULL;
-	retval = (*(XtTypeConverter)converter)
-	    (dpy, args, &num_args, from, to, &closure);
-	return retval;
+        XtPointer closure;
+
+        if (cache_ref_return)
+            *cache_ref_return = NULL;
+        retval = (*(XtTypeConverter) converter)
+            (dpy, args, &num_args, from, to, &closure);
+        return retval;
     }
 
     LOCK_PROCESS;
     /* Try to find cache entry for conversion */
     hash = HashCode(converter, from);
-    if (from->size > 1) hash += ((char *) from->addr)[1];
+    if (from->size > 1)
+        hash += ((char *) from->addr)[1];
 
     if (cP->cache_type != XtCacheNone) {
-	for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next){
-	    if ((p->hash == hash)
-	     && (p->converter == converter)
-	     && (p->from.size == from->size)
-	     && !(p->from_is_value ?
-		  XtMemcmp(&p->from.addr, from->addr, from->size) :
-		  memcmp((const void *)p->from.addr, (const void *)from->addr, from->size))
-	     && (p->num_args == num_args)) {
-		Cardinal i;
-		if ((i = num_args)) {
-		    XrmValue *pargs = CARGS(p);
-		    /* Are all args the same data ? */
-		    while (i) {
-			i--; /* do not move to while test, broken compilers */
-			if (pargs[i].size != args[i].size ||
-			    XtMemcmp(pargs[i].addr, args[i].addr, args[i].size)){
-			    i++;
-			    break;
-			}
-		    }
-		}
-		if (!i) {
-		    /* Perfect match */
-		    if (p->conversion_succeeded) {
-			if (to->addr) {	/* new-style call */
-			    if (to->size < p->to.size) {
-				to->size = p->to.size;
-				UNLOCK_PROCESS;
-				return False;
-			    }
-			    to->size = p->to.size;
-			    if (p->to_is_value) {
-				XtMemmove(to->addr, &p->to.addr,
-					  to->size);
-			    } else {
-				(void) memmove((char *)to->addr,
-					       (char *)p->to.addr, to->size);
-			    }
-			} else {	/* old-style call */
-			    to->size = p->to.size;
-			    if (p->to_is_value)
-				to->addr = (XPointer)&p->to.addr;
-			    else
-				to->addr = p->to.addr;
-			}
-		    }
-		    if (p->is_refcounted) {
-			CEXT(p)->ref_count++;
-			if (cache_ref_return)
-			    *cache_ref_return = (XtCacheRef)p;
-			else
-			    p->is_refcounted = False;
-		    }
-		    else {
-			if (cache_ref_return)
-			    *cache_ref_return = NULL;
-		    }
-		    retval = (p->conversion_succeeded);
-		    UNLOCK_PROCESS;
-		    return retval;
-		}
-	    }
-	}
+        for (p = cacheHashTable[hash & CACHEHASHMASK]; p; p = p->next) {
+            if ((p->hash == hash)
+                && (p->converter == converter)
+                && (p->from.size == from->size)
+                && !(p->from_is_value ?
+                     XtMemcmp(&p->from.addr, from->addr, from->size) :
+                     memcmp((const void *) p->from.addr,
+                            (const void *) from->addr, from->size))
+                && (p->num_args == num_args)) {
+                Cardinal i;
+
+                if ((i = num_args)) {
+                    XrmValue *pargs = CARGS(p);
+
+                    /* Are all args the same data ? */
+                    while (i) {
+                        i--;    /* do not move to while test, broken compilers */
+                        if (pargs[i].size != args[i].size ||
+                            XtMemcmp(pargs[i].addr, args[i].addr,
+                                     args[i].size)) {
+                            i++;
+                            break;
+                        }
+                    }
+                }
+                if (!i) {
+                    /* Perfect match */
+                    if (p->conversion_succeeded) {
+                        if (to->addr) { /* new-style call */
+                            if (to->size < p->to.size) {
+                                to->size = p->to.size;
+                                UNLOCK_PROCESS;
+                                return False;
+                            }
+                            to->size = p->to.size;
+                            if (p->to_is_value) {
+                                XtMemmove(to->addr, &p->to.addr, to->size);
+                            }
+                            else {
+                                (void) memmove((char *) to->addr,
+                                               (char *) p->to.addr, to->size);
+                            }
+                        }
+                        else {  /* old-style call */
+                            to->size = p->to.size;
+                            if (p->to_is_value)
+                                to->addr = (XPointer) &p->to.addr;
+                            else
+                                to->addr = p->to.addr;
+                        }
+                    }
+                    if (p->is_refcounted) {
+                        CEXT(p)->ref_count++;
+                        if (cache_ref_return)
+                            *cache_ref_return = (XtCacheRef) p;
+                        else
+                            p->is_refcounted = False;
+                    }
+                    else {
+                        if (cache_ref_return)
+                            *cache_ref_return = NULL;
+                    }
+                    retval = (p->conversion_succeeded);
+                    UNLOCK_PROCESS;
+                    return retval;
+                }
+            }
+        }
     }
 
     /* No cache entry, call converter procedure and enter result in cache */
     {
-	Heap *heap;
-	XtPointer closure = NULL;
-	unsigned int supplied_size = to->size;
-	Boolean do_ref = cP->do_ref_count && cache_ref_return;
-	Boolean do_free = False;
-	retval =
-	    (*(XtTypeConverter)converter)(dpy, args, &num_args, from, to, &closure);
-
-	if (retval == False && supplied_size < to->size) {
-	    /* programmer error: caller must allocate sufficient storage */
-	    if (cache_ref_return)
-		*cache_ref_return = NULL;
-	    UNLOCK_PROCESS;
-	    return False;
-	}
-
-	if ((cP->cache_type == XtCacheNone) || do_ref) {
-	    heap = NULL;
-	    do_free = True;
-	}
-	else if (cP->cache_type == XtCacheByDisplay)
-	    heap = &_XtGetPerDisplay(dpy)->heap;
-	else if (cP->global)
-	    heap = &globalHeap;
-	else
-	    heap = &XtDisplayToApplicationContext(dpy)->heap;
-
-	p = CacheEnter(heap, converter, args, num_args, from, to, retval,
-		       hash, do_ref, do_free, cP->destructor, closure);
-	if (do_ref)
-	    *cache_ref_return = (XtCacheRef)p;
-	else if (cache_ref_return)
-	    *cache_ref_return = NULL;
-	UNLOCK_PROCESS;
-	return retval;
+        Heap *heap;
+        XtPointer closure = NULL;
+        unsigned int supplied_size = to->size;
+        Boolean do_ref = cP->do_ref_count && cache_ref_return;
+        Boolean do_free = False;
+
+        retval =
+            (*(XtTypeConverter) converter) (dpy, args, &num_args, from, to,
+                                            &closure);
+
+        if (retval == False && supplied_size < to->size) {
+            /* programmer error: caller must allocate sufficient storage */
+            if (cache_ref_return)
+                *cache_ref_return = NULL;
+            UNLOCK_PROCESS;
+            return False;
+        }
+
+        if ((cP->cache_type == XtCacheNone) || do_ref) {
+            heap = NULL;
+            do_free = True;
+        }
+        else if (cP->cache_type == XtCacheByDisplay)
+            heap = &_XtGetPerDisplay(dpy)->heap;
+        else if (cP->global)
+            heap = &globalHeap;
+        else
+            heap = &XtDisplayToApplicationContext(dpy)->heap;
+
+        p = CacheEnter(heap, converter, args, num_args, from, to, retval,
+                       hash, do_ref, do_free, cP->destructor, closure);
+        if (do_ref)
+            *cache_ref_return = (XtCacheRef) p;
+        else if (cache_ref_return)
+            *cache_ref_return = NULL;
+        UNLOCK_PROCESS;
+        return retval;
     }
 }
 
 Boolean
-XtCallConverter(
-    Display*	    dpy,
-    XtTypeConverter converter,
-    XrmValuePtr     args,
-    Cardinal	    num_args,
-    register XrmValuePtr from,
-    XrmValuePtr     to,
-    XtCacheRef	    *cache_ref_return)
+XtCallConverter(Display *dpy,
+                XtTypeConverter converter,
+                XrmValuePtr args,
+                Cardinal num_args,
+                register XrmValuePtr from,
+                XrmValuePtr to,
+                XtCacheRef *cache_ref_return)
 {
     ConverterPtr cP;
     Boolean retval;
@@ -861,136 +884,145 @@ XtCallConverter(
 
     LOCK_APP(app);
     if ((cP = GetConverterEntry(app, converter)) == NULL) {
-	XtAppSetTypeConverter(XtDisplayToApplicationContext(dpy),
-			      "_XtUnk1", "_XtUnk2",
-			      converter, NULL, 0,
-			      XtCacheAll, NULL);
-	cP = GetConverterEntry(app, converter);
+        XtAppSetTypeConverter(XtDisplayToApplicationContext(dpy),
+                              "_XtUnk1", "_XtUnk2",
+                              converter, NULL, 0, XtCacheAll, NULL);
+        cP = GetConverterEntry(app, converter);
     }
     retval = CallConverter(dpy, converter, args, num_args, from, to,
-			    cache_ref_return, cP);
+                           cache_ref_return, cP);
     UNLOCK_APP(app);
     return retval;
 }
 
-Boolean _XtConvert(
-             Widget		widget,
-    register XrmRepresentation	from_type,
-	     XrmValuePtr	from,
-    register XrmRepresentation	to_type,
-    register XrmValuePtr	to,
-    XtCacheRef			*cache_ref_return)
+Boolean
+_XtConvert(Widget widget,
+           register XrmRepresentation from_type,
+           XrmValuePtr from,
+           register XrmRepresentation to_type,
+           register XrmValuePtr to,
+           XtCacheRef *cache_ref_return)
 {
-    XtAppContext	app = XtWidgetToApplicationContext(widget);
-    register ConverterPtr	p;
-    Cardinal		num_args;
-    XrmValue		*args;
+    XtAppContext app = XtWidgetToApplicationContext(widget);
+    register ConverterPtr p;
+    Cardinal num_args;
+    XrmValue *args;
 
     /* Look for type converter */
     LOCK_PROCESS;
     p = app->converterTable[ProcHash(from_type, to_type) & CONVERTHASHMASK];
     for (; p; p = p->next) {
-	if (from_type == p->from && to_type == p->to) {
-	    Boolean retval = False;
-	    /* Compute actual arguments from widget and arg descriptor */
-	    num_args = p->num_args;
-	    if (num_args != 0) {
-		args = (XrmValue*)
-		    ALLOCATE_LOCAL( num_args * sizeof (XrmValue) );
-		if (!args) _XtAllocError("alloca");
-		ComputeArgs(widget, ConvertArgs(p), num_args, args);
-	    } else args = NULL;
-	    if (p->new_style) {
-		retval =
-		    CallConverter(XtDisplayOfObject(widget),
-				     p->converter, args, num_args,
-				     from, to, cache_ref_return, p);
-	    }
-	    else { /* is old-style (non-display) converter */
-		XrmValue tempTo;
-		XtDirectConvert((XtConverter)p->converter, args, num_args,
-				from, &tempTo);
-		if (cache_ref_return)
-		    *cache_ref_return = NULL;
-		if (tempTo.addr) {
-		    if (to->addr) {	/* new-style caller */
-			if (to->size >= tempTo.size) {
-			    if (to_type == _XtQString)
-				*(String*)(to->addr) = tempTo.addr;
-			    else {
-				XtMemmove(to->addr, tempTo.addr,
-					  tempTo.size);
-			    }
-			    retval = True;
-			}
-			to->size = tempTo.size;
-		    } else {		/* old-style caller */
-			*to = tempTo;
-			retval = True;
-		    }
-		}
-	    }
-	    if (args) DEALLOCATE_LOCAL( (XtPointer)args );
-	    UNLOCK_PROCESS;
-	    return retval;
-	}
+        if (from_type == p->from && to_type == p->to) {
+            Boolean retval = False;
+
+            /* Compute actual arguments from widget and arg descriptor */
+            num_args = p->num_args;
+            if (num_args != 0) {
+                args = (XrmValue *)
+                    ALLOCATE_LOCAL(num_args * sizeof(XrmValue));
+                if (!args)
+                    _XtAllocError("alloca");
+                ComputeArgs(widget, ConvertArgs(p), num_args, args);
+            }
+            else
+                args = NULL;
+            if (p->new_style) {
+                retval =
+                    CallConverter(XtDisplayOfObject(widget),
+                                  p->converter, args, num_args,
+                                  from, to, cache_ref_return, p);
+            }
+            else {              /* is old-style (non-display) converter */
+                XrmValue tempTo;
+
+                XtDirectConvert((XtConverter) p->converter, args, num_args,
+                                from, &tempTo);
+                if (cache_ref_return)
+                    *cache_ref_return = NULL;
+                if (tempTo.addr) {
+                    if (to->addr) {     /* new-style caller */
+                        if (to->size >= tempTo.size) {
+                            if (to_type == _XtQString)
+                                *(String *) (to->addr) = tempTo.addr;
+                            else {
+                                XtMemmove(to->addr, tempTo.addr, tempTo.size);
+                            }
+                            retval = True;
+                        }
+                        to->size = tempTo.size;
+                    }
+                    else {      /* old-style caller */
+                        *to = tempTo;
+                        retval = True;
+                    }
+                }
+            }
+            if (args)
+                DEALLOCATE_LOCAL((XtPointer) args);
+            UNLOCK_PROCESS;
+            return retval;
+        }
     }
 
     {
-	String params[2];
-	Cardinal num_params = 2;
-	params[0] = XrmRepresentationToString(from_type);
-	params[1] = XrmRepresentationToString(to_type);
-	XtAppWarningMsg(app, "typeConversionError", "noConverter", XtCXtToolkitError,
-	     "No type converter registered for '%s' to '%s' conversion.",
-             params, &num_params);
+        String params[2];
+        Cardinal num_params = 2;
+
+        params[0] = XrmRepresentationToString(from_type);
+        params[1] = XrmRepresentationToString(to_type);
+        XtAppWarningMsg(app, "typeConversionError", "noConverter",
+                        XtCXtToolkitError,
+                        "No type converter registered for '%s' to '%s' conversion.",
+                        params, &num_params);
     }
     UNLOCK_PROCESS;
     return False;
 }
 
-void XtConvert(
-    Widget	widget,
-    _Xconst char* from_type_str,
-    XrmValuePtr	from,
-    _Xconst char* to_type_str,
-    XrmValuePtr	to)
+void
+XtConvert(Widget widget,
+          _Xconst char *from_type_str,
+          XrmValuePtr from,
+          _Xconst char *to_type_str,
+          XrmValuePtr to)
 {
-    XrmQuark    from_type, to_type;
+    XrmQuark from_type, to_type;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     from_type = XrmStringToRepresentation(from_type_str);
     to_type = XrmStringToRepresentation(to_type_str);
     if (from_type != to_type) {
-	/*  It's not safe to ref count these resources, 'cause we
-	    don't know what older clients may have assumed about
-	    the resource lifetimes.
-	XtCacheRef ref;
-	*/
-	to->addr = NULL;
-	to->size = 0;
-	_XtConvert(widget, from_type, from, to_type, to, /*&ref*/ NULL);
-	/*
-	if (ref) {
-	    XtAddCallback( widget, XtNdestroyCallback,
-			   XtCallbackReleaseCacheRef, (XtPointer)ref );
-	}
-	*/
+        /*  It's not safe to ref count these resources, 'cause we
+           don't know what older clients may have assumed about
+           the resource lifetimes.
+           XtCacheRef ref;
+         */
+        to->addr = NULL;
+        to->size = 0;
+        _XtConvert(widget, from_type, from, to_type, to, /*&ref */ NULL);
+        /*
+           if (ref) {
+           XtAddCallback( widget, XtNdestroyCallback,
+           XtCallbackReleaseCacheRef, (XtPointer)ref );
+           }
+         */
     }
     else
-	(*to) = *from;
+        (*to) = *from;
     UNLOCK_APP(app);
 }
 
-Boolean XtConvertAndStore(
-    Widget	object,
-    _Xconst char* from_type_str,
-    XrmValuePtr	from,
-    _Xconst char* to_type_str,
-    XrmValuePtr	to)
+Boolean
+XtConvertAndStore(Widget object,
+                  _Xconst char *from_type_str,
+                  XrmValuePtr from,
+                  _Xconst char *to_type_str,
+                  XrmValuePtr to)
 {
-    XrmQuark    from_type, to_type;
+    XrmQuark from_type, to_type;
+
     WIDGET_TO_APPCON(object);
 
     LOCK_APP(app);
@@ -998,98 +1030,97 @@ Boolean XtConvertAndStore(
     from_type = XrmStringToRepresentation(from_type_str);
     to_type = XrmStringToRepresentation(to_type_str);
     if (from_type != to_type) {
-	static XtPointer local_valueP = NULL;
-	static Cardinal local_valueS = 128;
-	XtCacheRef ref;
-	Boolean local = False;
-	do {
-	    if (!to->addr) {
-		if (!local_valueP)
-		    local_valueP = _XtHeapAlloc(&globalHeap, local_valueS);
-		to->addr = local_valueP;
-		to->size = local_valueS;
-		local = True;
-	    }
-	    if (!_XtConvert(object, from_type, from, to_type, to, &ref)) {
-		if (local && (to->size > local_valueS)) {
-		    to->addr =
-			local_valueP = _XtHeapAlloc(&globalHeap, to->size);
-		    local_valueS = to->size;
-		    continue;
-		} else {
-		    if (local) {
-			to->addr = NULL;
-			to->size = 0;
-		    }
-		    UNLOCK_PROCESS;
-		    UNLOCK_APP(app);
-		    return False;
-		}
-	    }
-	    if (ref) {
-		XtAddCallback( object, XtNdestroyCallback,
-			       XtCallbackReleaseCacheRef, (XtPointer)ref );
-	    }
-	    UNLOCK_PROCESS;
-	    UNLOCK_APP(app);
-	    return True;
-	} while (local /* && local_valueS < to->size */);
+        static XtPointer local_valueP = NULL;
+        static Cardinal local_valueS = 128;
+        XtCacheRef ref;
+        Boolean local = False;
+
+        do {
+            if (!to->addr) {
+                if (!local_valueP)
+                    local_valueP = _XtHeapAlloc(&globalHeap, local_valueS);
+                to->addr = local_valueP;
+                to->size = local_valueS;
+                local = True;
+            }
+            if (!_XtConvert(object, from_type, from, to_type, to, &ref)) {
+                if (local && (to->size > local_valueS)) {
+                    to->addr =
+                        local_valueP = _XtHeapAlloc(&globalHeap, to->size);
+                    local_valueS = to->size;
+                    continue;
+                }
+                else {
+                    if (local) {
+                        to->addr = NULL;
+                        to->size = 0;
+                    }
+                    UNLOCK_PROCESS;
+                    UNLOCK_APP(app);
+                    return False;
+                }
+            }
+            if (ref) {
+                XtAddCallback(object, XtNdestroyCallback,
+                              XtCallbackReleaseCacheRef, (XtPointer) ref);
+            }
+            UNLOCK_PROCESS;
+            UNLOCK_APP(app);
+            return True;
+        } while (local /* && local_valueS < to->size */ );
     }
     if (to->addr) {
-	if (to->size < from->size) {
-	    to->size = from->size;
-	    UNLOCK_PROCESS;
-	    UNLOCK_APP(app);
-	    return False;
-	}
-	(void) memmove(to->addr, from->addr, from->size );
-	to->size = from->size;
-    } else			/* from_type == to_type */
-	*to = *from;
+        if (to->size < from->size) {
+            to->size = from->size;
+            UNLOCK_PROCESS;
+            UNLOCK_APP(app);
+            return False;
+        }
+        (void) memmove(to->addr, from->addr, from->size);
+        to->size = from->size;
+    }
+    else                        /* from_type == to_type */
+        *to = *from;
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return True;
 }
 
-void XtAppReleaseCacheRefs(
-    XtAppContext app,
-    XtCacheRef *refs)
+void
+XtAppReleaseCacheRefs(XtAppContext app, XtCacheRef *refs)
 {
     register CachePtr *r;
     register CachePtr p;
 
     LOCK_APP(app);
     LOCK_PROCESS;
-    for (r = (CachePtr*)refs; (p = *r); r++) {
-	if (p->is_refcounted && --(CEXT(p)->ref_count) == 0) {
-	    FreeCacheRec(app, p, NULL);
-	}
+    for (r = (CachePtr *) refs; (p = *r); r++) {
+        if (p->is_refcounted && --(CEXT(p)->ref_count) == 0) {
+            FreeCacheRec(app, p, NULL);
+        }
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-
-/* ARGSUSED */
-void XtCallbackReleaseCacheRefList(
-    Widget widget,		/* unused */
-    XtPointer closure,
-    XtPointer call_data)	/* unused */
+void
+XtCallbackReleaseCacheRefList(Widget widget,
+                              XtPointer closure,
+                              XtPointer call_data _X_UNUSED)
 {
-    XtAppReleaseCacheRefs( XtWidgetToApplicationContext(widget),
-			   (XtCacheRef*)closure );
+    XtAppReleaseCacheRefs(XtWidgetToApplicationContext(widget),
+                          (XtCacheRef *) closure);
     XtFree(closure);
 }
 
-
-/* ARGSUSED */
-void XtCallbackReleaseCacheRef(
-    Widget widget,		/* unused */
-    XtPointer closure,
-    XtPointer call_data)	/* unused */
+void
+XtCallbackReleaseCacheRef(Widget widget,
+                          XtPointer closure,
+                          XtPointer call_data _X_UNUSED)
 {
     XtCacheRef cache_refs[2];
-    cache_refs[0] = (XtCacheRef)closure;
+
+    cache_refs[0] = (XtCacheRef) closure;
     cache_refs[1] = NULL;
-    XtAppReleaseCacheRefs( XtWidgetToApplicationContext(widget), cache_refs );
+    XtAppReleaseCacheRefs(XtWidgetToApplicationContext(widget), cache_refs);
 }
diff --git a/src/Converters.c b/src/Converters.c
index fbfa076..4c27623 100644
--- a/src/Converters.c
+++ b/src/Converters.c
@@ -68,20 +68,19 @@ in this Software without prior written authorization from The Open Group.
 
 */
 
-/*LINTLIBRARY*/
 /* Conversion.c - implementations of resource type conversion procs */
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
-#include	"IntrinsicI.h"
-#include	"StringDefs.h"
-#include	"Shell.h"
-#include	<stdio.h>
+#include        "IntrinsicI.h"
+#include        "StringDefs.h"
+#include        "Shell.h"
+#include        <stdio.h>
 #include        <X11/cursorfont.h>
-#include	<X11/keysym.h>
-#include	<X11/Xlocale.h>
-#include	<errno.h>	/* for StringToDirectoryString */
+#include        <X11/keysym.h>
+#include        <X11/Xlocale.h>
+#include        <errno.h>       /* for StringToDirectoryString */
 
 #define IsNewline(str) ((str) == '\n')
 #define IsWhitespace(str) ((str)== ' ' || (str) == '\t')
@@ -92,1474 +91,1510 @@ static _Xconst _XtString XtNmissingCharsetList = "missingCharsetList";
 
 /* Representation types */
 
-#define XtQAtom			XrmPermStringToQuark(XtRAtom)
-#define XtQCommandArgArray	XrmPermStringToQuark(XtRCommandArgArray)
-#define XtQCursor		XrmPermStringToQuark(XtRCursor)
-#define XtQDirectoryString	XrmPermStringToQuark(XtRDirectoryString)
-#define XtQDisplay		XrmPermStringToQuark(XtRDisplay)
-#define XtQFile			XrmPermStringToQuark(XtRFile)
-#define XtQFloat		XrmPermStringToQuark(XtRFloat)
-#define XtQInitialState		XrmPermStringToQuark(XtRInitialState)
-#define XtQPixmap		XrmPermStringToQuark(XtRPixmap)
-#define XtQRestartStyle 	XrmPermStringToQuark(XtRRestartStyle)
-#define XtQShort		XrmPermStringToQuark(XtRShort)
-#define XtQUnsignedChar		XrmPermStringToQuark(XtRUnsignedChar)
-#define XtQVisual		XrmPermStringToQuark(XtRVisual)
-
-static XrmQuark  XtQBool;
-static XrmQuark  XtQBoolean;
-static XrmQuark  XtQColor;
-static XrmQuark  XtQDimension;
-static XrmQuark  XtQFont;
-static XrmQuark  XtQFontSet;
-static XrmQuark  XtQFontStruct;
-static XrmQuark  XtQGravity;
-static XrmQuark  XtQInt;
-static XrmQuark  XtQPixel;
-static XrmQuark  XtQPosition;
-XrmQuark  _XtQString;
-
-void _XtConvertInitialize(void)
+#define XtQAtom                 XrmPermStringToQuark(XtRAtom)
+#define XtQCommandArgArray      XrmPermStringToQuark(XtRCommandArgArray)
+#define XtQCursor               XrmPermStringToQuark(XtRCursor)
+#define XtQDirectoryString      XrmPermStringToQuark(XtRDirectoryString)
+#define XtQDisplay              XrmPermStringToQuark(XtRDisplay)
+#define XtQFile                 XrmPermStringToQuark(XtRFile)
+#define XtQFloat                XrmPermStringToQuark(XtRFloat)
+#define XtQInitialState         XrmPermStringToQuark(XtRInitialState)
+#define XtQPixmap               XrmPermStringToQuark(XtRPixmap)
+#define XtQRestartStyle         XrmPermStringToQuark(XtRRestartStyle)
+#define XtQShort                XrmPermStringToQuark(XtRShort)
+#define XtQUnsignedChar         XrmPermStringToQuark(XtRUnsignedChar)
+#define XtQVisual               XrmPermStringToQuark(XtRVisual)
+
+static XrmQuark XtQBool;
+static XrmQuark XtQBoolean;
+static XrmQuark XtQColor;
+static XrmQuark XtQDimension;
+static XrmQuark XtQFont;
+static XrmQuark XtQFontSet;
+static XrmQuark XtQFontStruct;
+static XrmQuark XtQGravity;
+static XrmQuark XtQInt;
+static XrmQuark XtQPixel;
+static XrmQuark XtQPosition;
+XrmQuark _XtQString;
+
+void
+_XtConvertInitialize(void)
 {
-    XtQBool		= XrmPermStringToQuark(XtRBool);
-    XtQBoolean		= XrmPermStringToQuark(XtRBoolean);
-    XtQColor		= XrmPermStringToQuark(XtRColor);
-    XtQDimension	= XrmPermStringToQuark(XtRDimension);
-    XtQFont		= XrmPermStringToQuark(XtRFont);
-    XtQFontSet		= XrmPermStringToQuark(XtRFontSet);
-    XtQFontStruct	= XrmPermStringToQuark(XtRFontStruct);
-    XtQGravity		= XrmPermStringToQuark(XtRGravity);
-    XtQInt		= XrmPermStringToQuark(XtRInt);
-    XtQPixel		= XrmPermStringToQuark(XtRPixel);
-    XtQPosition		= XrmPermStringToQuark(XtRPosition);
-    _XtQString		= XrmPermStringToQuark(XtRString);
+    XtQBool = XrmPermStringToQuark(XtRBool);
+    XtQBoolean = XrmPermStringToQuark(XtRBoolean);
+    XtQColor = XrmPermStringToQuark(XtRColor);
+    XtQDimension = XrmPermStringToQuark(XtRDimension);
+    XtQFont = XrmPermStringToQuark(XtRFont);
+    XtQFontSet = XrmPermStringToQuark(XtRFontSet);
+    XtQFontStruct = XrmPermStringToQuark(XtRFontStruct);
+    XtQGravity = XrmPermStringToQuark(XtRGravity);
+    XtQInt = XrmPermStringToQuark(XtRInt);
+    XtQPixel = XrmPermStringToQuark(XtRPixel);
+    XtQPosition = XrmPermStringToQuark(XtRPosition);
+    _XtQString = XrmPermStringToQuark(XtRString);
 }
 
-#define	donestr(type, value, tstr) \
-	{							\
-	    if (toVal->addr != NULL) {				\
-		if (toVal->size < sizeof(type)) {		\
-		    toVal->size = sizeof(type);			\
-		    XtDisplayStringConversionWarning(dpy, 	\
-			(char*) fromVal->addr, tstr);		\
-		    return False;				\
-		}						\
-		*(type*)(toVal->addr) = (type) (value);		\
-	    }							\
-	    else {						\
-		static type static_val;				\
-		static_val = (type) (value);			\
-		toVal->addr = (XPointer)&static_val;		\
-	    }							\
-	    toVal->size = sizeof(type);				\
-	    return True;					\
-	}
-
-#define	done(type, value) \
-	{							\
-	    if (toVal->addr != NULL) {				\
-		if (toVal->size < sizeof(type)) {		\
-		    toVal->size = sizeof(type);			\
-		    return False;				\
-		}						\
-		*(type*)(toVal->addr) = (type) (value);		\
-	    }							\
-	    else {						\
-		static type static_val;				\
-		static_val = (type) (value);			\
-		toVal->addr = (XPointer)&static_val;		\
-	    }							\
-	    toVal->size = sizeof(type);				\
-	    return True;					\
-	}
-
-void XtDisplayStringConversionWarning(
-    Display* dpy,
-    _Xconst char* from,
-    _Xconst char* toType
-    )
+#define done_typed_string(type, typed_value, tstr) \
+        {                                                       \
+            if (toVal->addr != NULL) {                          \
+                if (toVal->size < sizeof(type)) {               \
+                    toVal->size = sizeof(type);                 \
+                    XtDisplayStringConversionWarning(dpy,       \
+                        (char*) fromVal->addr, tstr);           \
+                    return False;                               \
+                }                                               \
+                *(type*)(toVal->addr) = typed_value;            \
+            }                                                   \
+            else {                                              \
+                static type static_val;                         \
+                static_val = typed_value;                       \
+                toVal->addr = (XPointer)&static_val;            \
+            }                                                   \
+            toVal->size = sizeof(type);                         \
+            return True;                                        \
+        }
+
+#define done_string(type, value, tstr) \
+        done_typed_string(type, (type) (value), tstr)
+
+#define done_typed(type, typed_value) \
+        {                                                       \
+            if (toVal->addr != NULL) {                          \
+                if (toVal->size < sizeof(type)) {               \
+                    toVal->size = sizeof(type);                 \
+                    return False;                               \
+                }                                               \
+                *(type*)(toVal->addr) = typed_value;            \
+            }                                                   \
+            else {                                              \
+                static type static_val;                         \
+                static_val = typed_value;                       \
+                toVal->addr = (XPointer)&static_val;            \
+            }                                                   \
+            toVal->size = sizeof(type);                         \
+            return True;                                        \
+        }
+
+#define done(type, value) \
+        done_typed(type, (type) (value))
+
+void
+XtDisplayStringConversionWarning(Display *dpy,
+                                 _Xconst char *from,
+                                 _Xconst char *toType)
 {
 #ifndef NO_MIT_HACKS
     /* Allow suppression of conversion warnings. %%%  Not specified. */
 
-    static enum {Check, Report, Ignore} report_it = Check;
+    static enum { Check, Report, Ignore } report_it = Check;
     XtAppContext app = XtDisplayToApplicationContext(dpy);
 
     LOCK_APP(app);
     LOCK_PROCESS;
     if (report_it == Check) {
-	XrmDatabase rdb = XtDatabase(dpy);
-	XrmName xrm_name[2];
-	XrmClass xrm_class[2];
-	XrmRepresentation rep_type;
-	XrmValue value;
-	xrm_name[0] = XrmPermStringToQuark( "stringConversionWarnings" );
-	xrm_name[1] = 0;
-	xrm_class[0] = XrmPermStringToQuark( "StringConversionWarnings" );
-	xrm_class[1] = 0;
-	if (XrmQGetResource( rdb, xrm_name, xrm_class,
-			     &rep_type, &value ))
-	{
-	    if (rep_type == XtQBoolean)
-		report_it = *(Boolean*)value.addr ? Report : Ignore;
-	    else if (rep_type == _XtQString) {
-		XrmValue toVal;
-		Boolean report;
-		toVal.addr = (XPointer)&report;
-		toVal.size = sizeof(Boolean);
-		if (XtCallConverter(dpy, XtCvtStringToBoolean, (XrmValuePtr)NULL,
-				    (Cardinal)0, &value, &toVal,
-				    (XtCacheRef*)NULL))
-		    report_it = report ? Report : Ignore;
-	    }
-	    else report_it = Report;
-	}
-	else report_it = Report;
+        XrmDatabase rdb = XtDatabase(dpy);
+        XrmName xrm_name[2];
+        XrmClass xrm_class[2];
+        XrmRepresentation rep_type;
+        XrmValue value;
+
+        xrm_name[0] = XrmPermStringToQuark("stringConversionWarnings");
+        xrm_name[1] = 0;
+        xrm_class[0] = XrmPermStringToQuark("StringConversionWarnings");
+        xrm_class[1] = 0;
+        if (XrmQGetResource(rdb, xrm_name, xrm_class, &rep_type, &value)) {
+            if (rep_type == XtQBoolean)
+                report_it = *(Boolean *) value.addr ? Report : Ignore;
+            else if (rep_type == _XtQString) {
+                XrmValue toVal;
+                Boolean report;
+
+                toVal.addr = (XPointer) &report;
+                toVal.size = sizeof(Boolean);
+                if (XtCallConverter
+                    (dpy, XtCvtStringToBoolean, (XrmValuePtr) NULL,
+                     (Cardinal) 0, &value, &toVal, (XtCacheRef *) NULL))
+                    report_it = report ? Report : Ignore;
+            }
+            else
+                report_it = Report;
+        }
+        else
+            report_it = Report;
     }
 
     if (report_it == Report) {
-#endif /* ifndef NO_MIT_HACKS */
-	String params[2];
-	Cardinal num_params = 2;
-	params[0] = (String)from;
-	params[1] = (String)toType;
-	XtAppWarningMsg(app,
-		   XtNconversionError,"string",XtCXtToolkitError,
-		   "Cannot convert string \"%s\" to type %s",
-		    params,&num_params);
+#endif                          /* ifndef NO_MIT_HACKS */
+        String params[2];
+        Cardinal num_params = 2;
+
+        params[0] = (String) from;
+        params[1] = (String) toType;
+        XtAppWarningMsg(app,
+                        XtNconversionError, "string", XtCXtToolkitError,
+                        "Cannot convert string \"%s\" to type %s",
+                        params, &num_params);
 #ifndef NO_MIT_HACKS
     }
-#endif /* ifndef NO_MIT_HACKS */
+#endif                          /* ifndef NO_MIT_HACKS */
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void XtStringConversionWarning(
-    _Xconst char* from,
-    _Xconst char* toType
-    )
+void
+XtStringConversionWarning(_Xconst char *from, _Xconst char *toType)
 {
-	String params[2];
-	Cardinal num_params = 2;
-	params[0] = (String)from;
-	params[1] = (String)toType;
-	XtWarningMsg(XtNconversionError,"string",XtCXtToolkitError,
-		   "Cannot convert string \"%s\" to type %s",
-		    params,&num_params);
+    String params[2];
+    Cardinal num_params = 2;
+
+    params[0] = (String) from;
+    params[1] = (String) toType;
+    XtWarningMsg(XtNconversionError, "string", XtCXtToolkitError,
+                 "Cannot convert string \"%s\" to type %s",
+                 params, &num_params);
 }
 
 static int CompareISOLatin1(const char *, const char *);
 
-
-static Boolean IsInteger(
-    String string,
-    int *value)
+static Boolean
+IsInteger(String string, int *value)
 {
     Boolean foundDigit = False;
     Boolean isNegative = False;
     Boolean isPositive = False;
     int val = 0;
     char ch;
+
     /* skip leading whitespace */
-    while ((ch = *string) == ' ' || ch == '\t') string++;
+    while ((ch = *string) == ' ' || ch == '\t')
+        string++;
     while ((ch = *string++)) {
-	if (ch >= '0' && ch <= '9') {
-	    val *= 10;
-	    val += ch - '0';
-	    foundDigit = True;
-	    continue;
-	}
-	if (IsWhitespace(ch)) {
-	    if (!foundDigit) return False;
-	    /* make sure only trailing whitespace */
-	    while ((ch = *string++)) {
-		if (!IsWhitespace(ch))
-		    return False;
-	    }
-	    break;
-	}
-	if (ch == '-' && !foundDigit && !isNegative && !isPositive) {
-	    isNegative = True;
-	    continue;
-	}
-	if (ch == '+' && !foundDigit && !isNegative && !isPositive) {
-	    isPositive = True;
-	    continue;
-	}
-	return False;
+        if (ch >= '0' && ch <= '9') {
+            val *= 10;
+            val += ch - '0';
+            foundDigit = True;
+            continue;
+        }
+        if (IsWhitespace(ch)) {
+            if (!foundDigit)
+                return False;
+            /* make sure only trailing whitespace */
+            while ((ch = *string++)) {
+                if (!IsWhitespace(ch))
+                    return False;
+            }
+            break;
+        }
+        if (ch == '-' && !foundDigit && !isNegative && !isPositive) {
+            isNegative = True;
+            continue;
+        }
+        if (ch == '+' && !foundDigit && !isNegative && !isPositive) {
+            isPositive = True;
+            continue;
+        }
+        return False;
     }
     if (ch == '\0') {
-	if (isNegative)
-	    *value = -val;
-	else
-	    *value = val;
-	return True;
+        if (isNegative)
+            *value = -val;
+        else
+            *value = val;
+        return True;
     }
     return False;
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtIntToBoolean(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToBoolean(Display *dpy,
+                  XrmValuePtr args _X_UNUSED,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToBoolean",XtCXtToolkitError,
-                  "Integer to Boolean conversion needs no extra arguments",
-                   NULL, NULL);
-    done(Boolean, (*(int *)fromVal->addr != 0));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToBoolean",
+                        XtCXtToolkitError,
+                        "Integer to Boolean conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Boolean, (*(int *) fromVal->addr != 0));
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtIntToShort(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToShort(Display *dpy,
+                XrmValuePtr args _X_UNUSED,
+                Cardinal *num_args,
+                XrmValuePtr fromVal,
+                XrmValuePtr toVal,
+                XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToShort",XtCXtToolkitError,
-                  "Integer to Short conversion needs no extra arguments",
-                   NULL, NULL);
-    done(short, (*(int *)fromVal->addr));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToShort", XtCXtToolkitError,
+                        "Integer to Short conversion needs no extra arguments",
+                        NULL, NULL);
+    done(short, (*(int *) fromVal->addr));
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtStringToBoolean(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToBoolean(Display *dpy,
+                     XrmValuePtr args _X_UNUSED,
+                     Cardinal *num_args,
+                     XrmValuePtr fromVal,
+                     XrmValuePtr toVal,
+                     XtPointer *closure_ret _X_UNUSED)
 {
-    String str = (String)fromVal->addr;
-    if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToBoolean",XtCXtToolkitError,
-                  "String to Boolean conversion needs no extra arguments",
-                   NULL, NULL);
+    String str = (String) fromVal->addr;
 
-    if (   (CompareISOLatin1(str, "true") == 0)
-	|| (CompareISOLatin1(str, "yes") == 0)
-	|| (CompareISOLatin1(str, "on") == 0)
-	|| (CompareISOLatin1(str, "1") == 0))	donestr( Boolean, True, XtRBoolean );
-
-    if (   (CompareISOLatin1(str, "false") == 0)
-	|| (CompareISOLatin1(str, "no") == 0)
-	|| (CompareISOLatin1(str, "off") == 0)
-	|| (CompareISOLatin1(str, "0") == 0))	donestr( Boolean, False, XtRBoolean );
+    if (*num_args != 0)
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToBoolean",
+                        XtCXtToolkitError,
+                        "String to Boolean conversion needs no extra arguments",
+                        NULL, NULL);
+
+    if ((CompareISOLatin1(str, "true") == 0)
+        || (CompareISOLatin1(str, "yes") == 0)
+        || (CompareISOLatin1(str, "on") == 0)
+        || (CompareISOLatin1(str, "1") == 0))
+        done_string(Boolean, True, XtRBoolean);
+
+    if ((CompareISOLatin1(str, "false") == 0)
+        || (CompareISOLatin1(str, "no") == 0)
+        || (CompareISOLatin1(str, "off") == 0)
+        || (CompareISOLatin1(str, "0") == 0))
+        done_string(Boolean, False, XtRBoolean);
 
     XtDisplayStringConversionWarning(dpy, str, XtRBoolean);
     return False;
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtIntToBool(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToBool(Display *dpy,
+               XrmValuePtr args _X_UNUSED,
+               Cardinal *num_args,
+               XrmValuePtr fromVal,
+               XrmValuePtr toVal,
+               XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToBool",XtCXtToolkitError,
-                  "Integer to Bool conversion needs no extra arguments",
-                   NULL, NULL);
-    done(Bool, (*(int *)fromVal->addr != 0));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToBool", XtCXtToolkitError,
+                        "Integer to Bool conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Bool, (*(int *) fromVal->addr != 0));
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtStringToBool(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToBool(Display *dpy,
+                  XrmValuePtr args _X_UNUSED,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
-    String str = (String)fromVal->addr;
+    String str = (String) fromVal->addr;
+
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		XtNwrongParameters,"cvtStringToBool",
-		XtCXtToolkitError,
-                 "String to Bool conversion needs no extra arguments",
-                  NULL, NULL);
-
-    if (   (CompareISOLatin1(str, "true") == 0)
-	|| (CompareISOLatin1(str, "yes") == 0)
-	|| (CompareISOLatin1(str, "on") == 0)
-	|| (CompareISOLatin1(str, "1") == 0))	donestr( Bool, True, XtRBool );
-
-    if (   (CompareISOLatin1(str, "false") == 0)
-	|| (CompareISOLatin1(str, "no") == 0)
-	|| (CompareISOLatin1(str, "off") == 0)
-	|| (CompareISOLatin1(str, "0") == 0))	donestr( Bool, False, XtRBool );
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToBool",
+                        XtCXtToolkitError,
+                        "String to Bool conversion needs no extra arguments",
+                        NULL, NULL);
+
+    if ((CompareISOLatin1(str, "true") == 0)
+        || (CompareISOLatin1(str, "yes") == 0)
+        || (CompareISOLatin1(str, "on") == 0)
+        || (CompareISOLatin1(str, "1") == 0))
+        done_string(Bool, True, XtRBool);
+
+    if ((CompareISOLatin1(str, "false") == 0)
+        || (CompareISOLatin1(str, "no") == 0)
+        || (CompareISOLatin1(str, "off") == 0)
+        || (CompareISOLatin1(str, "0") == 0))
+        done_string(Bool, False, XtRBool);
 
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRBool);
     return False;
 }
 
+/* *INDENT-OFF* */
 XtConvertArgRec const colorConvertArgs[] = {
     {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
      sizeof(Screen *)},
     {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
      sizeof(Colormap)}
 };
+/* *INDENT-ON* */
 
-
-/* ARGSUSED */
-Boolean XtCvtIntToColor(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToColor(Display *dpy,
+                XrmValuePtr args,
+                Cardinal *num_args,
+                XrmValuePtr fromVal,
+                XrmValuePtr toVal,
+                XtPointer *closure_ret _X_UNUSED)
 {
-    XColor	c;
-    Screen	*screen;
-    Colormap	colormap;
+    XColor c;
+    Screen *screen;
+    Colormap colormap;
 
     if (*num_args != 2) {
-      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	 XtNwrongParameters,"cvtIntOrPixelToXColor",XtCXtToolkitError,
-         "Pixel to color conversion needs screen and colormap arguments",
-          NULL, NULL);
-      return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntOrPixelToXColor",
+                        XtCXtToolkitError,
+                        "Pixel to color conversion needs screen and colormap arguments",
+                        NULL, NULL);
+        return False;
     }
     screen = *((Screen **) args[0].addr);
     colormap = *((Colormap *) args[1].addr);
-    c.pixel = (unsigned long) (*(int *)fromVal->addr);
+    c.pixel = (unsigned long) (*(int *) fromVal->addr);
 
     XQueryColor(DisplayOfScreen(screen), colormap, &c);
-    done(XColor, c);
+    done_typed(XColor, c);
 }
 
-
-Boolean XtCvtStringToPixel(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToPixel(Display *dpy,
+                   XrmValuePtr args,
+                   Cardinal *num_args,
+                   XrmValuePtr fromVal,
+                   XrmValuePtr toVal,
+                   XtPointer *closure_ret)
 {
-    String	    str = (String)fromVal->addr;
-    XColor	    screenColor;
-    XColor	    exactColor;
-    Screen	    *screen;
-    XtPerDisplay    pd = _XtGetPerDisplay(dpy);
-    Colormap	    colormap;
-    Status	    status;
-    Cardinal	    num_params=1;
+    String str = (String) fromVal->addr;
+    XColor screenColor;
+    XColor exactColor;
+    Screen *screen;
+    XtPerDisplay pd = _XtGetPerDisplay(dpy);
+    Colormap colormap;
+    Status status;
+    Cardinal num_params = 1;
 
     if (*num_args != 2) {
-     XtAppWarningMsg(pd->appContext, XtNwrongParameters, "cvtStringToPixel",
-		     XtCXtToolkitError,
-	"String to pixel conversion needs screen and colormap arguments",
-        NULL, NULL);
-     return False;
+        XtAppWarningMsg(pd->appContext, XtNwrongParameters, "cvtStringToPixel",
+                        XtCXtToolkitError,
+                        "String to pixel conversion needs screen and colormap arguments",
+                        NULL, NULL);
+        return False;
     }
 
     screen = *((Screen **) args[0].addr);
     colormap = *((Colormap *) args[1].addr);
 
     if (CompareISOLatin1(str, XtDefaultBackground) == 0) {
-	*closure_ret = NULL;
-	if (pd->rv) donestr(Pixel, BlackPixelOfScreen(screen), XtRPixel)
-	else	    donestr(Pixel, WhitePixelOfScreen(screen), XtRPixel);
+        *closure_ret = NULL;
+        if (pd->rv) {
+            done_string(Pixel, BlackPixelOfScreen(screen), XtRPixel);
+        }
+        else {
+            done_string(Pixel, WhitePixelOfScreen(screen), XtRPixel);
+        }
     }
     if (CompareISOLatin1(str, XtDefaultForeground) == 0) {
-	*closure_ret = NULL;
-	if (pd->rv) donestr(Pixel, WhitePixelOfScreen(screen), XtRPixel)
-        else	    donestr(Pixel, BlackPixelOfScreen(screen), XtRPixel);
+        *closure_ret = NULL;
+        if (pd->rv) {
+            done_string(Pixel, WhitePixelOfScreen(screen), XtRPixel);
+        }
+        else {
+            done_string(Pixel, BlackPixelOfScreen(screen), XtRPixel);
+        }
     }
 
     status = XAllocNamedColor(DisplayOfScreen(screen), colormap,
-			      (char*)str, &screenColor, &exactColor);
+                              (_Xconst char *) str, &screenColor, &exactColor);
     if (status == 0) {
-	_Xconst _XtString msg;
-	_Xconst _XtString type;
-	String params[1];
-
-	params[0] = str;
-	/* Server returns a specific error code but Xlib discards it.  Ugh */
-	if (XLookupColor(DisplayOfScreen(screen), colormap, (char*)str,
-			 &exactColor, &screenColor)) {
-	    type = "noColormap";
-	    msg = "Cannot allocate colormap entry for \"%s\"";
-	}
-	else {
-	    type = "badValue";
-	    msg = "Color name \"%s\" is not defined";
-	}
-
-	XtAppWarningMsg(pd->appContext, type, "cvtStringToPixel",
-			XtCXtToolkitError, msg, params, &num_params);
-	*closure_ret = NULL;
-	return False;
-    } else {
-	*closure_ret = (char*)True;
-        donestr(Pixel, screenColor.pixel, XtRPixel);
+        _Xconst _XtString msg;
+        _Xconst _XtString type;
+        String params[1];
+
+        params[0] = str;
+        /* Server returns a specific error code but Xlib discards it.  Ugh */
+        if (XLookupColor
+            (DisplayOfScreen(screen), colormap, (_Xconst char *) str,
+             &exactColor, &screenColor)) {
+            type = "noColormap";
+            msg = "Cannot allocate colormap entry for \"%s\"";
+        }
+        else {
+            type = "badValue";
+            msg = "Color name \"%s\" is not defined";
+        }
+
+        XtAppWarningMsg(pd->appContext, type, "cvtStringToPixel",
+                        XtCXtToolkitError, msg, params, &num_params);
+        *closure_ret = NULL;
+        return False;
+    }
+    else {
+        *closure_ret = (char *) True;
+        done_string(Pixel, screenColor.pixel, XtRPixel);
     }
 }
 
-/* ARGSUSED */
-static void FreePixel(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+FreePixel(XtAppContext app,
+          XrmValuePtr toVal,
+          XtPointer closure,
+          XrmValuePtr args,
+          Cardinal *num_args)
 {
-    Screen	    *screen;
-    Colormap	    colormap;
+    Screen *screen;
+    Colormap colormap;
 
     if (*num_args != 2) {
-     XtAppWarningMsg(app, XtNwrongParameters,"freePixel",XtCXtToolkitError,
-	"Freeing a pixel requires screen and colormap arguments",
-        NULL, NULL);
-     return;
+        XtAppWarningMsg(app, XtNwrongParameters, "freePixel", XtCXtToolkitError,
+                        "Freeing a pixel requires screen and colormap arguments",
+                        NULL, NULL);
+        return;
     }
 
     screen = *((Screen **) args[0].addr);
     colormap = *((Colormap *) args[1].addr);
 
     if (closure) {
-	XFreeColors( DisplayOfScreen(screen), colormap,
-		     (unsigned long*)toVal->addr, 1, (unsigned long)0
-		    );
+        XFreeColors(DisplayOfScreen(screen), colormap,
+                    (unsigned long *) toVal->addr, 1, (unsigned long) 0);
     }
 }
 
-
 /* no longer used by Xt, but it's in the spec */
 XtConvertArgRec const screenConvertArg[] = {
-    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
+    {XtWidgetBaseOffset, (XtPointer) XtOffsetOf(WidgetRec, core.screen),
      sizeof(Screen *)}
 };
 
-/*ARGSUSED*/
-static void FetchDisplayArg(
-    Widget widget,
-    Cardinal *size,
-    XrmValue* value)
+static void
+FetchDisplayArg(Widget widget, Cardinal *size _X_UNUSED, XrmValue *value)
 {
     if (widget == NULL) {
-	XtErrorMsg("missingWidget", "fetchDisplayArg", XtCXtToolkitError,
-		   "FetchDisplayArg called without a widget to reference",
-		   NULL, NULL);
+        XtErrorMsg("missingWidget", "fetchDisplayArg", XtCXtToolkitError,
+                   "FetchDisplayArg called without a widget to reference",
+                   NULL, NULL);
         /* can't return any useful Display and caller will de-ref NULL,
-	   so aborting is the only useful option */
-    } else {
-	value->size = sizeof(Display*);
-	value->addr = (XPointer)&DisplayOfScreen(XtScreenOfObject(widget));
+           so aborting is the only useful option */
+    }
+    else {
+        value->size = sizeof(Display *);
+        value->addr = (XPointer) &DisplayOfScreen(XtScreenOfObject(widget));
     }
 }
 
+/* *INDENT-OFF* */
 static XtConvertArgRec const displayConvertArg[] = {
     {XtProcedureArg, (XtPointer)FetchDisplayArg, 0},
 };
+/* *INDENT-ON* */
 
-/*ARGSUSED*/
-Boolean XtCvtStringToCursor(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToCursor(Display *dpy,
+                    XrmValuePtr args,
+                    Cardinal *num_args,
+                    XrmValuePtr fromVal,
+                    XrmValuePtr toVal,
+                    XtPointer *closure_ret _X_UNUSED)
 {
+    /* *INDENT-OFF* */
     static const struct _CursorName {
-	const char	*name;
-	unsigned int	shape;
+        const char      *name;
+        unsigned int    shape;
     } cursor_names[] = {
-			{"X_cursor",		XC_X_cursor},
-			{"arrow",		XC_arrow},
-			{"based_arrow_down",	XC_based_arrow_down},
-			{"based_arrow_up",	XC_based_arrow_up},
-			{"boat",		XC_boat},
-			{"bogosity",		XC_bogosity},
-			{"bottom_left_corner",	XC_bottom_left_corner},
-			{"bottom_right_corner",	XC_bottom_right_corner},
-			{"bottom_side",		XC_bottom_side},
-			{"bottom_tee",		XC_bottom_tee},
-			{"box_spiral",		XC_box_spiral},
-			{"center_ptr",		XC_center_ptr},
-			{"circle",		XC_circle},
-			{"clock",		XC_clock},
-			{"coffee_mug",		XC_coffee_mug},
-			{"cross",		XC_cross},
-			{"cross_reverse",	XC_cross_reverse},
-			{"crosshair",		XC_crosshair},
-			{"diamond_cross",	XC_diamond_cross},
-			{"dot",			XC_dot},
-			{"dotbox",		XC_dotbox},
-			{"double_arrow",	XC_double_arrow},
-			{"draft_large",		XC_draft_large},
-			{"draft_small",		XC_draft_small},
-			{"draped_box",		XC_draped_box},
-			{"exchange",		XC_exchange},
-			{"fleur",		XC_fleur},
-			{"gobbler",		XC_gobbler},
-			{"gumby",		XC_gumby},
-			{"hand1",		XC_hand1},
-			{"hand2",		XC_hand2},
-			{"heart",		XC_heart},
-			{"icon",		XC_icon},
-			{"iron_cross",		XC_iron_cross},
-			{"left_ptr",		XC_left_ptr},
-			{"left_side",		XC_left_side},
-			{"left_tee",		XC_left_tee},
-			{"leftbutton",		XC_leftbutton},
-			{"ll_angle",		XC_ll_angle},
-			{"lr_angle",		XC_lr_angle},
-			{"man",			XC_man},
-			{"middlebutton",	XC_middlebutton},
-			{"mouse",		XC_mouse},
-			{"pencil",		XC_pencil},
-			{"pirate",		XC_pirate},
-			{"plus",		XC_plus},
-			{"question_arrow",	XC_question_arrow},
-			{"right_ptr",		XC_right_ptr},
-			{"right_side",		XC_right_side},
-			{"right_tee",		XC_right_tee},
-			{"rightbutton",		XC_rightbutton},
-			{"rtl_logo",		XC_rtl_logo},
-			{"sailboat",		XC_sailboat},
-			{"sb_down_arrow",	XC_sb_down_arrow},
-			{"sb_h_double_arrow",	XC_sb_h_double_arrow},
-			{"sb_left_arrow",	XC_sb_left_arrow},
-			{"sb_right_arrow",	XC_sb_right_arrow},
-			{"sb_up_arrow",		XC_sb_up_arrow},
-			{"sb_v_double_arrow",	XC_sb_v_double_arrow},
-			{"shuttle",		XC_shuttle},
-			{"sizing",		XC_sizing},
-			{"spider",		XC_spider},
-			{"spraycan",		XC_spraycan},
-			{"star",		XC_star},
-			{"target",		XC_target},
-			{"tcross",		XC_tcross},
-			{"top_left_arrow",	XC_top_left_arrow},
-			{"top_left_corner",	XC_top_left_corner},
-			{"top_right_corner",	XC_top_right_corner},
-			{"top_side",		XC_top_side},
-			{"top_tee",		XC_top_tee},
-			{"trek",		XC_trek},
-			{"ul_angle",		XC_ul_angle},
-			{"umbrella",		XC_umbrella},
-			{"ur_angle",		XC_ur_angle},
-			{"watch",		XC_watch},
-			{"xterm",		XC_xterm},
+        {"X_cursor",            XC_X_cursor},
+        {"arrow",               XC_arrow},
+        {"based_arrow_down",    XC_based_arrow_down},
+        {"based_arrow_up",      XC_based_arrow_up},
+        {"boat",                XC_boat},
+        {"bogosity",            XC_bogosity},
+        {"bottom_left_corner",  XC_bottom_left_corner},
+        {"bottom_right_corner", XC_bottom_right_corner},
+        {"bottom_side",         XC_bottom_side},
+        {"bottom_tee",          XC_bottom_tee},
+        {"box_spiral",          XC_box_spiral},
+        {"center_ptr",          XC_center_ptr},
+        {"circle",              XC_circle},
+        {"clock",               XC_clock},
+        {"coffee_mug",          XC_coffee_mug},
+        {"cross",               XC_cross},
+        {"cross_reverse",       XC_cross_reverse},
+        {"crosshair",           XC_crosshair},
+        {"diamond_cross",       XC_diamond_cross},
+        {"dot",                 XC_dot},
+        {"dotbox",              XC_dotbox},
+        {"double_arrow",        XC_double_arrow},
+        {"draft_large",         XC_draft_large},
+        {"draft_small",         XC_draft_small},
+        {"draped_box",          XC_draped_box},
+        {"exchange",            XC_exchange},
+        {"fleur",               XC_fleur},
+        {"gobbler",             XC_gobbler},
+        {"gumby",               XC_gumby},
+        {"hand1",               XC_hand1},
+        {"hand2",               XC_hand2},
+        {"heart",               XC_heart},
+        {"icon",                XC_icon},
+        {"iron_cross",          XC_iron_cross},
+        {"left_ptr",            XC_left_ptr},
+        {"left_side",           XC_left_side},
+        {"left_tee",            XC_left_tee},
+        {"leftbutton",          XC_leftbutton},
+        {"ll_angle",            XC_ll_angle},
+        {"lr_angle",            XC_lr_angle},
+        {"man",                 XC_man},
+        {"middlebutton",        XC_middlebutton},
+        {"mouse",               XC_mouse},
+        {"pencil",              XC_pencil},
+        {"pirate",              XC_pirate},
+        {"plus",                XC_plus},
+        {"question_arrow",      XC_question_arrow},
+        {"right_ptr",           XC_right_ptr},
+        {"right_side",          XC_right_side},
+        {"right_tee",           XC_right_tee},
+        {"rightbutton",         XC_rightbutton},
+        {"rtl_logo",            XC_rtl_logo},
+        {"sailboat",            XC_sailboat},
+        {"sb_down_arrow",       XC_sb_down_arrow},
+        {"sb_h_double_arrow",   XC_sb_h_double_arrow},
+        {"sb_left_arrow",       XC_sb_left_arrow},
+        {"sb_right_arrow",      XC_sb_right_arrow},
+        {"sb_up_arrow",         XC_sb_up_arrow},
+        {"sb_v_double_arrow",   XC_sb_v_double_arrow},
+        {"shuttle",             XC_shuttle},
+        {"sizing",              XC_sizing},
+        {"spider",              XC_spider},
+        {"spraycan",            XC_spraycan},
+        {"star",                XC_star},
+        {"target",              XC_target},
+        {"tcross",              XC_tcross},
+        {"top_left_arrow",      XC_top_left_arrow},
+        {"top_left_corner",     XC_top_left_corner},
+        {"top_right_corner",    XC_top_right_corner},
+        {"top_side",            XC_top_side},
+        {"top_tee",             XC_top_tee},
+        {"trek",                XC_trek},
+        {"ul_angle",            XC_ul_angle},
+        {"umbrella",            XC_umbrella},
+        {"ur_angle",            XC_ur_angle},
+        {"watch",               XC_watch},
+        {"xterm",               XC_xterm},
     };
+    /* *INDENT-ON* */
     const struct _CursorName *nP;
-    char *name = (char *)fromVal->addr;
+    char *name = (char *) fromVal->addr;
     register Cardinal i;
 
     if (*num_args != 1) {
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	     XtNwrongParameters,"cvtStringToCursor",XtCXtToolkitError,
-             "String to cursor conversion needs display argument",
-              NULL, NULL);
-	return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToCursor",
+                        XtCXtToolkitError,
+                        "String to cursor conversion needs display argument",
+                        NULL, NULL);
+        return False;
     }
 
-    for (i=0, nP=cursor_names; i < XtNumber(cursor_names); i++, nP++ ) {
-	if (strcmp(name, nP->name) == 0) {
-	    Display *display = *(Display**)args[0].addr;
-	    Cursor cursor = XCreateFontCursor(display, nP->shape );
-	    donestr(Cursor, cursor, XtRCursor);
-	}
+    for (i = 0, nP = cursor_names; i < XtNumber(cursor_names); i++, nP++) {
+        if (strcmp(name, nP->name) == 0) {
+            Display *display = *(Display **) args[0].addr;
+            Cursor cursor = XCreateFontCursor(display, nP->shape);
+
+            done_string(Cursor, cursor, XtRCursor);
+        }
     }
     XtDisplayStringConversionWarning(dpy, name, XtRCursor);
     return False;
 }
 
-/* ARGSUSED */
-static void FreeCursor(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,	/* unused */
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+FreeCursor(XtAppContext app,
+           XrmValuePtr toVal,
+           XtPointer closure _X_UNUSED,
+           XrmValuePtr args,
+           Cardinal *num_args)
 {
-    Display*	display;
+    Display *display;
 
     if (*num_args != 1) {
-     XtAppWarningMsg(app,
-	     XtNwrongParameters,"freeCursor",XtCXtToolkitError,
-             "Free Cursor requires display argument",
-              NULL, NULL);
-     return;
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeCursor", XtCXtToolkitError,
+                        "Free Cursor requires display argument", NULL, NULL);
+        return;
     }
 
-    display = *(Display**)args[0].addr;
-    XFreeCursor( display, *(Cursor*)toVal->addr );
+    display = *(Display **) args[0].addr;
+    XFreeCursor(display, *(Cursor *) toVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToDisplay(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToDisplay(Display *dpy,
+                     XrmValuePtr args _X_UNUSED,
+                     Cardinal *num_args,
+                     XrmValuePtr fromVal,
+                     XrmValuePtr toVal,
+                     XtPointer *closure_ret _X_UNUSED)
 {
-    Display	*d;
+    Display *d;
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToDisplay",XtCXtToolkitError,
-                  "String to Display conversion needs no extra arguments",
-                   NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToDisplay",
+                        XtCXtToolkitError,
+                        "String to Display conversion needs no extra arguments",
+                        NULL, NULL);
 
-    d = XOpenDisplay((char *)fromVal->addr);
+    d = XOpenDisplay((char *) fromVal->addr);
     if (d != NULL)
-	donestr(Display*, d, XtRDisplay);
+        done_string(Display *, d, XtRDisplay);
 
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRDisplay);
     return False;
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtStringToFile(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToFile(Display *dpy,
+                  XrmValuePtr args _X_UNUSED,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
     FILE *f;
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		 XtNwrongParameters,"cvtStringToFile",XtCXtToolkitError,
-                 "String to File conversion needs no extra arguments",
-                 NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToFile",
+                        XtCXtToolkitError,
+                        "String to File conversion needs no extra arguments",
+                        NULL, NULL);
 
-    f = fopen((char *)fromVal->addr, "r");
+    f = fopen((char *) fromVal->addr, "r");
     if (f != NULL)
-	donestr(FILE*, f, XtRFile);
+        done_string(FILE *, f, XtRFile);
 
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFile);
     return False;
 }
 
-/* ARGSUSED */
-static void FreeFile(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,	/* unused */
-    XrmValuePtr	args,		/* unused */
-    Cardinal	*num_args)
+static void
+FreeFile(XtAppContext app,
+         XrmValuePtr toVal,
+         XtPointer closure _X_UNUSED,
+         XrmValuePtr args _X_UNUSED,
+         Cardinal *num_args)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(app,
-		 XtNwrongParameters,"freeFile",XtCXtToolkitError,
-                 "Free File requires no extra arguments",
-                 NULL, NULL);
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeFile", XtCXtToolkitError,
+                        "Free File requires no extra arguments", NULL, NULL);
 
-    fclose( *(FILE**)toVal->addr );
+    fclose(*(FILE **) toVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtIntToFloat(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToFloat(Display *dpy,
+                XrmValuePtr args _X_UNUSED,
+                Cardinal *num_args,
+                XrmValuePtr fromVal,
+                XrmValuePtr toVal,
+                XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToFloat",XtCXtToolkitError,
-                  "Integer to Float conversion needs no extra arguments",
-                   NULL, NULL);
-    done(float, (*(int *)fromVal->addr));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToFloat", XtCXtToolkitError,
+                        "Integer to Float conversion needs no extra arguments",
+                        NULL, NULL);
+    done(float, (*(int *) fromVal->addr));
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToFloat(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToFloat(Display *dpy,
+                   XrmValuePtr args _X_UNUSED,
+                   Cardinal *num_args,
+                   XrmValuePtr fromVal,
+                   XrmValuePtr toVal,
+                   XtPointer *closure_ret _X_UNUSED)
 {
     int ret;
     float f, nan;
 
-    (void) sscanf ("NaN", "%g",
-		   toVal->addr != NULL ? (float*) toVal->addr : &nan);
+    (void) sscanf("NaN", "%g",
+                  toVal->addr != NULL ? (float *) toVal->addr : &nan);
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		 XtNwrongParameters,"cvtStringToFloat",XtCXtToolkitError,
-                 "String to Float conversion needs no extra arguments",
-                 NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToFloat",
+                        XtCXtToolkitError,
+                        "String to Float conversion needs no extra arguments",
+                        NULL, NULL);
 
-    ret = sscanf (fromVal->addr, "%g", &f);
+    ret = sscanf(fromVal->addr, "%g", &f);
     if (ret == 0) {
-	if (toVal->addr != NULL && toVal->size == sizeof nan)
-	    *(float*)toVal->addr = nan;
-	XtDisplayStringConversionWarning (dpy, (char*) fromVal->addr, XtRFloat);
-	return False;
+        if (toVal->addr != NULL && toVal->size == sizeof nan)
+            *(float *) toVal->addr = nan;
+        XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFloat);
+        return False;
     }
-    donestr(float, f, XtRFloat);
+    done_string(float, f, XtRFloat);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToFont(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToFont(Display *dpy,
+                  XrmValuePtr args,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
-    Font	f;
-    Display*	display;
+    Font f;
+    Display *display;
 
     if (*num_args != 1) {
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	     XtNwrongParameters,"cvtStringToFont",XtCXtToolkitError,
-             "String to font conversion needs display argument",
-              NULL, NULL);
-	return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToFont",
+                        XtCXtToolkitError,
+                        "String to font conversion needs display argument",
+                        NULL, NULL);
+        return False;
     }
 
-    display = *(Display**)args[0].addr;
+    display = *(Display **) args[0].addr;
+
+    if (CompareISOLatin1((String) fromVal->addr, XtDefaultFont) != 0) {
+        f = XLoadFont(display, (char *) fromVal->addr);
 
-    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFont) != 0) {
-	f = XLoadFont(display, (char *)fromVal->addr);
-	if (f != 0) {
-  Done:	    donestr( Font, f, XtRFont );
-	}
-	XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFont);
+        if (f != 0) {
+ Done:     done_string(Font, f, XtRFont);
+        }
+        XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRFont);
     }
     /* try and get the default font */
 
     {
-	XrmName xrm_name[2];
-	XrmClass xrm_class[2];
-	XrmRepresentation rep_type;
-	XrmValue value;
-
-	xrm_name[0] = XrmPermStringToQuark ("xtDefaultFont");
-	xrm_name[1] = 0;
-	xrm_class[0] = XrmPermStringToQuark ("XtDefaultFont");
-	xrm_class[1] = 0;
-	if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
-			    &rep_type, &value)) {
-	    if (rep_type == _XtQString) {
-		f = XLoadFont(display, (char *)value.addr);
-		if (f != 0)
-		    goto Done;
-		else
-		    XtDisplayStringConversionWarning(dpy, (char *)value.addr,
-						     XtRFont);
-	    } else if (rep_type == XtQFont) {
-		f = *(Font*)value.addr;
-		goto Done;
-	    } else if (rep_type == XtQFontStruct) {
-		f = ((XFontStruct*)value.addr)->fid;
-		goto Done;
-	    }
-	}
+        XrmName xrm_name[2];
+        XrmClass xrm_class[2];
+        XrmRepresentation rep_type;
+        XrmValue value;
+
+        xrm_name[0] = XrmPermStringToQuark("xtDefaultFont");
+        xrm_name[1] = 0;
+        xrm_class[0] = XrmPermStringToQuark("XtDefaultFont");
+        xrm_class[1] = 0;
+        if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+                            &rep_type, &value)) {
+            if (rep_type == _XtQString) {
+                f = XLoadFont(display, (char *) value.addr);
+
+                if (f != 0)
+                    goto Done;
+                else
+                    XtDisplayStringConversionWarning(dpy, (char *) value.addr,
+                                                     XtRFont);
+            }
+            else if (rep_type == XtQFont) {
+                f = *(Font *) value.addr;
+                goto Done;
+            }
+            else if (rep_type == XtQFontStruct) {
+                f = ((XFontStruct *) value.addr)->fid;
+                goto Done;
+            }
+        }
     }
     /* Should really do XListFonts, but most servers support this */
     f = XLoadFont(display, "-*-*-*-R-*-*-*-120-*-*-*-*-ISO8859-*");
+
     if (f != 0)
-	goto Done;
+        goto Done;
 
     XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		    "noFont","cvtStringToFont",XtCXtToolkitError,
-		    "Unable to load any usable ISO8859 font",
-		    NULL, NULL);
+                    "noFont", "cvtStringToFont", XtCXtToolkitError,
+                    "Unable to load any usable ISO8859 font", NULL, NULL);
 
     return False;
 }
 
-/* ARGSUSED */
-static void FreeFont(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,	/* unused */
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+FreeFont(XtAppContext app,
+         XrmValuePtr toVal,
+         XtPointer closure _X_UNUSED,
+         XrmValuePtr args,
+         Cardinal *num_args)
 {
     Display *display;
+
     if (*num_args != 1) {
-	XtAppWarningMsg(app,
-	     XtNwrongParameters,"freeFont",XtCXtToolkitError,
-             "Free Font needs display argument",
-              NULL, NULL);
-	return;
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeFont", XtCXtToolkitError,
+                        "Free Font needs display argument", NULL, NULL);
+        return;
     }
 
-    display = *(Display**)args[0].addr;
-    XUnloadFont( display, *(Font*)toVal->addr );
+    display = *(Display **) args[0].addr;
+    XUnloadFont(display, *(Font *) toVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtIntToFont(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToFont(Display *dpy,
+               XrmValuePtr args _X_UNUSED,
+               Cardinal *num_args,
+               XrmValuePtr fromVal,
+               XrmValuePtr toVal,
+               XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	   XtNwrongParameters,"cvtIntToFont",XtCXtToolkitError,
-           "Integer to Font conversion needs no extra arguments",
-            NULL, NULL);
-    done(Font, *(int*)fromVal->addr);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToFont", XtCXtToolkitError,
+                        "Integer to Font conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Font, *(int *) fromVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToFontSet(
-    Display*    dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer   *closure_ret)
+Boolean
+XtCvtStringToFontSet(Display *dpy,
+                     XrmValuePtr args,
+                     Cardinal *num_args,
+                     XrmValuePtr fromVal,
+                     XrmValuePtr toVal,
+                     XtPointer *closure_ret _X_UNUSED)
 {
-    XFontSet  f;
-    Display*  display;
-    char**    missing_charset_list;
-    int       missing_charset_count;
-    char*     def_string;
+    XFontSet f;
+    Display *display;
+    char **missing_charset_list;
+    int missing_charset_count;
+    char *def_string;
 
     if (*num_args != 2) {
-      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-           XtNwrongParameters,"cvtStringToFontSet",XtCXtToolkitError,
-             "String to FontSet conversion needs display and locale arguments",
-              NULL, NULL);
-      return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToFontSet",
+                        XtCXtToolkitError,
+                        "String to FontSet conversion needs display and locale arguments",
+                        NULL, NULL);
+        return False;
     }
 
-    display = *(Display**)args[0].addr;
+    display = *(Display **) args[0].addr;
 
-    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFontSet) != 0) {
-      f = XCreateFontSet(display, (char *)fromVal->addr,
-              &missing_charset_list, &missing_charset_count, &def_string);
+    if (CompareISOLatin1((String) fromVal->addr, XtDefaultFontSet) != 0) {
+        f = XCreateFontSet(display, (char *) fromVal->addr,
+                           &missing_charset_list, &missing_charset_count,
+                           &def_string);
         /* Free any returned missing charset list */
-      if (missing_charset_count) {
-          XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-                 XtNmissingCharsetList,"cvtStringToFontSet",XtCXtToolkitError,
-                 "Missing charsets in String to FontSet conversion",
-                 NULL, NULL);
+        if (missing_charset_count) {
+            XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                            XtNmissingCharsetList, "cvtStringToFontSet",
+                            XtCXtToolkitError,
+                            "Missing charsets in String to FontSet conversion",
+                            NULL, NULL);
             XFreeStringList(missing_charset_list);
-      }
-      if (f != NULL) {
-  Done:           donestr( XFontSet, f, XtRFontSet );
-      }
-      XtDisplayStringConversionWarning(dpy, (char *)fromVal->addr, XtRFontSet);
+        }
+        if (f != NULL) {
+ Done:     done_string(XFontSet, f, XtRFontSet);
+        }
+        XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                         XtRFontSet);
     }
     /* try and get the default fontset */
 
     {
-      XrmName xrm_name[2];
-      XrmClass xrm_class[2];
-      XrmRepresentation rep_type;
-      XrmValue value;
-
-      xrm_name[0] = XrmPermStringToQuark ("xtDefaultFontSet");
-      xrm_name[1] = 0;
-      xrm_class[0] = XrmPermStringToQuark ("XtDefaultFontSet");
-      xrm_class[1] = 0;
-      if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
-                          &rep_type, &value)) {
-          if (rep_type == _XtQString) {
-
-              f = XCreateFontSet(display, (char *)value.addr,
-				 &missing_charset_list, &missing_charset_count,
-				 &def_string);
+        XrmName xrm_name[2];
+        XrmClass xrm_class[2];
+        XrmRepresentation rep_type;
+        XrmValue value;
+
+        xrm_name[0] = XrmPermStringToQuark("xtDefaultFontSet");
+        xrm_name[1] = 0;
+        xrm_class[0] = XrmPermStringToQuark("XtDefaultFontSet");
+        xrm_class[1] = 0;
+        if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+                            &rep_type, &value)) {
+            if (rep_type == _XtQString) {
+
+                f = XCreateFontSet(display, (char *) value.addr,
+                                   &missing_charset_list,
+                                   &missing_charset_count, &def_string);
                 /* Free any returned missing charset list */
-              if (missing_charset_count) {
-                  XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-			 XtNmissingCharsetList,"cvtStringToFontSet",
-			 XtCXtToolkitError,
-			 "Missing charsets in String to FontSet conversion",
-                         NULL, NULL);
-		  XFreeStringList(missing_charset_list);
-              }
-              if (f != NULL)
-                  goto Done;
-              else
-                  XtDisplayStringConversionWarning(dpy, (char *)value.addr,
-                                                   XtRFontSet);
-          } else if (rep_type == XtQFontSet) {
-              f = *(XFontSet*)value.addr;
-              goto Done;
-          }
-      }
-  }
+                if (missing_charset_count) {
+                    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                                    XtNmissingCharsetList, "cvtStringToFontSet",
+                                    XtCXtToolkitError,
+                                    "Missing charsets in String to FontSet conversion",
+                                    NULL, NULL);
+                    XFreeStringList(missing_charset_list);
+                }
+                if (f != NULL)
+                    goto Done;
+                else
+                    XtDisplayStringConversionWarning(dpy, (char *) value.addr,
+                                                     XtRFontSet);
+            }
+            else if (rep_type == XtQFontSet) {
+                f = *(XFontSet *) value.addr;
+                goto Done;
+            }
+        }
+    }
 
     /* Should really do XListFonts, but most servers support this */
     f = XCreateFontSet(display, "-*-*-*-R-*-*-*-120-*-*-*-*,*",
-          &missing_charset_list, &missing_charset_count, &def_string);
+                       &missing_charset_list, &missing_charset_count,
+                       &def_string);
 
     /* Free any returned missing charset list */
     if (missing_charset_count) {
-      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-             XtNmissingCharsetList,"cvtStringToFontSet",XtCXtToolkitError,
-             "Missing charsets in String to FontSet conversion",
-             NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNmissingCharsetList, "cvtStringToFontSet",
+                        XtCXtToolkitError,
+                        "Missing charsets in String to FontSet conversion",
+                        NULL, NULL);
         XFreeStringList(missing_charset_list);
     }
     if (f != NULL)
-      goto Done;
+        goto Done;
 
     XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-           "noFont","cvtStringToFontSet",XtCXtToolkitError,
-             "Unable to load any usable fontset",
-              NULL, NULL);
+                    "noFont", "cvtStringToFontSet", XtCXtToolkitError,
+                    "Unable to load any usable fontset", NULL, NULL);
 
     return False;
 }
 
-/*ARGSUSED*/
-static void FreeFontSet(
-    XtAppContext	app,
-    XrmValuePtr		toVal,
-    XtPointer		closure,        /* unused */
-    XrmValuePtr		args,
-    Cardinal		*num_args)
+static void
+FreeFontSet(XtAppContext app,
+            XrmValuePtr toVal,
+            XtPointer closure _X_UNUSED,
+            XrmValuePtr args,
+            Cardinal *num_args)
 {
     Display *display;
+
     if (*num_args != 2) {
-      XtAppWarningMsg(app,
-           XtNwrongParameters,"freeFontSet",XtCXtToolkitError,
-             "FreeFontSet needs display and locale arguments",
-              NULL, NULL);
-      return;
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeFontSet", XtCXtToolkitError,
+                        "FreeFontSet needs display and locale arguments",
+                        NULL, NULL);
+        return;
     }
 
-    display = *(Display**)args[0].addr;
-    XFreeFontSet( display, *(XFontSet*)toVal->addr );
+    display = *(Display **) args[0].addr;
+    XFreeFontSet(display, *(XFontSet *) toVal->addr);
 }
 
-/*ARGSUSED*/
-static void FetchLocaleArg(
-    Widget widget,	/* unused */
-    Cardinal *size,	/* unused */
-    XrmValue *value)
+static void
+FetchLocaleArg(Widget widget _X_UNUSED,
+               Cardinal *size _X_UNUSED,
+               XrmValue *value)
 {
     static XrmString locale;
 
     locale = XrmQuarkToString(XrmStringToQuark
-			      (setlocale(LC_CTYPE, (char*)NULL)));
+                              (setlocale(LC_CTYPE, (char *) NULL)));
     value->size = sizeof(XrmString);
-    value->addr = (XPointer)&locale;
+    value->addr = (XPointer) &locale;
 }
 
+/* *INDENT-OFF* */
 static XtConvertArgRec const localeDisplayConvertArgs[] = {
     {XtProcedureArg, (XtPointer)FetchDisplayArg, 0},
     {XtProcedureArg, (XtPointer)FetchLocaleArg, 0},
 };
+/* *INDENT-ON* */
 
-
-/*ARGSUSED*/
 Boolean
-XtCvtStringToFontStruct(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+XtCvtStringToFontStruct(Display *dpy,
+                        XrmValuePtr args,
+                        Cardinal *num_args,
+                        XrmValuePtr fromVal,
+                        XrmValuePtr toVal,
+                        XtPointer *closure_ret _X_UNUSED)
 {
-    XFontStruct	    *f;
-    Display*	display;
+    XFontStruct *f;
+    Display *display;
 
     if (*num_args != 1) {
-     XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	     XtNwrongParameters,"cvtStringToFontStruct",XtCXtToolkitError,
-             "String to font conversion needs display argument",
-              NULL, NULL);
-     return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToFontStruct",
+                        XtCXtToolkitError,
+                        "String to font conversion needs display argument",
+                        NULL, NULL);
+        return False;
     }
 
-    display = *(Display**)args[0].addr;
+    display = *(Display **) args[0].addr;
 
-    if (CompareISOLatin1((String)fromVal->addr, XtDefaultFont) != 0) {
-	f = XLoadQueryFont(display, (char *)fromVal->addr);
-	if (f != NULL) {
-  Done:	    donestr( XFontStruct*, f, XtRFontStruct);
-	}
+    if (CompareISOLatin1((String) fromVal->addr, XtDefaultFont) != 0) {
+        f = XLoadQueryFont(display, (char *) fromVal->addr);
 
-	XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
-					 XtRFontStruct);
+        if (f != NULL) {
+ Done:     done_string(XFontStruct *, f, XtRFontStruct);
+        }
+
+        XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                         XtRFontStruct);
     }
 
     /* try and get the default font */
 
     {
-	XrmName xrm_name[2];
-	XrmClass xrm_class[2];
-	XrmRepresentation rep_type;
-	XrmValue value;
-
-	xrm_name[0] = XrmPermStringToQuark ("xtDefaultFont");
-	xrm_name[1] = 0;
-	xrm_class[0] = XrmPermStringToQuark ("XtDefaultFont");
-	xrm_class[1] = 0;
-	if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
-			    &rep_type, &value)) {
-	    if (rep_type == _XtQString) {
-		f = XLoadQueryFont(display, (char*)value.addr);
-		if (f != NULL)
-		    goto Done;
-		else
-		    XtDisplayStringConversionWarning(dpy, (char*)value.addr,
-						     XtRFontStruct);
-	    } else if (rep_type == XtQFont) {
-		f = XQueryFont(display, *(Font*)value.addr );
-		if (f != NULL) goto Done;
-	    } else if (rep_type == XtQFontStruct) {
-		f = (XFontStruct*)value.addr;
-		goto Done;
-	    }
-	}
+        XrmName xrm_name[2];
+        XrmClass xrm_class[2];
+        XrmRepresentation rep_type;
+        XrmValue value;
+
+        xrm_name[0] = XrmPermStringToQuark("xtDefaultFont");
+        xrm_name[1] = 0;
+        xrm_class[0] = XrmPermStringToQuark("XtDefaultFont");
+        xrm_class[1] = 0;
+        if (XrmQGetResource(XtDatabase(display), xrm_name, xrm_class,
+                            &rep_type, &value)) {
+            if (rep_type == _XtQString) {
+                f = XLoadQueryFont(display, (char *) value.addr);
+
+                if (f != NULL)
+                    goto Done;
+                else
+                    XtDisplayStringConversionWarning(dpy, (char *) value.addr,
+                                                     XtRFontStruct);
+            }
+            else if (rep_type == XtQFont) {
+                f = XQueryFont(display, *(Font *) value.addr);
+
+                if (f != NULL)
+                    goto Done;
+            }
+            else if (rep_type == XtQFontStruct) {
+                f = (XFontStruct *) value.addr;
+                goto Done;
+            }
+        }
     }
     /* Should really do XListFonts, but most servers support this */
     f = XLoadQueryFont(display, "-*-*-*-R-*-*-*-120-*-*-*-*-ISO8859-*");
+
     if (f != NULL)
-	goto Done;
+        goto Done;
 
     XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	     "noFont","cvtStringToFontStruct",XtCXtToolkitError,
-             "Unable to load any usable ISO8859 font",
-              NULL, NULL);
+                    "noFont", "cvtStringToFontStruct", XtCXtToolkitError,
+                    "Unable to load any usable ISO8859 font", NULL, NULL);
 
     return False;
 }
 
-/* ARGSUSED */
-static void FreeFontStruct(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,	/* unused */
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+FreeFontStruct(XtAppContext app,
+               XrmValuePtr toVal,
+               XtPointer closure _X_UNUSED,
+               XrmValuePtr args,
+               Cardinal *num_args)
 {
     Display *display;
+
     if (*num_args != 1) {
-     XtAppWarningMsg(app,
-	     XtNwrongParameters,"freeFontStruct",XtCXtToolkitError,
-             "Free FontStruct requires display argument",
-              NULL, NULL);
-     return;
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeFontStruct", XtCXtToolkitError,
+                        "Free FontStruct requires display argument",
+                        NULL, NULL);
+        return;
     }
 
-    display = *(Display**)args[0].addr;
-    XFreeFont( display, *(XFontStruct**)toVal->addr );
+    display = *(Display **) args[0].addr;
+    XFreeFont(display, *(XFontStruct **) toVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToInt(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToInt(Display *dpy,
+                 XrmValuePtr args _X_UNUSED,
+                 Cardinal *num_args,
+                 XrmValuePtr fromVal,
+                 XrmValuePtr toVal,
+                 XtPointer *closure_ret _X_UNUSED)
 {
-    int	i;
+    int i;
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToInt",XtCXtToolkitError,
-                  "String to Integer conversion needs no extra arguments",
-                  NULL, NULL);
-    if (IsInteger((String)fromVal->addr, &i))
-	donestr(int, i, XtRInt);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToInt", XtCXtToolkitError,
+                        "String to Integer conversion needs no extra arguments",
+                        NULL, NULL);
+    if (IsInteger((String) fromVal->addr, &i))
+        done_string(int, i, XtRInt);
 
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRInt);
     return False;
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToShort(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToShort(Display *dpy,
+                   XrmValuePtr args _X_UNUSED,
+                   Cardinal *num_args,
+                   XrmValuePtr fromVal,
+                   XrmValuePtr toVal,
+                   XtPointer *closure_ret _X_UNUSED)
 {
     int i;
 
     if (*num_args != 0)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  XtNwrongParameters,"cvtStringToShort",XtCXtToolkitError,
-          "String to Integer conversion needs no extra arguments",
-           NULL, NULL);
-    if (IsInteger((String)fromVal->addr, &i))
-        donestr(short, (short)i, XtRShort);
+                        XtNwrongParameters, "cvtStringToShort",
+                        XtCXtToolkitError,
+                        "String to Integer conversion needs no extra arguments",
+                        NULL, NULL);
+    if (IsInteger((String) fromVal->addr, &i))
+        done_string(short, (short) i, XtRShort);
 
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRShort);
     return False;
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToDimension(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToDimension(Display *dpy,
+                       XrmValuePtr args _X_UNUSED,
+                       Cardinal *num_args,
+                       XrmValuePtr fromVal,
+                       XrmValuePtr toVal,
+                       XtPointer *closure_ret _X_UNUSED)
 {
     int i;
 
     if (*num_args != 0)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  XtNwrongParameters,"cvtStringToDimension",XtCXtToolkitError,
-          "String to Dimension conversion needs no extra arguments",
-           NULL, NULL);
-    if (IsInteger((String)fromVal->addr, &i)) {
-        if ( i < 0 )
-            XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
-					     XtRDimension);
-        donestr(Dimension, (Dimension)i, XtRDimension);
+                        XtNwrongParameters, "cvtStringToDimension",
+                        XtCXtToolkitError,
+                        "String to Dimension conversion needs no extra arguments",
+                        NULL, NULL);
+    if (IsInteger((String) fromVal->addr, &i)) {
+        if (i < 0)
+            XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                             XtRDimension);
+        done_string(Dimension, (Dimension) i, XtRDimension);
     }
     XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRDimension);
     return False;
 }
 
-/*ARGSUSED*/
-Boolean XtCvtIntToUnsignedChar(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToUnsignedChar(Display *dpy,
+                       XrmValuePtr args _X_UNUSED,
+                       Cardinal *num_args,
+                       XrmValuePtr fromVal,
+                       XrmValuePtr toVal,
+                       XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToUnsignedChar",XtCXtToolkitError,
-                  "Integer to UnsignedChar conversion needs no extra arguments",
-                   NULL, NULL);
-    done(unsigned char, (*(int *)fromVal->addr));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToUnsignedChar",
+                        XtCXtToolkitError,
+                        "Integer to UnsignedChar conversion needs no extra arguments",
+                        NULL, NULL);
+    done(unsigned char, (*(int *) fromVal->addr));
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtStringToUnsignedChar(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToUnsignedChar(Display *dpy,
+                          XrmValuePtr args _X_UNUSED,
+                          Cardinal *num_args,
+                          XrmValuePtr fromVal,
+                          XrmValuePtr toVal,
+                          XtPointer *closure_ret _X_UNUSED)
 {
     int i;
 
     if (*num_args != 0)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToUnsignedChar",XtCXtToolkitError,
-                  "String to Integer conversion needs no extra arguments",
-                   NULL, NULL);
-    if (IsInteger((String)fromVal->addr, &i)) {
-        if ( i < 0 || i > 255 )
-            XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
-					     XtRUnsignedChar);
-        donestr(unsigned char, i, XtRUnsignedChar);
+                        XtNwrongParameters, "cvtStringToUnsignedChar",
+                        XtCXtToolkitError,
+                        "String to Integer conversion needs no extra arguments",
+                        NULL, NULL);
+    if (IsInteger((String) fromVal->addr, &i)) {
+        if (i < 0 || i > 255)
+            XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                             XtRUnsignedChar);
+        done_string(unsigned char, i, XtRUnsignedChar);
     }
-    XtDisplayStringConversionWarning(dpy, (char*)fromVal->addr,
-				     XtRUnsignedChar);
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                     XtRUnsignedChar);
     return False;
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtColorToPixel(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtColorToPixel(Display *dpy,
+                  XrmValuePtr args _X_UNUSED,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtXColorToPixel",XtCXtToolkitError,
-                  "Color to Pixel conversion needs no extra arguments",
-                   NULL, NULL);
-    done(Pixel, ((XColor *)fromVal->addr)->pixel);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtXColorToPixel",
+                        XtCXtToolkitError,
+                        "Color to Pixel conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Pixel, ((XColor *) fromVal->addr)->pixel);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtIntToPixel(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToPixel(Display *dpy,
+                XrmValuePtr args _X_UNUSED,
+                Cardinal *num_args,
+                XrmValuePtr fromVal,
+                XrmValuePtr toVal,
+                XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToPixel",XtCXtToolkitError,
-                  "Integer to Pixel conversion needs no extra arguments",
-                   NULL, NULL);
-    done(Pixel, *(int*)fromVal->addr);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtIntToPixel", XtCXtToolkitError,
+                        "Integer to Pixel conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Pixel, *(int *) fromVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtIntToPixmap(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtIntToPixmap(Display *dpy,
+                 XrmValuePtr args _X_UNUSED,
+                 Cardinal *num_args,
+                 XrmValuePtr fromVal,
+                 XrmValuePtr toVal,
+                 XtPointer *closure_ret _X_UNUSED)
 {
     if (*num_args != 0)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtIntToPixmap",XtCXtToolkitError,
-                  "Integer to Pixmap conversion needs no extra arguments",
-                   NULL, NULL);
-    done(Pixmap, *(int*)fromVal->addr);
+                        XtNwrongParameters, "cvtIntToPixmap", XtCXtToolkitError,
+                        "Integer to Pixmap conversion needs no extra arguments",
+                        NULL, NULL);
+    done(Pixmap, *(int *) fromVal->addr);
 }
 
 #ifdef MOTIFBC
-void LowerCase(register char  *source, register *dest)
+void
+LowerCase(register char *source, register *dest)
 {
     register char ch;
     int i;
 
     for (i = 0; (ch = *source) != 0 && i < 999; source++, dest++, i++) {
-    	if ('A' <= ch && ch <= 'Z')
-	    *dest = ch - 'A' + 'a';
-	else
-	    *dest = ch;
+        if ('A' <= ch && ch <= 'Z')
+            *dest = ch - 'A' + 'a';
+        else
+            *dest = ch;
     }
     *dest = 0;
 }
 #endif
 
-static int CompareISOLatin1 (const char *first, const char *second)
+static int
+CompareISOLatin1(const char *first, const char *second)
 {
     register const unsigned char *ap, *bp;
 
     for (ap = (const unsigned char *) first,
-	 bp = (const unsigned char *) second;
-	 *ap && *bp; ap++, bp++) {
-	register unsigned char a, b;
-
-	if ((a = *ap) != (b = *bp)) {
-	    /* try lowercasing and try again */
-
-	    if ((a >= XK_A) && (a <= XK_Z))
-	      a = (unsigned char) (a + (XK_a - XK_A));
-	    else if ((a >= XK_Agrave) && (a <= XK_Odiaeresis))
-	      a = (unsigned char) (a + (XK_agrave - XK_Agrave));
-	    else if ((a >= XK_Ooblique) && (a <= XK_Thorn))
-	      a = (unsigned char) (a + (XK_oslash - XK_Ooblique));
-
-	    if ((b >= XK_A) && (b <= XK_Z))
-	      b = (unsigned char) (b + (XK_a - XK_A));
-	    else if ((b >= XK_Agrave) && (b <= XK_Odiaeresis))
-	      b = (unsigned char) (b + (XK_agrave - XK_Agrave));
-	    else if ((b >= XK_Ooblique) && (b <= XK_Thorn))
-	      b = (unsigned char) (b + (XK_oslash - XK_Ooblique));
-
-	    if (a != b) break;
-	}
+         bp = (const unsigned char *) second; *ap && *bp; ap++, bp++) {
+        register unsigned char a, b;
+
+        if ((a = *ap) != (b = *bp)) {
+            /* try lowercasing and try again */
+
+            if ((a >= XK_A) && (a <= XK_Z))
+                a = (unsigned char) (a + (XK_a - XK_A));
+            else if ((a >= XK_Agrave) && (a <= XK_Odiaeresis))
+                a = (unsigned char) (a + (XK_agrave - XK_Agrave));
+            else if ((a >= XK_Ooblique) && (a <= XK_Thorn))
+                a = (unsigned char) (a + (XK_oslash - XK_Ooblique));
+
+            if ((b >= XK_A) && (b <= XK_Z))
+                b = (unsigned char) (b + (XK_a - XK_A));
+            else if ((b >= XK_Agrave) && (b <= XK_Odiaeresis))
+                b = (unsigned char) (b + (XK_agrave - XK_Agrave));
+            else if ((b >= XK_Ooblique) && (b <= XK_Thorn))
+                b = (unsigned char) (b + (XK_oslash - XK_Ooblique));
+
+            if (a != b)
+                break;
+        }
     }
     return (((int) *bp) - ((int) *ap));
 }
 
-static void CopyISOLatin1Lowered(char *dst, const char *src)
+static void
+CopyISOLatin1Lowered(char *dst, const char *src)
 {
     unsigned char *dest = (unsigned char *) dst;
     const unsigned char *source = (const unsigned char *) src;
 
-    for ( ; *source; source++, dest++) {
-	if (*source >= XK_A  && *source <= XK_Z)
-	    *dest = (unsigned char) (*source + (XK_a - XK_A));
-	else if (*source >= XK_Agrave && *source <= XK_Odiaeresis)
-	    *dest = (unsigned char) (*source + (XK_agrave - XK_Agrave));
-	else if (*source >= XK_Ooblique && *source <= XK_Thorn)
-	    *dest = (unsigned char) (*source + (XK_oslash - XK_Ooblique));
-	else
-	    *dest = *source;
+    for (; *source; source++, dest++) {
+        if (*source >= XK_A && *source <= XK_Z)
+            *dest = (unsigned char) (*source + (XK_a - XK_A));
+        else if (*source >= XK_Agrave && *source <= XK_Odiaeresis)
+            *dest = (unsigned char) (*source + (XK_agrave - XK_Agrave));
+        else if (*source >= XK_Ooblique && *source <= XK_Thorn)
+            *dest = (unsigned char) (*source + (XK_oslash - XK_Ooblique));
+        else
+            *dest = *source;
     }
     *dest = '\0';
 }
 
-/*ARGSUSED*/
 Boolean
-XtCvtStringToInitialState(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+XtCvtStringToInitialState(Display *dpy,
+                          XrmValuePtr args _X_UNUSED,
+                          Cardinal *num_args,
+                          XrmValuePtr fromVal,
+                          XrmValuePtr toVal,
+                          XtPointer *closure_ret _X_UNUSED)
 {
-    String str = (String)fromVal->addr;
+    String str = (String) fromVal->addr;
+
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToInitialState",XtCXtToolkitError,
-                  "String to InitialState conversion needs no extra arguments",
-                   NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToInitialState",
+                        XtCXtToolkitError,
+                        "String to InitialState conversion needs no extra arguments",
+                        NULL, NULL);
+
+    if (CompareISOLatin1(str, "NormalState") == 0)
+        done_string(int, NormalState, XtRInitialState);
+
+    if (CompareISOLatin1(str, "IconicState") == 0)
+        done_string(int, IconicState, XtRInitialState);
 
-    if (CompareISOLatin1(str, "NormalState") == 0) donestr(int, NormalState, XtRInitialState);
-    if (CompareISOLatin1(str, "IconicState") == 0) donestr(int, IconicState, XtRInitialState);
     {
-	int val;
-	if (IsInteger(str, &val)) donestr( int, val, XtRInitialState );
+        int val;
+
+        if (IsInteger(str, &val))
+            done_string(int, val, XtRInitialState);
     }
     XtDisplayStringConversionWarning(dpy, str, XtRInitialState);
     return False;
 }
 
+/* *INDENT-OFF* */
 static XtConvertArgRec const visualConvertArgs[] = {
     {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
      sizeof(Screen *)},
     {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.depth),
      sizeof(Cardinal)}
 };
+/* *INDENT-ON* */
 
-/*ARGSUSED*/
-Boolean XtCvtStringToVisual(
-    Display*	dpy,
-    XrmValuePtr args,		/* Screen, depth */
-    Cardinal    *num_args,	/* 2 */
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)	/* unused */
+Boolean
+XtCvtStringToVisual(Display *dpy, XrmValuePtr args,     /* Screen, depth */
+                    Cardinal *num_args,        /* 2 */
+                    XrmValuePtr fromVal,
+                    XrmValuePtr toVal,
+                    XtPointer *closure_ret _X_UNUSED)
 {
-    String str = (String)fromVal->addr;
+    String str = (String) fromVal->addr;
     int vc;
     XVisualInfo vinfo;
+
     if (*num_args != 2) {
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToVisual",XtCXtToolkitError,
-                  "String to Visual conversion needs screen and depth arguments",
-                   NULL, NULL);
-	return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToVisual",
+                        XtCXtToolkitError,
+                        "String to Visual conversion needs screen and depth arguments",
+                        NULL, NULL);
+        return False;
     }
 
-         if (CompareISOLatin1(str, "StaticGray") == 0)	vc = StaticGray;
-    else if (CompareISOLatin1(str, "StaticColor") == 0)	vc = StaticColor;
-    else if (CompareISOLatin1(str, "TrueColor") == 0)	vc = TrueColor;
-    else if (CompareISOLatin1(str, "GrayScale") == 0)	vc = GrayScale;
-    else if (CompareISOLatin1(str, "PseudoColor") == 0)	vc = PseudoColor;
-    else if (CompareISOLatin1(str, "DirectColor") == 0)	vc = DirectColor;
+    if (CompareISOLatin1(str, "StaticGray") == 0)
+        vc = StaticGray;
+    else if (CompareISOLatin1(str, "StaticColor") == 0)
+        vc = StaticColor;
+    else if (CompareISOLatin1(str, "TrueColor") == 0)
+        vc = TrueColor;
+    else if (CompareISOLatin1(str, "GrayScale") == 0)
+        vc = GrayScale;
+    else if (CompareISOLatin1(str, "PseudoColor") == 0)
+        vc = PseudoColor;
+    else if (CompareISOLatin1(str, "DirectColor") == 0)
+        vc = DirectColor;
     else if (!IsInteger(str, &vc)) {
-	XtDisplayStringConversionWarning(dpy, str, "Visual class name");
-	return False;
+        XtDisplayStringConversionWarning(dpy, str, "Visual class name");
+        return False;
     }
 
-    if (XMatchVisualInfo( XDisplayOfScreen((Screen*)*(Screen**)args[0].addr),
-		     XScreenNumberOfScreen((Screen*)*(Screen**)args[0].addr),
-		     (int)*(int*)args[1].addr,
-		     vc,
-		     &vinfo) ) {
-	donestr( Visual*, vinfo.visual, XtRVisual );
+    if (XMatchVisualInfo(XDisplayOfScreen((Screen *) *(Screen **) args[0].addr),
+                         XScreenNumberOfScreen((Screen *) *(Screen **) args[0].
+                                               addr),
+                         (int) *(int *) args[1].addr, vc, &vinfo)) {
+        done_string(Visual *, vinfo.visual, XtRVisual);
     }
     else {
-	String params[2];
-	Cardinal num_params = 2;
-	params[0] = str;
-	params[1] =
-	    DisplayString(XDisplayOfScreen((Screen*)*(Screen**)args[0].addr));
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNconversionError, "stringToVisual", XtCXtToolkitError,
-                  "Cannot find Visual of class %s for display %s",
-		  params, &num_params );
-	return False;
+        String params[2];
+        Cardinal num_params = 2;
+
+        params[0] = str;
+        params[1] =
+            DisplayString(XDisplayOfScreen
+                          ((Screen *) *(Screen **) args[0].addr));
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy), XtNconversionError,
+                        "stringToVisual", XtCXtToolkitError,
+                        "Cannot find Visual of class %s for display %s", params,
+                        &num_params);
+        return False;
     }
 }
 
-
-/*ARGSUSED*/
-Boolean XtCvtStringToAtom(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr	fromVal,
-    XrmValuePtr	toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToAtom(Display *dpy,
+                  XrmValuePtr args,
+                  Cardinal *num_args,
+                  XrmValuePtr fromVal,
+                  XrmValuePtr toVal,
+                  XtPointer *closure_ret _X_UNUSED)
 {
     Atom atom;
+
     if (*num_args != 1) {
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		  XtNwrongParameters,"cvtStringToAtom",XtCXtToolkitError,
-                  "String to Atom conversion needs Display argument",
-                   NULL, NULL);
-	return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToAtom",
+                        XtCXtToolkitError,
+                        "String to Atom conversion needs Display argument",
+                        NULL, NULL);
+        return False;
     }
 
-    atom =  XInternAtom( *(Display**)args->addr, (char*)fromVal->addr, False );
-    donestr(Atom, atom, XtRAtom);
+    atom = XInternAtom(*(Display **) args->addr, (char *) fromVal->addr, False);
+    done_string(Atom, atom, XtRAtom);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToDirectoryString(
-    Display	*dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToDirectoryString(Display *dpy,
+                             XrmValuePtr args _X_UNUSED,
+                             Cardinal *num_args,
+                             XrmValuePtr fromVal,
+                             XrmValuePtr toVal,
+                             XtPointer *closure_ret _X_UNUSED)
 {
     String str;
-    char directory[PATH_MAX+1];
+    char directory[PATH_MAX + 1];
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-           XtNwrongParameters,"cvtStringToDirectoryString",XtCXtToolkitError,
-           "String to DirectoryString conversion needs no extra arguments",
-           NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToDirectoryString",
+                        XtCXtToolkitError,
+                        "String to DirectoryString conversion needs no extra arguments",
+                        NULL, NULL);
 
-    str = (String)fromVal->addr;
+    str = (String) fromVal->addr;
     if (CompareISOLatin1(str, "XtCurrentDirectory") == 0) {
-	/* uglier, but does not depend on compiler knowing return type */
+        /* uglier, but does not depend on compiler knowing return type */
 #if !defined(X_NOT_POSIX) || defined(SYSV) || defined(WIN32)
-	if (getcwd(directory, PATH_MAX + 1))
-	    str = directory;
+        if (getcwd(directory, PATH_MAX + 1))
+            str = directory;
 #else
-	if (getwd(directory))
-	    str = directory;
+        if (getwd(directory))
+            str = directory;
 #endif
-	if (!str) {
-	    if (errno == EACCES)
-		errno = 0;	    /* reset errno */
-	    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
-					     XtRDirectoryString);
-	    return False;
-	}
+        if (!str) {
+            if (errno == EACCES)
+                errno = 0;      /* reset errno */
+            XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr,
+                                             XtRDirectoryString);
+            return False;
+        }
     }
 
     /* Since memory from the resource database or from static buffers of
@@ -1567,62 +1602,66 @@ Boolean XtCvtStringToDirectoryString(
      * The memory is freed when all cache references are released.
      */
     str = XtNewString(str);
-    donestr(String, str, XtRDirectoryString);
+    done_string(String, str, XtRDirectoryString);
 }
 
-/*ARGSUSED*/
-static void FreeDirectoryString(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,	/* unused */
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+FreeDirectoryString(XtAppContext app,
+                    XrmValuePtr toVal,
+                    XtPointer closure _X_UNUSED,
+                    XrmValuePtr args _X_UNUSED,
+                    Cardinal *num_args)
 {
     if (*num_args != 0)
-	XtAppWarningMsg(app,
-		 XtNwrongParameters,"freeDirectoryString",XtCXtToolkitError,
-		 "Free Directory String requires no extra arguments",
-                 NULL, NULL);
+        XtAppWarningMsg(app,
+                        XtNwrongParameters, "freeDirectoryString",
+                        XtCXtToolkitError,
+                        "Free Directory String requires no extra arguments",
+                        NULL, NULL);
 
     XtFree((char *) toVal->addr);
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToRestartStyle(
-    Display	*dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToRestartStyle(Display *dpy,
+                          XrmValuePtr args _X_UNUSED,
+                          Cardinal *num_args,
+                          XrmValuePtr fromVal,
+                          XrmValuePtr toVal,
+                          XtPointer *closure_ret _X_UNUSED)
 {
-    String str = (String)fromVal->addr;
+    String str = (String) fromVal->addr;
+
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	      XtNwrongParameters,"cvtStringToRestartStyle",XtCXtToolkitError,
-              "String to RestartStyle conversion needs no extra arguments",
-              NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToRestartStyle",
+                        XtCXtToolkitError,
+                        "String to RestartStyle conversion needs no extra arguments",
+                        NULL, NULL);
 
     if (CompareISOLatin1(str, "RestartIfRunning") == 0)
-	donestr(unsigned char, SmRestartIfRunning, XtRRestartStyle);
+        done_string(unsigned char, SmRestartIfRunning, XtRRestartStyle);
+
     if (CompareISOLatin1(str, "RestartAnyway") == 0)
-	donestr(unsigned char, SmRestartAnyway, XtRRestartStyle);
+        done_string(unsigned char, SmRestartAnyway, XtRRestartStyle);
+
     if (CompareISOLatin1(str, "RestartImmediately") == 0)
-	donestr(unsigned char, SmRestartImmediately, XtRRestartStyle);
+        done_string(unsigned char, SmRestartImmediately, XtRRestartStyle);
+
     if (CompareISOLatin1(str, "RestartNever") == 0)
-	donestr(unsigned char, SmRestartNever, XtRRestartStyle);
+        done_string(unsigned char, SmRestartNever, XtRRestartStyle);
+
     XtDisplayStringConversionWarning(dpy, str, XtRRestartStyle);
     return False;
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToCommandArgArray(
-    Display	*dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToCommandArgArray(Display *dpy,
+                             XrmValuePtr args _X_UNUSED,
+                             Cardinal *num_args,
+                             XrmValuePtr fromVal,
+                             XrmValuePtr toVal,
+                             XtPointer *closure_ret)
 {
     String *strarray, *ptr;
     char *src;
@@ -1630,125 +1669,128 @@ Boolean XtCvtStringToCommandArgArray(
     int tokens, len;
 
     if (*num_args != 0)
-	XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-            XtNwrongParameters,"cvtStringToCommandArgArray",XtCXtToolkitError,
-            "String to CommandArgArray conversion needs no extra arguments",
-            NULL, NULL);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        XtNwrongParameters, "cvtStringToCommandArgArray",
+                        XtCXtToolkitError,
+                        "String to CommandArgArray conversion needs no extra arguments",
+                        NULL, NULL);
 
     src = fromVal->addr;
     dst = dst_str = __XtMalloc((unsigned) strlen(src) + 1);
     tokens = 0;
 
     while (*src != '\0') {
-	char *start;
-
-	/* skip whitespace */
-	while (IsWhitespace(*src) || IsNewline(*src))
-	    src++;
-	/* test for end of string */
-	if (*src == '\0')
-	    break;
-
-	/* start new token */
-	tokens++;
-	start = src;
-	while (*src != '\0' && !IsWhitespace(*src) && !IsNewline(*src)) {
-	    if (*src == '\\' &&
-		(IsWhitespace(*(src+1)) || IsNewline(*(src+1)))) {
-		len = (int) (src - start);
-		if (len) {
-		    /* copy preceeding part of token */
-		    memcpy(dst, start, (size_t) len);
-		    dst += len;
-		}
-		/* skip backslash */
-		src++;
-		/* next part of token starts at whitespace */
-		start = src;
-	    }
-	    src++;
-	}
-	len = (int) (src - start);
-	if (len) {
-	    /* copy last part of token */
-	    memcpy(dst, start, (size_t) len);
-	    dst += len;
-	}
-	*dst = '\0';
-	if (*src != '\0')
-	    dst++;
+        char *start;
+
+        /* skip whitespace */
+        while (IsWhitespace(*src) || IsNewline(*src))
+            src++;
+        /* test for end of string */
+        if (*src == '\0')
+            break;
+
+        /* start new token */
+        tokens++;
+        start = src;
+        while (*src != '\0' && !IsWhitespace(*src) && !IsNewline(*src)) {
+            if (*src == '\\' &&
+                (IsWhitespace(*(src + 1)) || IsNewline(*(src + 1)))) {
+                len = (int) (src - start);
+                if (len) {
+                    /* copy preceeding part of token */
+                    memcpy(dst, start, (size_t) len);
+                    dst += len;
+                }
+                /* skip backslash */
+                src++;
+                /* next part of token starts at whitespace */
+                start = src;
+            }
+            src++;
+        }
+        len = (int) (src - start);
+        if (len) {
+            /* copy last part of token */
+            memcpy(dst, start, (size_t) len);
+            dst += len;
+        }
+        *dst = '\0';
+        if (*src != '\0')
+            dst++;
     }
 
-    ptr = strarray = (String*) __XtMalloc((Cardinal)((size_t)(tokens+1) * sizeof(String)));
+    ptr = strarray = (String *)
+        __XtMalloc((Cardinal) ((size_t) (tokens + 1) * sizeof(String)));
     src = dst_str;
     while (--tokens >= 0) {
-	*ptr = src;
-	ptr++;
-	if (tokens) {
-	    len = (int) strlen(src);
-	    src = src + len + 1;
-	}
+        *ptr = src;
+        ptr++;
+        if (tokens) {
+            len = (int) strlen(src);
+            src = src + len + 1;
+        }
     }
     *ptr = NULL;
 
     *closure_ret = (XtPointer) strarray;
-    donestr(char**, strarray, XtRCommandArgArray)
+    done_typed_string(String *, strarray, XtRCommandArgArray)
 }
 
-/*ARGSUSED*/
-static void ArgArrayDestructor(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+static void
+ArgArrayDestructor(XtAppContext app _X_UNUSED,
+                   XrmValuePtr toVal _X_UNUSED,
+                   XtPointer closure,
+                   XrmValuePtr args _X_UNUSED,
+                   Cardinal *num_args _X_UNUSED)
 {
     if (closure) {
-	_XtString *strarray = (_XtString*) closure;
-	XtFree(*strarray);
-	XtFree((char *) strarray);
+        _XtString *strarray = (_XtString *) closure;
+
+        XtFree(*strarray);
+        XtFree((char *) strarray);
     }
 }
 
-/*ARGSUSED*/
-Boolean XtCvtStringToGravity (
-    Display* dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr fromVal,
-    XrmValuePtr toVal,
-    XtPointer	*closure_ret)
+Boolean
+XtCvtStringToGravity(Display *dpy,
+                     XrmValuePtr args _X_UNUSED,
+                     Cardinal *num_args,
+                     XrmValuePtr fromVal,
+                     XrmValuePtr toVal,
+                     XtPointer *closure_ret _X_UNUSED)
 {
+    /* *INDENT-OFF* */
     static struct _namepair {
-	XrmQuark quark;
-	const char *name;
-	int gravity;
+        XrmQuark quark;
+        const char *name;
+        int gravity;
     } names[] = {
-	{ NULLQUARK, "forget",		ForgetGravity },
-	{ NULLQUARK, "northwest",	NorthWestGravity },
-	{ NULLQUARK, "north",		NorthGravity },
-	{ NULLQUARK, "northeast",	NorthEastGravity },
-	{ NULLQUARK, "west",		WestGravity },
-	{ NULLQUARK, "center",		CenterGravity },
-	{ NULLQUARK, "east",		EastGravity },
-	{ NULLQUARK, "southwest",	SouthWestGravity },
-	{ NULLQUARK, "south",		SouthGravity },
-	{ NULLQUARK, "southeast",	SouthEastGravity },
-	{ NULLQUARK, "static",		StaticGravity },
-	{ NULLQUARK, "unmap",		UnmapGravity },
-	{ NULLQUARK, "0",		ForgetGravity },
-	{ NULLQUARK, "1",		NorthWestGravity },
-	{ NULLQUARK, "2",		NorthGravity },
-	{ NULLQUARK, "3",		NorthEastGravity },
-	{ NULLQUARK, "4",		WestGravity },
-	{ NULLQUARK, "5",		CenterGravity },
-	{ NULLQUARK, "6",		EastGravity },
-	{ NULLQUARK, "7",		SouthWestGravity },
-	{ NULLQUARK, "8",		SouthGravity },
-	{ NULLQUARK, "9",		SouthEastGravity },
-	{ NULLQUARK, "10",		StaticGravity },
-	{ NULLQUARK, NULL,		ForgetGravity }
+        { NULLQUARK, "forget",          ForgetGravity },
+        { NULLQUARK, "northwest",       NorthWestGravity },
+        { NULLQUARK, "north",           NorthGravity },
+        { NULLQUARK, "northeast",       NorthEastGravity },
+        { NULLQUARK, "west",            WestGravity },
+        { NULLQUARK, "center",          CenterGravity },
+        { NULLQUARK, "east",            EastGravity },
+        { NULLQUARK, "southwest",       SouthWestGravity },
+        { NULLQUARK, "south",           SouthGravity },
+        { NULLQUARK, "southeast",       SouthEastGravity },
+        { NULLQUARK, "static",          StaticGravity },
+        { NULLQUARK, "unmap",           UnmapGravity },
+        { NULLQUARK, "0",               ForgetGravity },
+        { NULLQUARK, "1",               NorthWestGravity },
+        { NULLQUARK, "2",               NorthGravity },
+        { NULLQUARK, "3",               NorthEastGravity },
+        { NULLQUARK, "4",               WestGravity },
+        { NULLQUARK, "5",               CenterGravity },
+        { NULLQUARK, "6",               EastGravity },
+        { NULLQUARK, "7",               SouthWestGravity },
+        { NULLQUARK, "8",               SouthGravity },
+        { NULLQUARK, "9",               SouthEastGravity },
+        { NULLQUARK, "10",              StaticGravity },
+        { NULLQUARK, NULL,              ForgetGravity }
     };
+    /* *INDENT-ON* */
     static Boolean haveQuarks = FALSE;
     char lowerName[40];
     XrmQuark q;
@@ -1756,103 +1798,105 @@ Boolean XtCvtStringToGravity (
     struct _namepair *np;
 
     if (*num_args != 0) {
-        XtAppWarningMsg(XtDisplayToApplicationContext (dpy),
-			"wrongParameters","cvtStringToGravity","XtToolkitError",
-			"String to Gravity conversion needs no extra arguments",
-			NULL, NULL);
-	return False;
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        "wrongParameters", "cvtStringToGravity",
+                        "XtToolkitError",
+                        "String to Gravity conversion needs no extra arguments",
+                        NULL, NULL);
+        return False;
     }
     if (!haveQuarks) {
-	for (np = names; np->name; np++) {
-	    np->quark = XrmPermStringToQuark (np->name);
-	}
-	haveQuarks = TRUE;
+        for (np = names; np->name; np++) {
+            np->quark = XrmPermStringToQuark(np->name);
+        }
+        haveQuarks = TRUE;
     }
     s = (char *) fromVal->addr;
     if (strlen(s) < sizeof lowerName) {
-	CopyISOLatin1Lowered (lowerName, s);
-	q = XrmStringToQuark (lowerName);
-	for (np = names; np->name; np++)
-	    if (np->quark == q) donestr(int, np->gravity, XtRGravity);
+        CopyISOLatin1Lowered(lowerName, s);
+        q = XrmStringToQuark(lowerName);
+        for (np = names; np->name; np++)
+            if (np->quark == q)
+                done_string(int, np->gravity, XtRGravity);
     }
-    XtDisplayStringConversionWarning(dpy, (char *)fromVal->addr, XtRGravity);
+    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRGravity);
     return False;
 }
 
-void _XtAddDefaultConverters(
-    ConverterTable table)
+void
+_XtAddDefaultConverters(ConverterTable table)
 {
 #define Add(from, to, proc, convert_args, num_args, cache) \
     _XtTableAddConverter(table, from, to, proc, \
-	    (XtConvertArgList) convert_args, (Cardinal)num_args, \
-	    True, cache, (XtDestructor)NULL, True)
+            (XtConvertArgRec const*) convert_args, (Cardinal)num_args, \
+            True, cache, (XtDestructor)NULL, True)
 
 #define Add2(from, to, proc, convert_args, num_args, cache, destructor) \
     _XtTableAddConverter(table, from, to, proc, \
-	    (XtConvertArgList) convert_args, (Cardinal)num_args, \
-	    True, cache, destructor, True)
-
-    Add(XtQColor, XtQPixel,       XtCvtColorToPixel,   NULL, 0, XtCacheNone);
-
-    Add(XtQInt,   XtQBool,	  XtCvtIntToBool,      NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQBoolean,     XtCvtIntToBoolean,   NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQColor,	  XtCvtIntToColor,
-	colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
-    Add(XtQInt,   XtQDimension,   XtCvtIntToShort,     NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQFloat,       XtCvtIntToFloat,     NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQFont,        XtCvtIntToFont,      NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQPixel,       XtCvtIntToPixel,     NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQPixmap,      XtCvtIntToPixmap,    NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQPosition,    XtCvtIntToShort,     NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQShort,       XtCvtIntToShort,     NULL, 0, XtCacheNone);
-    Add(XtQInt,   XtQUnsignedChar,XtCvtIntToUnsignedChar,NULL, 0, XtCacheNone);
-
-    Add(XtQPixel, XtQColor,	  XtCvtIntToColor,
-	colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
-
-    Add(_XtQString, XtQAtom,      XtCvtStringToAtom,
-	displayConvertArg, XtNumber(displayConvertArg), XtCacheNone);
-    Add(_XtQString, XtQBool,      XtCvtStringToBool,    NULL, 0, XtCacheNone);
-    Add(_XtQString, XtQBoolean,   XtCvtStringToBoolean, NULL, 0, XtCacheNone);
-   Add2(_XtQString, XtQCommandArgArray,  XtCvtStringToCommandArgArray,
-	NULL, 0, XtCacheNone | XtCacheRefCount, ArgArrayDestructor);
-   Add2(_XtQString, XtQCursor,    XtCvtStringToCursor,
-	displayConvertArg, XtNumber(displayConvertArg),
-	XtCacheByDisplay, FreeCursor);
-    Add(_XtQString, XtQDimension, XtCvtStringToDimension,NULL, 0, XtCacheNone);
-   Add2(_XtQString, XtQDirectoryString, XtCvtStringToDirectoryString, NULL, 0,
-	XtCacheNone | XtCacheRefCount, FreeDirectoryString);
-    Add(_XtQString, XtQDisplay,   XtCvtStringToDisplay, NULL, 0, XtCacheAll);
-   Add2(_XtQString, XtQFile,      XtCvtStringToFile,    NULL, 0,
-	XtCacheAll | XtCacheRefCount, FreeFile);
-    Add(_XtQString, XtQFloat,     XtCvtStringToFloat,   NULL, 0, XtCacheNone);
-
-   Add2(_XtQString, XtQFont,      XtCvtStringToFont,
-	displayConvertArg, XtNumber(displayConvertArg),
-	XtCacheByDisplay, FreeFont);
-   Add2(_XtQString, XtQFontSet,   XtCvtStringToFontSet,
-	localeDisplayConvertArgs, XtNumber(localeDisplayConvertArgs),
-	XtCacheByDisplay, FreeFontSet);
-   Add2(_XtQString, XtQFontStruct,XtCvtStringToFontStruct,
-	displayConvertArg, XtNumber(displayConvertArg),
-	XtCacheByDisplay, FreeFontStruct);
-
-    Add(_XtQString, XtQGravity,   XtCvtStringToGravity, NULL, 0, XtCacheNone);
+            (XtConvertArgRec const *) convert_args, (Cardinal)num_args, \
+            True, cache, destructor, True)
+
+    Add(XtQColor, XtQPixel, XtCvtColorToPixel, NULL, 0, XtCacheNone);
+
+    Add(XtQInt, XtQBool, XtCvtIntToBool, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQBoolean, XtCvtIntToBoolean, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQColor, XtCvtIntToColor,
+        colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
+    Add(XtQInt, XtQDimension, XtCvtIntToShort, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQFloat, XtCvtIntToFloat, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQFont, XtCvtIntToFont, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQPixel, XtCvtIntToPixel, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQPixmap, XtCvtIntToPixmap, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQPosition, XtCvtIntToShort, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQShort, XtCvtIntToShort, NULL, 0, XtCacheNone);
+    Add(XtQInt, XtQUnsignedChar, XtCvtIntToUnsignedChar, NULL, 0, XtCacheNone);
+
+    Add(XtQPixel, XtQColor, XtCvtIntToColor,
+        colorConvertArgs, XtNumber(colorConvertArgs), XtCacheByDisplay);
+
+    Add(_XtQString, XtQAtom, XtCvtStringToAtom,
+        displayConvertArg, XtNumber(displayConvertArg), XtCacheNone);
+    Add(_XtQString, XtQBool, XtCvtStringToBool, NULL, 0, XtCacheNone);
+    Add(_XtQString, XtQBoolean, XtCvtStringToBoolean, NULL, 0, XtCacheNone);
+    Add2(_XtQString, XtQCommandArgArray, XtCvtStringToCommandArgArray,
+         NULL, 0, XtCacheNone | XtCacheRefCount, ArgArrayDestructor);
+    Add2(_XtQString, XtQCursor, XtCvtStringToCursor,
+         displayConvertArg, XtNumber(displayConvertArg),
+         XtCacheByDisplay, FreeCursor);
+    Add(_XtQString, XtQDimension, XtCvtStringToDimension, NULL, 0, XtCacheNone);
+    Add2(_XtQString, XtQDirectoryString, XtCvtStringToDirectoryString, NULL, 0,
+         XtCacheNone | XtCacheRefCount, FreeDirectoryString);
+    Add(_XtQString, XtQDisplay, XtCvtStringToDisplay, NULL, 0, XtCacheAll);
+    Add2(_XtQString, XtQFile, XtCvtStringToFile, NULL, 0,
+         XtCacheAll | XtCacheRefCount, FreeFile);
+    Add(_XtQString, XtQFloat, XtCvtStringToFloat, NULL, 0, XtCacheNone);
+
+    Add2(_XtQString, XtQFont, XtCvtStringToFont,
+         displayConvertArg, XtNumber(displayConvertArg),
+         XtCacheByDisplay, FreeFont);
+    Add2(_XtQString, XtQFontSet, XtCvtStringToFontSet,
+         localeDisplayConvertArgs, XtNumber(localeDisplayConvertArgs),
+         XtCacheByDisplay, FreeFontSet);
+    Add2(_XtQString, XtQFontStruct, XtCvtStringToFontStruct,
+         displayConvertArg, XtNumber(displayConvertArg),
+         XtCacheByDisplay, FreeFontStruct);
+
+    Add(_XtQString, XtQGravity, XtCvtStringToGravity, NULL, 0, XtCacheNone);
     Add(_XtQString, XtQInitialState, XtCvtStringToInitialState, NULL, 0,
-	XtCacheNone);
-    Add(_XtQString, XtQInt,	     XtCvtStringToInt,    NULL, 0, XtCacheAll);
-   Add2(_XtQString, XtQPixel,        XtCvtStringToPixel,
-	colorConvertArgs, XtNumber(colorConvertArgs),
-	XtCacheByDisplay, FreePixel);
-    Add(_XtQString, XtQPosition,     XtCvtStringToShort,  NULL, 0, XtCacheAll);
+        XtCacheNone);
+    Add(_XtQString, XtQInt, XtCvtStringToInt, NULL, 0, XtCacheAll);
+    Add2(_XtQString, XtQPixel, XtCvtStringToPixel,
+         colorConvertArgs, XtNumber(colorConvertArgs),
+         XtCacheByDisplay, FreePixel);
+    Add(_XtQString, XtQPosition, XtCvtStringToShort, NULL, 0, XtCacheAll);
     Add(_XtQString, XtQRestartStyle, XtCvtStringToRestartStyle, NULL, 0,
-	XtCacheNone);
-    Add(_XtQString, XtQShort,        XtCvtStringToShort,  NULL, 0, XtCacheAll);
+        XtCacheNone);
+    Add(_XtQString, XtQShort, XtCvtStringToShort, NULL, 0, XtCacheAll);
     Add(_XtQString, XtQUnsignedChar, XtCvtStringToUnsignedChar,
-	NULL, 0, XtCacheAll);
-   Add2(_XtQString, XtQVisual,       XtCvtStringToVisual,
-	visualConvertArgs, XtNumber(visualConvertArgs),
-	XtCacheByDisplay, NULL);
+        NULL, 0, XtCacheAll);
+    Add2(_XtQString, XtQVisual, XtCvtStringToVisual,
+         visualConvertArgs, XtNumber(visualConvertArgs),
+         XtCacheByDisplay, NULL);
 
-   _XtAddTMConverters(table);
+    _XtAddTMConverters(table);
 }
diff --git a/src/Core.c b/src/Core.c
index 0f89ef3..d728a92 100644
--- a/src/Core.c
+++ b/src/Core.c
@@ -87,145 +87,147 @@ in this Software without prior written authorization from The Open Group.
  *
  ******************************************************************/
 
-externaldef(xtinherittranslations) int _XtInheritTranslations = 0;
-extern String XtCXtToolkitError; /* from IntrinsicI.h */
-static void XtCopyScreen(Widget, int, XrmValue *);
+externaldef(xtinherittranslations)
+int _XtInheritTranslations = 0;
+extern String XtCXtToolkitError;        /* from IntrinsicI.h */
+static void
+XtCopyScreen(Widget, int, XrmValue *);
 
 static XtResource resources[] = {
-    {XtNscreen, XtCScreen, XtRScreen, sizeof(Screen*),
-      XtOffsetOf(CoreRec,core.screen), XtRCallProc, (XtPointer)XtCopyScreen},
+    {XtNscreen, XtCScreen, XtRScreen, sizeof(Screen *),
+     XtOffsetOf(CoreRec, core.screen), XtRCallProc, (XtPointer) XtCopyScreen},
 /*_XtCopyFromParent does not work for screen because the Display
 parameter is not passed through to the XtRCallProc routines */
-    {XtNdepth, XtCDepth, XtRInt,sizeof(int),
-         XtOffsetOf(CoreRec,core.depth),
-	 XtRCallProc, (XtPointer)_XtCopyFromParent},
+    {XtNdepth, XtCDepth, XtRInt, sizeof(int),
+     XtOffsetOf(CoreRec, core.depth),
+     XtRCallProc, (XtPointer) _XtCopyFromParent},
     {XtNcolormap, XtCColormap, XtRColormap, sizeof(Colormap),
-	 XtOffsetOf(CoreRec,core.colormap),
-	 XtRCallProc,(XtPointer)_XtCopyFromParent},
-    {XtNbackground, XtCBackground, XtRPixel,sizeof(Pixel),
-         XtOffsetOf(CoreRec,core.background_pixel),
-	 XtRString, (XtPointer)"XtDefaultBackground"},
+     XtOffsetOf(CoreRec, core.colormap),
+     XtRCallProc, (XtPointer) _XtCopyFromParent},
+    {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel),
+     XtOffsetOf(CoreRec, core.background_pixel),
+     XtRString, (XtPointer) "XtDefaultBackground"},
     {XtNbackgroundPixmap, XtCPixmap, XtRPixmap, sizeof(Pixmap),
-         XtOffsetOf(CoreRec,core.background_pixmap),
-	 XtRImmediate, (XtPointer)XtUnspecifiedPixmap},
-    {XtNborderColor, XtCBorderColor, XtRPixel,sizeof(Pixel),
-         XtOffsetOf(CoreRec,core.border_pixel),
-         XtRString,(XtPointer)"XtDefaultForeground"},
+     XtOffsetOf(CoreRec, core.background_pixmap),
+     XtRImmediate, (XtPointer) XtUnspecifiedPixmap},
+    {XtNborderColor, XtCBorderColor, XtRPixel, sizeof(Pixel),
+     XtOffsetOf(CoreRec, core.border_pixel),
+     XtRString, (XtPointer) "XtDefaultForeground"},
     {XtNborderPixmap, XtCPixmap, XtRPixmap, sizeof(Pixmap),
-         XtOffsetOf(CoreRec,core.border_pixmap),
-	 XtRImmediate, (XtPointer)XtUnspecifiedPixmap},
+     XtOffsetOf(CoreRec, core.border_pixmap),
+     XtRImmediate, (XtPointer) XtUnspecifiedPixmap},
     {XtNmappedWhenManaged, XtCMappedWhenManaged, XtRBoolean, sizeof(Boolean),
-         XtOffsetOf(CoreRec,core.mapped_when_managed),
-	 XtRImmediate, (XtPointer)True},
+     XtOffsetOf(CoreRec, core.mapped_when_managed),
+     XtRImmediate, (XtPointer) True},
     {XtNtranslations, XtCTranslations, XtRTranslationTable,
-        sizeof(XtTranslations), XtOffsetOf(CoreRec,core.tm.translations),
-        XtRTranslationTable, (XtPointer)NULL},
+     sizeof(XtTranslations), XtOffsetOf(CoreRec, core.tm.translations),
+     XtRTranslationTable, (XtPointer) NULL},
     {XtNaccelerators, XtCAccelerators, XtRAcceleratorTable,
-        sizeof(XtTranslations), XtOffsetOf(CoreRec,core.accelerators),
-        XtRTranslationTable, (XtPointer)NULL}
-    };
+     sizeof(XtTranslations), XtOffsetOf(CoreRec, core.accelerators),
+     XtRTranslationTable, (XtPointer) NULL}
+};
 
 static void CoreInitialize(Widget, Widget, ArgList, Cardinal *);
 static void CoreClassPartInitialize(WidgetClass);
 static void CoreDestroy(Widget);
 static void CoreRealize(Widget, XtValueMask *, XSetWindowAttributes *);
 static Boolean CoreSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
-static void CoreSetValuesAlmost(Widget, Widget, XtWidgetGeometry *, XtWidgetGeometry *);
+static void CoreSetValuesAlmost(Widget, Widget, XtWidgetGeometry *,
+                                XtWidgetGeometry *);
 
 static RectObjClassRec unNamedObjClassRec = {
-  {
-    /* superclass	  */	(WidgetClass)&rectObjClassRec,
-    /* class_name	  */	"UnNamedObj",
-    /* widget_size	  */	0,
-    /* class_initialize   */    NULL,
-    /* class_part_initialize*/	NULL,
-    /* class_inited       */	FALSE,
-    /* initialize	  */	NULL,
-    /* initialize_hook    */	NULL,
-    /* realize		  */	(XtProc)XtInheritRealize,
-    /* actions		  */	NULL,
-    /* num_actions	  */	0,
-    /* resources	  */	NULL,
-    /* num_resources	  */	0,
-    /* xrm_class	  */	NULLQUARK,
-    /* compress_motion	  */	FALSE,
-    /* compress_exposure  */	FALSE,
-    /* compress_enterleave*/ 	FALSE,
-    /* visible_interest	  */	FALSE,
-    /* destroy		  */	NULL,
-    /* resize		  */	NULL,
-    /* expose		  */	NULL,
-    /* set_values	  */	NULL,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */	XtInheritSetValuesAlmost,
-    /* get_values_hook    */	NULL,
-    /* accept_focus	  */	NULL,
-    /* version		  */	XtVersion,
-    /* callback_offsets   */    NULL,
-    /* tm_table           */    NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */	NULL,
-    /* extension	    */  NULL
-  }
+    {
+     /* superclass         */ (WidgetClass) &rectObjClassRec,
+     /* class_name         */ "UnNamedObj",
+     /* widget_size        */ 0,
+     /* class_initialize   */ NULL,
+     /* class_part_initialize */ NULL,
+     /* class_inited       */ FALSE,
+     /* initialize         */ NULL,
+     /* initialize_hook    */ NULL,
+     /* realize            */ (XtProc) XtInheritRealize,
+     /* actions            */ NULL,
+     /* num_actions        */ 0,
+     /* resources          */ NULL,
+     /* num_resources      */ 0,
+     /* xrm_class          */ NULLQUARK,
+     /* compress_motion    */ FALSE,
+     /* compress_exposure  */ FALSE,
+     /* compress_enterleave */ FALSE,
+     /* visible_interest   */ FALSE,
+     /* destroy            */ NULL,
+     /* resize             */ NULL,
+     /* expose             */ NULL,
+     /* set_values         */ NULL,
+     /* set_values_hook    */ NULL,
+     /* set_values_almost  */ XtInheritSetValuesAlmost,
+     /* get_values_hook    */ NULL,
+     /* accept_focus       */ NULL,
+     /* version            */ XtVersion,
+     /* callback_offsets   */ NULL,
+     /* tm_table           */ NULL,
+     /* query_geometry       */ NULL,
+     /* display_accelerator  */ NULL,
+     /* extension            */ NULL
+     }
 };
 
-
-externaldef(widgetclassrec) WidgetClassRec widgetClassRec = {
-{
-    /* superclass         */    (WidgetClass)&unNamedObjClassRec,
-    /* class_name         */    "Core",
-    /* widget_size        */    sizeof(WidgetRec),
-    /* class_initialize   */    NULL,
-    /* class_part_initialize*/  CoreClassPartInitialize,
-    /* class_inited       */    FALSE,
-    /* initialize         */    CoreInitialize,
-    /* initialize_hook    */    NULL,
-    /* realize            */    CoreRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    resources,
-    /* num_resources      */    XtNumber(resources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/    FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    CoreDestroy,
-    /* resize             */    NULL,
-    /* expose             */    NULL,
-    /* set_values         */    CoreSetValues,
-    /* set_values_hook    */    NULL,
-    /* set_values_almost  */    CoreSetValuesAlmost,
-    /* get_values_hook    */    NULL,
-    /* accept_focus       */    NULL,
-    /* version            */    XtVersion,
-    /* callback_offsets   */    NULL,
-    /* tm_table           */    NULL,
-    /* query_geometry       */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension            */  NULL
-  }
+externaldef(widgetclassrec)
+WidgetClassRec widgetClassRec = {
+    {
+     /* superclass         */ (WidgetClass) &unNamedObjClassRec,
+     /* class_name         */ "Core",
+     /* widget_size        */ sizeof(WidgetRec),
+     /* class_initialize   */ NULL,
+     /* class_part_initialize */ CoreClassPartInitialize,
+     /* class_inited       */ FALSE,
+     /* initialize         */ CoreInitialize,
+     /* initialize_hook    */ NULL,
+     /* realize            */ CoreRealize,
+     /* actions            */ NULL,
+     /* num_actions        */ 0,
+     /* resources          */ resources,
+     /* num_resources      */ XtNumber(resources),
+     /* xrm_class          */ NULLQUARK,
+     /* compress_motion    */ FALSE,
+     /* compress_exposure  */ TRUE,
+     /* compress_enterleave */ FALSE,
+     /* visible_interest   */ FALSE,
+     /* destroy            */ CoreDestroy,
+     /* resize             */ NULL,
+     /* expose             */ NULL,
+     /* set_values         */ CoreSetValues,
+     /* set_values_hook    */ NULL,
+     /* set_values_almost  */ CoreSetValuesAlmost,
+     /* get_values_hook    */ NULL,
+     /* accept_focus       */ NULL,
+     /* version            */ XtVersion,
+     /* callback_offsets   */ NULL,
+     /* tm_table           */ NULL,
+     /* query_geometry       */ NULL,
+     /* display_accelerator  */ NULL,
+     /* extension            */ NULL
+     }
 };
-externaldef (WidgetClass) WidgetClass widgetClass = &widgetClassRec;
 
-externaldef (WidgetClass) WidgetClass coreWidgetClass = &widgetClassRec;
+externaldef(WidgetClass)
+WidgetClass widgetClass = &widgetClassRec;
 
+externaldef(WidgetClass)
+WidgetClass coreWidgetClass = &widgetClassRec;
 
-/*ARGSUSED*/
-static void XtCopyScreen(
-    Widget      widget,
-    int		offset,
-    XrmValue    *value)
+static void
+XtCopyScreen(Widget widget, int offset _X_UNUSED, XrmValue *value)
 {
-    value->addr = (XPointer)(&widget->core.screen);
+    value->addr = (XPointer) (&widget->core.screen);
 }
 
 /*
  * Start of Core methods
  */
 
-static void CoreClassPartInitialize(
-    register WidgetClass wc)
+static void
+CoreClassPartInitialize(register WidgetClass wc)
 {
     /* We don't need to check for null super since we'll get to object
        eventually, and it had better define them!  */
@@ -234,173 +236,179 @@ static void CoreClassPartInitialize(
 
     LOCK_PROCESS;
     if (wc->core_class.realize == XtInheritRealize) {
-	wc->core_class.realize = super->core_class.realize;
+        wc->core_class.realize = super->core_class.realize;
     }
 
     if (wc->core_class.accept_focus == XtInheritAcceptFocus) {
-	wc->core_class.accept_focus = super->core_class.accept_focus;
+        wc->core_class.accept_focus = super->core_class.accept_focus;
     }
 
     if (wc->core_class.display_accelerator == XtInheritDisplayAccelerator) {
-	wc->core_class.display_accelerator =
-		super->core_class.display_accelerator;
+        wc->core_class.display_accelerator =
+            super->core_class.display_accelerator;
     }
 
-    if (wc->core_class.tm_table == (char *) XtInheritTranslations) {
-	wc->core_class.tm_table =
-		wc->core_class.superclass->core_class.tm_table;
-    } else if (wc->core_class.tm_table != NULL) {
-	wc->core_class.tm_table =
-	      (String)XtParseTranslationTable(wc->core_class.tm_table);
+    if (wc->core_class.tm_table == XtInheritTranslations) {
+        wc->core_class.tm_table =
+            wc->core_class.superclass->core_class.tm_table;
+    }
+    else if (wc->core_class.tm_table != NULL) {
+        wc->core_class.tm_table =
+            (String) XtParseTranslationTable(wc->core_class.tm_table);
     }
 
     if (wc->core_class.actions != NULL) {
-	Boolean inPlace;
-
-	if (wc->core_class.version == XtVersionDontCheck)
-	    inPlace = True;
-	else
-	    inPlace = (wc->core_class.version < XtVersion) ? False : True;
-
-	/* Compile the action table into a more efficient form */
-        wc->core_class.actions = (XtActionList) _XtInitializeActionData(
-	    wc->core_class.actions, wc->core_class.num_actions, inPlace);
+        Boolean inPlace;
+
+        if (wc->core_class.version == XtVersionDontCheck)
+            inPlace = True;
+        else
+            inPlace = (wc->core_class.version < XtVersion) ? False : True;
+
+        /* Compile the action table into a more efficient form */
+        wc->core_class.actions =
+            (XtActionList) _XtInitializeActionData(wc->core_class.actions,
+                                                   wc->core_class.num_actions,
+                                                   inPlace);
     }
     UNLOCK_PROCESS;
 }
-/* ARGSUSED */
-static void CoreInitialize(
-    Widget   requested_widget,
-    register Widget new_widget,
-    ArgList args,
-    Cardinal *num_args)
+
+static void
+CoreInitialize(Widget requested_widget _X_UNUSED,
+               register Widget new_widget,
+               ArgList args _X_UNUSED,
+               Cardinal *num_args _X_UNUSED)
 {
     XtTranslations save1, save2;
+
     new_widget->core.event_table = NULL;
     new_widget->core.tm.proc_table = NULL;
     new_widget->core.tm.lastEventTime = 0;
     /* magic semi-resource fetched by GetResources */
-    save1 = (XtTranslations)new_widget->core.tm.current_state;
+    save1 = (XtTranslations) new_widget->core.tm.current_state;
     new_widget->core.tm.current_state = NULL;
     save2 = new_widget->core.tm.translations;
     LOCK_PROCESS;
     new_widget->core.tm.translations =
-	(XtTranslations)new_widget->core.widget_class->core_class.tm_table;
+        (XtTranslations) new_widget->core.widget_class->core_class.tm_table;
     UNLOCK_PROCESS;
     if (save1)
-	_XtMergeTranslations(new_widget, save1, save1->operation);
+        _XtMergeTranslations(new_widget, save1, save1->operation);
     if (save2)
-	_XtMergeTranslations(new_widget, save2, save2->operation);
+        _XtMergeTranslations(new_widget, save2, save2->operation);
 }
 
-static void CoreRealize(
-    Widget		 widget,
-    XtValueMask		 *value_mask,
-    XSetWindowAttributes *attributes)
+static void
+CoreRealize(Widget widget,
+            XtValueMask *value_mask,
+            XSetWindowAttributes *attributes)
 {
     XtCreateWindow(widget, (unsigned int) InputOutput,
-	(Visual *) CopyFromParent, *value_mask, attributes);
-} /* CoreRealize */
+                   (Visual *) CopyFromParent, *value_mask, attributes);
+}                               /* CoreRealize */
 
-static void CoreDestroy (
-     Widget    widget)
+static void
+CoreDestroy(Widget widget)
 {
     _XtFreeEventTable(&widget->core.event_table);
     _XtDestroyTMData(widget);
     XtUnregisterDrawable(XtDisplay(widget), widget->core.window);
 
     if (widget->core.popup_list != NULL)
-        XtFree((char *)widget->core.popup_list);
+        XtFree((char *) widget->core.popup_list);
 
-} /* CoreDestroy */
+}                               /* CoreDestroy */
 
-/* ARGSUSED */
-static Boolean CoreSetValues(
-    Widget old, Widget reference, Widget new,
-    ArgList args,
-    Cardinal *num_args)
+static Boolean
+CoreSetValues(Widget old,
+              Widget reference _X_UNUSED,
+              Widget new,
+              ArgList args _X_UNUSED,
+              Cardinal *num_args _X_UNUSED)
 {
     Boolean redisplay;
-    Mask    window_mask;
+    Mask window_mask;
     XSetWindowAttributes attributes;
 
     redisplay = FALSE;
-    if  (old->core.tm.translations != new->core.tm.translations) {
-	XtTranslations save = new->core.tm.translations;
-	new->core.tm.translations = old->core.tm.translations;
-	_XtMergeTranslations(new, save, XtTableReplace);
+    if (old->core.tm.translations != new->core.tm.translations) {
+        XtTranslations save = new->core.tm.translations;
+
+        new->core.tm.translations = old->core.tm.translations;
+        _XtMergeTranslations(new, save, XtTableReplace);
     }
 
     /* Check everything that depends upon window being realized */
     if (XtIsRealized(old)) {
-	window_mask = 0;
-	/* Check window attributes */
-	if (old->core.background_pixel != new->core.background_pixel
-	    && new->core.background_pixmap == XtUnspecifiedPixmap) {
-	   attributes.background_pixel  = new->core.background_pixel;
-	   window_mask |= CWBackPixel;
-	   redisplay = TRUE;
-	}
-	if (old->core.background_pixmap != new->core.background_pixmap) {
-	   if (new->core.background_pixmap == XtUnspecifiedPixmap) {
-	       window_mask |= CWBackPixel;
-	       attributes.background_pixel  = new->core.background_pixel;
-	   }
-	   else {
-	       attributes.background_pixmap = new->core.background_pixmap;
-	       window_mask &= (unsigned long) (~CWBackPixel);
-	       window_mask |= CWBackPixmap;
-	   }
-	   redisplay = TRUE;
-	}
-	if (old->core.border_pixel != new->core.border_pixel
-	    && new->core.border_pixmap == XtUnspecifiedPixmap) {
-	   attributes.border_pixel  = new->core.border_pixel;
-	   window_mask |= CWBorderPixel;
-       }
-	if (old->core.border_pixmap != new->core.border_pixmap) {
-	   if (new->core.border_pixmap == XtUnspecifiedPixmap) {
-	       window_mask |= CWBorderPixel;
-	       attributes.border_pixel  = new->core.border_pixel;
-	   }
-	   else {
-	       attributes.border_pixmap = new->core.border_pixmap;
-	       window_mask &= (unsigned long) (~CWBorderPixel);
-	       window_mask |= CWBorderPixmap;
-	   }
-       }
-	if (old->core.depth != new->core.depth) {
-	   XtAppWarningMsg(XtWidgetToApplicationContext(old),
-		    "invalidDepth","setValues",XtCXtToolkitError,
-               "Can't change widget depth", NULL, NULL);
-	   new->core.depth = old->core.depth;
-	}
-	if (old->core.colormap != new->core.colormap) {
-	    window_mask |= CWColormap;
-	    attributes.colormap = new->core.colormap;
-	}
-	if (window_mask != 0) {
-	    /* Actually change X window attributes */
-	    XChangeWindowAttributes(
-		XtDisplay(new), XtWindow(new), window_mask, &attributes);
-	}
-
-	if (old->core.mapped_when_managed != new->core.mapped_when_managed) {
-	    Boolean mapped_when_managed = new->core.mapped_when_managed;
-	    new->core.mapped_when_managed = !mapped_when_managed;
-	    XtSetMappedWhenManaged(new, mapped_when_managed);
-	}
-    } /* if realized */
+        window_mask = 0;
+        /* Check window attributes */
+        if (old->core.background_pixel != new->core.background_pixel
+            && new->core.background_pixmap == XtUnspecifiedPixmap) {
+            attributes.background_pixel = new->core.background_pixel;
+            window_mask |= CWBackPixel;
+            redisplay = TRUE;
+        }
+        if (old->core.background_pixmap != new->core.background_pixmap) {
+            if (new->core.background_pixmap == XtUnspecifiedPixmap) {
+                window_mask |= CWBackPixel;
+                attributes.background_pixel = new->core.background_pixel;
+            }
+            else {
+                attributes.background_pixmap = new->core.background_pixmap;
+                window_mask &= (unsigned long) (~CWBackPixel);
+                window_mask |= CWBackPixmap;
+            }
+            redisplay = TRUE;
+        }
+        if (old->core.border_pixel != new->core.border_pixel
+            && new->core.border_pixmap == XtUnspecifiedPixmap) {
+            attributes.border_pixel = new->core.border_pixel;
+            window_mask |= CWBorderPixel;
+        }
+        if (old->core.border_pixmap != new->core.border_pixmap) {
+            if (new->core.border_pixmap == XtUnspecifiedPixmap) {
+                window_mask |= CWBorderPixel;
+                attributes.border_pixel = new->core.border_pixel;
+            }
+            else {
+                attributes.border_pixmap = new->core.border_pixmap;
+                window_mask &= (unsigned long) (~CWBorderPixel);
+                window_mask |= CWBorderPixmap;
+            }
+        }
+        if (old->core.depth != new->core.depth) {
+            XtAppWarningMsg(XtWidgetToApplicationContext(old),
+                            "invalidDepth", "setValues", XtCXtToolkitError,
+                            "Can't change widget depth", NULL, NULL);
+            new->core.depth = old->core.depth;
+        }
+        if (old->core.colormap != new->core.colormap) {
+            window_mask |= CWColormap;
+            attributes.colormap = new->core.colormap;
+        }
+        if (window_mask != 0) {
+            /* Actually change X window attributes */
+            XChangeWindowAttributes(XtDisplay(new), XtWindow(new), window_mask,
+                                    &attributes);
+        }
+
+        if (old->core.mapped_when_managed != new->core.mapped_when_managed) {
+            Boolean mapped_when_managed = new->core.mapped_when_managed;
+
+            new->core.mapped_when_managed = !mapped_when_managed;
+            XtSetMappedWhenManaged(new, mapped_when_managed);
+        }
+    }                           /* if realized */
 
     return redisplay;
-} /* CoreSetValues */
-
-/*ARGSUSED*/
-static void CoreSetValuesAlmost(
-    Widget		old,
-    Widget		new,
-    XtWidgetGeometry    *request,
-    XtWidgetGeometry    *reply)
+}                               /* CoreSetValues */
+
+static void
+CoreSetValuesAlmost(Widget old _X_UNUSED,
+                    Widget new _X_UNUSED,
+                    XtWidgetGeometry *request,
+                    XtWidgetGeometry *reply)
 {
     *request = *reply;
 }
diff --git a/src/Create.c b/src/Create.c
index 1d18590..27df827 100644
--- a/src/Create.c
+++ b/src/Create.c
@@ -87,10 +87,10 @@ static void
 CallClassPartInit(WidgetClass ancestor, WidgetClass wc)
 {
     if (ancestor->core_class.superclass != NULL) {
-	CallClassPartInit(ancestor->core_class.superclass, wc);
+        CallClassPartInit(ancestor->core_class.superclass, wc);
     }
     if (ancestor->core_class.class_part_initialize != NULL) {
-	(*(ancestor->core_class.class_part_initialize)) (wc);
+        (*(ancestor->core_class.class_part_initialize)) (wc);
     }
 }
 
@@ -98,117 +98,110 @@ void
 XtInitializeWidgetClass(WidgetClass wc)
 {
     XtEnum inited;
+
     LOCK_PROCESS;
     if (wc->core_class.class_inited) {
-	UNLOCK_PROCESS;
-	return;
+        UNLOCK_PROCESS;
+        return;
     }
     inited = 0x01;
     {
-	WidgetClass pc;
+        WidgetClass pc;
+
 #define LeaveIfClass(c, d) if (pc == c) { inited = d; break; }
-	for (pc = wc; pc; pc = pc->core_class.superclass) {
-	    LeaveIfClass(rectObjClass, 0x01 |
-			 RectObjClassFlag);
-	    LeaveIfClass(coreWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag);
-	    LeaveIfClass(compositeWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag |
-			 CompositeClassFlag);
-	    LeaveIfClass(constraintWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag |
-			 CompositeClassFlag |
-			 ConstraintClassFlag);
-	    LeaveIfClass(shellWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag |
-			 CompositeClassFlag |
-			 ShellClassFlag);
-	    LeaveIfClass(wmShellWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag |
-			 CompositeClassFlag |
-			 ShellClassFlag |
-			 WMShellClassFlag);
-	    LeaveIfClass(topLevelShellWidgetClass, 0x01 |
-			 RectObjClassFlag |
-			 WidgetClassFlag |
-			 CompositeClassFlag |
-			 ShellClassFlag |
-			 WMShellClassFlag |
-			 TopLevelClassFlag);
-	}
+        for (pc = wc; pc; pc = pc->core_class.superclass) {
+            LeaveIfClass(rectObjClass, 0x01 | RectObjClassFlag);
+            LeaveIfClass(coreWidgetClass, 0x01 |
+                         RectObjClassFlag | WidgetClassFlag);
+            LeaveIfClass(compositeWidgetClass, 0x01 |
+                         RectObjClassFlag |
+                         WidgetClassFlag | CompositeClassFlag);
+            LeaveIfClass(constraintWidgetClass, 0x01 |
+                         RectObjClassFlag |
+                         WidgetClassFlag |
+                         CompositeClassFlag | ConstraintClassFlag);
+            LeaveIfClass(shellWidgetClass, 0x01 |
+                         RectObjClassFlag |
+                         WidgetClassFlag | CompositeClassFlag | ShellClassFlag);
+            LeaveIfClass(wmShellWidgetClass, 0x01 |
+                         RectObjClassFlag |
+                         WidgetClassFlag |
+                         CompositeClassFlag |
+                         ShellClassFlag | WMShellClassFlag);
+            LeaveIfClass(topLevelShellWidgetClass, 0x01 |
+                         RectObjClassFlag |
+                         WidgetClassFlag |
+                         CompositeClassFlag |
+                         ShellClassFlag | WMShellClassFlag | TopLevelClassFlag);
+        }
 #undef LeaveIfClass
     }
     if (wc->core_class.version != XtVersion &&
-	wc->core_class.version != XtVersionDontCheck) {
-	String param[3];
-	_Xconst _XtString mismatch = "Widget class %s version mismatch (recompilation needed):\n  widget %d vs. intrinsics %d.";
-	_Xconst _XtString recompile = "Widget class %s must be re-compiled.";
-	Cardinal num_params;
-
-	param[0] = wc->core_class.class_name;
-	param[1] = (String) wc->core_class.version;
-	param[2] = (String) XtVersion;
-
-	if (wc->core_class.version == (11 * 1000 + 5) || /* MIT X11R5 */
-	    wc->core_class.version == (11 * 1000 + 4)) { /* MIT X11R4 */
-	    if ((inited & WMShellClassFlag) &&
-		(sizeof(Boolean) != sizeof(char) ||
-		 sizeof(Atom) != sizeof(Widget) ||
-		 sizeof(Atom) != sizeof(String))) {
-		num_params=3;
-		XtWarningMsg("versionMismatch","widget",XtCXtToolkitError,
-			     mismatch, param, &num_params);
-		num_params=1;
-		XtErrorMsg("R4orR5versionMismatch","widget",XtCXtToolkitError,
-			   recompile, param, &num_params);
-
-	    }
-	}
-	else if (wc->core_class.version == (11 * 1000 + 3)) { /* MIT X11R3 */
-	    if (inited & ShellClassFlag) {
-		num_params=1;
-		XtWarningMsg("r3versionMismatch","widget",XtCXtToolkitError,
-			     "Shell Widget class %s binary compiled for R3",
-			     param,&num_params);
-		XtErrorMsg("R3versionMismatch","widget",XtCXtToolkitError,
-			   recompile, param, &num_params);
-	    }
-	}
-	else {
-	    num_params=3;
-	    XtWarningMsg("versionMismatch","widget",XtCXtToolkitError,
-			 mismatch, param, &num_params);
-	    if (wc->core_class.version == (2 * 1000 + 2)) /* MIT X11R2 */ {
-		num_params=1;
-		XtErrorMsg("r2versionMismatch","widget",XtCXtToolkitError,
-			   recompile, param, &num_params);
-	    }
-	}
+        wc->core_class.version != XtVersionDontCheck) {
+        String param[3];
+        _Xconst _XtString mismatch =
+            "Widget class %s version mismatch (recompilation needed):\n  widget %d vs. intrinsics %d.";
+        _Xconst _XtString recompile = "Widget class %s must be re-compiled.";
+        Cardinal num_params;
+
+        param[0] = wc->core_class.class_name;
+        param[1] = (String) wc->core_class.version;
+        param[2] = (String) XtVersion;
+
+        if (wc->core_class.version == (11 * 1000 + 5) ||        /* MIT X11R5 */
+            wc->core_class.version == (11 * 1000 + 4)) {        /* MIT X11R4 */
+            if ((inited & WMShellClassFlag) &&
+                (sizeof(Boolean) != sizeof(char) ||
+                 sizeof(Atom) != sizeof(Widget) ||
+                 sizeof(Atom) != sizeof(String))) {
+                num_params = 3;
+                XtWarningMsg("versionMismatch", "widget", XtCXtToolkitError,
+                             mismatch, param, &num_params);
+                num_params = 1;
+                XtErrorMsg("R4orR5versionMismatch", "widget", XtCXtToolkitError,
+                           recompile, param, &num_params);
+
+            }
+        }
+        else if (wc->core_class.version == (11 * 1000 + 3)) {   /* MIT X11R3 */
+            if (inited & ShellClassFlag) {
+                num_params = 1;
+                XtWarningMsg("r3versionMismatch", "widget", XtCXtToolkitError,
+                             "Shell Widget class %s binary compiled for R3",
+                             param, &num_params);
+                XtErrorMsg("R3versionMismatch", "widget", XtCXtToolkitError,
+                           recompile, param, &num_params);
+            }
+        }
+        else {
+            num_params = 3;
+            XtWarningMsg("versionMismatch", "widget", XtCXtToolkitError,
+                         mismatch, param, &num_params);
+            if (wc->core_class.version == (2 * 1000 + 2)) {     /* MIT X11R2 */
+                num_params = 1;
+                XtErrorMsg("r2versionMismatch", "widget", XtCXtToolkitError,
+                           recompile, param, &num_params);
+            }
+        }
     }
 
     if ((wc->core_class.superclass != NULL)
-	    && (!(wc->core_class.superclass->core_class.class_inited)))
- 	XtInitializeWidgetClass(wc->core_class.superclass);
+        && (!(wc->core_class.superclass->core_class.class_inited)))
+        XtInitializeWidgetClass(wc->core_class.superclass);
 
     if (wc->core_class.class_initialize != NULL)
-	(*(wc->core_class.class_initialize))();
+        (*(wc->core_class.class_initialize)) ();
     CallClassPartInit(wc, wc);
     wc->core_class.class_inited = inited;
     UNLOCK_PROCESS;
 }
 
 static void
-CallInitialize (
-    WidgetClass class,
-    Widget      req_widget,
-    Widget      new_widget,
-    ArgList     args,
-    Cardinal    num_args)
+CallInitialize(WidgetClass class,
+               Widget req_widget,
+               Widget new_widget,
+               ArgList args,
+               Cardinal num_args)
 {
     WidgetClass superclass;
     XtInitProc initialize;
@@ -218,26 +211,25 @@ CallInitialize (
     superclass = class->core_class.superclass;
     UNLOCK_PROCESS;
     if (superclass)
-        CallInitialize (superclass, req_widget, new_widget, args, num_args);
+        CallInitialize(superclass, req_widget, new_widget, args, num_args);
     LOCK_PROCESS;
     initialize = class->core_class.initialize;
     UNLOCK_PROCESS;
     if (initialize)
-	(*initialize) (req_widget, new_widget, args, &num_args);
+        (*initialize) (req_widget, new_widget, args, &num_args);
     LOCK_PROCESS;
     initialize_hook = class->core_class.initialize_hook;
     UNLOCK_PROCESS;
     if (initialize_hook)
-	(*initialize_hook) (new_widget, args, &num_args);
+        (*initialize_hook) (new_widget, args, &num_args);
 }
 
 static void
-CallConstraintInitialize (
-    ConstraintWidgetClass class,
-    Widget	req_widget,
-    Widget	new_widget,
-    ArgList	args,
-    Cardinal	num_args)
+CallConstraintInitialize(ConstraintWidgetClass class,
+                         Widget req_widget,
+                         Widget new_widget,
+                         ArgList args,
+                         Cardinal num_args)
 {
     WidgetClass superclass;
     XtInitProc initialize;
@@ -246,8 +238,8 @@ CallConstraintInitialize (
     superclass = class->core_class.superclass;
     UNLOCK_PROCESS;
     if (superclass != constraintWidgetClass)
-	CallConstraintInitialize((ConstraintWidgetClass) superclass,
-		req_widget, new_widget, args, num_args);
+        CallConstraintInitialize((ConstraintWidgetClass) superclass,
+                                 req_widget, new_widget, args, num_args);
     LOCK_PROCESS;
     initialize = class->constraint_class.initialize;
     UNLOCK_PROCESS;
@@ -256,212 +248,224 @@ CallConstraintInitialize (
 }
 
 static Widget
-xtWidgetAlloc(
-    WidgetClass widget_class,
-    ConstraintWidgetClass parent_constraint_class,
-    Widget parent,
-    _Xconst _XtString name,
-    ArgList     args,		/* must be NULL if typed_args is non-NULL */
-    Cardinal    num_args,
-    XtTypedArgList typed_args,	/* must be NULL if args is non-NULL */
-    Cardinal	num_typed_args)
+xtWidgetAlloc(WidgetClass widget_class,
+              ConstraintWidgetClass parent_constraint_class,
+              Widget parent,
+              _Xconst _XtString name,
+              ArgList args,     /* must be NULL if typed_args is non-NULL */
+              Cardinal num_args,
+              XtTypedArgList typed_args,     /* must be NULL if args is non-NULL */
+              Cardinal num_typed_args)
 {
     Widget widget;
-    Cardinal                csize = 0;
-    ObjectClassExtension    ext;
+    Cardinal csize = 0;
+    ObjectClassExtension ext;
 
     if (widget_class == NULL)
-	return 0;
+        return 0;
 
     LOCK_PROCESS;
-    if (! (widget_class->core_class.class_inited))
-	XtInitializeWidgetClass(widget_class);
+    if (!(widget_class->core_class.class_inited))
+        XtInitializeWidgetClass(widget_class);
     ext = (ObjectClassExtension)
-	XtGetClassExtension(widget_class,
-			    XtOffsetOf(ObjectClassRec, object_class.extension),
-			    NULLQUARK, XtObjectExtensionVersion,
-			    sizeof(ObjectClassExtensionRec));
+        XtGetClassExtension(widget_class,
+                            XtOffsetOf(ObjectClassRec, object_class.extension),
+                            NULLQUARK, XtObjectExtensionVersion,
+                            sizeof(ObjectClassExtensionRec));
     if (parent_constraint_class)
-	csize = parent_constraint_class->constraint_class.constraint_size;
+        csize = parent_constraint_class->constraint_class.constraint_size;
     if (ext && ext->allocate) {
-	XtAllocateProc allocate;
-	Cardinal extra = 0;
-	Cardinal nargs = num_args;
-	Cardinal ntyped = num_typed_args;
-	allocate = ext->allocate;
-	UNLOCK_PROCESS;
-	(*allocate)(widget_class, &csize, &extra, args, &nargs,
-		    typed_args, &ntyped, &widget, NULL);
-    } else {
+        XtAllocateProc allocate;
+        Cardinal extra = 0;
+        Cardinal nargs = num_args;
+        Cardinal ntyped = num_typed_args;
+
+        allocate = ext->allocate;
+        UNLOCK_PROCESS;
+        (*allocate) (widget_class, &csize, &extra, args, &nargs,
+                     typed_args, &ntyped, &widget, NULL);
+    }
+    else {
         Cardinal wsize = widget_class->core_class.widget_size;
-	UNLOCK_PROCESS;
-	if (csize) {
-	    if (sizeof(struct {char a; double b;}) !=
-		(sizeof(struct {char a; unsigned long b;}) -
-		 sizeof(unsigned long) + sizeof(double))) {
-		if (csize && !(csize & (sizeof(double) - 1)))
-		    wsize = (Cardinal) ((wsize + sizeof(double) - 1) & ~(sizeof(double)-1));
-	    }
-	}
-	widget = (Widget) __XtCalloc(1,(unsigned)(wsize + csize));
-	widget->core.constraints =
-	    (csize ? (XtPointer)((char *)widget + wsize) : NULL);
+
+        UNLOCK_PROCESS;
+        if (csize) {
+            if (sizeof(struct {
+                       char a; double b;}) != (sizeof(struct {
+                                                      char a;
+                                                      unsigned long b;}) -
+                                               sizeof(unsigned long) +
+                                               sizeof(double))) {
+                if (csize && !(csize & (sizeof(double) - 1)))
+                    wsize = (Cardinal) ((wsize + sizeof(double) - 1)
+                                        & ~(sizeof(double) - 1));
+            }
+        }
+        widget = (Widget) __XtCalloc(1, (unsigned) (wsize + csize));
+        widget->core.constraints =
+            (csize ? (XtPointer) ((char *) widget + wsize) : NULL);
     }
     widget->core.self = widget;
     widget->core.parent = parent;
     widget->core.widget_class = widget_class;
     widget->core.xrm_name = StringToName((name != NULL) ? name : "");
     widget->core.being_destroyed =
-	(parent != NULL ? parent->core.being_destroyed : FALSE);
+        (parent != NULL ? parent->core.being_destroyed : FALSE);
     return widget;
 }
 
 static void
-CompileCallbacks(
-    Widget widget)
+CompileCallbacks(Widget widget)
 {
     CallbackTable offsets;
     int i;
 
     LOCK_PROCESS;
     offsets = (CallbackTable)
-	widget->core.widget_class->core_class.callback_private;
+        widget->core.widget_class->core_class.callback_private;
+
+    for (i = (int) (long) *(offsets++); --i >= 0; offsets++) {
+        InternalCallbackList *cl = (InternalCallbackList *)
+            ((char *) widget - (*offsets)->xrm_offset - 1);
 
-    for (i = (int)(long) *(offsets++); --i >= 0; offsets++) {
-        InternalCallbackList* cl = (InternalCallbackList *)
-	    ((char *) widget - (*offsets)->xrm_offset - 1);
-	if (*cl)
-	    *cl = _XtCompileCallbackList((XtCallbackList) *cl);
+        if (*cl)
+            *cl = _XtCompileCallbackList((XtCallbackList) *cl);
     }
     UNLOCK_PROCESS;
 }
 
 static Widget
-xtCreate(
-    String      name,
-    String      class,
-    WidgetClass widget_class,
-    Widget      parent,
-    Screen*     default_screen, /* undefined when creating a nonwidget */
-    ArgList     args,		/* must be NULL if typed_args is non-NULL */
-    Cardinal    num_args,
-    XtTypedArgList typed_args,	/* must be NULL if args is non-NULL */
-    Cardinal	num_typed_args,
-    ConstraintWidgetClass parent_constraint_class,
-        /* NULL if not a subclass of Constraint or if child is popup shell */
-    XtWidgetProc post_proc)
+xtCreate(String name,
+         String class,
+         WidgetClass widget_class,
+         Widget parent,
+         Screen *default_screen,    /* undefined when creating a nonwidget */
+         ArgList args,          /* must be NULL if typed_args is non-NULL */
+         Cardinal num_args,
+         XtTypedArgList typed_args,  /* must be NULL if args is non-NULL */
+         Cardinal num_typed_args,
+         ConstraintWidgetClass parent_constraint_class,
+         /* NULL if not a subclass of Constraint or if child is popup shell */
+         XtWidgetProc post_proc)
 {
     /* need to use strictest alignment rules possible in next two decls. */
-    double                  widget_cache[100];
-    Widget                  req_widget;
-    XtPointer               req_constraints = NULL;
-    Cardinal                wsize, csize;
-    Widget	    	    widget;
-    XtCacheRef		    *cache_refs;
-    XtCreateHookDataRec     call_data;
+    double widget_cache[100];
+    Widget req_widget;
+    XtPointer req_constraints = NULL;
+    Cardinal wsize, csize;
+    Widget widget;
+    XtCacheRef *cache_refs;
+    XtCreateHookDataRec call_data;
 
     widget = xtWidgetAlloc(widget_class, parent_constraint_class, parent,
-		name, args, num_args, typed_args, num_typed_args);
+                           name, args, num_args, typed_args, num_typed_args);
 
     if (XtIsRectObj(widget)) {
-	widget->core.managed = FALSE;
+        widget->core.managed = FALSE;
     }
     if (XtIsWidget(widget)) {
-	widget->core.name = XrmNameToString(widget->core.xrm_name);
+        widget->core.name = XrmNameToString(widget->core.xrm_name);
         widget->core.screen = default_screen;
         widget->core.tm.translations = NULL;
-	widget->core.window = (Window) 0;
-	widget->core.visible = TRUE;
-	widget->core.popup_list = NULL;
-	widget->core.num_popups = 0;
+        widget->core.window = (Window) 0;
+        widget->core.visible = TRUE;
+        widget->core.popup_list = NULL;
+        widget->core.num_popups = 0;
     };
     LOCK_PROCESS;
     if (XtIsApplicationShell(widget)) {
-	ApplicationShellWidget a = (ApplicationShellWidget) widget;
-	if (class != NULL)
-	    a->application.xrm_class = StringToClass(class);
-	else
-	    a->application.xrm_class = widget_class->core_class.xrm_class;
-	a->application.class = XrmQuarkToString(a->application.xrm_class);
+        ApplicationShellWidget a = (ApplicationShellWidget) widget;
+
+        if (class != NULL)
+            a->application.xrm_class = StringToClass(class);
+        else
+            a->application.xrm_class = widget_class->core_class.xrm_class;
+        a->application.class = XrmQuarkToString(a->application.xrm_class);
     }
     UNLOCK_PROCESS;
 
     /* fetch resources */
     cache_refs = _XtGetResources(widget, args, num_args,
-		typed_args, &num_typed_args);
+                                 typed_args, &num_typed_args);
 
     /* Convert typed arg list to arg list */
     if (typed_args != NULL && num_typed_args > 0) {
-	Cardinal i;
-	args = (ArgList)ALLOCATE_LOCAL(sizeof(Arg) * num_typed_args);
-	if (args == NULL) _XtAllocError(NULL);
-	for (i = 0; i < num_typed_args; i++) {
-	    args[i].name = typed_args[i].name;
-	    args[i].value = typed_args[i].value;
-	}
-	num_args = num_typed_args;
+        Cardinal i;
+
+        args = (ArgList) ALLOCATE_LOCAL(sizeof(Arg) * num_typed_args);
+        if (args == NULL)
+            _XtAllocError(NULL);
+        for (i = 0; i < num_typed_args; i++) {
+            args[i].name = typed_args[i].name;
+            args[i].value = typed_args[i].value;
+        }
+        num_args = num_typed_args;
     }
 
     CompileCallbacks(widget);
 
     if (cache_refs != NULL) {
-	XtAddCallback(widget, XtNdestroyCallback,
-		XtCallbackReleaseCacheRefList, (XtPointer)cache_refs );
+        XtAddCallback(widget, XtNdestroyCallback,
+                      XtCallbackReleaseCacheRefList, (XtPointer) cache_refs);
     }
 
     wsize = widget_class->core_class.widget_size;
     req_widget = (Widget) XtStackAlloc(wsize, widget_cache);
-    (void) memmove ((char *) req_widget, (char *) widget, (size_t) wsize);
-    CallInitialize (XtClass(widget), req_widget, widget, args, num_args);
+    (void) memmove((char *) req_widget, (char *) widget, (size_t) wsize);
+    CallInitialize(XtClass(widget), req_widget, widget, args, num_args);
     if (parent_constraint_class != NULL) {
-	double constraint_cache[20];
+        double constraint_cache[20];
+
         csize = parent_constraint_class->constraint_class.constraint_size;
-	if (csize) {
-	    req_constraints = XtStackAlloc(csize, constraint_cache);
-	    (void) memmove((char*)req_constraints, widget->core.constraints,
-			(size_t)csize);
-	    req_widget->core.constraints = req_constraints;
-	} else req_widget->core.constraints = NULL;
-	CallConstraintInitialize(parent_constraint_class, req_widget, widget,
-		args, num_args);
-	if (csize) {
-	    XtStackFree(req_constraints, constraint_cache);
-	}
+        if (csize) {
+            req_constraints = XtStackAlloc(csize, constraint_cache);
+            (void) memmove((char *) req_constraints, widget->core.constraints,
+                           (size_t) csize);
+            req_widget->core.constraints = req_constraints;
+        }
+        else
+            req_widget->core.constraints = NULL;
+        CallConstraintInitialize(parent_constraint_class, req_widget, widget,
+                                 args, num_args);
+        if (csize) {
+            XtStackFree(req_constraints, constraint_cache);
+        }
     }
-    XtStackFree((XtPointer)req_widget, widget_cache);
+    XtStackFree((XtPointer) req_widget, widget_cache);
     if (post_proc != (XtWidgetProc) NULL) {
-	Widget hookobj;
-	(*post_proc)(widget);
-	hookobj = XtHooksOfDisplay((default_screen != (Screen*) NULL) ?
-		default_screen->display :
-		XtDisplayOfObject(parent));
-	if (XtHasCallbacks(hookobj, XtNcreateHook) == XtCallbackHasSome) {
-
-	    call_data.type = XtHcreate;
-	    call_data.widget = widget;
-	    call_data.args = args;
-	    call_data.num_args = num_args;
-	    XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.createhook_callbacks,
-		(XtPointer)&call_data);
-	}
+        Widget hookobj;
+
+        (*post_proc) (widget);
+        hookobj = XtHooksOfDisplay((default_screen != (Screen *) NULL) ?
+                                   default_screen->display :
+                                   XtDisplayOfObject(parent));
+        if (XtHasCallbacks(hookobj, XtNcreateHook) == XtCallbackHasSome) {
+
+            call_data.type = XtHcreate;
+            call_data.widget = widget;
+            call_data.args = args;
+            call_data.num_args = num_args;
+            XtCallCallbackList(hookobj,
+                               ((HookObject) hookobj)->hooks.
+                               createhook_callbacks, (XtPointer) &call_data);
+        }
     }
     if (typed_args != NULL) {
-	while (num_typed_args-- > 0) {
-
-	    /* In GetResources we may have dynamically alloc'd store to hold */
-	    /* a copy of a resource which was larger then sizeof(XtArgVal). */
-	    /* We must free this store now in order to prevent a memory leak */
-	    /* A typed arg that has a converted value in dynamic store has a */
-	    /* negated size field. */
-
-	    if (typed_args->type != NULL && typed_args->size < 0) {
-		XtFree((char*)typed_args->value);
-		typed_args->size = -(typed_args->size);
-	    }
-	    typed_args++;
-	}
-	DEALLOCATE_LOCAL((char*)args);
+        while (num_typed_args-- > 0) {
+
+            /* In GetResources we may have dynamically alloc'd store to hold */
+            /* a copy of a resource which was larger then sizeof(XtArgVal). */
+            /* We must free this store now in order to prevent a memory leak */
+            /* A typed arg that has a converted value in dynamic store has a */
+            /* negated size field. */
+
+            if (typed_args->type != NULL && typed_args->size < 0) {
+                XtFree((char *) typed_args->value);
+                typed_args->size = -(typed_args->size);
+            }
+            typed_args++;
+        }
+        DEALLOCATE_LOCAL((char *) args);
     }
     return (widget);
 }
@@ -475,140 +479,145 @@ widgetPostProc(Widget w)
     Cardinal num_params = 1;
 
     if (XtIsComposite(parent)) {
-	LOCK_PROCESS;
-	insert_child = ((CompositeWidgetClass) parent->core.widget_class)->
-	    composite_class.insert_child;
-	UNLOCK_PROCESS;
-    } else {
-	return;
+        LOCK_PROCESS;
+        insert_child =
+            ((CompositeWidgetClass) parent->core.widget_class)->composite_class.
+            insert_child;
+        UNLOCK_PROCESS;
+    }
+    else {
+        return;
     }
     if (insert_child == NULL) {
-	XtAppErrorMsg(XtWidgetToApplicationContext(parent),
-		"nullProc","insertChild",XtCXtToolkitError,
-		"\"%s\" parent has NULL insert_child method",
-		&param, &num_params);
-    } else {
-	(*insert_child) (w);
+        XtAppErrorMsg(XtWidgetToApplicationContext(parent),
+                      "nullProc", "insertChild", XtCXtToolkitError,
+                      "\"%s\" parent has NULL insert_child method",
+                      &param, &num_params);
+    }
+    else {
+        (*insert_child) (w);
     }
 }
 
 Widget
-_XtCreateWidget(
-    String      name,
-    WidgetClass widget_class,
-    Widget      parent,
-    ArgList     args,
-    Cardinal    num_args,
-    XtTypedArgList typed_args,
-    Cardinal	num_typed_args)
+_XtCreateWidget(String name,
+                WidgetClass widget_class,
+                Widget parent,
+                ArgList args,
+                Cardinal num_args,
+                XtTypedArgList typed_args,
+                Cardinal num_typed_args)
 {
-    register Widget	    widget;
-    ConstraintWidgetClass   cwc;
-    Screen*                 default_screen;
-    XtEnum		    class_inited;
-    String		    params[3];
-    Cardinal		    num_params;
+    register Widget widget;
+    ConstraintWidgetClass cwc;
+    Screen *default_screen;
+    XtEnum class_inited;
+    String params[3];
+    Cardinal num_params;
 
     params[0] = name;
     num_params = 1;
 
     if (parent == NULL) {
-	XtErrorMsg("invalidParent", XtNxtCreateWidget, XtCXtToolkitError,
-		   "XtCreateWidget \"%s\" requires non-NULL parent",
-		   params, &num_params);
-    } else if (widget_class == NULL) {
-	XtAppErrorMsg(XtWidgetToApplicationContext(parent),
-		      "invalidClass", XtNxtCreateWidget, XtCXtToolkitError,
-		      "XtCreateWidget \"%s\" requires non-NULL widget class",
-		      params, &num_params);
+        XtErrorMsg("invalidParent", XtNxtCreateWidget, XtCXtToolkitError,
+                   "XtCreateWidget \"%s\" requires non-NULL parent",
+                   params, &num_params);
+    }
+    else if (widget_class == NULL) {
+        XtAppErrorMsg(XtWidgetToApplicationContext(parent),
+                      "invalidClass", XtNxtCreateWidget, XtCXtToolkitError,
+                      "XtCreateWidget \"%s\" requires non-NULL widget class",
+                      params, &num_params);
     }
     LOCK_PROCESS;
     if (!widget_class->core_class.class_inited)
-	XtInitializeWidgetClass(widget_class);
+        XtInitializeWidgetClass(widget_class);
     class_inited = widget_class->core_class.class_inited;
     UNLOCK_PROCESS;
     if ((class_inited & WidgetClassFlag) == 0) {
-	/* not a widget */
-	default_screen = NULL;
-	if (XtIsComposite(parent)) {
-	    CompositeClassExtension ext;
-	    ext = (CompositeClassExtension)
-		XtGetClassExtension(XtClass(parent),
-		      XtOffsetOf(CompositeClassRec, composite_class.extension),
-		      NULLQUARK, 1L, (Cardinal) 0);
-	    LOCK_PROCESS;
-	    if (ext &&
-		(ext->version > XtCompositeExtensionVersion ||
-		 ext->record_size > sizeof(CompositeClassExtensionRec))) {
-		params[1] = XtClass(parent)->core_class.class_name;
-		num_params = 2;
-		XtAppWarningMsg(XtWidgetToApplicationContext(parent),
-				"invalidExtension", XtNxtCreateWidget,
-				XtCXtToolkitError,
-	   "widget \"%s\" class %s has invalid CompositeClassExtension record",
-				params, &num_params);
-	    }
-	    if (!ext || !ext->accepts_objects) {
-		params[1] = XtName(parent);
-		num_params = 2;
-		XtAppErrorMsg(XtWidgetToApplicationContext(parent),
-			      "nonWidget", XtNxtCreateWidget,XtCXtToolkitError,
-"attempt to add non-widget child \"%s\" to parent \"%s\" which supports only widgets",
-			      params, &num_params);
-	    }
-	    UNLOCK_PROCESS;
-	}
-    } else {
-	default_screen = parent->core.screen;
+        /* not a widget */
+        default_screen = NULL;
+        if (XtIsComposite(parent)) {
+            CompositeClassExtension ext;
+
+            ext = (CompositeClassExtension)
+                XtGetClassExtension(XtClass(parent),
+                                    XtOffsetOf(CompositeClassRec,
+                                               composite_class.extension),
+                                    NULLQUARK, 1L, (Cardinal) 0);
+            LOCK_PROCESS;
+            if (ext &&
+                (ext->version > XtCompositeExtensionVersion ||
+                 ext->record_size > sizeof(CompositeClassExtensionRec))) {
+                params[1] = XtClass(parent)->core_class.class_name;
+                num_params = 2;
+                XtAppWarningMsg(XtWidgetToApplicationContext(parent),
+                                "invalidExtension", XtNxtCreateWidget,
+                                XtCXtToolkitError,
+                                "widget \"%s\" class %s has invalid CompositeClassExtension record",
+                                params, &num_params);
+            }
+            if (!ext || !ext->accepts_objects) {
+                params[1] = XtName(parent);
+                num_params = 2;
+                XtAppErrorMsg(XtWidgetToApplicationContext(parent),
+                              "nonWidget", XtNxtCreateWidget, XtCXtToolkitError,
+                              "attempt to add non-widget child \"%s\" to parent \"%s\" which supports only widgets",
+                              params, &num_params);
+            }
+            UNLOCK_PROCESS;
+        }
+    }
+    else {
+        default_screen = parent->core.screen;
     }
 
     if (XtIsConstraint(parent)) {
-	cwc = (ConstraintWidgetClass) parent->core.widget_class;
-    } else {
-	cwc = NULL;
+        cwc = (ConstraintWidgetClass) parent->core.widget_class;
+    }
+    else {
+        cwc = NULL;
     }
-    widget = xtCreate(name, (char *)NULL, widget_class, parent,
-		default_screen, args, num_args,
-		typed_args, num_typed_args, cwc, widgetPostProc);
+    widget = xtCreate(name, (char *) NULL, widget_class, parent,
+                      default_screen, args, num_args,
+                      typed_args, num_typed_args, cwc, widgetPostProc);
     return (widget);
 }
 
 Widget
-XtCreateWidget(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget   	parent,
-    ArgList 	args,
-    Cardinal    num_args
-    )
+XtCreateWidget(_Xconst char *name,
+               WidgetClass widget_class,
+               Widget parent,
+               ArgList args,
+               Cardinal num_args)
 {
     Widget retval;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
-    retval = _XtCreateWidget((String)name, widget_class, parent, args, num_args,
-		(XtTypedArgList)NULL, (Cardinal)0);
+    retval =
+        _XtCreateWidget((String) name, widget_class, parent, args, num_args,
+                        (XtTypedArgList) NULL, (Cardinal) 0);
     UNLOCK_APP(app);
     return retval;
 }
 
-
 Widget
-XtCreateManagedWidget(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget      parent,
-    ArgList     args,
-    Cardinal    num_args
-    )
+XtCreateManagedWidget(_Xconst char *name,
+                      WidgetClass widget_class,
+                      Widget parent,
+                      ArgList args,
+                      Cardinal num_args)
 {
-    register Widget	    widget;
+    register Widget widget;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
     XtCheckSubclass(parent, compositeWidgetClass, "in XtCreateManagedWidget");
-    widget = _XtCreateWidget((String)name, widget_class, parent, args,
-		num_args, (XtTypedArgList)NULL, (Cardinal) 0);
+    widget = _XtCreateWidget((String) name, widget_class, parent, args,
+                             num_args, (XtTypedArgList) NULL, (Cardinal) 0);
     XtManageChild(widget);
     UNLOCK_APP(app);
     return widget;
@@ -620,132 +629,125 @@ popupPostProc(Widget w)
     Widget parent = XtParent(w);
 
     parent->core.popup_list =
-	(WidgetList) XtRealloc((char*) parent->core.popup_list,
-		(Cardinal)((unsigned) (parent->core.num_popups+1) * sizeof(Widget)));
+        (WidgetList) XtRealloc((char *) parent->core.popup_list,
+                               (Cardinal) ((unsigned)
+                                           (parent->core.num_popups +
+                                            1) * sizeof(Widget)));
     parent->core.popup_list[parent->core.num_popups++] = w;
 }
 
 Widget
-_XtCreatePopupShell(
-    String      name,
-    WidgetClass widget_class,
-    Widget      parent,
-    ArgList     args,
-    Cardinal    num_args,
-    XtTypedArgList      typed_args,
-    Cardinal            num_typed_args)
+_XtCreatePopupShell(String name,
+                    WidgetClass widget_class,
+                    Widget parent,
+                    ArgList args,
+                    Cardinal num_args,
+                    XtTypedArgList typed_args,
+                    Cardinal num_typed_args)
 {
     register Widget widget;
-    Screen* default_screen;
+    Screen *default_screen;
 
     if (parent == NULL) {
-	XtErrorMsg("invalidParent",XtNxtCreatePopupShell,XtCXtToolkitError,
-		"XtCreatePopupShell requires non-NULL parent",
-		NULL, NULL);
-    } else if (widget_class == NULL) {
-	XtAppErrorMsg(XtWidgetToApplicationContext(parent),
-		"invalidClass",XtNxtCreatePopupShell,XtCXtToolkitError,
-		"XtCreatePopupShell requires non-NULL widget class",
-		NULL, NULL);
+        XtErrorMsg("invalidParent", XtNxtCreatePopupShell, XtCXtToolkitError,
+                   "XtCreatePopupShell requires non-NULL parent", NULL, NULL);
+    }
+    else if (widget_class == NULL) {
+        XtAppErrorMsg(XtWidgetToApplicationContext(parent),
+                      "invalidClass", XtNxtCreatePopupShell, XtCXtToolkitError,
+                      "XtCreatePopupShell requires non-NULL widget class",
+                      NULL, NULL);
     }
     XtCheckSubclass(parent, coreWidgetClass, "in XtCreatePopupShell");
     default_screen = parent->core.screen;
-    widget = xtCreate(name, (char *)NULL, widget_class, parent,
-		default_screen, args, num_args, typed_args,
-		num_typed_args, (ConstraintWidgetClass)NULL,
-		popupPostProc);
+    widget = xtCreate(name, (char *) NULL, widget_class, parent,
+                      default_screen, args, num_args, typed_args,
+                      num_typed_args, (ConstraintWidgetClass) NULL,
+                      popupPostProc);
 
 #ifndef X_NO_RESOURCE_CONFIGURATION_MANAGEMENT
-    XtAddEventHandler (widget, (EventMask) PropertyChangeMask, FALSE,
-		(XtEventHandler) _XtResourceConfigurationEH, NULL);
+    XtAddEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
+                      (XtEventHandler) _XtResourceConfigurationEH, NULL);
 #endif
-    return(widget);
+    return (widget);
 }
 
 Widget
-XtCreatePopupShell(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget      parent,
-    ArgList     args,
-    Cardinal    num_args
-    )
+XtCreatePopupShell(_Xconst char *name,
+                   WidgetClass widget_class,
+                   Widget parent,
+                   ArgList args,
+                   Cardinal num_args)
 {
     Widget retval;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
-    retval = _XtCreatePopupShell((String)name, widget_class, parent, args,
-		num_args, (XtTypedArgList)NULL, (Cardinal)0);
+    retval = _XtCreatePopupShell((String) name, widget_class, parent, args,
+                                 num_args, (XtTypedArgList) NULL, (Cardinal) 0);
     UNLOCK_APP(app);
     return retval;
 }
 
 Widget
-_XtAppCreateShell(
-    String      name,
-    String      class,
-    WidgetClass widget_class,
-    Display*    display,
-    ArgList     args,
-    Cardinal    num_args,
-    XtTypedArgList typed_args,
-    Cardinal	num_typed_args)
+_XtAppCreateShell(String name,
+                  String class,
+                  WidgetClass widget_class,
+                  Display *display,
+                  ArgList args,
+                  Cardinal num_args,
+                  XtTypedArgList typed_args,
+                  Cardinal num_typed_args)
 {
     Widget shell;
 
     if (widget_class == NULL) {
-	XtAppErrorMsg(XtDisplayToApplicationContext(display),
-		"invalidClass","xtAppCreateShell",XtCXtToolkitError,
-		"XtAppCreateShell requires non-NULL widget class",
-		NULL, NULL);
+        XtAppErrorMsg(XtDisplayToApplicationContext(display),
+                      "invalidClass", "xtAppCreateShell", XtCXtToolkitError,
+                      "XtAppCreateShell requires non-NULL widget class",
+                      NULL, NULL);
     }
     if (name == NULL)
-	name = XrmNameToString(_XtGetPerDisplay(display)->name);
-    shell = xtCreate(name, class, widget_class, (Widget)NULL,
-		(Screen*)DefaultScreenOfDisplay(display),
-		args, num_args, typed_args, num_typed_args,
-		(ConstraintWidgetClass) NULL, _XtAddShellToHookObj);
+        name = XrmNameToString(_XtGetPerDisplay(display)->name);
+    shell = xtCreate(name, class, widget_class, (Widget) NULL,
+                     (Screen *) DefaultScreenOfDisplay(display),
+                     args, num_args, typed_args, num_typed_args,
+                     (ConstraintWidgetClass) NULL, _XtAddShellToHookObj);
 
 #ifndef X_NO_RESOURCE_CONFIGURATION_MANAGEMENT
-    XtAddEventHandler (shell, (EventMask) PropertyChangeMask, FALSE,
-		(XtEventHandler) _XtResourceConfigurationEH, NULL);
+    XtAddEventHandler(shell, (EventMask) PropertyChangeMask, FALSE,
+                      (XtEventHandler) _XtResourceConfigurationEH, NULL);
 #endif
 
     return shell;
 }
 
 Widget
-XtAppCreateShell(
-    _Xconst char*       name,
-    _Xconst char*       class,
-    WidgetClass         widget_class,
-    Display             *display,
-    ArgList             args,
-    Cardinal            num_args
-    )
+XtAppCreateShell(_Xconst char *name,
+                 _Xconst char *class,
+                 WidgetClass widget_class,
+                 Display *display, ArgList args, Cardinal num_args)
 {
     Widget retval;
     DPY_TO_APPCON(display);
 
     LOCK_APP(app);
-    retval = _XtAppCreateShell((String)name, (String)class, widget_class,
-		display, args, num_args, (XtTypedArgList)NULL, (Cardinal)0);
+    retval = _XtAppCreateShell((String) name, (String) class, widget_class,
+                               display, args, num_args, (XtTypedArgList) NULL,
+                               (Cardinal) 0);
     UNLOCK_APP(app);
     return retval;
 }
 
-/* ARGSUSED */
 Widget
-XtCreateApplicationShell(
-    _Xconst char* name,		/* unused in R3 and later */
-    WidgetClass widget_class,
-    ArgList     args,
-    Cardinal    num_args
-    )
+XtCreateApplicationShell(_Xconst char *name _X_UNUSED,
+                         WidgetClass widget_class,
+                         ArgList args,
+                         Cardinal num_args)
 {
     Widget retval;
-    Display* dpy;
+    Display *dpy;
     XrmClass class;
     XtAppContext app = _XtDefaultAppContext();
 
@@ -753,34 +755,35 @@ XtCreateApplicationShell(
     dpy = app->list[0];
     class = _XtGetPerDisplay(dpy)->class;
 
-    retval = _XtAppCreateShell((String)NULL, XrmQuarkToString((XrmQuark)class),
-		widget_class, dpy, args, num_args,
-		(XtTypedArgList)NULL, (Cardinal)0);
+    retval =
+        _XtAppCreateShell((String) NULL, XrmQuarkToString((XrmQuark) class),
+                          widget_class, dpy, args, num_args,
+                          (XtTypedArgList) NULL, (Cardinal) 0);
     UNLOCK_APP(app);
     return retval;
 }
 
 Widget
-_XtCreateHookObj(Screen* screen)
+_XtCreateHookObj(Screen *screen)
 {
     Widget req_widget;
     double widget_cache[100];
     Cardinal wsize = 0;
     Widget hookobj = xtWidgetAlloc(hookObjectClass,
-		(ConstraintWidgetClass)NULL,
-		(Widget)NULL, "hooks",
-		(ArgList)NULL, (Cardinal)0,
-		(XtTypedArgList)NULL, (Cardinal)0);
-
-    ((HookObject)hookobj)->hooks.screen = screen;
-    (void) _XtGetResources(hookobj, (ArgList)NULL, 0,
-		(XtTypedArgList)NULL, &wsize);
+                                   (ConstraintWidgetClass) NULL,
+                                   (Widget) NULL, "hooks",
+                                   (ArgList) NULL, (Cardinal) 0,
+                                   (XtTypedArgList) NULL, (Cardinal) 0);
+
+    ((HookObject) hookobj)->hooks.screen = screen;
+    (void) _XtGetResources(hookobj, (ArgList) NULL, 0,
+                           (XtTypedArgList) NULL, &wsize);
     CompileCallbacks(hookobj);
     wsize = hookObjectClass->core_class.widget_size;
     req_widget = (Widget) XtStackAlloc(wsize, widget_cache);
-    (void) memmove ((char *) req_widget, (char *) hookobj, (size_t) wsize);
-    CallInitialize (hookObjectClass, req_widget, hookobj,
-		(ArgList)NULL, (Cardinal) 0);
-    XtStackFree((XtPointer)req_widget, widget_cache);
+    (void) memmove((char *) req_widget, (char *) hookobj, (size_t) wsize);
+    CallInitialize(hookObjectClass, req_widget, hookobj,
+                   (ArgList) NULL, (Cardinal) 0);
+    XtStackFree((XtPointer) req_widget, widget_cache);
     return hookobj;
 }
diff --git a/src/Destroy.c b/src/Destroy.c
index 37e918a..3c6e564 100644
--- a/src/Destroy.c
+++ b/src/Destroy.c
@@ -78,127 +78,140 @@ struct _DestroyRec {
     Widget widget;
 };
 
-static void Recursive(Widget widget, XtWidgetProc proc)
+static void
+Recursive(Widget widget, XtWidgetProc proc)
 {
     register Cardinal i;
 
     /* Recurse down normal children */
     if (XtIsComposite(widget)) {
-	CompositePart *cwp = &(((CompositeWidget) widget)->composite);
-	for (i = 0; i < cwp->num_children; i++) {
-	    Recursive(cwp->children[i], proc);
-	}
+        CompositePart *cwp = &(((CompositeWidget) widget)->composite);
+
+        for (i = 0; i < cwp->num_children; i++) {
+            Recursive(cwp->children[i], proc);
+        }
     }
 
     /* Recurse down popup children */
     if (XtIsWidget(widget)) {
-	for (i = 0; i < widget->core.num_popups; i++) {
-	    Recursive(widget->core.popup_list[i], proc);
-	}
+        for (i = 0; i < widget->core.num_popups; i++) {
+            Recursive(widget->core.popup_list[i], proc);
+        }
     }
 
     /* Finally, apply procedure to this widget */
     (*proc) (widget);
-} /* Recursive */
+}                               /* Recursive */
 
-static void Phase1Destroy (Widget widget)
+static void
+Phase1Destroy(Widget widget)
 {
     Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
 
     widget->core.being_destroyed = TRUE;
     if (XtHasCallbacks(hookobj, XtNdestroyHook) == XtCallbackHasSome) {
-	XtDestroyHookDataRec call_data;
+        XtDestroyHookDataRec call_data;
 
-	call_data.type = XtHdestroy;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.destroyhook_callbacks,
-		(XtPointer) &call_data);
+        call_data.type = XtHdestroy;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.destroyhook_callbacks,
+                           (XtPointer) &call_data);
     }
-} /* Phase1Destroy */
+}                               /* Phase1Destroy */
 
-static void Phase2Callbacks(Widget widget)
+static void
+Phase2Callbacks(Widget widget)
 {
     if (widget->core.destroy_callbacks != NULL) {
-	XtCallCallbackList(widget,
-			   widget->core.destroy_callbacks, (XtPointer) NULL);
+        XtCallCallbackList(widget,
+                           widget->core.destroy_callbacks, (XtPointer) NULL);
     }
-} /* Phase2Callbacks */
+}                               /* Phase2Callbacks */
 
-static void Phase2Destroy(register Widget widget)
+static void
+Phase2Destroy(register Widget widget)
 {
-    register WidgetClass	    class;
-    register ConstraintWidgetClass  cwClass;
-    ObjectClassExtension	    ext;
+    register WidgetClass class;
+    register ConstraintWidgetClass cwClass;
+    ObjectClassExtension ext;
 
     /* Call constraint destroy procedures */
-    if (XtParent(widget) != NULL && !XtIsShell(widget) && XtIsConstraint(XtParent(widget))) {
-	LOCK_PROCESS;
-	cwClass = (ConstraintWidgetClass)XtParent(widget)->core.widget_class;
-	UNLOCK_PROCESS;
-	for (;;) {
-	    XtWidgetProc destroy;
-
-	    LOCK_PROCESS;
-	    destroy = cwClass->constraint_class.destroy;
-	    UNLOCK_PROCESS;
-	    if (destroy)
-		(*destroy) (widget);
-            if (cwClass == (ConstraintWidgetClass)constraintWidgetClass) break;
-	    LOCK_PROCESS;
-	    cwClass = (ConstraintWidgetClass) cwClass->core_class.superclass;
-	    UNLOCK_PROCESS;
-	}
+    if (XtParent(widget) != NULL && !XtIsShell(widget) &&
+        XtIsConstraint(XtParent(widget))) {
+        LOCK_PROCESS;
+        cwClass = (ConstraintWidgetClass) XtParent(widget)->core.widget_class;
+        UNLOCK_PROCESS;
+        for (;;) {
+            XtWidgetProc destroy;
+
+            LOCK_PROCESS;
+            destroy = cwClass->constraint_class.destroy;
+            UNLOCK_PROCESS;
+            if (destroy)
+                (*destroy) (widget);
+            if (cwClass == (ConstraintWidgetClass) constraintWidgetClass)
+                break;
+            LOCK_PROCESS;
+            cwClass = (ConstraintWidgetClass) cwClass->core_class.superclass;
+            UNLOCK_PROCESS;
+        }
     }
 
     /* Call widget destroy procedures */
     LOCK_PROCESS;
     for (class = widget->core.widget_class;
-	 class != NULL;
-	 class = class->core_class.superclass) {
-	XtWidgetProc destroy;
-
-	destroy = class->core_class.destroy;
-	UNLOCK_PROCESS;
-	if (destroy)
-	    (*destroy) (widget);
-	LOCK_PROCESS;
+         class != NULL; class = class->core_class.superclass) {
+        XtWidgetProc destroy;
+
+        destroy = class->core_class.destroy;
+        UNLOCK_PROCESS;
+        if (destroy)
+            (*destroy) (widget);
+        LOCK_PROCESS;
     }
 
     /* Call widget deallocate procedure */
-    ext = (ObjectClassExtension)
-	XtGetClassExtension(widget->core.widget_class,
-			    XtOffsetOf(CoreClassPart, extension),
-			    NULLQUARK, XtObjectExtensionVersion,
-			    sizeof(ObjectClassExtensionRec));
+    ext = (ObjectClassExtension) XtGetClassExtension(widget->core.widget_class,
+                                                     XtOffsetOf(CoreClassPart,
+                                                                extension),
+                                                     NULLQUARK,
+                                                     XtObjectExtensionVersion,
+                                                     sizeof
+                                                     (ObjectClassExtensionRec));
     if (ext && ext->deallocate) {
-	XtDeallocateProc deallocate;
-	deallocate = ext->deallocate;
-	UNLOCK_PROCESS;
-	(*deallocate)(widget, NULL);
-    } else {
-	UNLOCK_PROCESS;
-	XtFree((char *)widget);
+        XtDeallocateProc deallocate;
+
+        deallocate = ext->deallocate;
+        UNLOCK_PROCESS;
+        (*deallocate) (widget, NULL);
+    }
+    else {
+        UNLOCK_PROCESS;
+        XtFree((char *) widget);
     }
-} /* Phase2Destroy */
+}                               /* Phase2Destroy */
 
-static Boolean IsDescendant(Widget widget, Widget root)
+static Boolean
+IsDescendant(Widget widget, Widget root)
 {
     while ((widget = XtParent(widget)) != root) {
-	if (widget == NULL) return False;
+        if (widget == NULL)
+            return False;
     }
     return True;
 }
 
-static void XtPhase2Destroy (Widget widget)
+static void
+XtPhase2Destroy(Widget widget)
 {
-    Display	    *display = NULL;
-    Window	    window;
-    Widget          parent;
-    XtAppContext    app = XtWidgetToApplicationContext(widget);
-    Widget	    outerInPhase2Destroy = app->in_phase2_destroy;
-    int		    starting_count = app->destroy_count;
-    Boolean	    isPopup = False;
+    Display *display = NULL;
+    Window window;
+    Widget parent;
+    XtAppContext app = XtWidgetToApplicationContext(widget);
+    Widget outerInPhase2Destroy = app->in_phase2_destroy;
+    int starting_count = app->destroy_count;
+    Boolean isPopup = False;
 
     /* invalidate focus trace cache for this display */
     _XtGetPerDisplay(XtDisplayOfObject(widget))->pdi.traceDepth = 0;
@@ -206,40 +219,43 @@ static void XtPhase2Destroy (Widget widget)
     parent = widget->core.parent;
 
     if (parent && XtIsWidget(parent) && parent->core.num_popups) {
-	Cardinal i;
-	for (i = 0; i < parent->core.num_popups; i++) {
-	    if (parent->core.popup_list[i] == widget) {
-		isPopup = True;
-		break;
-	    }
-	}
+        Cardinal i;
+
+        for (i = 0; i < parent->core.num_popups; i++) {
+            if (parent->core.popup_list[i] == widget) {
+                isPopup = True;
+                break;
+            }
+        }
     }
 
     if (!isPopup && parent && XtIsComposite(parent)) {
-	XtWidgetProc delete_child;
+        XtWidgetProc delete_child;
 
-	LOCK_PROCESS;
-	delete_child =
-	    ((CompositeWidgetClass) parent->core.widget_class)->
-		composite_class.delete_child;
-	UNLOCK_PROCESS;
+        LOCK_PROCESS;
+        delete_child =
+            ((CompositeWidgetClass) parent->core.widget_class)->composite_class.
+            delete_child;
+        UNLOCK_PROCESS;
         if (XtIsRectObj(widget)) {
-       	    XtUnmanageChild(widget);
+            XtUnmanageChild(widget);
+        }
+        if (delete_child == NULL) {
+            String param;
+            Cardinal num_params = 1;
+
+            LOCK_PROCESS;
+            param = parent->core.widget_class->core_class.class_name;
+            UNLOCK_PROCESS;
+            XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                            "invalidProcedure", "deleteChild",
+                            XtCXtToolkitError,
+                            "null delete_child procedure for class %s in XtDestroy",
+                            &param, &num_params);
+        }
+        else {
+            (*delete_child) (widget);
         }
-	if (delete_child == NULL) {
-	    String param;
-	    Cardinal num_params = 1;
-
-	    LOCK_PROCESS;
-	    param = parent->core.widget_class->core_class.class_name;
-	    UNLOCK_PROCESS;
-	    XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidProcedure","deleteChild",XtCXtToolkitError,
-		"null delete_child procedure for class %s in XtDestroy",
-		&param, &num_params);
-	} else {
-	    (*delete_child) (widget);
-	}
     }
 
     /* widget is freed in Phase2Destroy, so retrieve window now.
@@ -247,29 +263,34 @@ static void XtPhase2Destroy (Widget widget)
      * popups; this test is practical only when XtIsShell() is cheap.
      */
     if (XtIsShell(widget) || !XtIsWidget(widget)) {
-	window = 0;
+        window = 0;
     }
     else {
-	display = XtDisplay(widget);
-	window = widget->core.window;
+        display = XtDisplay(widget);
+
+        window = widget->core.window;
     }
 
     Recursive(widget, Phase2Callbacks);
     if (app->destroy_count > starting_count) {
-	int i = starting_count;
-	while (i < app->destroy_count) {
-
-	    DestroyRec * dr = app->destroy_list + i;
-	    if (IsDescendant(dr->widget, widget)) {
-		Widget descendant = dr->widget;
-		register int j;
-		app->destroy_count--;
-		for (j = app->destroy_count - i; --j >= 0; dr++)
-		    *dr = *(dr + 1);
-		XtPhase2Destroy(descendant);
-	    }
-	    else i++;
-	}
+        int i = starting_count;
+
+        while (i < app->destroy_count) {
+
+            DestroyRec *dr = app->destroy_list + i;
+
+            if (IsDescendant(dr->widget, widget)) {
+                Widget descendant = dr->widget;
+                register int j;
+
+                app->destroy_count--;
+                for (j = app->destroy_count - i; --j >= 0; dr++)
+                    *dr = *(dr + 1);
+                XtPhase2Destroy(descendant);
+            }
+            else
+                i++;
+        }
     }
 
     app->in_phase2_destroy = widget;
@@ -277,16 +298,17 @@ static void XtPhase2Destroy (Widget widget)
     app->in_phase2_destroy = outerInPhase2Destroy;
 
     if (isPopup) {
-	Cardinal i;
-	for (i = 0; i < parent->core.num_popups; i++)
-	    if (parent->core.popup_list[i] == widget) {
-		parent->core.num_popups--;
-		while (i < parent->core.num_popups) {
-		    parent->core.popup_list[i] = parent->core.popup_list[i+1];
-		    i++;
-		}
-		break;
-	    }
+        Cardinal i;
+
+        for (i = 0; i < parent->core.num_popups; i++)
+            if (parent->core.popup_list[i] == widget) {
+                parent->core.num_popups--;
+                while (i < parent->core.num_popups) {
+                    parent->core.popup_list[i] = parent->core.popup_list[i + 1];
+                    i++;
+                }
+                break;
+            }
     }
 
     /* %%% the following parent test hides a more serious problem,
@@ -294,38 +316,42 @@ static void XtPhase2Destroy (Widget widget)
        until we have time to fix it properly. */
 
     if (window && (parent == NULL || !parent->core.being_destroyed))
-	XDestroyWindow(display, window);
-} /* XtPhase2Destroy */
-
+        XDestroyWindow(display, window);
+}                               /* XtPhase2Destroy */
 
-void _XtDoPhase2Destroy(XtAppContext app, int dispatch_level)
+void
+_XtDoPhase2Destroy(XtAppContext app, int dispatch_level)
 {
     /* Phase 2 must occur in fifo order.  List is not necessarily
      * contiguous in dispatch_level.
      */
 
     int i = 0;
+
     while (i < app->destroy_count) {
 
-	/* XtPhase2Destroy can result in calls to XtDestroyWidget,
-	 * and these could cause app->destroy_list to be reallocated.
-	 */
-
-	DestroyRec* dr = app->destroy_list + i;
-	if (dr->dispatch_level >= dispatch_level)  {
-	    Widget w = dr->widget;
-	    register int j;
-	    app->destroy_count--;
-	    for (j = app->destroy_count - i; --j >=0; dr++)
-		*dr = *(dr + 1);
-	    XtPhase2Destroy(w);
-	}
-	else i++;
+        /* XtPhase2Destroy can result in calls to XtDestroyWidget,
+         * and these could cause app->destroy_list to be reallocated.
+         */
+
+        DestroyRec *dr = app->destroy_list + i;
+
+        if (dr->dispatch_level >= dispatch_level) {
+            Widget w = dr->widget;
+            register int j;
+
+            app->destroy_count--;
+            for (j = app->destroy_count - i; --j >= 0; dr++)
+                *dr = *(dr + 1);
+            XtPhase2Destroy(w);
+        }
+        else
+            i++;
     }
 }
 
-
-void XtDestroyWidget (Widget widget)
+void
+XtDestroyWidget(Widget widget)
 {
     XtAppContext app;
     DestroyRec *dr;
@@ -333,49 +359,50 @@ void XtDestroyWidget (Widget widget)
     app = XtWidgetToApplicationContext(widget);
     LOCK_APP(app);
     if (widget->core.being_destroyed) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
     Recursive(widget, Phase1Destroy);
 
-    if (app->in_phase2_destroy &&
-	IsDescendant(widget, app->in_phase2_destroy))
-    {
-	XtPhase2Destroy(widget);
-	UNLOCK_APP(app);
-	return;
+    if (app->in_phase2_destroy && IsDescendant(widget, app->in_phase2_destroy)) {
+        XtPhase2Destroy(widget);
+        UNLOCK_APP(app);
+        return;
     }
 
     if (app->destroy_count == app->destroy_list_size) {
-	app->destroy_list_size += 10;
-	app->destroy_list = (DestroyRec*)
-	    XtRealloc( (char*)app->destroy_list,
-		       (Cardinal)(sizeof(DestroyRec) * (size_t)app->destroy_list_size)
-		      );
+        app->destroy_list_size += 10;
+        app->destroy_list = (DestroyRec *)
+            XtRealloc((char *) app->destroy_list,
+                      (Cardinal) (sizeof(DestroyRec) *
+                                  (size_t) app->destroy_list_size)
+            );
     }
     dr = app->destroy_list + app->destroy_count++;
     dr->dispatch_level = app->dispatch_level;
     dr->widget = widget;
 
     if (app->dispatch_level > 1) {
-	int i;
-	for (i = app->destroy_count - 1; i;) {
-	    /* this handles only one case of nesting difficulties */
- 	    dr = app->destroy_list + (--i);
- 	    if (dr->dispatch_level < app->dispatch_level &&
- 		IsDescendant(dr->widget, widget)) {
-		DestroyRec *dr2 = app->destroy_list + (app->destroy_count-1);
- 		dr2->dispatch_level = dr->dispatch_level;
-  		break;
-  	    }
-  	}
+        int i;
+
+        for (i = app->destroy_count - 1; i;) {
+            /* this handles only one case of nesting difficulties */
+            dr = app->destroy_list + (--i);
+            if (dr->dispatch_level < app->dispatch_level &&
+                IsDescendant(dr->widget, widget)) {
+                DestroyRec *dr2 = app->destroy_list + (app->destroy_count - 1);
+
+                dr2->dispatch_level = dr->dispatch_level;
+                break;
+            }
+        }
     }
 
     if (_XtSafeToDestroy(app)) {
-	app->dispatch_level = 1; /* avoid nested _XtDoPhase2Destroy */
-	_XtDoPhase2Destroy(app, 0);
-	app->dispatch_level = 0;
+        app->dispatch_level = 1;        /* avoid nested _XtDoPhase2Destroy */
+        _XtDoPhase2Destroy(app, 0);
+        app->dispatch_level = 0;
     }
     UNLOCK_APP(app);
 
-} /* XtDestroyWidget */
+}                               /* XtDestroyWidget */
diff --git a/src/Display.c b/src/Display.c
index 9f52576..cff344c 100644
--- a/src/Display.c
+++ b/src/Display.c
@@ -79,107 +79,112 @@ in this Software without prior written authorization from The Open Group.
 #include <stdlib.h>
 
 #ifdef XTHREADS
-void (*_XtProcessLock)(void) = NULL;
-void (*_XtProcessUnlock)(void) = NULL;
-void (*_XtInitAppLock)(XtAppContext) = NULL;
+void (*_XtProcessLock) (void) = NULL;
+void (*_XtProcessUnlock) (void) = NULL;
+void (*_XtInitAppLock) (XtAppContext) = NULL;
 #endif
 
 static _Xconst _XtString XtNnoPerDisplay = "noPerDisplay";
 
-ProcessContext _XtGetProcessContext(void)
+ProcessContext
+_XtGetProcessContext(void)
 {
     static ProcessContextRec processContextRec = {
-	(XtAppContext)NULL,
-	(XtAppContext)NULL,
-	(ConverterTable)NULL,
-	{(XtLanguageProc)NULL, (XtPointer)NULL}
+        (XtAppContext) NULL,
+        (XtAppContext) NULL,
+        (ConverterTable) NULL,
+        {(XtLanguageProc) NULL, (XtPointer) NULL}
     };
 
     return &processContextRec;
 }
 
-
-XtAppContext _XtDefaultAppContext(void)
+XtAppContext
+_XtDefaultAppContext(void)
 {
     ProcessContext process = _XtGetProcessContext();
     XtAppContext app;
 
     LOCK_PROCESS;
     if (process->defaultAppContext == NULL) {
-	process->defaultAppContext = XtCreateApplicationContext();
+        process->defaultAppContext = XtCreateApplicationContext();
     }
     app = process->defaultAppContext;
     UNLOCK_PROCESS;
     return app;
 }
 
-static void AddToAppContext(
-	Display *d,
-	XtAppContext app)
+static void
+AddToAppContext(Display *d, XtAppContext app)
 {
 #define DISPLAYS_TO_ADD 4
 
-	if (app->count >= app->max) {
-	    app->max = (short) (app->max + DISPLAYS_TO_ADD);
-	    app->list = (Display **) XtRealloc((char *)app->list,
-		    (Cardinal) (((size_t) app->max) * sizeof(Display *)));
-	}
+    if (app->count >= app->max) {
+        app->max = (short) (app->max + DISPLAYS_TO_ADD);
+        app->list = (Display **) XtRealloc((char *) app->list,
+                                           (Cardinal) (((size_t) app->max) *
+                                                       sizeof(Display *)));
+    }
 
-	app->list[app->count++] = d;
-	app->rebuild_fdlist = TRUE;
+    app->list[app->count++] = d;
+    app->rebuild_fdlist = TRUE;
 #ifdef USE_POLL
-	app->fds.nfds++;
+    app->fds.nfds++;
 #else
-	if (ConnectionNumber(d) + 1 > app->fds.nfds) {
-	    app->fds.nfds = ConnectionNumber(d) + 1;
-	}
+    if (ConnectionNumber(d) + 1 > app->fds.nfds) {
+        app->fds.nfds = ConnectionNumber(d) + 1;
+    }
 #endif
 #undef DISPLAYS_TO_ADD
 }
 
-static void XtDeleteFromAppContext(
-	Display *d,
-	register XtAppContext app)
+static void
+XtDeleteFromAppContext(Display *d, register XtAppContext app)
 {
-	register int i;
-
-	for (i = 0; i < app->count; i++) if (app->list[i] == d) break;
-
-	if (i < app->count) {
-	    if (i <= app->last && app->last > 0) app->last--;
-	    for (i++; i < app->count; i++) app->list[i-1] = app->list[i];
-	    app->count--;
-	}
-	app->rebuild_fdlist = TRUE;
+    register int i;
+
+    for (i = 0; i < app->count; i++)
+        if (app->list[i] == d)
+            break;
+
+    if (i < app->count) {
+        if (i <= app->last && app->last > 0)
+            app->last--;
+        for (i++; i < app->count; i++)
+            app->list[i - 1] = app->list[i];
+        app->count--;
+    }
+    app->rebuild_fdlist = TRUE;
 #ifdef USE_POLL
-	app->fds.nfds--;
+    app->fds.nfds--;
 #else
-	if ((ConnectionNumber(d) + 1) == app->fds.nfds)
-	    app->fds.nfds--;
-	else			/* Unnecessary, just to be fool-proof */
-	    FD_CLR(ConnectionNumber(d), &app->fds.rmask);
+    if ((ConnectionNumber(d) + 1) == app->fds.nfds)
+        app->fds.nfds--;
+    else                        /* Unnecessary, just to be fool-proof */
+        FD_CLR(ConnectionNumber(d), &app->fds.rmask);
 #endif
 }
 
-static XtPerDisplay NewPerDisplay(
-	Display *dpy)
+static XtPerDisplay
+NewPerDisplay(Display *dpy)
 {
-	PerDisplayTablePtr pd;
-
-	pd = XtNew(PerDisplayTable);
-	LOCK_PROCESS;
-	pd->dpy = dpy;
-	pd->next = _XtperDisplayList;
-	_XtperDisplayList = pd;
-	UNLOCK_PROCESS;
-	return &(pd->perDpy);
+    PerDisplayTablePtr pd;
+
+    pd = XtNew(PerDisplayTable);
+
+    LOCK_PROCESS;
+    pd->dpy = dpy;
+    pd->next = _XtperDisplayList;
+    _XtperDisplayList = pd;
+    UNLOCK_PROCESS;
+    return &(pd->perDpy);
 }
 
-static XtPerDisplay InitPerDisplay(
-    Display *dpy,
-    XtAppContext app,
-    _Xconst char * name,
-    _Xconst char * classname)
+static XtPerDisplay
+InitPerDisplay(Display *dpy,
+               XtAppContext app,
+               _Xconst char *name,
+               _Xconst char *classname)
 {
     XtPerDisplay pd;
 
@@ -216,129 +221,156 @@ static XtPerDisplay InitPerDisplay(
     pd->pdi.focusWidget = NULL;
     pd->pdi.activatingKey = 0;
     pd->pdi.keyboard.grabType = XtNoServerGrab;
-    pd->pdi.pointer.grabType  = XtNoServerGrab;
+    pd->pdi.pointer.grabType = XtNoServerGrab;
+
     _XtAllocWWTable(pd);
-    pd->per_screen_db = (XrmDatabase *)__XtCalloc((Cardinal)ScreenCount(dpy),
-						(Cardinal)sizeof(XrmDatabase));
-    pd->cmd_db = (XrmDatabase)NULL;
-    pd->server_db = (XrmDatabase)NULL;
+    pd->per_screen_db = (XrmDatabase *) __XtCalloc((Cardinal) ScreenCount(dpy),
+                                                   (Cardinal)
+                                                   sizeof(XrmDatabase));
+    pd->cmd_db = (XrmDatabase) NULL;
+    pd->server_db = (XrmDatabase) NULL;
     pd->dispatcher_list = NULL;
     pd->ext_select_list = NULL;
     pd->ext_select_count = 0;
     pd->hook_object = NULL;
 #if 0
     pd->hook_object = _XtCreate("hooks", "Hooks", hookObjectClass,
-	(Widget)NULL, (Screen*)DefaultScreenOfDisplay(dpy),
-	(ArgList)NULL, 0, (XtTypedArgList)NULL, 0,
-	(ConstraintWidgetClass)NULL);
+                                (Widget) NULL,
+                                (Screen *) DefaultScreenOfDisplay(dpy),
+                                (ArgList) NULL, 0, (XtTypedArgList) NULL, 0,
+                                (ConstraintWidgetClass) NULL);
 #endif
 
 #ifndef X_NO_RESOURCE_CONFIGURATION_MANAGEMENT
-    pd->rcm_init = XInternAtom (dpy, RCM_INIT, 0);
-    pd->rcm_data = XInternAtom (dpy, RCM_DATA, 0);
+    pd->rcm_init = XInternAtom(dpy, RCM_INIT, 0);
+    pd->rcm_data = XInternAtom(dpy, RCM_DATA, 0);
 #endif
 
     return pd;
 }
 
-Display *XtOpenDisplay(
-	XtAppContext app,
-	_Xconst _XtString displayName,
-	_Xconst _XtString applName,
-	_Xconst _XtString className,
-	XrmOptionDescRec *urlist,
-	Cardinal num_urs,
-	int *argc,
-	_XtString *argv)
+#define THIS_FUNC "XtOpenDisplay"
+Display *
+XtOpenDisplay(XtAppContext app,
+              _Xconst _XtString displayName,
+              _Xconst _XtString applName,
+              _Xconst _XtString className,
+              XrmOptionDescRec *urlist,
+              Cardinal num_urs,
+              int *argc,
+              _XtString *argv)
 {
-	Display *d;
-	XrmDatabase db = NULL;
-	String language = NULL;
-
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	/* parse the command line for name, display, and/or language */
-	db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv,
-				(String *)&applName,
-				(String *)(displayName ? NULL : &displayName),
-				(app->process->globalLangProcRec.proc ?
-				&language : NULL));
-	UNLOCK_PROCESS;
-	d = XOpenDisplay(displayName);
-
-	if (! applName && !(applName = getenv("RESOURCE_NAME"))) {
-	    if (*argc > 0 && argv[0] && *argv[0]) {
+    Display *d;
+    XrmDatabase db = NULL;
+    String language = NULL;
+
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    /* parse the command line for name, display, and/or language */
+    db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv,
+                                (String *) &applName,
+                                (String *) (displayName ? NULL : &displayName),
+                                (app->process->globalLangProcRec.proc ?
+                                 &language : NULL));
+    UNLOCK_PROCESS;
+    d = XOpenDisplay(displayName);
+    if (d != NULL) {
+        if (ScreenCount(d) <= 0) {
+            XtErrorMsg("nullDisplay",
+                       THIS_FUNC, XtCXtToolkitError,
+                       THIS_FUNC " requires a non-NULL display",
+                       NULL, NULL);
+        }
+        if (DefaultScreen(d) < 0 || DefaultScreen(d) >= ScreenCount(d)) {
+            XtWarningMsg("nullDisplay",
+                         THIS_FUNC, XtCXtToolkitError,
+                         THIS_FUNC " default screen is invalid (ignoring)",
+                         NULL, NULL);
+            DefaultScreen(d) = 0;
+        }
+    }
+
+    if (!applName && !(applName = getenv("RESOURCE_NAME"))) {
+        if (*argc > 0 && argv[0] && *argv[0]) {
 #ifdef WIN32
-		char *ptr = strrchr(argv[0], '\\');
+            char *ptr = strrchr(argv[0], '\\');
 #else
-		char *ptr = strrchr(argv[0], '/');
+            char *ptr = strrchr(argv[0], '/');
 #endif
 
-		if (ptr) applName = ++ptr;
-		else applName = argv[0];
-	    } else
-		applName = "main";
-	}
-
-	if (d) {
-	    XtPerDisplay pd;
-	    pd = InitPerDisplay(d, app, applName, className);
-	    pd->language = language;
-	    _XtDisplayInitialize(d, pd, applName, urlist, num_urs, argc, argv);
-	} else {
-	    int len;
-	    displayName = XDisplayName(displayName);
-	    len = (int) strlen (displayName);
-	    app->display_name_tried = (_XtString) __XtMalloc ((Cardinal)(len + 1));
-	    strncpy ((char*) app->display_name_tried, displayName, (size_t) (len + 1));
-	    app->display_name_tried[len] = '\0';
-	}
-	if (db) XrmDestroyDatabase(db);
-	UNLOCK_APP(app);
-	return d;
+            if (ptr)
+                applName = ++ptr;
+            else
+                applName = argv[0];
+        }
+        else
+            applName = "main";
+    }
+
+    if (d) {
+        XtPerDisplay pd;
+
+        pd = InitPerDisplay(d, app, applName, className);
+        pd->language = language;
+        _XtDisplayInitialize(d, pd, applName, urlist, num_urs, argc, argv);
+    }
+    else {
+        int len;
+
+        displayName = XDisplayName(displayName);
+        len = (int) strlen(displayName);
+        app->display_name_tried = (_XtString) __XtMalloc((Cardinal) (len + 1));
+        strncpy((char *) app->display_name_tried, displayName,
+                (size_t) (len + 1));
+        app->display_name_tried[len] = '\0';
+    }
+    if (db)
+        XrmDestroyDatabase(db);
+    UNLOCK_APP(app);
+    return d;
 }
 
 Display *
-_XtAppInit(
-	XtAppContext * app_context_return,
-	String application_class,
-	XrmOptionDescRec *options,
-	Cardinal num_options,
-	int *argc_in_out,
-	_XtString **argv_in_out,
-	String * fallback_resources)
+_XtAppInit(XtAppContext *app_context_return,
+           String application_class,
+           XrmOptionDescRec *options,
+           Cardinal num_options,
+           int *argc_in_out,
+           _XtString **argv_in_out,
+           String *fallback_resources)
 {
     _XtString *saved_argv;
     int i;
     Display *dpy;
 
-/*
- * Save away argv and argc so we can set the properties later
- */
-
+    /*
+     * Save away argv and argc so we can set the properties later
+     */
     saved_argv = (_XtString *)
-	__XtMalloc( (Cardinal)((size_t)(*argc_in_out + 1) * sizeof(_XtString)) );
-
-    for (i = 0 ; i < *argc_in_out ; i++) saved_argv[i] = (*argv_in_out)[i];
-    saved_argv[i] = NULL;	/* NULL terminate that sucker. */
+        __XtMalloc((Cardinal)
+                   ((size_t) (*argc_in_out + 1) * sizeof(_XtString)));
 
+    for (i = 0; i < *argc_in_out; i++)
+        saved_argv[i] = (*argv_in_out)[i];
+    saved_argv[i] = NULL;       /* NULL terminate that sucker. */
 
     *app_context_return = XtCreateApplicationContext();
 
     LOCK_APP((*app_context_return));
-    if (fallback_resources) /* save a procedure call */
-	XtAppSetFallbackResources(*app_context_return, fallback_resources);
+    if (fallback_resources)     /* save a procedure call */
+        XtAppSetFallbackResources(*app_context_return, fallback_resources);
 
     dpy = XtOpenDisplay(*app_context_return, NULL, NULL,
-			application_class,
-			options, num_options, argc_in_out, *argv_in_out);
+                        application_class,
+                        options, num_options, argc_in_out, *argv_in_out);
 
     if (!dpy) {
-	String param = (*app_context_return)->display_name_tried;
-	Cardinal param_count = 1;
-	XtErrorMsg("invalidDisplay","xtInitialize",XtCXtToolkitError,
+        String param = (*app_context_return)->display_name_tried;
+        Cardinal param_count = 1;
+
+        XtErrorMsg("invalidDisplay", "xtInitialize", XtCXtToolkitError,
                    "Can't open display: %s", &param, &param_count);
-	XtFree((char *) (*app_context_return)->display_name_tried);
+        XtFree((char *) (*app_context_return)->display_name_tried);
     }
     *argv_in_out = saved_argv;
     UNLOCK_APP((*app_context_return));
@@ -346,16 +378,14 @@ _XtAppInit(
 }
 
 void
-XtDisplayInitialize(
-	XtAppContext app,
-	Display *dpy,
-	_Xconst _XtString name,
-	_Xconst _XtString classname,
-	XrmOptionDescRec *urlist,
-	Cardinal num_urs,
-	int *argc,
-	_XtString *argv
-	)
+XtDisplayInitialize(XtAppContext app,
+                    Display *dpy,
+                    _Xconst _XtString name,
+                    _Xconst _XtString classname,
+                    XrmOptionDescRec *urlist,
+                    Cardinal num_urs,
+                    int *argc,
+                    _XtString *argv)
 {
     XtPerDisplay pd;
     XrmDatabase db = NULL;
@@ -364,184 +394,205 @@ XtDisplayInitialize(
     pd = InitPerDisplay(dpy, app, name, classname);
     LOCK_PROCESS;
     if (app->process->globalLangProcRec.proc)
-	/* pre-parse the command line for the language resource */
-	db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv, NULL, NULL,
-				    &pd->language);
+        /* pre-parse the command line for the language resource */
+        db = _XtPreparseCommandLine(urlist, num_urs, *argc, argv, NULL, NULL,
+                                    &pd->language);
     UNLOCK_PROCESS;
     _XtDisplayInitialize(dpy, pd, name, urlist, num_urs, argc, argv);
-    if (db) XrmDestroyDatabase(db);
+    if (db)
+        XrmDestroyDatabase(db);
     UNLOCK_APP(app);
 }
 
-XtAppContext XtCreateApplicationContext(void)
+XtAppContext
+XtCreateApplicationContext(void)
 {
-	XtAppContext app = XtNew(XtAppStruct);
+    XtAppContext app = XtNew(XtAppStruct);
+
 #ifdef XTHREADS
-	app->lock_info = NULL;
-	app->lock = NULL;
-	app->unlock = NULL;
-	app->yield_lock = NULL;
-	app->restore_lock = NULL;
-	app->free_lock = NULL;
+    app->lock_info = NULL;
+    app->lock = NULL;
+    app->unlock = NULL;
+    app->yield_lock = NULL;
+    app->restore_lock = NULL;
+    app->free_lock = NULL;
 #endif
-	INIT_APP_LOCK(app);
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	app->process = _XtGetProcessContext();
-	app->next = app->process->appContextList;
-	app->process->appContextList = app;
-	app->langProcRec.proc = app->process->globalLangProcRec.proc;
-	app->langProcRec.closure = app->process->globalLangProcRec.closure;
-	app->destroy_callbacks = NULL;
-	app->list = NULL;
-	app->count = app->max = app->last = 0;
-	app->timerQueue = NULL;
-	app->workQueue = NULL;
-	app->signalQueue = NULL;
-	app->input_list = NULL;
-	app->outstandingQueue = NULL;
-	app->errorDB = NULL;
-	_XtSetDefaultErrorHandlers(&app->errorMsgHandler,
-		&app->warningMsgHandler, &app->errorHandler,
-		&app->warningHandler);
-	app->action_table = NULL;
-	_XtSetDefaultSelectionTimeout(&app->selectionTimeout);
-	_XtSetDefaultConverterTable(&app->converterTable);
-	app->sync = app->being_destroyed = app->error_inited = FALSE;
-	app->in_phase2_destroy = NULL;
+    INIT_APP_LOCK(app);
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    app->process = _XtGetProcessContext();
+    app->next = app->process->appContextList;
+    app->process->appContextList = app;
+    app->langProcRec.proc = app->process->globalLangProcRec.proc;
+    app->langProcRec.closure = app->process->globalLangProcRec.closure;
+    app->destroy_callbacks = NULL;
+    app->list = NULL;
+    app->count = app->max = app->last = 0;
+    app->timerQueue = NULL;
+    app->workQueue = NULL;
+    app->signalQueue = NULL;
+    app->input_list = NULL;
+    app->outstandingQueue = NULL;
+    app->errorDB = NULL;
+    _XtSetDefaultErrorHandlers(&app->errorMsgHandler,
+                               &app->warningMsgHandler, &app->errorHandler,
+                               &app->warningHandler);
+    app->action_table = NULL;
+    _XtSetDefaultSelectionTimeout(&app->selectionTimeout);
+    _XtSetDefaultConverterTable(&app->converterTable);
+    app->sync = app->being_destroyed = app->error_inited = FALSE;
+    app->in_phase2_destroy = NULL;
 #ifndef USE_POLL
-	FD_ZERO(&app->fds.rmask);
-	FD_ZERO(&app->fds.wmask);
-	FD_ZERO(&app->fds.emask);
+    FD_ZERO(&app->fds.rmask);
+    FD_ZERO(&app->fds.wmask);
+    FD_ZERO(&app->fds.emask);
 #endif
-	app->fds.nfds = 0;
-	app->input_count = app->input_max = 0;
-	_XtHeapInit(&app->heap);
-	app->fallback_resources = NULL;
-	_XtPopupInitialize(app);
-	app->action_hook_list = NULL;
-	app->block_hook_list = NULL;
-	app->destroy_list_size = app->destroy_count = app->dispatch_level = 0;
-	app->destroy_list = NULL;
+    app->fds.nfds = 0;
+    app->input_count = app->input_max = 0;
+    _XtHeapInit(&app->heap);
+    app->fallback_resources = NULL;
+    _XtPopupInitialize(app);
+    app->action_hook_list = NULL;
+    app->block_hook_list = NULL;
+    app->destroy_list_size = app->destroy_count = app->dispatch_level = 0;
+    app->destroy_list = NULL;
 #ifndef NO_IDENTIFY_WINDOWS
-	app->identify_windows = False;
+    app->identify_windows = False;
 #endif
-	app->free_bindings = NULL;
-	app->display_name_tried = NULL;
-	app->dpy_destroy_count = 0;
-	app->dpy_destroy_list = NULL;
-	app->exit_flag = FALSE;
-	app->rebuild_fdlist = TRUE;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-	return app;
+    app->free_bindings = NULL;
+    app->display_name_tried = NULL;
+    app->dpy_destroy_count = 0;
+    app->dpy_destroy_list = NULL;
+    app->exit_flag = FALSE;
+    app->rebuild_fdlist = TRUE;
+    UNLOCK_PROCESS;
+    UNLOCK_APP(app);
+    return app;
 }
 
-void XtAppSetExitFlag (
-    XtAppContext app)
+void
+XtAppSetExitFlag(XtAppContext app)
 {
     LOCK_APP(app);
     app->exit_flag = TRUE;
     UNLOCK_APP(app);
 }
 
-Boolean XtAppGetExitFlag (
-    XtAppContext app)
+Boolean
+XtAppGetExitFlag(XtAppContext app)
 {
     Boolean retval;
+
     LOCK_APP(app);
     retval = app->exit_flag;
     UNLOCK_APP(app);
     return retval;
 }
 
-static void DestroyAppContext(XtAppContext app)
+static void
+DestroyAppContext(XtAppContext app)
 {
-	XtAppContext* prev_app;
-
-	prev_app = &app->process->appContextList;
-	while (app->count-- > 0) XtCloseDisplay(app->list[app->count]);
-	if (app->list != NULL) XtFree((char *)app->list);
-	_XtFreeConverterTable(app->converterTable);
-	_XtCacheFlushTag(app, (XtPointer)&app->heap);
-	_XtFreeActions(app->action_table);
-	if (app->destroy_callbacks != NULL) {
-	    XtCallCallbackList((Widget) NULL,
-			       (XtCallbackList)app->destroy_callbacks,
-			       (XtPointer)app);
-	    _XtRemoveAllCallbacks(&app->destroy_callbacks);
-	}
-	while (app->timerQueue) XtRemoveTimeOut((XtIntervalId)app->timerQueue);
-	while (app->workQueue) XtRemoveWorkProc((XtWorkProcId)app->workQueue);
-	while (app->signalQueue) XtRemoveSignal((XtSignalId)app->signalQueue);
-	if (app->input_list) _XtRemoveAllInputs(app);
-	XtFree((char*)app->destroy_list);
-	_XtHeapFree(&app->heap);
-	while (*prev_app != app) prev_app = &(*prev_app)->next;
-	*prev_app = app->next;
-	if (app->process->defaultAppContext == app)
-	    app->process->defaultAppContext = NULL;
-	if (app->free_bindings) _XtDoFreeBindings (app);
-	FREE_APP_LOCK(app);
-	XtFree((char *)app);
+    XtAppContext *prev_app;
+
+    prev_app = &app->process->appContextList;
+    while (app->count-- > 0)
+        XtCloseDisplay(app->list[app->count]);
+    if (app->list != NULL)
+        XtFree((char *) app->list);
+    _XtFreeConverterTable(app->converterTable);
+    _XtCacheFlushTag(app, (XtPointer) &app->heap);
+    _XtFreeActions(app->action_table);
+    if (app->destroy_callbacks != NULL) {
+        XtCallCallbackList((Widget) NULL,
+                           (XtCallbackList) app->destroy_callbacks,
+                           (XtPointer) app);
+        _XtRemoveAllCallbacks(&app->destroy_callbacks);
+    }
+    while (app->timerQueue)
+        XtRemoveTimeOut((XtIntervalId) app->timerQueue);
+    while (app->workQueue)
+        XtRemoveWorkProc((XtWorkProcId) app->workQueue);
+    while (app->signalQueue)
+        XtRemoveSignal((XtSignalId) app->signalQueue);
+    if (app->input_list)
+        _XtRemoveAllInputs(app);
+    XtFree((char *) app->destroy_list);
+    _XtHeapFree(&app->heap);
+    while (*prev_app != app)
+        prev_app = &(*prev_app)->next;
+    *prev_app = app->next;
+    if (app->process->defaultAppContext == app)
+        app->process->defaultAppContext = NULL;
+    if (app->free_bindings)
+        _XtDoFreeBindings(app);
+    FREE_APP_LOCK(app);
+    XtFree((char *) app);
 }
 
-static XtAppContext* appDestroyList = NULL;
+static XtAppContext *appDestroyList = NULL;
 int _XtAppDestroyCount = 0;
 
-void XtDestroyApplicationContext(XtAppContext app)
+void
+XtDestroyApplicationContext(XtAppContext app)
 {
-	LOCK_APP(app);
-	if (app->being_destroyed) {
-	    UNLOCK_APP(app);
-	    return;
-	}
-
-	if (_XtSafeToDestroy(app)) {
-	    LOCK_PROCESS;
-	    DestroyAppContext(app);
-	    UNLOCK_PROCESS;
-	} else {
-	    app->being_destroyed = TRUE;
-	    LOCK_PROCESS;
-	    _XtAppDestroyCount++;
-	    appDestroyList =
-		    (XtAppContext *) XtRealloc((char *) appDestroyList,
-		    (unsigned) ((size_t)_XtAppDestroyCount * sizeof(XtAppContext)));
-	    appDestroyList[_XtAppDestroyCount-1] = app;
-	    UNLOCK_PROCESS;
-	    UNLOCK_APP(app);
-	}
+    LOCK_APP(app);
+    if (app->being_destroyed) {
+        UNLOCK_APP(app);
+        return;
+    }
+
+    if (_XtSafeToDestroy(app)) {
+        LOCK_PROCESS;
+        DestroyAppContext(app);
+        UNLOCK_PROCESS;
+    }
+    else {
+        app->being_destroyed = TRUE;
+        LOCK_PROCESS;
+        _XtAppDestroyCount++;
+        appDestroyList =
+            (XtAppContext *) XtRealloc((char *) appDestroyList,
+                                       (unsigned) ((size_t) _XtAppDestroyCount *
+                                                   sizeof(XtAppContext)));
+        appDestroyList[_XtAppDestroyCount - 1] = app;
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+    }
 }
 
-void _XtDestroyAppContexts(void)
+void
+_XtDestroyAppContexts(void)
 {
-	int i,ii;
-	XtAppContext apps[8];
-	XtAppContext* pApps;
-
-	pApps = XtStackAlloc (sizeof (XtAppContext) * (size_t)_XtAppDestroyCount, apps);
-
-	for (i = ii = 0; i < _XtAppDestroyCount; i++) {
-	    if (_XtSafeToDestroy(appDestroyList[i]))
-		DestroyAppContext(appDestroyList[i]);
-	    else
-		pApps[ii++] = appDestroyList[i];
-	}
-	_XtAppDestroyCount = ii;
-	if (_XtAppDestroyCount == 0) {
-	    XtFree((char *) appDestroyList);
-	    appDestroyList = NULL;
-	} else {
-	    for (i = 0; i < ii; i++)
-		appDestroyList[i] = pApps[i];
-	}
-	XtStackFree ((XtPointer) pApps, apps);
+    int i, ii;
+    XtAppContext apps[8];
+    XtAppContext *pApps;
+
+    pApps =
+        XtStackAlloc(sizeof(XtAppContext) * (size_t) _XtAppDestroyCount, apps);
+
+    for (i = ii = 0; i < _XtAppDestroyCount; i++) {
+        if (_XtSafeToDestroy(appDestroyList[i]))
+            DestroyAppContext(appDestroyList[i]);
+        else
+            pApps[ii++] = appDestroyList[i];
+    }
+    _XtAppDestroyCount = ii;
+    if (_XtAppDestroyCount == 0) {
+        XtFree((char *) appDestroyList);
+        appDestroyList = NULL;
+    }
+    else {
+        for (i = 0; i < ii; i++)
+            appDestroyList[i] = pApps[i];
+    }
+    XtStackFree((XtPointer) pApps, apps);
 }
 
-XrmDatabase XtDatabase(Display *dpy)
+XrmDatabase
+XtDatabase(Display *dpy)
 {
     XrmDatabase retval;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
@@ -552,174 +603,179 @@ XrmDatabase XtDatabase(Display *dpy)
 
 PerDisplayTablePtr _XtperDisplayList = NULL;
 
-XtPerDisplay _XtSortPerDisplayList(Display *dpy)
+XtPerDisplay
+_XtSortPerDisplayList(Display *dpy)
 {
-	register PerDisplayTablePtr pd, opd = NULL;
-	XtPerDisplay result = NULL;
-
-	LOCK_PROCESS;
-	for (pd = _XtperDisplayList;
-	     pd != NULL && pd->dpy != dpy;
-	     pd = pd->next) {
-	    opd = pd;
-	}
-
-	if (pd == NULL) {
-	    XtErrorMsg(XtNnoPerDisplay, "getPerDisplay", XtCXtToolkitError,
-		    "Couldn't find per display information",
-		    NULL, NULL);
-	} else {
-	    if (pd != _XtperDisplayList) {	/* move it to the front */
-		/* opd points to the previous one... */
-
-		opd->next = pd->next;
-		pd->next = _XtperDisplayList;
-		_XtperDisplayList = pd;
-	    }
-	    result = &(pd->perDpy);
-	}
-	UNLOCK_PROCESS;
-	return result;
+    register PerDisplayTablePtr pd, opd = NULL;
+    XtPerDisplay result = NULL;
+
+    LOCK_PROCESS;
+    for (pd = _XtperDisplayList; pd != NULL && pd->dpy != dpy; pd = pd->next) {
+        opd = pd;
+    }
+
+    if (pd == NULL) {
+        XtErrorMsg(XtNnoPerDisplay, "getPerDisplay", XtCXtToolkitError,
+                   "Couldn't find per display information", NULL, NULL);
+    }
+    else {
+        if (pd != _XtperDisplayList) {  /* move it to the front */
+            /* opd points to the previous one... */
+
+            opd->next = pd->next;
+            pd->next = _XtperDisplayList;
+            _XtperDisplayList = pd;
+        }
+        result = &(pd->perDpy);
+    }
+    UNLOCK_PROCESS;
+    return result;
 }
 
-XtAppContext XtDisplayToApplicationContext(Display *dpy)
+XtAppContext
+XtDisplayToApplicationContext(Display *dpy)
 {
-	XtAppContext retval;
+    XtAppContext retval;
 
-	retval = _XtGetPerDisplay(dpy)->appContext;
-	return retval;
+    retval = _XtGetPerDisplay(dpy)->appContext;
+    return retval;
 }
 
-static void CloseDisplay(Display *dpy)
+static void
+CloseDisplay(Display *dpy)
 {
-        register XtPerDisplay xtpd = NULL;
-	register PerDisplayTablePtr pd, opd = NULL;
-	XrmDatabase db;
-
-	XtDestroyWidget(XtHooksOfDisplay(dpy));
-
-	LOCK_PROCESS;
-	for (pd = _XtperDisplayList;
-	     pd != NULL && pd->dpy != dpy;
-	     pd = pd->next){
-	    opd = pd;
-	}
-
-	if (pd == NULL) {
-	    XtErrorMsg(XtNnoPerDisplay, "closeDisplay", XtCXtToolkitError,
-		    "Couldn't find per display information",
-		    NULL, NULL);
-	} else {
-
-	    if (pd == _XtperDisplayList) _XtperDisplayList = pd->next;
-	    else opd->next = pd->next;
-
-	    xtpd = &(pd->perDpy);
-	}
-
-        if (xtpd != NULL) {
-	    int i;
-
-	    if (xtpd->destroy_callbacks != NULL) {
-		XtCallCallbackList((Widget) NULL,
-				   (XtCallbackList)xtpd->destroy_callbacks,
-				   (XtPointer)xtpd);
-		_XtRemoveAllCallbacks(&xtpd->destroy_callbacks);
-	    }
-	    if (xtpd->mapping_callbacks != NULL)
-		_XtRemoveAllCallbacks(&xtpd->mapping_callbacks);
-	    XtDeleteFromAppContext(dpy, xtpd->appContext);
-	    if (xtpd->keysyms)
-		XFree((char *) xtpd->keysyms);
-            XtFree((char *) xtpd->modKeysyms);
-            XtFree((char *) xtpd->modsToKeysyms);
-            xtpd->keysyms_per_keycode = 0;
-            xtpd->being_destroyed = FALSE;
-            xtpd->keysyms = NULL;
-            xtpd->modKeysyms = NULL;
-            xtpd->modsToKeysyms = NULL;
-	    XDestroyRegion(xtpd->region);
-	    _XtCacheFlushTag(xtpd->appContext, (XtPointer)&xtpd->heap);
-	    _XtGClistFree(dpy, xtpd);
-	    XtFree((char*)xtpd->pdi.trace);
-	    _XtHeapFree(&xtpd->heap);
-	    _XtFreeWWTable(xtpd);
-	    xtpd->per_screen_db[DefaultScreen(dpy)] = (XrmDatabase)NULL;
-	    for (i = ScreenCount(dpy); --i >= 0; ) {
-		db = xtpd->per_screen_db[i];
-		if (db)
-		    XrmDestroyDatabase(db);
-	    }
-	    XtFree((char *)xtpd->per_screen_db);
-	    if ((db = XrmGetDatabase(dpy)))
-		XrmDestroyDatabase(db);
-	    if (xtpd->cmd_db)
-		XrmDestroyDatabase(xtpd->cmd_db);
-	    if (xtpd->server_db)
-		XrmDestroyDatabase(xtpd->server_db);
-	    XtFree((_XtString)xtpd->language);
-	    if (xtpd->dispatcher_list != NULL)
-		XtFree((char *) xtpd->dispatcher_list);
-	    if (xtpd->ext_select_list != NULL)
-		XtFree((char *) xtpd->ext_select_list);
+    register XtPerDisplay xtpd = NULL;
+    register PerDisplayTablePtr pd, opd = NULL;
+    XrmDatabase db;
+
+    XtDestroyWidget(XtHooksOfDisplay(dpy));
+
+    LOCK_PROCESS;
+    for (pd = _XtperDisplayList; pd != NULL && pd->dpy != dpy; pd = pd->next) {
+        opd = pd;
+    }
+
+    if (pd == NULL) {
+        XtErrorMsg(XtNnoPerDisplay, "closeDisplay", XtCXtToolkitError,
+                   "Couldn't find per display information", NULL, NULL);
+    }
+    else {
+
+        if (pd == _XtperDisplayList)
+            _XtperDisplayList = pd->next;
+        else
+            opd->next = pd->next;
+
+        xtpd = &(pd->perDpy);
+    }
+
+    if (xtpd != NULL) {
+        int i;
+
+        if (xtpd->destroy_callbacks != NULL) {
+            XtCallCallbackList((Widget) NULL,
+                               (XtCallbackList) xtpd->destroy_callbacks,
+                               (XtPointer) xtpd);
+            _XtRemoveAllCallbacks(&xtpd->destroy_callbacks);
+        }
+        if (xtpd->mapping_callbacks != NULL)
+            _XtRemoveAllCallbacks(&xtpd->mapping_callbacks);
+        XtDeleteFromAppContext(dpy, xtpd->appContext);
+        if (xtpd->keysyms)
+            XFree((char *) xtpd->keysyms);
+        XtFree((char *) xtpd->modKeysyms);
+        XtFree((char *) xtpd->modsToKeysyms);
+        xtpd->keysyms_per_keycode = 0;
+        xtpd->being_destroyed = FALSE;
+        xtpd->keysyms = NULL;
+        xtpd->modKeysyms = NULL;
+        xtpd->modsToKeysyms = NULL;
+        XDestroyRegion(xtpd->region);
+        _XtCacheFlushTag(xtpd->appContext, (XtPointer) &xtpd->heap);
+        _XtGClistFree(dpy, xtpd);
+        XtFree((char *) xtpd->pdi.trace);
+        _XtHeapFree(&xtpd->heap);
+        _XtFreeWWTable(xtpd);
+        xtpd->per_screen_db[DefaultScreen(dpy)] = (XrmDatabase) NULL;
+        for (i = ScreenCount(dpy); --i >= 0;) {
+            db = xtpd->per_screen_db[i];
+            if (db)
+                XrmDestroyDatabase(db);
         }
-	XtFree((char*)pd);
-	XrmSetDatabase(dpy, (XrmDatabase)NULL);
-	XCloseDisplay(dpy);
-	UNLOCK_PROCESS;
+        XtFree((char *) xtpd->per_screen_db);
+        if ((db = XrmGetDatabase(dpy)))
+            XrmDestroyDatabase(db);
+        if (xtpd->cmd_db)
+            XrmDestroyDatabase(xtpd->cmd_db);
+        if (xtpd->server_db)
+            XrmDestroyDatabase(xtpd->server_db);
+        XtFree((_XtString) xtpd->language);
+        if (xtpd->dispatcher_list != NULL)
+            XtFree((char *) xtpd->dispatcher_list);
+        if (xtpd->ext_select_list != NULL)
+            XtFree((char *) xtpd->ext_select_list);
+    }
+    XtFree((char *) pd);
+    XrmSetDatabase(dpy, (XrmDatabase) NULL);
+    XCloseDisplay(dpy);
+    UNLOCK_PROCESS;
 }
 
-void XtCloseDisplay(Display *dpy)
+void
+XtCloseDisplay(Display *dpy)
 {
-	XtPerDisplay pd;
-	XtAppContext app = XtDisplayToApplicationContext(dpy);
-
-	LOCK_APP(app);
-	pd = _XtGetPerDisplay(dpy);
-	if (pd->being_destroyed) {
-	    UNLOCK_APP(app);
-	    return;
-	}
-
-	if (_XtSafeToDestroy(app)) CloseDisplay(dpy);
-	else {
-	    pd->being_destroyed = TRUE;
-	    app->dpy_destroy_count++;
-	    app->dpy_destroy_list = (Display **)
-		XtRealloc((char *) app->dpy_destroy_list,
-		    (Cardinal) ((size_t)app->dpy_destroy_count * sizeof(Display *)));
-	    app->dpy_destroy_list[app->dpy_destroy_count-1] = dpy;
-	}
-	UNLOCK_APP(app);
+    XtPerDisplay pd;
+    XtAppContext app = XtDisplayToApplicationContext(dpy);
+
+    LOCK_APP(app);
+    pd = _XtGetPerDisplay(dpy);
+    if (pd->being_destroyed) {
+        UNLOCK_APP(app);
+        return;
+    }
+
+    if (_XtSafeToDestroy(app))
+        CloseDisplay(dpy);
+    else {
+        pd->being_destroyed = TRUE;
+        app->dpy_destroy_count++;
+        app->dpy_destroy_list = (Display **)
+            XtRealloc((char *) app->dpy_destroy_list,
+                      (Cardinal) ((size_t) app->dpy_destroy_count *
+                                  sizeof(Display *)));
+        app->dpy_destroy_list[app->dpy_destroy_count - 1] = dpy;
+    }
+    UNLOCK_APP(app);
 }
 
-void _XtCloseDisplays(XtAppContext app)
+void
+_XtCloseDisplays(XtAppContext app)
 {
-	int i;
-
-	LOCK_APP(app);
-	for (i = 0; i < app->dpy_destroy_count; i++) {
-	    CloseDisplay(app->dpy_destroy_list[i]);
-	}
-	app->dpy_destroy_count = 0;
-	XtFree((char *) app->dpy_destroy_list);
-	app->dpy_destroy_list = NULL;
-	UNLOCK_APP(app);
+    int i;
+
+    LOCK_APP(app);
+    for (i = 0; i < app->dpy_destroy_count; i++) {
+        CloseDisplay(app->dpy_destroy_list[i]);
+    }
+    app->dpy_destroy_count = 0;
+    XtFree((char *) app->dpy_destroy_list);
+    app->dpy_destroy_list = NULL;
+    UNLOCK_APP(app);
 }
 
-XtAppContext XtWidgetToApplicationContext(Widget w)
+XtAppContext
+XtWidgetToApplicationContext(Widget w)
 {
-	XtAppContext retval;
+    XtAppContext retval;
 
-	retval = _XtGetPerDisplay(XtDisplayOfObject(w))->appContext;
-	return retval;
+    retval = _XtGetPerDisplay(XtDisplayOfObject(w))->appContext;
+    return retval;
 }
 
-
-void XtGetApplicationNameAndClass(
-    Display *dpy,
-    String *name_return,
-    String *class_return)
+void
+XtGetApplicationNameAndClass(Display *dpy,
+                             String *name_return,
+                             String *class_return)
 {
     XtPerDisplay pd;
 
@@ -728,41 +784,45 @@ void XtGetApplicationNameAndClass(
     *class_return = XrmQuarkToString(pd->class);
 }
 
-XtPerDisplay _XtGetPerDisplay (Display* display)
+XtPerDisplay
+_XtGetPerDisplay(Display *display)
 {
     XtPerDisplay retval;
 
     LOCK_PROCESS;
-    retval = ((_XtperDisplayList != NULL &&
-	      _XtperDisplayList->dpy == display)
-	      ? &_XtperDisplayList->perDpy
-	      : _XtSortPerDisplayList(display));
+    retval = ((_XtperDisplayList != NULL && _XtperDisplayList->dpy == display)
+              ? &_XtperDisplayList->perDpy : _XtSortPerDisplayList(display));
+
     UNLOCK_PROCESS;
     return retval;
 }
 
-XtPerDisplayInputRec* _XtGetPerDisplayInput(Display* display)
+XtPerDisplayInputRec *
+_XtGetPerDisplayInput(Display *display)
 {
-    XtPerDisplayInputRec* retval;
+    XtPerDisplayInputRec *retval;
+
     LOCK_PROCESS;
-    retval = ((_XtperDisplayList != NULL &&
-	      _XtperDisplayList->dpy == display)
-	      ? &_XtperDisplayList->perDpy.pdi
-	      : &_XtSortPerDisplayList(display)->pdi);
+    retval = ((_XtperDisplayList != NULL && _XtperDisplayList->dpy == display)
+              ? &_XtperDisplayList->perDpy.pdi
+              : &_XtSortPerDisplayList(display)->pdi);
     UNLOCK_PROCESS;
     return retval;
 }
 
-void XtGetDisplays(
-    XtAppContext app_context,
-    Display*** dpy_return,
-    Cardinal* num_dpy_return)
+void
+XtGetDisplays(XtAppContext app_context,
+              Display ***dpy_return,
+              Cardinal *num_dpy_return)
 {
     int ii;
+
     LOCK_APP(app_context);
-    *num_dpy_return = (Cardinal)app_context->count;
-    *dpy_return = (Display**)__XtMalloc((Cardinal)((size_t)app_context->count * sizeof(Display*)));
+    *num_dpy_return = (Cardinal) app_context->count;
+    *dpy_return = (Display **)
+        __XtMalloc((Cardinal)
+                   ((size_t) app_context->count * sizeof(Display *)));
     for (ii = 0; ii < app_context->count; ii++)
-	(*dpy_return)[ii] = app_context->list[ii];
+        (*dpy_return)[ii] = app_context->list[ii];
     UNLOCK_APP(app_context);
 }
diff --git a/src/Error.c b/src/Error.c
index a302dbd..4bf4713 100644
--- a/src/Error.c
+++ b/src/Error.c
@@ -84,74 +84,82 @@ in this Software without prior written authorization from The Open Group.
 #endif
 
 static void InitErrorHandling(XrmDatabase *);
+
 #if GLOBALERRORS
 static XrmDatabase errorDB = NULL;
 static Boolean error_inited = FALSE;
-void _XtDefaultErrorMsg(String, String, String, String, String*, Cardinal*);
-void _XtDefaultWarningMsg(String, String, String, String, String*, Cardinal*);
-void _XtDefaultError(String) _X_NORETURN;
-void _XtDefaultWarning(String);
+void _XtDefaultErrorMsg(String, String, String, String, String *, Cardinal *);
+void _XtDefaultWarningMsg(String, String, String, String, String *, Cardinal *);
+void
+_XtDefaultError(String)
+    _X_NORETURN;
+void
+_XtDefaultWarning(String);
 static XtErrorMsgHandler errorMsgHandler = _XtDefaultErrorMsg;
 static XtErrorMsgHandler warningMsgHandler = _XtDefaultWarningMsg;
 static XtErrorHandler errorHandler _X_NORETURN = _XtDefaultError;
 static XtErrorHandler warningHandler = _XtDefaultWarning;
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 
-XrmDatabase *XtGetErrorDatabase(void)
+XrmDatabase *
+XtGetErrorDatabase(void)
 {
-    XrmDatabase* retval;
+    XrmDatabase *retval;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     retval = &errorDB;
     UNLOCK_PROCESS;
 #else
     retval = XtAppGetErrorDatabase(_XtDefaultAppContext());
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return retval;
 }
 
-XrmDatabase *XtAppGetErrorDatabase(
-	XtAppContext app)
+XrmDatabase *
+XtAppGetErrorDatabase(XtAppContext app _X_UNUSED)
 {
-    XrmDatabase* retval;
+    XrmDatabase *retval;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     retval = &errorDB;
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
-    retval= &app->errorDB;
+    retval = &app->errorDB;
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return retval;
 }
 
-void XtGetErrorDatabaseText(
-    register _Xconst char* name,
-    register _Xconst char* type,
-    register _Xconst char* class,
-    _Xconst char* defaultp,
-    _XtString buffer,
-    int nbytes)
+void
+XtGetErrorDatabaseText(register _Xconst char *name,
+                       register _Xconst char *type,
+                       register _Xconst char *class,
+                       _Xconst char *defaultp,
+                       _XtString buffer, int nbytes)
 {
 #if GLOBALERRORS
     XtAppGetErrorDatabaseText(NULL,
-	    name,type,class,defaultp, buffer, nbytes, NULL);
+                              name, type, class, defaultp, buffer, nbytes,
+                              NULL);
 #else
     XtAppGetErrorDatabaseText(_XtDefaultAppContext(),
-	    name,type,class,defaultp, buffer, nbytes, NULL);
-#endif /* GLOBALERRORS */
+                              name, type, class, defaultp, buffer, nbytes,
+                              NULL);
+#endif                          /* GLOBALERRORS */
 }
 
-void XtAppGetErrorDatabaseText(
-    XtAppContext app,
-    register _Xconst char* name,
-    register _Xconst char* type,
-    register _Xconst char* class,
-    _Xconst char* defaultp,
-    _XtString buffer,
-    int nbytes,
-    XrmDatabase db)
+void
+XtAppGetErrorDatabaseText(XtAppContext app _X_UNUSED,
+                          register _Xconst char *name,
+                          register _Xconst char *type,
+                          register _Xconst char *class,
+                          _Xconst char *defaultp,
+                          _XtString buffer,
+                          int nbytes,
+                          XrmDatabase db)
 {
     String str_class;
     _XtString type_str;
@@ -162,50 +170,55 @@ void XtAppGetErrorDatabaseText(
 #if GLOBALERRORS
     LOCK_PROCESS;
     if (error_inited == FALSE) {
-        InitErrorHandling (&errorDB);
+        InitErrorHandling(&errorDB);
         error_inited = TRUE;
     }
 #else
     LOCK_APP(app);
     if (app->error_inited == FALSE) {
-        InitErrorHandling (&app->errorDB);
+        InitErrorHandling(&app->errorDB);
         app->error_inited = TRUE;
     }
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     if (!(str_name = ALLOCATE_LOCAL(strlen(name) + strlen(type) + 2)))
-	_XtAllocError(NULL);
+        _XtAllocError(NULL);
     (void) sprintf(str_name, "%s.%s", name, type);
     /* XrmGetResource requires the name and class to be fully qualified
      * and to have the same number of components. */
-    str_class = (char *)class;
-    if (! strchr(class, '.')) {
-	if (!(temp = ALLOCATE_LOCAL(2 * strlen(class) + 2)))
-	    _XtAllocError(NULL);
-	(void) sprintf(temp, "%s.%s", class, class);
-	str_class = temp;
+    str_class = (String) class;
+    if (!strchr(class, '.')) {
+        if (!(temp = ALLOCATE_LOCAL(2 * strlen(class) + 2)))
+            _XtAllocError(NULL);
+        (void) sprintf(temp, "%s.%s", class, class);
+        str_class = temp;
     }
     if (db == NULL) {
 #if GLOBALERRORS
-	(void) XrmGetResource(errorDB, str_name, str_class, &type_str,
-			      &result);
+        (void) XrmGetResource(errorDB, str_name, str_class, &type_str, &result);
 #else
-	(void) XrmGetResource(app->errorDB, str_name, str_class, &type_str,
-			      &result);
-#endif /* GLOBALERRORS */
-    } else (void) XrmGetResource(db, str_name, str_class, &type_str, &result);
+        (void) XrmGetResource(app->errorDB, str_name, str_class, &type_str,
+                              &result);
+#endif                          /* GLOBALERRORS */
+    }
+    else
+        (void) XrmGetResource(db, str_name, str_class, &type_str, &result);
     if (result.addr) {
-        (void) strncpy (buffer, result.addr, (size_t) nbytes);
-        if (result.size > (unsigned) nbytes) buffer[nbytes-1] = 0;
-    } else {
-	int len = (int) strlen(defaultp);
-	if (len >= nbytes) len = nbytes-1;
-	(void) memmove(buffer, defaultp, (size_t) len);
-	buffer[len] = '\0';
+        (void) strncpy(buffer, result.addr, (size_t) nbytes);
+        if (result.size > (unsigned) nbytes)
+            buffer[nbytes - 1] = 0;
+    }
+    else {
+        int len = (int) strlen(defaultp);
+
+        if (len >= nbytes)
+            len = nbytes - 1;
+        (void) memmove(buffer, defaultp, (size_t) len);
+        buffer[len] = '\0';
     }
     if (str_name)
-	DEALLOCATE_LOCAL(str_name);
+        DEALLOCATE_LOCAL(str_name);
     if (temp)
-	DEALLOCATE_LOCAL(temp);
+        DEALLOCATE_LOCAL(temp);
 #if GLOBALERRORS
     UNLOCK_PROCESS;
 #else
@@ -213,8 +226,8 @@ void XtAppGetErrorDatabaseText(
 #endif
 }
 
-static void InitErrorHandling (
-    XrmDatabase *db)
+static void
+InitErrorHandling(XrmDatabase *db)
 {
     XrmDatabase errordb;
 
@@ -222,404 +235,442 @@ static void InitErrorHandling (
     XrmMergeDatabases(errordb, db);
 }
 
-static void DefaultMsg (
-    String name,
-    String type,
-    String class,
-    String defaultp,
-    String* params,
-    Cardinal* num_params,
-    Bool error,
-    void (*fn)(_Xconst _XtString))
+static void
+DefaultMsg(String name,
+           String type,
+           String class,
+           String defaultp,
+           String *params,
+           Cardinal *num_params,
+           Bool error,
+           void (*fn) (_Xconst _XtString))
 {
 #define BIGBUF 1024
     char buffer[BIGBUF];
-    char* message;
-    XtGetErrorDatabaseText(name,type,class,defaultp, buffer, BIGBUF);
+    char *message;
+
+    XtGetErrorDatabaseText(name, type, class, defaultp, buffer, BIGBUF);
 /*need better solution here, perhaps use lower level printf primitives? */
     if (params == NULL || num_params == NULL || *num_params == 0)
-	(*fn)(buffer);
-#ifndef WIN32 /* and OS/2 */
-    else if ((getuid () != geteuid ()) || getuid() == 0) {
-	if ((error && errorHandler == _XtDefaultError) ||
-	    (!error && warningHandler == _XtDefaultWarning)) {
-	    /*
-	     * if it's just going to go to stderr anyway, then we'll
-	     * fprintf to stderr ourselves and skip the insecure sprintf.
-	     */
-	    Cardinal i = *num_params;
-	    String par[10];
-	    if (i > 10) i = 10;
-	    (void) memmove((char*)par, (char*)params, i * sizeof(String) );
-	    memset( &par[i], 0, (10-i) * sizeof(String) );
-	    (void) fprintf (stderr, "%s%s",
-			    error ? XTERROR_PREFIX : XTWARNING_PREFIX,
-			    error ? "Error: " : "Warning: ");
-	    (void) fprintf (stderr, buffer,
-			    par[0], par[1], par[2], par[3], par[4],
-			    par[5], par[6], par[7], par[8], par[9]);
-	    (void) fprintf (stderr, "%c", '\n');
-	    if (i != *num_params)
-		(*fn) ( "Some arguments in previous message were lost" );
-	    else if (error) exit (1);
-	} else {
-	    /*
-	     * can't tell what it might do, so we'll play it safe
-	     */
-	    XtWarning ("\
+        (*fn) (buffer);
+#ifndef WIN32                   /* and OS/2 */
+    else if ((getuid() != geteuid()) || getuid() == 0) {
+        if ((error && errorHandler == _XtDefaultError) ||
+            (!error && warningHandler == _XtDefaultWarning)) {
+            /*
+             * if it's just going to go to stderr anyway, then we'll
+             * fprintf to stderr ourselves and skip the insecure sprintf.
+             */
+            Cardinal i = *num_params;
+            String par[10];
+
+            if (i > 10)
+                i = 10;
+            (void) memmove((char *) par, (char *) params, i * sizeof(String));
+            memset(&par[i], 0, (10 - i) * sizeof(String));
+            (void) fprintf(stderr, "%s%s",
+                           error ? XTERROR_PREFIX : XTWARNING_PREFIX,
+                           error ? "Error: " : "Warning: ");
+            (void) fprintf(stderr, buffer,
+                           par[0], par[1], par[2], par[3], par[4],
+                           par[5], par[6], par[7], par[8], par[9]);
+            (void) fprintf(stderr, "%c", '\n');
+            if (i != *num_params)
+                (*fn) ("Some arguments in previous message were lost");
+            else if (error)
+                exit(1);
+        }
+        else {
+            /*
+             * can't tell what it might do, so we'll play it safe
+             */
+            XtWarning("\
 This program is an suid-root program or is being run by the root user.\n\
 The full text of the error or warning message cannot be safely formatted\n\
 in this environment. You may get a more descriptive message by running the\n\
 program as a non-root user or by removing the suid bit on the executable.");
-	    (*fn)(buffer); /* if *fn is an ErrorHandler it should exit */
-	}
+            (*fn) (buffer);     /* if *fn is an ErrorHandler it should exit */
+        }
     }
 #endif
     else {
-	/*
-	 * If you have snprintf the worst thing that could happen is you'd
-	 * lose some information. Without snprintf you're probably going to
-	 * scramble your heap and perhaps SEGV -- sooner or later.
-	 * If it hurts when you go like this then don't go like this! :-)
-	 */
-	Cardinal i = *num_params;
-	String par[10];
-	if (i > 10) i = 10;
-	(void) memmove((char*)par, (char*)params, i * sizeof(String) );
-	memset( &par[i], 0, (10-i) * sizeof(String) );
-	if (i != *num_params)
-	    XtWarning( "Some arguments in following message were lost" );
-	/*
-	 * resist any temptation you might have to make `message' a
-	 * local buffer on the stack. Doing so is a security hole
-	 * in programs executing as root. Error and Warning
-	 * messages shouldn't be called frequently enough for this
-	 * to be a performance issue.
-	 */
-	if ((message = __XtMalloc (BIGBUF))) {
-	    (void) snprintf (message, BIGBUF, buffer,
-			     par[0], par[1], par[2], par[3], par[4],
-			     par[5], par[6], par[7], par[8], par[9]);
-	    (*fn)(message);
-	    XtFree(message);
-	} else {
-	    XtWarning ("Memory allocation failed, arguments in the following message were lost");
-	    (*fn)(buffer);
-	}
+        /*
+         * If you have snprintf the worst thing that could happen is you'd
+         * lose some information. Without snprintf you're probably going to
+         * scramble your heap and perhaps SEGV -- sooner or later.
+         * If it hurts when you go like this then don't go like this! :-)
+         */
+        Cardinal i = *num_params;
+        String par[10];
+
+        if (i > 10)
+            i = 10;
+        (void) memmove((char *) par, (char *) params, i * sizeof(String));
+        memset(&par[i], 0, (10 - i) * sizeof(String));
+        if (i != *num_params)
+            XtWarning("Some arguments in following message were lost");
+        /*
+         * resist any temptation you might have to make `message' a
+         * local buffer on the stack. Doing so is a security hole
+         * in programs executing as root. Error and Warning
+         * messages shouldn't be called frequently enough for this
+         * to be a performance issue.
+         */
+        if ((message = __XtMalloc(BIGBUF))) {
+            (void) snprintf(message, BIGBUF, buffer,
+                            par[0], par[1], par[2], par[3], par[4],
+                            par[5], par[6], par[7], par[8], par[9]);
+            (*fn) (message);
+            XtFree(message);
+        }
+        else {
+            XtWarning
+                ("Memory allocation failed, arguments in the following message were lost");
+            (*fn) (buffer);
+        }
     }
 }
 
-void _XtDefaultErrorMsg (
-    String name,
-    String type,
-    String class,
-    String defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+_XtDefaultErrorMsg(String name,
+                   String type,
+                   String class,
+                   String defaultp,
+                   String *params,
+                   Cardinal *num_params)
 {
-    DefaultMsg (name,type,class,defaultp,params,num_params,True,XtError);
+    DefaultMsg(name, type, class, defaultp, params, num_params, True, XtError);
 }
 
-void _XtDefaultWarningMsg (
-    String name,
-    String type,
-    String class,
-    String defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+_XtDefaultWarningMsg(String name,
+                     String type,
+                     String class,
+                     String defaultp,
+                     String *params,
+                     Cardinal *num_params)
 {
-    DefaultMsg (name,type,class,defaultp,params,num_params,False,XtWarning);
+    DefaultMsg(name, type, class, defaultp, params, num_params, False,
+               XtWarning);
 }
 
-void XtErrorMsg(
-    _Xconst char* name,
-    _Xconst char* type,
-    _Xconst char* class,
-    _Xconst char* defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+XtErrorMsg(_Xconst char *name,
+           _Xconst char *type,
+           _Xconst char *class,
+           _Xconst char *defaultp,
+           String *params,
+           Cardinal *num_params)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*errorMsgHandler)((String)name,(String)type,(String)class,
-		       (String)defaultp,params,num_params);
+    (*errorMsgHandler) ((String) name, (String) type, (String) class,
+                        (String) defaultp, params, num_params);
     UNLOCK_PROCESS;
     exit(1);
 #else
-    XtAppErrorMsg(_XtDefaultAppContext(),name,type,class,
-	    defaultp,params,num_params);
-#endif /* GLOBALERRORS */
+    XtAppErrorMsg(_XtDefaultAppContext(), name, type, class,
+                  defaultp, params, num_params);
+#endif                          /* GLOBALERRORS */
 }
 
-void XtAppErrorMsg(
-    XtAppContext app,
-    _Xconst char* name,
-    _Xconst char* type,
-    _Xconst char* class,
-    _Xconst char* defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+XtAppErrorMsg(XtAppContext app _X_UNUSED,
+              _Xconst char *name,
+              _Xconst char *type,
+              _Xconst char *class,
+              _Xconst char *defaultp,
+              String *params,
+              Cardinal *num_params)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*errorMsgHandler)((String)name,(String)type,(String)class,
-		       (String)defaultp,params,num_params);
+    (*errorMsgHandler) ((String) name, (String) type, (String) class,
+                        (String) defaultp, params, num_params);
     UNLOCK_PROCESS;
     exit(1);
 #else
     LOCK_APP(app);
-    (*app->errorMsgHandler)(name,type,class,defaultp,params,num_params);
+    (*app->errorMsgHandler) (name, type, class, defaultp, params, num_params);
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
 
-void XtWarningMsg(
-    _Xconst char* name,
-    _Xconst char* type,
-    _Xconst char* class,
-    _Xconst char* defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+XtWarningMsg(_Xconst char *name,
+             _Xconst char *type,
+             _Xconst char *class,
+             _Xconst char *defaultp,
+             String *params,
+             Cardinal *num_params)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*warningMsgHandler)((String)name,(String)type,(String)class,
-			 (String)defaultp,params,num_params);
+    (*warningMsgHandler) ((String) name, (String) type, (String) class,
+                          (String) defaultp, params, num_params);
     UNLOCK_PROCESS;
 #else
-    XtAppWarningMsg(_XtDefaultAppContext(),name,type,class,
-	    defaultp,params,num_params);
-#endif /* GLOBALERRORS */
+    XtAppWarningMsg(_XtDefaultAppContext(), name, type, class,
+                    defaultp, params, num_params);
+#endif                          /* GLOBALERRORS */
 }
 
-void XtAppWarningMsg(
-    XtAppContext app,
-    _Xconst char* name,
-    _Xconst char* type,
-    _Xconst char* class,
-    _Xconst char* defaultp,
-    String* params,
-    Cardinal* num_params)
+void
+XtAppWarningMsg(XtAppContext app _X_UNUSED,
+                _Xconst char *name,
+                _Xconst char *type,
+                _Xconst char *class,
+                _Xconst char *defaultp,
+                String *params,
+                Cardinal *num_params)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*warningMsgHandler)((String)name,(String)type,(String)class,
-			 (String)defaultp,params,num_params);
+    (*warningMsgHandler) ((String) name, (String) type, (String) class,
+                          (String) defaultp, params, num_params);
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
-    (*app->warningMsgHandler)(name,type,class,defaultp,params,num_params);
+    (*app->warningMsgHandler) (name, type, class, defaultp, params, num_params);
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
 
-void XtSetErrorMsgHandler(
-    XtErrorMsgHandler handler _X_NORETURN)
+void
+XtSetErrorMsgHandler(XtErrorMsgHandler handler _X_NORETURN)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    if (handler != NULL) errorMsgHandler = handler;
-    else errorMsgHandler  = _XtDefaultErrorMsg;
+    if (handler != NULL)
+        errorMsgHandler = handler;
+    else
+        errorMsgHandler = _XtDefaultErrorMsg;
     UNLOCK_PROCESS;
 #else
     XtAppSetErrorMsgHandler(_XtDefaultAppContext(), handler);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
 
-XtErrorMsgHandler XtAppSetErrorMsgHandler(
-    XtAppContext app,
-    XtErrorMsgHandler handler _X_NORETURN)
+XtErrorMsgHandler
+XtAppSetErrorMsgHandler(XtAppContext app _X_UNUSED,
+                        XtErrorMsgHandler handler _X_NORETURN)
 {
     XtErrorMsgHandler old;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     old = errorMsgHandler;
-    if (handler != NULL) errorMsgHandler = handler;
-    else errorMsgHandler  = _XtDefaultErrorMsg;
+    if (handler != NULL)
+        errorMsgHandler = handler;
+    else
+        errorMsgHandler = _XtDefaultErrorMsg;
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
     old = app->errorMsgHandler;
-    if (handler != NULL) app->errorMsgHandler = handler;
-    else app->errorMsgHandler  = _XtDefaultErrorMsg;
+    if (handler != NULL)
+        app->errorMsgHandler = handler;
+    else
+        app->errorMsgHandler = _XtDefaultErrorMsg;
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return old;
 }
 
-void XtSetWarningMsgHandler(
-    XtErrorMsgHandler handler)
+void
+XtSetWarningMsgHandler(XtErrorMsgHandler handler)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    if (handler != NULL) warningMsgHandler  = handler;
-    else warningMsgHandler = _XtDefaultWarningMsg;
+    if (handler != NULL)
+        warningMsgHandler = handler;
+    else
+        warningMsgHandler = _XtDefaultWarningMsg;
     UNLOCK_PROCESS;
 #else
-    XtAppSetWarningMsgHandler(_XtDefaultAppContext(),handler);
-#endif /* GLOBALERRORS */
+    XtAppSetWarningMsgHandler(_XtDefaultAppContext(), handler);
+#endif                          /* GLOBALERRORS */
 }
 
-XtErrorMsgHandler XtAppSetWarningMsgHandler(
-    XtAppContext app,
-    XtErrorMsgHandler handler)
+XtErrorMsgHandler
+XtAppSetWarningMsgHandler(XtAppContext app _X_UNUSED, XtErrorMsgHandler handler)
 {
     XtErrorMsgHandler old;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     old = warningMsgHandler;
-    if (handler != NULL) warningMsgHandler  = handler;
-    else warningMsgHandler = _XtDefaultWarningMsg;
+    if (handler != NULL)
+        warningMsgHandler = handler;
+    else
+        warningMsgHandler = _XtDefaultWarningMsg;
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
     old = app->warningMsgHandler;
-    if (handler != NULL) app->warningMsgHandler  = handler;
-    else app->warningMsgHandler = _XtDefaultWarningMsg;
+    if (handler != NULL)
+        app->warningMsgHandler = handler;
+    else
+        app->warningMsgHandler = _XtDefaultWarningMsg;
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return old;
 }
 
-void _XtDefaultError(String message)
+void
+_XtDefaultError(String message)
 {
     if (message && *message)
-	(void)fprintf(stderr, "%sError: %s\n", XTERROR_PREFIX, message);
+        (void) fprintf(stderr, "%sError: %s\n", XTERROR_PREFIX, message);
     exit(1);
 }
 
-void _XtDefaultWarning(String message)
+void
+_XtDefaultWarning(String message)
 {
     if (message && *message)
-       (void)fprintf(stderr, "%sWarning: %s\n", XTWARNING_PREFIX, message);
+        (void) fprintf(stderr, "%sWarning: %s\n", XTWARNING_PREFIX, message);
     return;
 }
 
-void XtError(
-    _Xconst char* message)
+void
+XtError(_Xconst char *message)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*errorHandler)((String)message);
+    (*errorHandler) ((String) message);
     UNLOCK_PROCESS;
 #else
-    XtAppError(_XtDefaultAppContext(),message);
-#endif /* GLOBALERRORS */
+    XtAppError(_XtDefaultAppContext(), message);
+#endif                          /* GLOBALERRORS */
 }
 
-void XtAppError(
-    XtAppContext app,
-    _Xconst char* message)
+void
+XtAppError(XtAppContext app _X_UNUSED, _Xconst char *message)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*errorHandler)((String)message);
+    (*errorHandler) ((String) message);
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
-    (*app->errorHandler)(message);
+    (*app->errorHandler) (message);
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
 
-void XtWarning(
-    _Xconst char* message)
+void
+XtWarning(_Xconst char *message)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*warningHandler)((String)message);
+    (*warningHandler) ((String) message);
     UNLOCK_PROCESS;
 #else
-    XtAppWarning(_XtDefaultAppContext(),message);
-#endif /* GLOBALERRORS */
+    XtAppWarning(_XtDefaultAppContext(), message);
+#endif                          /* GLOBALERRORS */
 }
 
-void XtAppWarning(
-    XtAppContext app,
-    _Xconst char* message)
+void
+XtAppWarning(XtAppContext app _X_UNUSED, _Xconst char *message)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    (*warningHandler)((String)message);
+    (*warningHandler) ((String) message);
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
-    (*app->warningHandler)(message);
+    (*app->warningHandler) (message);
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
 
-void XtSetErrorHandler(XtErrorHandler handler _X_NORETURN)
+void
+XtSetErrorHandler(XtErrorHandler handler _X_NORETURN)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    if (handler != NULL) errorHandler = handler;
-    else errorHandler  = _XtDefaultError;
+    if (handler != NULL)
+        errorHandler = handler;
+    else
+        errorHandler = _XtDefaultError;
     UNLOCK_PROCESS;
 #else
-    XtAppSetErrorHandler(_XtDefaultAppContext(),handler);
-#endif /* GLOBALERRORS */
+    XtAppSetErrorHandler(_XtDefaultAppContext(), handler);
+#endif                          /* GLOBALERRORS */
 }
 
-XtErrorHandler XtAppSetErrorHandler(
-    XtAppContext app,
-    XtErrorHandler handler _X_NORETURN)
+XtErrorHandler
+XtAppSetErrorHandler(XtAppContext app _X_UNUSED,
+                     XtErrorHandler handler _X_NORETURN)
 {
     XtErrorHandler old;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     old = errorHandler;
-    if (handler != NULL) errorHandler = handler;
-    else errorHandler  = _XtDefaultError;
+    if (handler != NULL)
+        errorHandler = handler;
+    else
+        errorHandler = _XtDefaultError;
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
     old = app->errorHandler;
-    if (handler != NULL) app->errorHandler = handler;
-    else app->errorHandler  = _XtDefaultError;
+    if (handler != NULL)
+        app->errorHandler = handler;
+    else
+        app->errorHandler = _XtDefaultError;
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return old;
 }
 
-void XtSetWarningHandler(XtErrorHandler handler)
+void
+XtSetWarningHandler(XtErrorHandler handler)
 {
 #if GLOBALERRORS
     LOCK_PROCESS;
-    if (handler != NULL) warningHandler = handler;
-    else warningHandler = _XtDefaultWarning;
+    if (handler != NULL)
+        warningHandler = handler;
+    else
+        warningHandler = _XtDefaultWarning;
     UNLOCK_PROCESS;
 #else
-    XtAppSetWarningHandler(_XtDefaultAppContext(),handler);
-#endif /* GLOBALERRORS */
+    XtAppSetWarningHandler(_XtDefaultAppContext(), handler);
+#endif                          /* GLOBALERRORS */
 }
 
-XtErrorHandler XtAppSetWarningHandler(
-    XtAppContext app,
-    XtErrorHandler handler)
+XtErrorHandler
+XtAppSetWarningHandler(XtAppContext app _X_UNUSED, XtErrorHandler handler)
 {
     XtErrorHandler old;
+
 #if GLOBALERRORS
     LOCK_PROCESS;
     old = warningHandler;
-    if (handler != NULL) warningHandler  = handler;
-    else warningHandler = _XtDefaultWarning;
+    if (handler != NULL)
+        warningHandler = handler;
+    else
+        warningHandler = _XtDefaultWarning;
     UNLOCK_PROCESS;
 #else
     LOCK_APP(app);
     old = app->warningHandler;
-    if (handler != NULL) app->warningHandler  = handler;
-    else app->warningHandler = _XtDefaultWarning;
+    if (handler != NULL)
+        app->warningHandler = handler;
+    else
+        app->warningHandler = _XtDefaultWarning;
     UNLOCK_APP(app);
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
     return old;
 }
 
-void _XtSetDefaultErrorHandlers(
-    XtErrorMsgHandler *errMsg,
-    XtErrorMsgHandler *warnMsg,
-    XtErrorHandler *err,
-    XtErrorHandler *warn)
+void
+_XtSetDefaultErrorHandlers(XtErrorMsgHandler *errMsg _X_UNUSED,
+                           XtErrorMsgHandler *warnMsg _X_UNUSED,
+                           XtErrorHandler *err _X_UNUSED,
+                           XtErrorHandler *warn _X_UNUSED)
 {
 #ifndef GLOBALERRORS
     LOCK_PROCESS;
@@ -628,5 +679,5 @@ void _XtSetDefaultErrorHandlers(
     *err = _XtDefaultError;
     *warn = _XtDefaultWarning;
     UNLOCK_PROCESS;
-#endif /* GLOBALERRORS */
+#endif                          /* GLOBALERRORS */
 }
diff --git a/src/Event.c b/src/Event.c
index a682d24..dadcede 100644
--- a/src/Event.c
+++ b/src/Event.c
@@ -77,7 +77,7 @@ in this Software without prior written authorization from The Open Group.
 
 typedef struct _XtEventRecExt {
     int type;
-    XtPointer select_data[1]; /* actual dimension is [mask] */
+    XtPointer select_data[1];   /* actual dimension is [mask] */
 } XtEventRecExt;
 
 #define EXT_TYPE(p) (((XtEventRecExt*) ((p)+1))->type)
@@ -99,159 +99,171 @@ typedef struct _XtEventRecExt {
 #define COMP_EXPOSE   (widget->core.widget_class->core_class.compress_exposure)
 #define COMP_EXPOSE_TYPE (COMP_EXPOSE & 0x0f)
 #define GRAPHICS_EXPOSE  ((XtExposeGraphicsExpose & COMP_EXPOSE) || \
-			  (XtExposeGraphicsExposeMerged & COMP_EXPOSE))
+                          (XtExposeGraphicsExposeMerged & COMP_EXPOSE))
 #define NO_EXPOSE        (XtExposeNoExpose & COMP_EXPOSE)
 
-EventMask XtBuildEventMask(
-    Widget widget)
+EventMask
+XtBuildEventMask(Widget widget)
 {
     XtEventTable ev;
-    EventMask	mask = 0L;
+    EventMask mask = 0L;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     for (ev = widget->core.event_table; ev != NULL; ev = ev->next) {
-	if (! ev->select) continue;
-
-	if (!ev->has_type_specifier)
-	    mask |= ev->mask;
-	else {
-	    if (EXT_TYPE(ev) < LASTEvent) {
-		Cardinal i;
-		for (i = 0; i < ev->mask; i++)
-		    if (EXT_SELECT_DATA(ev, i))
-		        mask |= *(EventMask*)EXT_SELECT_DATA(ev, i);
-		}
-	    }
-	}
+        if (!ev->select)
+            continue;
+
+        if (!ev->has_type_specifier)
+            mask |= ev->mask;
+        else {
+            if (EXT_TYPE(ev) < LASTEvent) {
+                Cardinal i;
+
+                for (i = 0; i < ev->mask; i++)
+                    if (EXT_SELECT_DATA(ev, i))
+                        mask |= *(EventMask *) EXT_SELECT_DATA(ev, i);
+            }
+        }
+    }
     LOCK_PROCESS;
     if (widget->core.widget_class->core_class.expose != NULL)
-	mask |= ExposureMask;
+        mask |= ExposureMask;
     if (widget->core.widget_class->core_class.visible_interest)
-	mask |= VisibilityChangeMask;
+        mask |= VisibilityChangeMask;
     UNLOCK_PROCESS;
     if (widget->core.tm.translations)
-	mask |= widget->core.tm.translations->eventMask;
+        mask |= widget->core.tm.translations->eventMask;
 
-    mask =  mask & ~NonMaskableMask;
+    mask = mask & ~NonMaskableMask;
     UNLOCK_APP(app);
     return mask;
 }
 
-static void CallExtensionSelector(
-    Widget widget,
-    ExtSelectRec* rec,
-    Boolean forceCall)
+static void
+CallExtensionSelector(Widget widget, ExtSelectRec *rec, Boolean forceCall)
 {
-    XtEventRec* p;
-    XtPointer* data;
-    int* types;
+    XtEventRec *p;
+    XtPointer *data;
+    int *types;
     Cardinal i, count = 0;
 
     for (p = widget->core.event_table; p != NULL; p = p->next)
-	if (p->has_type_specifier &&
-	    EXT_TYPE(p) >= rec->min && EXT_TYPE(p) <= rec->max)
-	    count = (Cardinal) (count + p->mask);
+        if (p->has_type_specifier &&
+            EXT_TYPE(p) >= rec->min && EXT_TYPE(p) <= rec->max)
+            count = (Cardinal) (count + p->mask);
 
-    if (count == 0 && !forceCall) return;
+    if (count == 0 && !forceCall)
+        return;
 
-    data = (XtPointer *) ALLOCATE_LOCAL(count * sizeof (XtPointer));
-    types = (int *) ALLOCATE_LOCAL(count * sizeof (int));
+    data = (XtPointer *) ALLOCATE_LOCAL(count * sizeof(XtPointer));
+    types = (int *) ALLOCATE_LOCAL(count * sizeof(int));
     count = 0;
 
     for (p = widget->core.event_table; p != NULL; p = p->next)
-	if (p->has_type_specifier &&
-	    EXT_TYPE(p) >= rec->min && EXT_TYPE(p) <= rec->max)
-	    for (i =0; i < p->mask; i++) {
-		types[count] = EXT_TYPE(p);
-		data[count++] = EXT_SELECT_DATA(p, i);
-	    }
-
-    (*rec->proc)(widget, types, data, (int) count, rec->client_data);
-    DEALLOCATE_LOCAL((char*) types);
-    DEALLOCATE_LOCAL((char*) data);
+        if (p->has_type_specifier &&
+            EXT_TYPE(p) >= rec->min && EXT_TYPE(p) <= rec->max)
+            for (i = 0; i < p->mask; i++) {
+                types[count] = EXT_TYPE(p);
+                data[count++] = EXT_SELECT_DATA(p, i);
+            }
+
+    (*rec->proc) (widget, types, data, (int) count, rec->client_data);
+    DEALLOCATE_LOCAL((char *) types);
+    DEALLOCATE_LOCAL((char *) data);
 }
 
 static void
-RemoveEventHandler(
-    Widget widget,
-    XtPointer select_data,
-    int type,
-    Boolean has_type_specifier,
-    Boolean other,
-    XtEventHandler proc,
-    XtPointer closure,
-    Boolean raw)
+RemoveEventHandler(Widget widget,
+                   XtPointer select_data,
+                   int type,
+                   Boolean has_type_specifier,
+                   Boolean other,
+                   XtEventHandler proc,
+                   XtPointer closure,
+                   Boolean raw)
 {
     XtEventRec *p, **pp;
     EventMask oldMask = XtBuildEventMask(widget);
 
-    if (raw) raw = 1;
+    if (raw)
+        raw = 1;
     pp = &widget->core.event_table;
     while ((p = *pp) &&
-	   (p->proc != proc || p->closure != closure || p->select == raw ||
-	    has_type_specifier != p->has_type_specifier ||
-	    (has_type_specifier && EXT_TYPE(p) != type)))
-	pp = &p->next;
-    if (!p) return;
+           (p->proc != proc || p->closure != closure || p->select == raw ||
+            has_type_specifier != p->has_type_specifier ||
+            (has_type_specifier && EXT_TYPE(p) != type)))
+        pp = &p->next;
+    if (!p)
+        return;
 
     /* un-register it */
     if (!has_type_specifier) {
-        EventMask eventMask = *(EventMask*)select_data;
-	eventMask &= ~NonMaskableMask;
-	if (other)
-	    eventMask |= NonMaskableMask;
-	p->mask &= ~eventMask;
-    } else {
-	Cardinal i;
-	/* p->mask specifies count of EXT_SELECT_DATA(p,i)
-	 * search through the list of selection data, if not found
-	 * dont remove this handler
-	 */
-	for (i = 0; i < p->mask && select_data != EXT_SELECT_DATA(p,i);) i++;
-	if (i == p->mask) return;
-	if (p->mask == 1) p->mask = 0;
-	else {
-	    p->mask--;
-	    while (i < p->mask) {
-		EXT_SELECT_DATA(p,i) = EXT_SELECT_DATA(p, i+1);
-		i++;
-	    }
-	}
+        EventMask eventMask = *(EventMask *) select_data;
+
+        eventMask &= ~NonMaskableMask;
+        if (other)
+            eventMask |= NonMaskableMask;
+        p->mask &= ~eventMask;
+    }
+    else {
+        Cardinal i;
+
+        /* p->mask specifies count of EXT_SELECT_DATA(p,i)
+         * search through the list of selection data, if not found
+         * dont remove this handler
+         */
+        for (i = 0; i < p->mask && select_data != EXT_SELECT_DATA(p, i);)
+            i++;
+        if (i == p->mask)
+            return;
+        if (p->mask == 1)
+            p->mask = 0;
+        else {
+            p->mask--;
+            while (i < p->mask) {
+                EXT_SELECT_DATA(p, i) = EXT_SELECT_DATA(p, i + 1);
+                i++;
+            }
+        }
     }
 
-    if (!p->mask) {        /* delete it entirely */
+    if (!p->mask) {             /* delete it entirely */
         *pp = p->next;
-	XtFree((char *)p);
+        XtFree((char *) p);
     }
 
     /* Reset select mask if realized and not raw. */
-    if ( !raw && XtIsRealized(widget) && !widget->core.being_destroyed) {
-	EventMask mask = XtBuildEventMask(widget);
-	Display* dpy = XtDisplay (widget);
-
-	if (oldMask != mask)
-	    XSelectInput(dpy, XtWindow(widget), (long) mask);
-
-	if (has_type_specifier) {
-	    XtPerDisplay pd = _XtGetPerDisplay(dpy);
-	    int i;
-	    for (i = 0; i < pd->ext_select_count; i++) {
-		if (type >= pd->ext_select_list[i].min &&
-		    type <= pd->ext_select_list[i].max) {
-		    CallExtensionSelector(widget, pd->ext_select_list+i, TRUE);
-		    break;
-		}
-		if (type < pd->ext_select_list[i].min) break;
-	    }
-	}
+    if (!raw && XtIsRealized(widget) && !widget->core.being_destroyed) {
+        EventMask mask = XtBuildEventMask(widget);
+        Display *dpy = XtDisplay(widget);
+
+        if (oldMask != mask)
+            XSelectInput(dpy, XtWindow(widget), (long) mask);
+
+        if (has_type_specifier) {
+            XtPerDisplay pd = _XtGetPerDisplay(dpy);
+            int i;
+
+            for (i = 0; i < pd->ext_select_count; i++) {
+                if (type >= pd->ext_select_list[i].min &&
+                    type <= pd->ext_select_list[i].max) {
+                    CallExtensionSelector(widget, pd->ext_select_list + i,
+                                          TRUE);
+                    break;
+                }
+                if (type < pd->ext_select_list[i].min)
+                    break;
+            }
+        }
     }
 }
 
-/*	Function Name: AddEventHandler
- *	Description: An Internal routine that does the actual work of
+/*      Function Name: AddEventHandler
+ *      Description: An Internal routine that does the actual work of
  *                   adding the event handlers.
- *	Arguments: widget - widget to register an event handler for.
+ *      Arguments: widget - widget to register an event handler for.
  *                 eventMask - events to mask for.
  *                 other - pass non maskable events to this proceedure.
  *                 proc - proceedure to register.
@@ -261,237 +273,250 @@ RemoveEventHandler(
  *                                      list, this will force it to the
  *                                      beginning or end depending on position.
  *                 raw - If FALSE call XSelectInput for events in mask.
- *	Returns: none
+ *      Returns: none
  */
 
 static void
-AddEventHandler(
-    Widget widget,
-    XtPointer select_data,
-    int type,
-    Boolean         has_type_specifier,
-    Boolean         other,
-    XtEventHandler  proc,
-    XtPointer	closure,
-    XtListPosition  position,
-    Boolean         force_new_position,
-    Boolean         raw)
+AddEventHandler(Widget widget,
+                XtPointer select_data,
+                int type,
+                Boolean has_type_specifier,
+                Boolean other,
+                XtEventHandler proc,
+                XtPointer closure,
+                XtListPosition position,
+                Boolean force_new_position,
+                Boolean raw)
 {
     register XtEventRec *p, **pp;
     EventMask oldMask = 0, eventMask = 0;
 
     if (!has_type_specifier) {
-	eventMask = *(EventMask*)select_data & ~NonMaskableMask;
-	if (other) eventMask |= NonMaskableMask;
-	if (!eventMask) return;
-    } else if (!type) return;
+        eventMask = *(EventMask *) select_data & ~NonMaskableMask;
+        if (other)
+            eventMask |= NonMaskableMask;
+        if (!eventMask)
+            return;
+    }
+    else if (!type)
+        return;
 
-    if (XtIsRealized(widget) && !raw) oldMask = XtBuildEventMask(widget);
+    if (XtIsRealized(widget) && !raw)
+        oldMask = XtBuildEventMask(widget);
 
-    if (raw) raw = 1;
+    if (raw)
+        raw = 1;
     pp = &widget->core.event_table;
     while ((p = *pp) &&
-	   (p->proc != proc || p->closure != closure || p->select == raw ||
-	    has_type_specifier != p->has_type_specifier ||
-	    (has_type_specifier && EXT_TYPE(p) != type)))
-	pp = &p->next;
-
-    if (!p) {		                /* New proc to add to list */
-	if (has_type_specifier) {
-	    p = (XtEventRec*) __XtMalloc(sizeof(XtEventRec) +
-				       sizeof(XtEventRecExt));
-	    EXT_TYPE(p) = type;
-	    EXT_SELECT_DATA(p,0) = select_data;
-	    p->mask = 1;
-	    p->has_type_specifier = True;
-	} else {
-	    p = (XtEventRec*) __XtMalloc(sizeof(XtEventRec));
-	    p->mask = eventMask;
-	    p->has_type_specifier = False;
-	}
-	p->proc = proc;
-	p->closure = closure;
-	p->select = ! raw;
-
-	if (position == XtListHead) {
-	    p->next = widget->core.event_table;
-	    widget->core.event_table = p;
-	} else {
-	    *pp = p;
-	    p->next = NULL;
-	}
+           (p->proc != proc || p->closure != closure || p->select == raw ||
+            has_type_specifier != p->has_type_specifier ||
+            (has_type_specifier && EXT_TYPE(p) != type)))
+        pp = &p->next;
+
+    if (!p) {                   /* New proc to add to list */
+        if (has_type_specifier) {
+            p = (XtEventRec *) __XtMalloc(sizeof(XtEventRec) +
+                                          sizeof(XtEventRecExt));
+            EXT_TYPE(p) = type;
+            EXT_SELECT_DATA(p, 0) = select_data;
+            p->mask = 1;
+            p->has_type_specifier = True;
+        }
+        else {
+            p = (XtEventRec *) __XtMalloc(sizeof(XtEventRec));
+            p->mask = eventMask;
+            p->has_type_specifier = False;
+        }
+        p->proc = proc;
+        p->closure = closure;
+        p->select = !raw;
+
+        if (position == XtListHead) {
+            p->next = widget->core.event_table;
+            widget->core.event_table = p;
+        }
+        else {
+            *pp = p;
+            p->next = NULL;
+        }
     }
     else {
-	if (force_new_position) {
-	    *pp = p->next;
-
-	    if (position == XtListHead) {
-		p->next = widget->core.event_table;
-		widget->core.event_table = p;
-	    } else {
-	       	/*
-		 * Find the last element in the list.
-		 */
-		while (*pp)
-		    pp = &(*pp)->next;
-		*pp = p;
-		p->next = NULL;
-	    }
-	}
-
-	if (!has_type_specifier)
-	    p->mask |= eventMask;
-	else {
-	    Cardinal i;
-	    /* p->mask specifies count of EXT_SELECT_DATA(p,i) */
-	    for (i = 0; i < p->mask && select_data != EXT_SELECT_DATA(p,i); )
-		i++;
-	    if (i == p->mask) {
-		p = (XtEventRec*) XtRealloc((char*)p,
-					    (Cardinal)(sizeof(XtEventRec) +
-					    sizeof(XtEventRecExt) +
-					    p->mask * sizeof(XtPointer)));
-		EXT_SELECT_DATA(p,i) = select_data;
-		p->mask++;
-		*pp = p;
-	    }
-	}
+        if (force_new_position) {
+            *pp = p->next;
+
+            if (position == XtListHead) {
+                p->next = widget->core.event_table;
+                widget->core.event_table = p;
+            }
+            else {
+                /*
+                 * Find the last element in the list.
+                 */
+                while (*pp)
+                    pp = &(*pp)->next;
+                *pp = p;
+                p->next = NULL;
+            }
+        }
+
+        if (!has_type_specifier)
+            p->mask |= eventMask;
+        else {
+            Cardinal i;
+
+            /* p->mask specifies count of EXT_SELECT_DATA(p,i) */
+            for (i = 0; i < p->mask && select_data != EXT_SELECT_DATA(p, i);)
+                i++;
+            if (i == p->mask) {
+                p = (XtEventRec *) XtRealloc((char *) p,
+                                             (Cardinal) (sizeof(XtEventRec) +
+                                                         sizeof(XtEventRecExt) +
+                                                         p->mask *
+                                                         sizeof(XtPointer)));
+                EXT_SELECT_DATA(p, i) = select_data;
+                p->mask++;
+                *pp = p;
+            }
+        }
     }
 
     if (XtIsRealized(widget) && !raw) {
-	EventMask mask = XtBuildEventMask(widget);
-	Display* dpy = XtDisplay (widget);
-
-	if (oldMask != mask)
-	    XSelectInput(dpy, XtWindow(widget), (long) mask);
-
-	if (has_type_specifier) {
-	    XtPerDisplay pd = _XtGetPerDisplay (dpy);
-	    int i;
-	    for (i = 0; i < pd->ext_select_count; i++) {
-		if (type >= pd->ext_select_list[i].min &&
-		    type <= pd->ext_select_list[i].max) {
-		    CallExtensionSelector(widget, pd->ext_select_list+i, FALSE);
-		    break;
-		}
-		if (type < pd->ext_select_list[i].min) break;
-	    }
-	}
+        EventMask mask = XtBuildEventMask(widget);
+        Display *dpy = XtDisplay(widget);
+
+        if (oldMask != mask)
+            XSelectInput(dpy, XtWindow(widget), (long) mask);
+
+        if (has_type_specifier) {
+            XtPerDisplay pd = _XtGetPerDisplay(dpy);
+            int i;
+
+            for (i = 0; i < pd->ext_select_count; i++) {
+                if (type >= pd->ext_select_list[i].min &&
+                    type <= pd->ext_select_list[i].max) {
+                    CallExtensionSelector(widget, pd->ext_select_list + i,
+                                          FALSE);
+                    break;
+                }
+                if (type < pd->ext_select_list[i].min)
+                    break;
+            }
+        }
     }
 }
 
-void XtRemoveEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean	    other,
-    XtEventHandler  proc,
-    XtPointer	    closure)
+void
+XtRemoveEventHandler(Widget widget,
+                     EventMask eventMask,
+                     _XtBoolean other,
+                     XtEventHandler proc,
+                     XtPointer closure)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     RemoveEventHandler(widget, (XtPointer) &eventMask, 0, FALSE,
-		       (Boolean) other, proc, closure, FALSE);
+                       (Boolean) other, proc, closure, FALSE);
     UNLOCK_APP(app);
 }
 
-void XtAddEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean      other,
-    XtEventHandler  proc,
-    XtPointer	    closure)
+void
+XtAddEventHandler(Widget widget,
+                  EventMask eventMask,
+                  _XtBoolean other,
+                  XtEventHandler proc,
+                  XtPointer closure)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, (Boolean) other,
-		    proc, closure, XtListTail, FALSE, FALSE);
+                    proc, closure, XtListTail, FALSE, FALSE);
     UNLOCK_APP(app);
 }
 
-void XtInsertEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean      other,
-    XtEventHandler  proc,
-    XtPointer	    closure,
-    XtListPosition  position)
+void
+XtInsertEventHandler(Widget widget,
+                     EventMask eventMask,
+                     _XtBoolean other,
+                     XtEventHandler proc,
+                     XtPointer closure,
+                     XtListPosition position)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, (Boolean) other,
-		    proc, closure, position, TRUE, FALSE);
+                    proc, closure, position, TRUE, FALSE);
     UNLOCK_APP(app);
 }
 
-void XtRemoveRawEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean	    other,
-    XtEventHandler  proc,
-    XtPointer	    closure)
+void
+XtRemoveRawEventHandler(Widget widget,
+                        EventMask eventMask,
+                        _XtBoolean other,
+                        XtEventHandler proc,
+                        XtPointer closure)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     RemoveEventHandler(widget, (XtPointer) &eventMask, 0, FALSE,
-		       (Boolean) other, proc, closure, TRUE);
+                       (Boolean) other, proc, closure, TRUE);
     UNLOCK_APP(app);
 }
 
-void XtInsertRawEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean	    other,
-    XtEventHandler  proc,
-    XtPointer	    closure,
-    XtListPosition  position)
+void
+XtInsertRawEventHandler(Widget widget,
+                        EventMask eventMask,
+                        _XtBoolean other,
+                        XtEventHandler proc,
+                        XtPointer closure,
+                        XtListPosition position)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, (Boolean) other,
-		    proc, closure, position, TRUE, TRUE);
+                    proc, closure, position, TRUE, TRUE);
     UNLOCK_APP(app);
 }
 
-void XtAddRawEventHandler(
-    Widget	    widget,
-    EventMask       eventMask,
-    _XtBoolean      other,
-    XtEventHandler  proc,
-    XtPointer	    closure)
+void
+XtAddRawEventHandler(Widget widget,
+                     EventMask eventMask,
+                     _XtBoolean other,
+                     XtEventHandler proc,
+                     XtPointer closure)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     AddEventHandler(widget, (XtPointer) &eventMask, 0, FALSE, (Boolean) other,
-		    proc, closure, XtListTail, FALSE, TRUE);
+                    proc, closure, XtListTail, FALSE, TRUE);
     UNLOCK_APP(app);
 }
 
-void XtRemoveEventTypeHandler(
-    Widget	    widget,
-    int		    type,
-    XtPointer	    select_data,
-    XtEventHandler  proc,
-    XtPointer	    closure)
+void
+XtRemoveEventTypeHandler(Widget widget,
+                         int type,
+                         XtPointer select_data,
+                         XtEventHandler proc,
+                         XtPointer closure)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     RemoveEventHandler(widget, select_data, type, TRUE,
-		       FALSE, proc, closure, FALSE);
+                       FALSE, proc, closure, FALSE);
     UNLOCK_APP(app);
 }
 
-void XtInsertEventTypeHandler(
-    Widget	    widget,
-    int		    type,
-    XtPointer	    select_data,
-    XtEventHandler  proc,
-    XtPointer	    closure,
-    XtListPosition  position)
+void
+XtInsertEventTypeHandler(Widget widget,
+                         int type,
+                         XtPointer select_data,
+                         XtEventHandler proc,
+                         XtPointer closure,
+                         XtListPosition position)
 {
     WIDGET_TO_APPCON(widget);
     LOCK_APP(app);
     AddEventHandler(widget, select_data, type, TRUE, FALSE,
-		    proc, closure, position, TRUE, FALSE);
+                    proc, closure, position, TRUE, FALSE);
     UNLOCK_APP(app);
 }
 
@@ -502,15 +527,15 @@ typedef struct _WWPair {
 } *WWPair;
 
 typedef struct _WWTable {
-    unsigned int mask;		/* size of hash table - 1 */
-    unsigned int rehash;	/* mask - 2 */
-    unsigned int occupied;	/* number of occupied entries */
-    unsigned int fakes;		/* number occupied by WWfake */
-    Widget *entries;		/* the entries */
-    WWPair pairs;		/* bogus entries */
+    unsigned int mask;          /* size of hash table - 1 */
+    unsigned int rehash;        /* mask - 2 */
+    unsigned int occupied;      /* number of occupied entries */
+    unsigned int fakes;         /* number occupied by WWfake */
+    Widget *entries;            /* the entries */
+    WWPair pairs;               /* bogus entries */
 } *WWTable;
 
-static const WidgetRec WWfake;	/* placeholder for deletions */
+static const WidgetRec WWfake;  /* placeholder for deletions */
 
 #define WWHASH(tab,win) ((win) & tab->mask)
 #define WWREHASHVAL(tab,win) ((((win) % tab->rehash) + 2) | 1)
@@ -519,102 +544,105 @@ static const WidgetRec WWfake;	/* placeholder for deletions */
 
 static void ExpandWWTable(WWTable);
 
-void XtRegisterDrawable(
-    Display* display,
-    Drawable drawable,
-    Widget widget)
+void
+XtRegisterDrawable(Display *display, Drawable drawable, Widget widget)
 {
     WWTable tab;
     int idx;
     Widget entry;
     Window window = (Window) drawable;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     LOCK_PROCESS;
     tab = WWTABLE(display);
+
     if (window != XtWindow(widget)) {
-	WWPair pair;
-	pair = XtNew(struct _WWPair);
-	pair->next = tab->pairs;
-	pair->window = window;
-	pair->widget = widget;
-	tab->pairs = pair;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-	return;
+        WWPair pair;
+        pair = XtNew(struct _WWPair);
+
+        pair->next = tab->pairs;
+        pair->window = window;
+        pair->widget = widget;
+        tab->pairs = pair;
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return;
     }
     if ((tab->occupied + (tab->occupied >> 2)) > tab->mask)
-	ExpandWWTable(tab);
+        ExpandWWTable(tab);
 
     idx = (int) WWHASH(tab, window);
     if ((entry = tab->entries[idx]) && entry != &WWfake) {
-	int rehash = (int) WWREHASHVAL(tab, window);
-	do {
-	    idx = (int) WWREHASH(tab, idx, rehash);
-	} while ((entry = tab->entries[idx]) && entry != &WWfake);
+        int rehash = (int) WWREHASHVAL(tab, window);
+
+        do {
+            idx = (int) WWREHASH(tab, idx, rehash);
+        } while ((entry = tab->entries[idx]) && entry != &WWfake);
     }
     if (!entry)
-	tab->occupied++;
+        tab->occupied++;
     else if (entry == &WWfake)
-	tab->fakes--;
+        tab->fakes--;
     tab->entries[idx] = widget;
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void XtUnregisterDrawable(
-    Display* display,
-    Drawable drawable)
+void
+XtUnregisterDrawable(Display *display, Drawable drawable)
 {
     WWTable tab;
     int idx;
     Widget entry;
     Window window = (Window) drawable;
-    Widget widget = XtWindowToWidget (display, window);
+    Widget widget = XtWindowToWidget(display, window);
     DPY_TO_APPCON(display);
 
-    if (widget == NULL) return;
+    if (widget == NULL)
+        return;
 
     LOCK_APP(app);
     LOCK_PROCESS;
     tab = WWTABLE(display);
     if (window != XtWindow(widget)) {
-	WWPair *prev, pair;
-
-	prev = &tab->pairs;
-	while ((pair = *prev) && pair->window != window)
-	    prev = &pair->next;
-	if (pair) {
-	    *prev = pair->next;
-	    XtFree((char *)pair);
-	}
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-	return;
+        WWPair *prev, pair;
+
+        prev = &tab->pairs;
+        while ((pair = *prev) && pair->window != window)
+            prev = &pair->next;
+        if (pair) {
+            *prev = pair->next;
+            XtFree((char *) pair);
+        }
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return;
     }
     idx = (int) WWHASH(tab, window);
     if ((entry = tab->entries[idx])) {
-	if (entry != widget) {
-	    int rehash = (int) WWREHASHVAL(tab, window);
-	    do {
-		idx = (int) WWREHASH(tab, idx, rehash);
-		if (!(entry = tab->entries[idx])) {
-		    UNLOCK_PROCESS;
-		    UNLOCK_APP(app);
-		    return;
-		}
-	    } while (entry != widget);
-	}
-	tab->entries[idx] = (Widget)&WWfake;
-	tab->fakes++;
+        if (entry != widget) {
+            int rehash = (int) WWREHASHVAL(tab, window);
+
+            do {
+                idx = (int) WWREHASH(tab, idx, rehash);
+                if (!(entry = tab->entries[idx])) {
+                    UNLOCK_PROCESS;
+                    UNLOCK_APP(app);
+                    return;
+                }
+            } while (entry != widget);
+        }
+        tab->entries[idx] = (Widget) &WWfake;
+        tab->fakes++;
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-static void ExpandWWTable(
-    register WWTable tab)
+static void
+ExpandWWTable(register WWTable tab)
 {
     unsigned int oldmask;
     register Widget *oldentries, *entries;
@@ -627,29 +655,29 @@ static void ExpandWWTable(
     tab->occupied -= tab->fakes;
     tab->fakes = 0;
     if ((tab->occupied + (tab->occupied >> 2)) > tab->mask) {
-	tab->mask = (tab->mask << 1) + 1;
-	tab->rehash = tab->mask - 2;
+        tab->mask = (tab->mask << 1) + 1;
+        tab->rehash = tab->mask - 2;
     }
-    entries = tab->entries = (Widget *) __XtCalloc(tab->mask+1, sizeof(Widget));
+    entries = tab->entries =
+        (Widget *) __XtCalloc(tab->mask + 1, sizeof(Widget));
     for (oldidx = 0; oldidx <= oldmask; oldidx++) {
-	if ((entry = oldentries[oldidx]) && entry != &WWfake) {
-	    newidx = (Cardinal) WWHASH(tab, XtWindow(entry));
-	    if (entries[newidx]) {
-		rehash = (Cardinal) WWREHASHVAL(tab, XtWindow(entry));
-		do {
-		    newidx = (Cardinal) WWREHASH(tab, newidx, rehash);
-		} while (entries[newidx]);
-	    }
-	    entries[newidx] = entry;
-	}
+        if ((entry = oldentries[oldidx]) && entry != &WWfake) {
+            newidx = (Cardinal) WWHASH(tab, XtWindow(entry));
+            if (entries[newidx]) {
+                rehash = (Cardinal) WWREHASHVAL(tab, XtWindow(entry));
+                do {
+                    newidx = (Cardinal) WWREHASH(tab, newidx, rehash);
+                } while (entries[newidx]);
+            }
+            entries[newidx] = entry;
+        }
     }
-    XtFree((char *)oldentries);
+    XtFree((char *) oldentries);
     UNLOCK_PROCESS;
 }
 
-Widget XtWindowToWidget(
-    register Display *display,
-    register Window window)
+Widget
+XtWindowToWidget(register Display *display, register Window window)
 {
     WWTable tab;
     int idx;
@@ -657,70 +685,70 @@ Widget XtWindowToWidget(
     WWPair pair;
     DPY_TO_APPCON(display);
 
-    if (!window) return NULL;
+    if (!window)
+        return NULL;
 
     LOCK_APP(app);
     LOCK_PROCESS;
     tab = WWTABLE(display);
     idx = (int) WWHASH(tab, window);
     if ((entry = tab->entries[idx]) && XtWindow(entry) != window) {
-	int rehash = (int) WWREHASHVAL(tab, window);
-	do {
-	    idx = (int) WWREHASH(tab, idx, rehash);
-	} while ((entry = tab->entries[idx]) && XtWindow(entry) != window);
+        int rehash = (int) WWREHASHVAL(tab, window);
+
+        do {
+            idx = (int) WWREHASH(tab, idx, rehash);
+        } while ((entry = tab->entries[idx]) && XtWindow(entry) != window);
     }
     if (entry) {
-    	UNLOCK_PROCESS;
-    	UNLOCK_APP(app);
-	return entry;
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return entry;
     }
     for (pair = tab->pairs; pair; pair = pair->next) {
-	if (pair->window == window) {
-	    entry = pair->widget;
-	    UNLOCK_PROCESS;
-    	    UNLOCK_APP(app);
-	    return entry;
-	}
+        if (pair->window == window) {
+            entry = pair->widget;
+            UNLOCK_PROCESS;
+            UNLOCK_APP(app);
+            return entry;
+        }
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return NULL;
 }
 
-void _XtAllocWWTable(
-    XtPerDisplay pd)
+void
+_XtAllocWWTable(XtPerDisplay pd)
 {
     register WWTable tab;
 
     tab = (WWTable) __XtMalloc(sizeof(struct _WWTable));
     tab->mask = 0x7f;
     tab->rehash = tab->mask - 2;
-    tab->entries = (Widget *) __XtCalloc(tab->mask+1, sizeof(Widget));
+    tab->entries = (Widget *) __XtCalloc(tab->mask + 1, sizeof(Widget));
     tab->occupied = 0;
     tab->fakes = 0;
     tab->pairs = NULL;
     pd->WWtable = tab;
 }
 
-void _XtFreeWWTable(
-    register XtPerDisplay pd)
+void
+_XtFreeWWTable(register XtPerDisplay pd)
 {
     register WWPair pair, next;
 
     for (pair = pd->WWtable->pairs; pair; pair = next) {
-	next = pair->next;
-	XtFree((char *)pair);
+        next = pair->next;
+        XtFree((char *) pair);
     }
-    XtFree((char *)pd->WWtable->entries);
-    XtFree((char *)pd->WWtable);
+    XtFree((char *) pd->WWtable->entries);
+    XtFree((char *) pd->WWtable);
 }
 
-#define EHMAXSIZE 25 /* do not make whopping big */
+#define EHMAXSIZE 25            /* do not make whopping big */
 
-static Boolean CallEventHandlers(
-    Widget     widget,
-    XEvent    *event,
-    EventMask  mask)
+static Boolean
+CallEventHandlers(Widget widget, XEvent *event, EventMask mask)
 {
     register XtEventRec *p;
     XtEventHandler *proc;
@@ -732,173 +760,178 @@ static Boolean CallEventHandlers(
      * call XtRemoveEventHandler, which would break our linked list. */
 
     numprocs = 0;
-    for (p=widget->core.event_table; p; p = p->next) {
-	if ((!p->has_type_specifier && (mask & p->mask)) ||
-	    (p->has_type_specifier && event->type == EXT_TYPE(p)))
-	    numprocs++;
+    for (p = widget->core.event_table; p; p = p->next) {
+        if ((!p->has_type_specifier && (mask & p->mask)) ||
+            (p->has_type_specifier && event->type == EXT_TYPE(p)))
+            numprocs++;
     }
-    proc = (XtEventHandler *)__XtMalloc((Cardinal)((size_t)numprocs * (sizeof(XtEventHandler) +
-						   sizeof(XtPointer))));
-    closure = (XtPointer *)(proc + numprocs);
+    proc = (XtEventHandler *)
+        __XtMalloc((Cardinal)
+                   ((size_t) numprocs *
+                    (sizeof(XtEventHandler) + sizeof(XtPointer))));
+    closure = (XtPointer *) (proc + numprocs);
 
     numprocs = 0;
-    for (p=widget->core.event_table; p; p = p->next) {
-	if ((!p->has_type_specifier && (mask & p->mask)) ||
-	    (p->has_type_specifier && event->type == EXT_TYPE(p))) {
-	    proc[numprocs] = p->proc;
-	    closure[numprocs] = p->closure;
-	    numprocs++;
-	}
+    for (p = widget->core.event_table; p; p = p->next) {
+        if ((!p->has_type_specifier && (mask & p->mask)) ||
+            (p->has_type_specifier && event->type == EXT_TYPE(p))) {
+            proc[numprocs] = p->proc;
+            closure[numprocs] = p->closure;
+            numprocs++;
+        }
     }
-/* FUNCTIONS CALLED THROUGH POINTER proc:
-		Selection.c:ReqCleanup,
-		"Shell.c":EventHandler,
-		PassivGrab.c:ActiveHandler,
-		PassivGrab.c:RealizeHandler,
-		Keyboard.c:QueryEventMask,
-		_XtHandleFocus,
-		Selection.c:HandleSelectionReplies,
-		Selection.c:HandleGetIncrement,
-		Selection.c:HandleIncremental,
-		Selection.c:HandlePropertyGone,
-		Selection.c:HandleSelectionEvents
-		*/
+    /* FUNCTIONS CALLED THROUGH POINTER proc:
+       Selection.c:ReqCleanup,
+       "Shell.c":EventHandler,
+       PassivGrab.c:ActiveHandler,
+       PassivGrab.c:RealizeHandler,
+       Keyboard.c:QueryEventMask,
+       _XtHandleFocus,
+       Selection.c:HandleSelectionReplies,
+       Selection.c:HandleGetIncrement,
+       Selection.c:HandleIncremental,
+       Selection.c:HandlePropertyGone,
+       Selection.c:HandleSelectionEvents
+     */
     for (i = 0; i < numprocs && cont_to_disp; i++)
-	(*(proc[i]))(widget, closure[i], event, &cont_to_disp);
-    XtFree((char *)proc);
+        (*(proc[i])) (widget, closure[i], event, &cont_to_disp);
+    XtFree((char *) proc);
     return cont_to_disp;
 }
 
 static void CompressExposures(XEvent *, Widget);
 
 #define KnownButtons (Button1MotionMask|Button2MotionMask|Button3MotionMask|\
-		      Button4MotionMask|Button5MotionMask)
+                      Button4MotionMask|Button5MotionMask)
 
 /* keep this SMALL to avoid blowing stack cache! */
 /* because some compilers allocate all local locals on procedure entry */
 #define EHSIZE 4
 
-Boolean XtDispatchEventToWidget(
-    Widget widget,
-    XEvent* event)
+Boolean
+XtDispatchEventToWidget(Widget widget, XEvent *event)
 {
     register XtEventRec *p;
     Boolean was_dispatched = False;
     Boolean call_tm = False;
     Boolean cont_to_disp;
     EventMask mask;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
 
     mask = _XtConvertTypeToMask(event->type);
     if (event->type == MotionNotify)
-	mask |= (event->xmotion.state & KnownButtons);
+        mask |= (event->xmotion.state & KnownButtons);
 
     LOCK_PROCESS;
-    if ( (mask == ExposureMask) ||
-	 ((event->type == NoExpose) && NO_EXPOSE) ||
-	 ((event->type == GraphicsExpose) && GRAPHICS_EXPOSE) ) {
+    if ((mask == ExposureMask) ||
+        ((event->type == NoExpose) && NO_EXPOSE) ||
+        ((event->type == GraphicsExpose) && GRAPHICS_EXPOSE)) {
 
-	if (widget->core.widget_class->core_class.expose != NULL ) {
+        if (widget->core.widget_class->core_class.expose != NULL) {
 
-	    /* We need to mask off the bits that could contain the information
-	     * about whether or not we desire Graphics and NoExpose events.  */
+            /* We need to mask off the bits that could contain the information
+             * about whether or not we desire Graphics and NoExpose events.  */
 
-	    if ( (COMP_EXPOSE_TYPE == XtExposeNoCompress) ||
-		 (event->type == NoExpose) )
+            if ((COMP_EXPOSE_TYPE == XtExposeNoCompress) ||
+                (event->type == NoExpose))
 
-		(*widget->core.widget_class->core_class.expose)
-		    (widget, event, (Region)NULL);
-	    else {
-		CompressExposures(event, widget);
-	    }
-	    was_dispatched = True;
-	}
+                (*widget->core.widget_class->core_class.expose)
+                    (widget, event, (Region) NULL);
+            else {
+                CompressExposures(event, widget);
+            }
+            was_dispatched = True;
+        }
     }
 
     if ((mask == VisibilityChangeMask) &&
         XtClass(widget)->core_class.visible_interest) {
-	    was_dispatched = True;
-	    /* our visibility just changed... */
-	    switch (((XVisibilityEvent *)event)->state) {
-		case VisibilityUnobscured:
-		    widget->core.visible = TRUE;
-		    break;
-
-		case VisibilityPartiallyObscured:
-		    /* what do we want to say here? */
-		    /* well... some of us is visible */
-		    widget->core.visible = TRUE;
-		    break;
-
-		case VisibilityFullyObscured:
-		    widget->core.visible = FALSE;
-		    /* do we want to mark our children obscured? */
-		    break;
-	    }
-	}
+        was_dispatched = True;
+        /* our visibility just changed... */
+        switch (((XVisibilityEvent *) event)->state) {
+        case VisibilityUnobscured:
+            widget->core.visible = TRUE;
+            break;
+
+        case VisibilityPartiallyObscured:
+            /* what do we want to say here? */
+            /* well... some of us is visible */
+            widget->core.visible = TRUE;
+            break;
+
+        case VisibilityFullyObscured:
+            widget->core.visible = FALSE;
+            /* do we want to mark our children obscured? */
+            break;
+        }
+    }
     UNLOCK_PROCESS;
 
     /* to maintain "copy" semantics we check TM now but call later */
     if (widget->core.tm.translations &&
-	(mask & widget->core.tm.translations->eventMask))
-	call_tm = True;
+        (mask & widget->core.tm.translations->eventMask))
+        call_tm = True;
 
     cont_to_disp = True;
-    p=widget->core.event_table;
+    p = widget->core.event_table;
     if (p) {
-	if (p->next) {
-	    XtEventHandler proc[EHSIZE];
-	    XtPointer closure[EHSIZE];
-	    int numprocs = 0;
-
-	    /* Have to copy the procs into an array, because one of them might
-	     * call XtRemoveEventHandler, which would break our linked list. */
-
-	    for (; p; p = p->next) {
-		if ((!p->has_type_specifier && (mask & p->mask)) ||
-		    (p->has_type_specifier && event->type == EXT_TYPE(p))) {
-		    if (numprocs >= EHSIZE)
-			break;
-		    proc[numprocs] = p->proc;
-		    closure[numprocs] = p->closure;
-		    numprocs++;
-		}
-	    }
-	    if (numprocs) {
-		if (p) {
-		    cont_to_disp = CallEventHandlers(widget, event, mask);
-		} else {
-		    int i;
-		    for (i = 0; i < numprocs && cont_to_disp; i++)
-			(*(proc[i]))(widget, closure[i], event, &cont_to_disp);
-/* FUNCTIONS CALLED THROUGH POINTER proc:
-		Selection.c:ReqCleanup,
-		"Shell.c":EventHandler,
-		PassivGrab.c:ActiveHandler,
-		PassivGrab.c:RealizeHandler,
-		Keyboard.c:QueryEventMask,
-		_XtHandleFocus,
-		Selection.c:HandleSelectionReplies,
-		Selection.c:HandleGetIncrement,
-		Selection.c:HandleIncremental,
-		Selection.c:HandlePropertyGone,
-		Selection.c:HandleSelectionEvents
-		*/
-		}
-		was_dispatched = True;
-	    }
-	} else if ((!p->has_type_specifier && (mask & p->mask)) ||
-		   (p->has_type_specifier && event->type == EXT_TYPE(p))) {
-	    (*p->proc)(widget, p->closure, event, &cont_to_disp);
-	    was_dispatched = True;
-	}
+        if (p->next) {
+            XtEventHandler proc[EHSIZE];
+            XtPointer closure[EHSIZE];
+            int numprocs = 0;
+
+            /* Have to copy the procs into an array, because one of them might
+             * call XtRemoveEventHandler, which would break our linked list. */
+
+            for (; p; p = p->next) {
+                if ((!p->has_type_specifier && (mask & p->mask)) ||
+                    (p->has_type_specifier && event->type == EXT_TYPE(p))) {
+                    if (numprocs >= EHSIZE)
+                        break;
+                    proc[numprocs] = p->proc;
+                    closure[numprocs] = p->closure;
+                    numprocs++;
+                }
+            }
+            if (numprocs) {
+                if (p) {
+                    cont_to_disp = CallEventHandlers(widget, event, mask);
+                }
+                else {
+                    int i;
+
+                    for (i = 0; i < numprocs && cont_to_disp; i++)
+                        (*(proc[i])) (widget, closure[i], event, &cont_to_disp);
+                    /* FUNCTIONS CALLED THROUGH POINTER proc:
+                       Selection.c:ReqCleanup,
+                       "Shell.c":EventHandler,
+                       PassivGrab.c:ActiveHandler,
+                       PassivGrab.c:RealizeHandler,
+                       Keyboard.c:QueryEventMask,
+                       _XtHandleFocus,
+                       Selection.c:HandleSelectionReplies,
+                       Selection.c:HandleGetIncrement,
+                       Selection.c:HandleIncremental,
+                       Selection.c:HandlePropertyGone,
+                       Selection.c:HandleSelectionEvents
+                     */
+                }
+                was_dispatched = True;
+            }
+        }
+        else if ((!p->has_type_specifier && (mask & p->mask)) ||
+                 (p->has_type_specifier && event->type == EXT_TYPE(p))) {
+            (*p->proc) (widget, p->closure, event, &cont_to_disp);
+            was_dispatched = True;
+        }
     }
     if (call_tm && cont_to_disp)
-	_XtTranslateEvent(widget, event);
+        _XtTranslateEvent(widget, event);
     UNLOCK_APP(app);
-    return (was_dispatched|call_tm);
+    return (was_dispatched | call_tm);
 }
 
 /*
@@ -906,11 +939,11 @@ Boolean XtDispatchEventToWidget(
  */
 
 typedef struct _CheckExposeInfo {
-    int type1, type2;		/* Types of events to check for. */
-    Boolean maximal;		/* Ignore non-exposure events? */
-    Boolean non_matching;	/* Was there an event that did not
-				   match either type? */
-    Window window;		/* Window to match. */
+    int type1, type2;           /* Types of events to check for. */
+    Boolean maximal;            /* Ignore non-exposure events? */
+    Boolean non_matching;       /* Was there an event that did not
+                                   match either type? */
+    Window window;              /* Window to match. */
 } CheckExposeInfo;
 
 #define GetCount(ev) (((XExposeEvent *)(ev))->count)
@@ -919,23 +952,21 @@ static void SendExposureEvent(XEvent *, Widget, XtPerDisplay);
 static Bool CheckExposureEvent(Display *, XEvent *, char *);
 static void AddExposureToRectangularRegion(XEvent *, Region);
 
-/*	Function Name: CompressExposures
- *	Description: Handles all exposure compression
- *	Arguments: event - the xevent that is to be dispatched
+/*      Function Name: CompressExposures
+ *      Description: Handles all exposure compression
+ *      Arguments: event - the xevent that is to be dispatched
  *                 widget - the widget that this event occured in.
- *	Returns: none.
+ *      Returns: none.
  *
  *      NOTE: Event must be of type Expose or GraphicsExpose.
  */
 
 static void
-CompressExposures(
-XEvent * event,
-Widget widget)
+CompressExposures(XEvent *event, Widget widget)
 {
     CheckExposeInfo info;
     int count;
-    Display* dpy = XtDisplay (widget);
+    Display *dpy = XtDisplay(widget);
     XtPerDisplay pd = _XtGetPerDisplay(dpy);
     XtEnum comp_expose;
     XtEnum comp_expose_type;
@@ -948,93 +979,92 @@ Widget widget)
     no_region = ((comp_expose & XtExposeNoRegion) ? True : False);
 
     if (no_region)
-	AddExposureToRectangularRegion(event, pd->region);
+        AddExposureToRectangularRegion(event, pd->region);
     else
-	XtAddExposureToRegion(event, pd->region);
+        XtAddExposureToRegion(event, pd->region);
 
-    if ( GetCount(event) != 0 )
- 	return;
+    if (GetCount(event) != 0)
+        return;
 
     if ((comp_expose_type == XtExposeCompressSeries) ||
-	(XEventsQueued(dpy, QueuedAfterReading) == 0)) {
-	SendExposureEvent(event, widget, pd);
-	return;
+        (XEventsQueued(dpy, QueuedAfterReading) == 0)) {
+        SendExposureEvent(event, widget, pd);
+        return;
     }
 
     if (comp_expose & XtExposeGraphicsExposeMerged) {
-	info.type1 = Expose;
-	info.type2 = GraphicsExpose;
+        info.type1 = Expose;
+        info.type2 = GraphicsExpose;
     }
     else {
-	info.type1 = event->type;
-	info.type2 = 0;
+        info.type1 = event->type;
+        info.type2 = 0;
     }
     info.maximal = (comp_expose_type == XtExposeCompressMaximal);
     info.non_matching = FALSE;
     info.window = XtWindow(widget);
 
-/*
- * We have to be very careful here not to hose down the processor
- * when blocking until count gets to zero.
- *
- * First, check to see if there are any events in the queue for this
- * widget, and of the correct type.
- *
- * Once we cannot find any more events, check to see that count is zero.
- * If it is not then block until we get another exposure event.
- *
- * If we find no more events, and count on the last one we saw was zero we
- * we can be sure that all events have been processed.
- *
- * Unfortunately, we wind up having to look at the entire queue
- * event if we're not doing Maximal compression, due to the
- * semantics of XCheckIfEvent (we can't abort without re-ordering
- * the event queue as a side-effect).
- */
+    /*
+     * We have to be very careful here not to hose down the processor
+     * when blocking until count gets to zero.
+     *
+     * First, check to see if there are any events in the queue for this
+     * widget, and of the correct type.
+     *
+     * Once we cannot find any more events, check to see that count is zero.
+     * If it is not then block until we get another exposure event.
+     *
+     * If we find no more events, and count on the last one we saw was zero we
+     * we can be sure that all events have been processed.
+     *
+     * Unfortunately, we wind up having to look at the entire queue
+     * event if we're not doing Maximal compression, due to the
+     * semantics of XCheckIfEvent (we can't abort without re-ordering
+     * the event queue as a side-effect).
+     */
 
     count = 0;
     while (TRUE) {
-	XEvent event_return;
-
-	if (XCheckIfEvent(dpy, &event_return,
-			  CheckExposureEvent, (char *) &info)) {
-
-	    count = GetCount(&event_return);
- 	    if (no_region)
-		AddExposureToRectangularRegion(&event_return, pd->region);
- 	    else
-		XtAddExposureToRegion(&event_return, pd->region);
-	}
-	else if (count != 0) {
-	    XIfEvent(dpy, &event_return,
-		     CheckExposureEvent, (char *) &info);
-	    count = GetCount(&event_return);
- 	    if (no_region)
-		AddExposureToRectangularRegion(&event_return, pd->region);
- 	    else
-		XtAddExposureToRegion(&event_return, pd->region);
-	}
-	else /* count == 0 && XCheckIfEvent Failed. */
-	    break;
+        XEvent event_return;
+
+        if (XCheckIfEvent(dpy, &event_return,
+                          CheckExposureEvent, (char *) &info)) {
+
+            count = GetCount(&event_return);
+            if (no_region)
+                AddExposureToRectangularRegion(&event_return, pd->region);
+            else
+                XtAddExposureToRegion(&event_return, pd->region);
+        }
+        else if (count != 0) {
+            XIfEvent(dpy, &event_return, CheckExposureEvent, (char *) &info);
+            count = GetCount(&event_return);
+            if (no_region)
+                AddExposureToRectangularRegion(&event_return, pd->region);
+            else
+                XtAddExposureToRegion(&event_return, pd->region);
+        }
+        else                    /* count == 0 && XCheckIfEvent Failed. */
+            break;
     }
 
     SendExposureEvent(event, widget, pd);
 }
 
-void XtAddExposureToRegion(
-    XEvent   *event,
-    Region   region)
+void
+XtAddExposureToRegion(XEvent *event, Region region)
 {
     XRectangle rect;
     XExposeEvent *ev = (XExposeEvent *) event;
+
     /* These Expose and GraphicsExpose fields are at identical offsets */
 
     if (event->type == Expose || event->type == GraphicsExpose) {
-	rect.x = (Position) ev->x;
-	rect.y = (Position) ev->y;
-	rect.width = (Dimension) ev->width;
-	rect.height = (Dimension) ev->height;
-	XUnionRectWithRegion(&rect, region, region);
+        rect.x = (Position) ev->x;
+        rect.y = (Position) ev->y;
+        rect.width = (Dimension) ev->width;
+        rect.height = (Dimension) ev->height;
+        XUnionRectWithRegion(&rect, region, region);
     }
 }
 
@@ -1046,12 +1076,13 @@ void XtAddExposureToRegion(
 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
 #endif
 
-static void AddExposureToRectangularRegion(
-     XEvent *event, /* when called internally, type is always appropriate */
-     Region  region)
+static void
+AddExposureToRectangularRegion(XEvent *event,   /* when called internally, type is always appropriate */
+                               Region region)
 {
     XRectangle rect;
     XExposeEvent *ev = (XExposeEvent *) event;
+
     /* These Expose and GraphicsExpose fields are at identical offsets */
 
     rect.x = (Position) ev->x;
@@ -1060,45 +1091,45 @@ static void AddExposureToRectangularRegion(
     rect.height = (Dimension) ev->height;
 
     if (XEmptyRegion(region)) {
-	XUnionRectWithRegion(&rect, region, region);
-    } else {
-	XRectangle merged, bbox;
-
-	XClipBox(region, &bbox);
-	merged.x = MIN(rect.x, bbox.x);
-	merged.y = MIN(rect.y, bbox.y);
-	merged.width = (unsigned short)(MAX(rect.x + rect.width,
-					    bbox.x + bbox.width) - merged.x);
-	merged.height = (unsigned short)(MAX(rect.y + rect.height,
-					     bbox.y + bbox.height) - merged.y);
-	XUnionRectWithRegion(&merged, region, region);
+        XUnionRectWithRegion(&rect, region, region);
+    }
+    else {
+        XRectangle merged, bbox;
+
+        XClipBox(region, &bbox);
+        merged.x = MIN(rect.x, bbox.x);
+        merged.y = MIN(rect.y, bbox.y);
+        merged.width = (unsigned short) (MAX(rect.x + rect.width,
+                                             bbox.x + bbox.width) - merged.x);
+        merged.height = (unsigned short) (MAX(rect.y + rect.height,
+                                              bbox.y + bbox.height) - merged.y);
+        XUnionRectWithRegion(&merged, region, region);
     }
 }
 
 static Region nullRegion;
+
 /* READ-ONLY VARIABLES: nullRegion */
 
-void _XtEventInitialize(void)
+void
+_XtEventInitialize(void)
 {
 #ifndef __lock_lint
     nullRegion = XCreateRegion();
 #endif
 }
 
-/*	Function Name: SendExposureEvent
- *	Description: Sets the x, y, width, and height of the event
+/*      Function Name: SendExposureEvent
+ *      Description: Sets the x, y, width, and height of the event
  *                   to be the clip box of Expose Region.
- *	Arguments: event  - the X Event to mangle; Expose or GraphicsExpose.
+ *      Arguments: event  - the X Event to mangle; Expose or GraphicsExpose.
  *                 widget - the widget that this event occured in.
  *                 pd     - the per display information for this widget.
- *	Returns: none.
+ *      Returns: none.
  */
 
 static void
-SendExposureEvent(
-XEvent * event,
-Widget widget,
-XtPerDisplay pd)
+SendExposureEvent(XEvent *event, Widget widget, XtPerDisplay pd)
 {
     XtExposeProc expose;
     XRectangle rect;
@@ -1116,275 +1147,291 @@ XtPerDisplay pd)
     expose = widget->core.widget_class->core_class.expose;
     UNLOCK_PROCESS;
     if (comp_expose & XtExposeNoRegion)
-	(*expose)(widget, event, NULL);
+        (*expose) (widget, event, NULL);
     else
-	(*expose)(widget, event, pd->region);
+        (*expose) (widget, event, pd->region);
     (void) XIntersectRegion(nullRegion, pd->region, pd->region);
 }
 
-/*	Function Name: CheckExposureEvent
- *	Description: Checks the event queue for an expose event
- *	Arguments: display - the display connection.
+/*      Function Name: CheckExposureEvent
+ *      Description: Checks the event queue for an expose event
+ *      Arguments: display - the display connection.
  *                 event - the event to check.
  *                 arg - a pointer to the exposure info structure.
- *	Returns: TRUE if we found an event of the correct type
+ *      Returns: TRUE if we found an event of the correct type
  *               with the right window.
  *
  * NOTE: The only valid types (info.type1 and info.type2) are Expose
  *       and GraphicsExpose.
  */
 
-/* ARGSUSED */
 static Bool
-CheckExposureEvent(
-Display * disp,
-XEvent * event,
-char * arg)
+CheckExposureEvent(Display *disp _X_UNUSED, XEvent *event, char *arg)
 {
-    CheckExposeInfo * info = ((CheckExposeInfo *) arg);
-
-    if ( (info->type1 == event->type) || (info->type2 == event->type)) {
-	if (!info->maximal && info->non_matching) return FALSE;
-	if (event->type == GraphicsExpose)
-	    return(event->xgraphicsexpose.drawable == info->window);
-	return(event->xexpose.window == info->window);
+    CheckExposeInfo *info = ((CheckExposeInfo *) arg);
+
+    if ((info->type1 == event->type) || (info->type2 == event->type)) {
+        if (!info->maximal && info->non_matching)
+            return FALSE;
+        if (event->type == GraphicsExpose)
+            return (event->xgraphicsexpose.drawable == info->window);
+        return (event->xexpose.window == info->window);
     }
     info->non_matching = TRUE;
-    return(FALSE);
+    return (FALSE);
 }
 
 static EventMask const masks[] = {
-	0,			    /* Error, should never see  */
-	0,			    /* Reply, should never see  */
-	KeyPressMask,		    /* KeyPress			*/
-	KeyReleaseMask,		    /* KeyRelease		*/
-	ButtonPressMask,	    /* ButtonPress		*/
-	ButtonReleaseMask,	    /* ButtonRelease		*/
-	PointerMotionMask	    /* MotionNotify		*/
-		| ButtonMotionMask,
-	EnterWindowMask,	    /* EnterNotify		*/
-	LeaveWindowMask,	    /* LeaveNotify		*/
-	FocusChangeMask,	    /* FocusIn			*/
-	FocusChangeMask,	    /* FocusOut			*/
-	KeymapStateMask,	    /* KeymapNotify		*/
-	ExposureMask,		    /* Expose			*/
-	NonMaskableMask,	    /* GraphicsExpose, in GC    */
-	NonMaskableMask,	    /* NoExpose, in GC		*/
-	VisibilityChangeMask,       /* VisibilityNotify		*/
-	SubstructureNotifyMask,     /* CreateNotify		*/
-	StructureNotifyMask	    /* DestroyNotify		*/
-		| SubstructureNotifyMask,
-	StructureNotifyMask	    /* UnmapNotify		*/
-		| SubstructureNotifyMask,
-	StructureNotifyMask	    /* MapNotify		*/
-		| SubstructureNotifyMask,
-	SubstructureRedirectMask,   /* MapRequest		*/
-	StructureNotifyMask	    /* ReparentNotify		*/
-		| SubstructureNotifyMask,
-	StructureNotifyMask	    /* ConfigureNotify		*/
-		| SubstructureNotifyMask,
-	SubstructureRedirectMask,   /* ConfigureRequest		*/
-	StructureNotifyMask	    /* GravityNotify		*/
-		| SubstructureNotifyMask,
-	ResizeRedirectMask,	    /* ResizeRequest		*/
-	StructureNotifyMask	    /* CirculateNotify		*/
-		| SubstructureNotifyMask,
-	SubstructureRedirectMask,   /* CirculateRequest		*/
-	PropertyChangeMask,	    /* PropertyNotify		*/
-	NonMaskableMask,	    /* SelectionClear		*/
-	NonMaskableMask,	    /* SelectionRequest		*/
-	NonMaskableMask,	    /* SelectionNotify		*/
-	ColormapChangeMask,	    /* ColormapNotify		*/
-	NonMaskableMask,	    /* ClientMessage		*/
-	NonMaskableMask		    /* MappingNotify		*/
+    0,                          /* Error, should never see  */
+    0,                          /* Reply, should never see  */
+    KeyPressMask,               /* KeyPress                 */
+    KeyReleaseMask,             /* KeyRelease               */
+    ButtonPressMask,            /* ButtonPress              */
+    ButtonReleaseMask,          /* ButtonRelease            */
+    PointerMotionMask           /* MotionNotify             */
+        | ButtonMotionMask,
+    EnterWindowMask,            /* EnterNotify              */
+    LeaveWindowMask,            /* LeaveNotify              */
+    FocusChangeMask,            /* FocusIn                  */
+    FocusChangeMask,            /* FocusOut                 */
+    KeymapStateMask,            /* KeymapNotify             */
+    ExposureMask,               /* Expose                   */
+    NonMaskableMask,            /* GraphicsExpose, in GC    */
+    NonMaskableMask,            /* NoExpose, in GC          */
+    VisibilityChangeMask,       /* VisibilityNotify         */
+    SubstructureNotifyMask,     /* CreateNotify             */
+    StructureNotifyMask         /* DestroyNotify            */
+        | SubstructureNotifyMask,
+    StructureNotifyMask         /* UnmapNotify              */
+        | SubstructureNotifyMask,
+    StructureNotifyMask         /* MapNotify                */
+        | SubstructureNotifyMask,
+    SubstructureRedirectMask,   /* MapRequest               */
+    StructureNotifyMask         /* ReparentNotify           */
+        | SubstructureNotifyMask,
+    StructureNotifyMask         /* ConfigureNotify          */
+        | SubstructureNotifyMask,
+    SubstructureRedirectMask,   /* ConfigureRequest         */
+    StructureNotifyMask         /* GravityNotify            */
+        | SubstructureNotifyMask,
+    ResizeRedirectMask,         /* ResizeRequest            */
+    StructureNotifyMask         /* CirculateNotify          */
+        | SubstructureNotifyMask,
+    SubstructureRedirectMask,   /* CirculateRequest         */
+    PropertyChangeMask,         /* PropertyNotify           */
+    NonMaskableMask,            /* SelectionClear           */
+    NonMaskableMask,            /* SelectionRequest         */
+    NonMaskableMask,            /* SelectionNotify          */
+    ColormapChangeMask,         /* ColormapNotify           */
+    NonMaskableMask,            /* ClientMessage            */
+    NonMaskableMask             /* MappingNotify            */
 };
 
-EventMask _XtConvertTypeToMask (
-    int		eventType)
+EventMask
+_XtConvertTypeToMask(int eventType)
 {
     if ((Cardinal) eventType < XtNumber(masks))
-	return masks[eventType];
+        return masks[eventType];
     else
-	return NoEventMask;
+        return NoEventMask;
 }
 
-Boolean _XtOnGrabList(
-    register Widget widget,
-    XtGrabRec  *grabList)
+Boolean
+_XtOnGrabList(register Widget widget, XtGrabRec *grabList)
 {
-    register XtGrabRec* gl;
-    for (; widget != NULL; widget = (Widget)widget->core.parent) {
-	for (gl = grabList; gl != NULL; gl = gl->next) {
-	    if (gl->widget == widget) return TRUE;
-	    if (gl->exclusive) break;
-	}
+    register XtGrabRec *gl;
+
+    for (; widget != NULL; widget = (Widget) widget->core.parent) {
+        for (gl = grabList; gl != NULL; gl = gl->next) {
+            if (gl->widget == widget)
+                return TRUE;
+            if (gl->exclusive)
+                break;
+        }
     }
     return FALSE;
 }
 
-static Widget LookupSpringLoaded(
-    XtGrabList	grabList)
+static Widget
+LookupSpringLoaded(XtGrabList grabList)
 {
-    XtGrabList	gl;
+    XtGrabList gl;
 
     for (gl = grabList; gl != NULL; gl = gl->next) {
-	if (gl->spring_loaded) {
-	  if (XtIsSensitive(gl->widget))
-	    return gl->widget;
-	  else
-	    return NULL;
-	}
-	if (gl->exclusive) break;
+        if (gl->spring_loaded) {
+            if (XtIsSensitive(gl->widget))
+                return gl->widget;
+            else
+                return NULL;
+        }
+        if (gl->exclusive)
+            break;
     }
     return NULL;
 }
 
-static Boolean DispatchEvent(
-    XEvent* event,
-    Widget widget)
+static Boolean
+DispatchEvent(XEvent *event, Widget widget)
 {
 
     if (event->type == EnterNotify &&
-	event->xcrossing.mode == NotifyNormal &&
-	widget->core.widget_class->core_class.compress_enterleave) {
-	if (XPending(event->xcrossing.display)) {
-	    XEvent nextEvent;
-	    XPeekEvent(event->xcrossing.display, &nextEvent);
-	    if (nextEvent.type == LeaveNotify &&
-		event->xcrossing.window == nextEvent.xcrossing.window &&
-		nextEvent.xcrossing.mode == NotifyNormal &&
-		((event->xcrossing.detail != NotifyInferior &&
-		 nextEvent.xcrossing.detail != NotifyInferior) ||
-		 (event->xcrossing.detail == NotifyInferior &&
-		 nextEvent.xcrossing.detail == NotifyInferior))) {
-		/* skip the enter/leave pair */
-		XNextEvent(event->xcrossing.display, &nextEvent);
-		return False;
-	    }
-	}
+        event->xcrossing.mode == NotifyNormal &&
+        widget->core.widget_class->core_class.compress_enterleave) {
+        if (XPending(event->xcrossing.display)) {
+            XEvent nextEvent;
+            XPeekEvent(event->xcrossing.display, &nextEvent);
+
+            if (nextEvent.type == LeaveNotify &&
+                event->xcrossing.window == nextEvent.xcrossing.window &&
+                nextEvent.xcrossing.mode == NotifyNormal &&
+                ((event->xcrossing.detail != NotifyInferior &&
+                  nextEvent.xcrossing.detail != NotifyInferior) ||
+                 (event->xcrossing.detail == NotifyInferior &&
+                  nextEvent.xcrossing.detail == NotifyInferior))) {
+                /* skip the enter/leave pair */
+                XNextEvent(event->xcrossing.display, &nextEvent);
+
+                return False;
+            }
+        }
     }
 
     if (event->type == MotionNotify &&
-	    widget->core.widget_class->core_class.compress_motion) {
-	while (XPending(event->xmotion.display)) {
-	    XEvent nextEvent;
-	    XPeekEvent(event->xmotion.display, &nextEvent);
-	    if (nextEvent.type == MotionNotify &&
-		    event->xmotion.window == nextEvent.xmotion.window &&
-		    event->xmotion.subwindow == nextEvent.xmotion.subwindow) {
-		/* replace the current event with the next one */
-		XNextEvent(event->xmotion.display, event);
-	    } else break;
-	}
+        widget->core.widget_class->core_class.compress_motion) {
+        while (XPending(event->xmotion.display)) {
+            XEvent nextEvent;
+            XPeekEvent(event->xmotion.display, &nextEvent);
+
+            if (nextEvent.type == MotionNotify &&
+                event->xmotion.window == nextEvent.xmotion.window &&
+                event->xmotion.subwindow == nextEvent.xmotion.subwindow) {
+                /* replace the current event with the next one */
+                XNextEvent(event->xmotion.display, event);
+            }
+            else
+                break;
+        }
     }
 
     return XtDispatchEventToWidget(widget, event);
 }
 
-typedef enum _GrabType {pass, ignore, remap} GrabType;
+typedef enum _GrabType { pass, ignore, remap } GrabType;
 
 #if !defined(AIXV3) || !defined(AIXSHLIB)
-static /* AIX shared libraries are broken */
+static                          /* AIX shared libraries are broken */
 #endif
-Boolean _XtDefaultDispatcher(
-    XEvent  *event)
+Boolean
+_XtDefaultDispatcher(XEvent *event)
 {
-    register    Widget widget;
-    GrabType    grabType;
+    register Widget widget;
+    GrabType grabType;
     XtPerDisplayInput pdi;
-    XtGrabList  grabList;
-    Boolean	was_dispatched = False;
+    XtGrabList grabList;
+    Boolean was_dispatched = False;
     DPY_TO_APPCON(event->xany.display);
 
     /* the default dispatcher discards all extension events */
     if (event->type >= LASTEvent)
-	return False;
+        return False;
 
     LOCK_APP(app);
 
     switch (event->type) {
-      case KeyPress:
-      case KeyRelease:
-      case ButtonPress:
-      case ButtonRelease:	grabType = remap;	break;
-      case MotionNotify:
-      case EnterNotify:		grabType = ignore;	break;
-      default:			grabType = pass;	break;
+    case KeyPress:
+    case KeyRelease:
+    case ButtonPress:
+    case ButtonRelease:
+        grabType = remap;
+        break;
+    case MotionNotify:
+    case EnterNotify:
+        grabType = ignore;
+        break;
+    default:
+        grabType = pass;
+        break;
     }
 
-    widget = XtWindowToWidget (event->xany.display, event->xany.window);
+    widget = XtWindowToWidget(event->xany.display, event->xany.window);
     pdi = _XtGetPerDisplayInput(event->xany.display);
+
     grabList = *_XtGetGrabList(pdi);
 
     if (widget == NULL) {
-	if (grabType == remap
-	    && (widget = LookupSpringLoaded(grabList)) != NULL) {
-	    /* event occurred in a non-widget window, but we've promised also
-	       to dispatch it to the nearest accessible spring_loaded widget */
-	    was_dispatched = (XFilterEvent(event, XtWindow(widget))
-			      || XtDispatchEventToWidget(widget, event));
-	}
-	else was_dispatched = (Boolean) XFilterEvent(event, None);
+        if (grabType == remap
+            && (widget = LookupSpringLoaded(grabList)) != NULL) {
+            /* event occurred in a non-widget window, but we've promised also
+               to dispatch it to the nearest accessible spring_loaded widget */
+            was_dispatched = (XFilterEvent(event, XtWindow(widget))
+                              || XtDispatchEventToWidget(widget, event));
+        }
+        else
+            was_dispatched = (Boolean) XFilterEvent(event, None);
     }
     else if (grabType == pass) {
-	if (event->type == LeaveNotify ||
-	    event->type == FocusIn ||
-	    event->type == FocusOut) {
-		if (XtIsSensitive (widget))
-		    was_dispatched = (XFilterEvent(event, XtWindow(widget)) ||
-				      XtDispatchEventToWidget(widget, event));
-	    } else was_dispatched = (XFilterEvent(event, XtWindow(widget)) ||
-				     XtDispatchEventToWidget(widget, event));
+        if (event->type == LeaveNotify ||
+            event->type == FocusIn || event->type == FocusOut) {
+            if (XtIsSensitive(widget))
+                was_dispatched = (XFilterEvent(event, XtWindow(widget)) ||
+                                  XtDispatchEventToWidget(widget, event));
+        }
+        else
+            was_dispatched = (XFilterEvent(event, XtWindow(widget)) ||
+                              XtDispatchEventToWidget(widget, event));
     }
     else if (grabType == ignore) {
-	if ((grabList == NULL || _XtOnGrabList(widget, grabList))
-	    && XtIsSensitive(widget)) {
-	    was_dispatched = (XFilterEvent(event, XtWindow(widget))
-			      || DispatchEvent(event, widget));
-	}
+        if ((grabList == NULL || _XtOnGrabList(widget, grabList))
+            && XtIsSensitive(widget)) {
+            was_dispatched = (XFilterEvent(event, XtWindow(widget))
+                              || DispatchEvent(event, widget));
+        }
     }
     else if (grabType == remap) {
-	EventMask	mask = _XtConvertTypeToMask(event->type);
-	Widget		dspWidget;
-	Boolean		was_filtered = False;
-
-	dspWidget = _XtFindRemapWidget(event, widget, mask, pdi);
-
-	if ((grabList == NULL ||_XtOnGrabList(dspWidget, grabList))
-	    && XtIsSensitive(dspWidget)) {
-	    if ((was_filtered = (Boolean) XFilterEvent(event, XtWindow(dspWidget)))) {
-		/* If this event activated a device grab, release it. */
-		_XtUngrabBadGrabs(event, widget, mask, pdi);
-		was_dispatched = True;
-	    } else
-		was_dispatched = XtDispatchEventToWidget(dspWidget, event);
-	}
-	else _XtUngrabBadGrabs(event, widget, mask, pdi);
-
-	if (!was_filtered) {
-	    /* Also dispatch to nearest accessible spring_loaded. */
-	    /* Fetch this afterward to reflect modal list changes */
-	    grabList = *_XtGetGrabList(pdi);
-	    widget = LookupSpringLoaded(grabList);
-	    if (widget != NULL && widget != dspWidget) {
-		was_dispatched = (XFilterEvent(event, XtWindow(widget))
-				  || XtDispatchEventToWidget(widget, event)
-				  || was_dispatched);
-	    }
-	}
+        EventMask mask = _XtConvertTypeToMask(event->type);
+        Widget dspWidget;
+        Boolean was_filtered = False;
+
+        dspWidget = _XtFindRemapWidget(event, widget, mask, pdi);
+
+        if ((grabList == NULL || _XtOnGrabList(dspWidget, grabList))
+            && XtIsSensitive(dspWidget)) {
+            if ((was_filtered =
+                 (Boolean) XFilterEvent(event, XtWindow(dspWidget)))) {
+                /* If this event activated a device grab, release it. */
+                _XtUngrabBadGrabs(event, widget, mask, pdi);
+                was_dispatched = True;
+            }
+            else
+                was_dispatched = XtDispatchEventToWidget(dspWidget, event);
+        }
+        else
+            _XtUngrabBadGrabs(event, widget, mask, pdi);
+
+        if (!was_filtered) {
+            /* Also dispatch to nearest accessible spring_loaded. */
+            /* Fetch this afterward to reflect modal list changes */
+            grabList = *_XtGetGrabList(pdi);
+            widget = LookupSpringLoaded(grabList);
+            if (widget != NULL && widget != dspWidget) {
+                was_dispatched = (XFilterEvent(event, XtWindow(widget))
+                                  || XtDispatchEventToWidget(widget, event)
+                                  || was_dispatched);
+            }
+        }
     }
     UNLOCK_APP(app);
     return was_dispatched;
 }
 
-Boolean XtDispatchEvent (
-    XEvent  *event)
+Boolean
+XtDispatchEvent(XEvent *event)
 {
     Boolean was_dispatched, safe;
     int dispatch_level;
     int starting_count;
     XtPerDisplay pd;
-    Time	time = 0;
+    Time time = 0;
     XtEventDispatchProc dispatch = _XtDefaultDispatcher;
     XtAppContext app = XtDisplayToApplicationContext(event->xany.display);
 
@@ -1393,27 +1440,44 @@ Boolean XtDispatchEvent (
     starting_count = app->destroy_count;
 
     switch (event->type) {
-      case KeyPress:
-      case KeyRelease:	   time = event->xkey.time;		break;
-      case ButtonPress:
-      case ButtonRelease:  time = event->xbutton.time;		break;
-      case MotionNotify:   time = event->xmotion.time;		break;
-      case EnterNotify:
-      case LeaveNotify:	   time = event->xcrossing.time;	break;
-      case PropertyNotify: time = event->xproperty.time;	break;
-      case SelectionClear: time = event->xselectionclear.time;	break;
-
-      case MappingNotify:  _XtRefreshMapping(event, True);	break;
+    case KeyPress:
+    case KeyRelease:
+        time = event->xkey.time;
+        break;
+    case ButtonPress:
+    case ButtonRelease:
+        time = event->xbutton.time;
+        break;
+    case MotionNotify:
+        time = event->xmotion.time;
+        break;
+    case EnterNotify:
+    case LeaveNotify:
+        time = event->xcrossing.time;
+        break;
+    case PropertyNotify:
+        time = event->xproperty.time;
+        break;
+    case SelectionClear:
+        time = event->xselectionclear.time;
+        break;
+
+    case MappingNotify:
+        _XtRefreshMapping(event, True);
+        break;
     }
     pd = _XtGetPerDisplay(event->xany.display);
-    if (time) pd->last_timestamp = time;
+
+    if (time)
+        pd->last_timestamp = time;
     pd->last_event = *event;
 
     if (pd->dispatcher_list) {
-	dispatch = pd->dispatcher_list[event->type];
-	if (dispatch == NULL) dispatch = _XtDefaultDispatcher;
+        dispatch = pd->dispatcher_list[event->type];
+        if (dispatch == NULL)
+            dispatch = _XtDefaultDispatcher;
     }
-    was_dispatched = (*dispatch)(event);
+    was_dispatched = (*dispatch) (event);
 
     /*
      * To make recursive XtDispatchEvent work, we need to do phase 2 destroys
@@ -1422,54 +1486,52 @@ Boolean XtDispatchEvent (
      */
 
     if (app->destroy_count > starting_count)
-	_XtDoPhase2Destroy(app, dispatch_level);
+        _XtDoPhase2Destroy(app, dispatch_level);
 
     app->dispatch_level = dispatch_level - 1;
 
     if ((safe = _XtSafeToDestroy(app))) {
-	if (app->dpy_destroy_count != 0) _XtCloseDisplays(app);
-	if (app->free_bindings) _XtDoFreeBindings(app);
+        if (app->dpy_destroy_count != 0)
+            _XtCloseDisplays(app);
+        if (app->free_bindings)
+            _XtDoFreeBindings(app);
     }
     UNLOCK_APP(app);
     LOCK_PROCESS;
-    if (_XtAppDestroyCount != 0 && safe) _XtDestroyAppContexts();
+    if (_XtAppDestroyCount != 0 && safe)
+        _XtDestroyAppContexts();
     UNLOCK_PROCESS;
     return was_dispatched;
 }
 
-/* ARGSUSED */
-static void GrabDestroyCallback(
-    Widget  widget,
-    XtPointer closure,
-    XtPointer call_data)
+static void
+GrabDestroyCallback(Widget widget,
+                    XtPointer closure _X_UNUSED,
+                    XtPointer call_data _X_UNUSED)
 {
     /* Remove widget from grab list if it destroyed */
     XtRemoveGrab(widget);
 }
 
-static XtGrabRec *NewGrabRec(
-    Widget  widget,
-    Boolean exclusive,
-    Boolean spring_loaded)
+static XtGrabRec *
+NewGrabRec(Widget widget, Boolean exclusive, Boolean spring_loaded)
 {
-    register XtGrabList    gl;
+    register XtGrabList gl;
 
-    gl		      = XtNew(XtGrabRec);
-    gl->next	      = NULL;
-    gl->widget        = widget;
-    XtSetBit(gl->exclusive,     exclusive);
+    gl = XtNew(XtGrabRec);
+    gl->next = NULL;
+    gl->widget = widget;
+    XtSetBit(gl->exclusive, exclusive);
     XtSetBit(gl->spring_loaded, spring_loaded);
 
     return gl;
 }
 
-void XtAddGrab(
-    Widget  widget,
-    _XtBoolean exclusive,
-    _XtBoolean spring_loaded)
+void
+XtAddGrab(Widget widget, _XtBoolean exclusive, _XtBoolean spring_loaded)
 {
-    register    XtGrabList gl;
-    XtGrabList	*grabListPtr;
+    register XtGrabList gl;
+    XtGrabList *grabListPtr;
     XtAppContext app = XtWidgetToApplicationContext(widget);
 
     LOCK_APP(app);
@@ -1477,29 +1539,29 @@ void XtAddGrab(
     grabListPtr = _XtGetGrabList(_XtGetPerDisplayInput(XtDisplay(widget)));
 
     if (spring_loaded && !exclusive) {
-	XtAppWarningMsg(app,
-		"grabError", "xtAddGrab", XtCXtToolkitError,
-		"XtAddGrab requires exclusive grab if spring_loaded is TRUE",
-		NULL, NULL);
-	exclusive = TRUE;
+        XtAppWarningMsg(app,
+                        "grabError", "xtAddGrab", XtCXtToolkitError,
+                        "XtAddGrab requires exclusive grab if spring_loaded is TRUE",
+                        NULL, NULL);
+        exclusive = TRUE;
     }
 
     gl = NewGrabRec(widget, (Boolean) exclusive, (Boolean) spring_loaded);
     gl->next = *grabListPtr;
     *grabListPtr = gl;
 
-    XtAddCallback (widget, XtNdestroyCallback,
-	    GrabDestroyCallback, (XtPointer) NULL);
+    XtAddCallback(widget, XtNdestroyCallback,
+                  GrabDestroyCallback, (XtPointer) NULL);
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void XtRemoveGrab(
-    Widget  widget)
+void
+XtRemoveGrab(Widget widget)
 {
     register XtGrabList gl;
     register Boolean done;
-    XtGrabList	*grabListPtr;
+    XtGrabList *grabListPtr;
     XtAppContext app = XtWidgetToApplicationContext(widget);
 
     LOCK_APP(app);
@@ -1508,139 +1570,149 @@ void XtRemoveGrab(
     grabListPtr = _XtGetGrabList(_XtGetPerDisplayInput(XtDisplay(widget)));
 
     for (gl = *grabListPtr; gl != NULL; gl = gl->next) {
-	if (gl->widget == widget) break;
+        if (gl->widget == widget)
+            break;
     }
 
     if (gl == NULL) {
-	    XtAppWarningMsg(app,
-		       "grabError","xtRemoveGrab",XtCXtToolkitError,
-		       "XtRemoveGrab asked to remove a widget not on the list",
-		       NULL, NULL);
-	    UNLOCK_PROCESS;
-    	    UNLOCK_APP(app);
-	    return;
-	}
+        XtAppWarningMsg(app,
+                        "grabError", "xtRemoveGrab", XtCXtToolkitError,
+                        "XtRemoveGrab asked to remove a widget not on the list",
+                        NULL, NULL);
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return;
+    }
 
     do {
-	gl = *grabListPtr;
-	done = (gl->widget == widget);
-	*grabListPtr = gl->next;
-	XtRemoveCallback(gl->widget, XtNdestroyCallback,
-		GrabDestroyCallback, (XtPointer)NULL);
-	XtFree((char *)gl);
-    } while (! done);
+        gl = *grabListPtr;
+        done = (gl->widget == widget);
+        *grabListPtr = gl->next;
+        XtRemoveCallback(gl->widget, XtNdestroyCallback,
+                         GrabDestroyCallback, (XtPointer) NULL);
+        XtFree((char *) gl);
+    } while (!done);
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return;
 }
 
-void XtMainLoop(void)
+void
+XtMainLoop(void)
 {
-	XtAppMainLoop(_XtDefaultAppContext());
+    XtAppMainLoop(_XtDefaultAppContext());
 }
 
-void XtAppMainLoop(
-	XtAppContext app)
+void
+XtAppMainLoop(XtAppContext app)
 {
     XtInputMask m = XtIMAll;
     XtInputMask t;
+
     LOCK_APP(app);
     do {
-	if (m == 0) {
-	    m = XtIMAll;
-	    /* wait for any event, blocking */
-	    XtAppProcessEvent(app, m);
-	} else if (((t = XtAppPending(app)) & m)) {
-	    /* wait for certain events, stepping through choices */
-	    XtAppProcessEvent(app, t & m);
-	}
-	m >>= 1;
-    } while(app->exit_flag == FALSE);
+        if (m == 0) {
+            m = XtIMAll;
+            /* wait for any event, blocking */
+            XtAppProcessEvent(app, m);
+        }
+        else if (((t = XtAppPending(app)) & m)) {
+            /* wait for certain events, stepping through choices */
+            XtAppProcessEvent(app, t & m);
+        }
+        m >>= 1;
+    } while (app->exit_flag == FALSE);
     UNLOCK_APP(app);
 }
 
-void _XtFreeEventTable(
-    XtEventTable *event_table)
+void
+_XtFreeEventTable(XtEventTable *event_table)
 {
     register XtEventTable event;
 
     event = *event_table;
     while (event != NULL) {
-	register XtEventTable next = event->next;
-	XtFree((char *) event);
-	event = next;
+        register XtEventTable next = event->next;
+
+        XtFree((char *) event);
+        event = next;
     }
 }
 
-Time XtLastTimestampProcessed(
-    Display *dpy)
+Time
+XtLastTimestampProcessed(Display *dpy)
 {
     Time time;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     LOCK_PROCESS;
-    time =  _XtGetPerDisplay(dpy)->last_timestamp;
+    time = _XtGetPerDisplay(dpy)->last_timestamp;
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
-    return(time);
+    return (time);
 }
 
-XEvent* XtLastEventProcessed(
-    Display* dpy)
+XEvent *
+XtLastEventProcessed(Display *dpy)
 {
-    XEvent* le = NULL;
+    XEvent *le = NULL;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     le = &_XtGetPerDisplay(dpy)->last_event;
     if (!le->xany.serial)
-	le =  NULL;
+        le = NULL;
     UNLOCK_APP(app);
     return le;
 }
 
-void _XtSendFocusEvent(
-    Widget child,
-    int type)
+void
+_XtSendFocusEvent(Widget child, int type)
 {
     child = XtIsWidget(child) ? child : _XtWindowedAncestor(child);
     if (XtIsSensitive(child) && !child->core.being_destroyed
-	&& XtIsRealized(child)
-	&& (XtBuildEventMask(child) & FocusChangeMask))
-    {
-	XFocusChangeEvent event;
-	Display* dpy = XtDisplay (child);
-
-	event.type = type;
-	event.serial = LastKnownRequestProcessed(dpy);
-	event.send_event = True;
-	event.display = dpy;
-	event.window = XtWindow(child);
-	event.mode = NotifyNormal;
-	event.detail = NotifyAncestor;
-	if (XFilterEvent((XEvent*)&event, XtWindow(child)))
-	    return;
-	XtDispatchEventToWidget(child, (XEvent*)&event);
+        && XtIsRealized(child)
+        && (XtBuildEventMask(child) & FocusChangeMask)) {
+        XFocusChangeEvent event;
+        Display *dpy = XtDisplay(child);
+
+        event.type = type;
+        event.serial = LastKnownRequestProcessed(dpy);
+        event.send_event = True;
+        event.display = dpy;
+
+        event.window = XtWindow(child);
+        event.mode = NotifyNormal;
+        event.detail = NotifyAncestor;
+        if (XFilterEvent((XEvent *) &event, XtWindow(child)))
+            return;
+        XtDispatchEventToWidget(child, (XEvent *) &event);
     }
 }
 
-static XtEventDispatchProc* NewDispatcherList(void)
+static XtEventDispatchProc *
+NewDispatcherList(void)
 {
-    XtEventDispatchProc* l =
-	(XtEventDispatchProc*) __XtCalloc((Cardinal) 128,
-					(Cardinal)sizeof(XtEventDispatchProc));
+    XtEventDispatchProc *l = (XtEventDispatchProc *)
+        __XtCalloc((Cardinal) 128,
+                   (Cardinal)
+                   sizeof(XtEventDispatchProc));
+
     return l;
 }
 
-XtEventDispatchProc XtSetEventDispatcher(
-    Display		*dpy,
-    int			event_type,
-    XtEventDispatchProc	proc)
+XtEventDispatchProc
+XtSetEventDispatcher(Display *dpy,
+                     int event_type,
+                     XtEventDispatchProc proc)
 {
     XtEventDispatchProc *list;
     XtEventDispatchProc old_proc;
     register XtPerDisplay pd;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
@@ -1649,32 +1721,37 @@ XtEventDispatchProc XtSetEventDispatcher(
 
     list = pd->dispatcher_list;
     if (!list) {
-	if (proc) list = pd->dispatcher_list = NewDispatcherList();
-	else return _XtDefaultDispatcher;
+        if (proc)
+            list = pd->dispatcher_list = NewDispatcherList();
+        else
+            return _XtDefaultDispatcher;
     }
     old_proc = list[event_type];
     list[event_type] = proc;
-    if (old_proc == NULL) old_proc = _XtDefaultDispatcher;
+    if (old_proc == NULL)
+        old_proc = _XtDefaultDispatcher;
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return old_proc;
 }
 
-void XtRegisterExtensionSelector(
-    Display		*dpy,
-    int			min_event_type,
-    int			max_event_type,
-    XtExtensionSelectProc	proc,
-    XtPointer 		client_data)
+void
+XtRegisterExtensionSelector(Display *dpy,
+                            int min_event_type,
+                            int max_event_type,
+                            XtExtensionSelectProc proc,
+                            XtPointer client_data)
 {
     XtPerDisplay pd;
     int i;
+
     DPY_TO_APPCON(dpy);
 
-    if (dpy == NULL) XtErrorMsg("nullDisplay",
-		"xtRegisterExtensionSelector", XtCXtToolkitError,
-		"XtRegisterExtensionSelector requires a non-NULL display",
-		NULL, NULL);
+    if (dpy == NULL)
+        XtErrorMsg("nullDisplay",
+                   "xtRegisterExtensionSelector", XtCXtToolkitError,
+                   "XtRegisterExtensionSelector requires a non-NULL display",
+                   NULL, NULL);
 
     LOCK_APP(app);
     LOCK_PROCESS;
@@ -1682,30 +1759,34 @@ void XtRegisterExtensionSelector(
 
     for (i = 0; i < pd->ext_select_count; i++) {
         ExtSelectRec *e = &pd->ext_select_list[i];
-	if (e->min == min_event_type && e->max == max_event_type) {
-	    e->proc = proc;
-	    e->client_data = client_data;
-	    return;
-	}
-	if ((min_event_type >= e->min && min_event_type <= e->max) ||
-	    (max_event_type >= e->min && max_event_type <= e->max)) {
-	    XtErrorMsg("rangeError", "xtRegisterExtensionSelector",
-		       XtCXtToolkitError,
-	"Attempt to register multiple selectors for one extension event type",
-		       NULL, NULL);
-	    UNLOCK_PROCESS;
-	    UNLOCK_APP(app);
-	    return;
-	}
+
+        if (e->min == min_event_type && e->max == max_event_type) {
+            e->proc = proc;
+            e->client_data = client_data;
+            return;
+        }
+        if ((min_event_type >= e->min && min_event_type <= e->max) ||
+            (max_event_type >= e->min && max_event_type <= e->max)) {
+            XtErrorMsg("rangeError", "xtRegisterExtensionSelector",
+                       XtCXtToolkitError,
+                       "Attempt to register multiple selectors for one extension event type",
+                       NULL, NULL);
+            UNLOCK_PROCESS;
+            UNLOCK_APP(app);
+            return;
+        }
     }
     pd->ext_select_count++;
     pd->ext_select_list =
-	    (ExtSelectRec *) XtRealloc((char *) pd->ext_select_list,
-		       (Cardinal) ((size_t)pd->ext_select_count * sizeof(ExtSelectRec)));
+        (ExtSelectRec *) XtRealloc((char *) pd->ext_select_list,
+                                   (Cardinal) ((size_t) pd->ext_select_count *
+                                               sizeof(ExtSelectRec)));
     for (i = pd->ext_select_count - 1; i > 0; i--) {
-	if (pd->ext_select_list[i-1].min > min_event_type) {
-	    pd->ext_select_list[i] = pd->ext_select_list[i-1];
-	} else break;
+        if (pd->ext_select_list[i - 1].min > min_event_type) {
+            pd->ext_select_list[i] = pd->ext_select_list[i - 1];
+        }
+        else
+            break;
     }
     pd->ext_select_list[i].min = min_event_type;
     pd->ext_select_list[i].max = max_event_type;
@@ -1715,11 +1796,12 @@ void XtRegisterExtensionSelector(
     UNLOCK_APP(app);
 }
 
-void _XtExtensionSelect(
-    Widget widget)
+void
+_XtExtensionSelect(Widget widget)
 {
     int i;
     XtPerDisplay pd;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -1728,7 +1810,7 @@ void _XtExtensionSelect(
     pd = _XtGetPerDisplay(XtDisplay(widget));
 
     for (i = 0; i < pd->ext_select_count; i++) {
-	CallExtensionSelector(widget, pd->ext_select_list+i, FALSE);
+        CallExtensionSelector(widget, pd->ext_select_list + i, FALSE);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
diff --git a/src/EventUtil.c b/src/EventUtil.c
index 4dcbbc6..848cead 100644
--- a/src/EventUtil.c
+++ b/src/EventUtil.c
@@ -80,18 +80,15 @@ in this Software without prior written authorization from The Open Group.
 #include "StringDefs.h"
 #include "EventI.h"
 
-static XContext 	perWidgetInputContext = 0;
+static XContext perWidgetInputContext = 0;
 
-void _XtFreePerWidgetInput(
-    Widget 		w,
-    XtPerWidgetInput	pwi)
+void
+_XtFreePerWidgetInput(Widget w, XtPerWidgetInput pwi)
 {
     LOCK_PROCESS;
-    XDeleteContext(XtDisplay(w),
-		   (Window)w,
-		   perWidgetInputContext);
+    XDeleteContext(XtDisplay(w), (Window) w, perWidgetInputContext);
 
-    XtFree((char *)pwi);
+    XtFree((char *) pwi);
     UNLOCK_PROCESS;
 }
 
@@ -99,134 +96,120 @@ void _XtFreePerWidgetInput(
  * This routine gets the passive list associated with the widget
  * from the context manager.
  */
-XtPerWidgetInput _XtGetPerWidgetInput(
-    Widget	widget,
-    _XtBoolean	create)
+XtPerWidgetInput
+_XtGetPerWidgetInput(Widget widget, _XtBoolean create)
 {
-    XtPerWidgetInput	pwi = NULL;
-    Display		*dpy = widget->core.screen->display;
+    XtPerWidgetInput pwi = NULL;
+    Display *dpy = widget->core.screen->display;
 
     LOCK_PROCESS;
-    if (! perWidgetInputContext)
-      perWidgetInputContext = XUniqueContext();
+    if (!perWidgetInputContext)
+        perWidgetInputContext = XUniqueContext();
 
     if (XFindContext(dpy,
-		     (Window)widget,
-		     perWidgetInputContext,
-		     (XPointer *)&pwi) &&
-	create)
-      {
-	  pwi = (XtPerWidgetInput)
-	    __XtMalloc((unsigned) sizeof(XtPerWidgetInputRec));
-
-	  pwi->focusKid = NULL;
-	  pwi->queryEventDescendant = NULL;
-	  pwi->focalPoint = XtUnrelated;
-	  pwi->keyList =
-	    pwi->ptrList = NULL;
-
-	  pwi->haveFocus =
-	      pwi->map_handler_added =
-		  pwi->realize_handler_added =
-		      pwi->active_handler_added = FALSE;
-
-	  XtAddCallback(widget, XtNdestroyCallback,
-			_XtDestroyServerGrabs, (XtPointer)pwi);
-
-	  (void) XSaveContext(dpy,
-			      (Window)widget,
-			      perWidgetInputContext,
-			      (char *) pwi);
-      }
+                     (Window) widget,
+                     perWidgetInputContext, (XPointer *) &pwi) && create) {
+        pwi = (XtPerWidgetInput)
+            __XtMalloc((unsigned) sizeof(XtPerWidgetInputRec));
+
+        pwi->focusKid = NULL;
+        pwi->queryEventDescendant = NULL;
+        pwi->focalPoint = XtUnrelated;
+        pwi->keyList = pwi->ptrList = NULL;
+
+        pwi->haveFocus =
+            pwi->map_handler_added =
+            pwi->realize_handler_added = pwi->active_handler_added = FALSE;
+
+        XtAddCallback(widget, XtNdestroyCallback,
+                      _XtDestroyServerGrabs, (XtPointer) pwi);
+
+        (void) XSaveContext(dpy,
+                            (Window) widget,
+                            perWidgetInputContext, (char *) pwi);
+    }
     UNLOCK_PROCESS;
     return pwi;
 }
 
-
-void _XtFillAncestorList(
-    Widget	**listPtr,
-    int		*maxElemsPtr,
-    int		*numElemsPtr,
-    Widget	start,
-    Widget	breakWidget)
+void
+_XtFillAncestorList(Widget **listPtr,
+                    int *maxElemsPtr,
+                    int *numElemsPtr,
+                    Widget start,
+                    Widget breakWidget)
 {
 #define CACHESIZE 16
-    Cardinal	i;
-    Widget	w;
-    Widget	*trace = *listPtr;
+    Cardinal i;
+    Widget w;
+    Widget *trace = *listPtr;
 
     /* First time in, allocate the ancestor list */
-    if (trace == NULL)
-      {
-	  trace = (Widget *) __XtMalloc(CACHESIZE * sizeof(Widget));
-	  *maxElemsPtr = CACHESIZE;
-      }
+    if (trace == NULL) {
+        trace = (Widget *) __XtMalloc(CACHESIZE * sizeof(Widget));
+        *maxElemsPtr = CACHESIZE;
+    }
     /* First fill in the ancestor list */
 
     trace[0] = start;
 
     for (i = 1, w = XtParent(start);
-	 w != NULL && !XtIsShell(trace[i-1]) && trace[i-1] != breakWidget;
-	 w = XtParent(w), i++) {
-	if (i == (Cardinal) *maxElemsPtr) {
-	    /* This should rarely happen, but if it does it'll probably
-	       happen again, so grow the ancestor list */
-	    *maxElemsPtr += CACHESIZE;
-	    trace = (Widget *) XtRealloc((char*)trace,
-					 (Cardinal)(sizeof(Widget) * (size_t)(*maxElemsPtr)));
-	}
-	trace[i] = w;
+         w != NULL && !XtIsShell(trace[i - 1]) && trace[i - 1] != breakWidget;
+         w = XtParent(w), i++) {
+        if (i == (Cardinal) *maxElemsPtr) {
+            /* This should rarely happen, but if it does it'll probably
+               happen again, so grow the ancestor list */
+            *maxElemsPtr += CACHESIZE;
+            trace = (Widget *) XtRealloc((char *) trace,
+                                         (Cardinal) (sizeof(Widget) *
+                                                     (size_t) (*maxElemsPtr)));
+        }
+        trace[i] = w;
     }
     *listPtr = trace;
     *numElemsPtr = (int) i;
 #undef CACHESIZE
 }
 
-
-Widget _XtFindRemapWidget(
-    XEvent	*event,
-    Widget	widget,
-    EventMask	mask,
-    XtPerDisplayInput pdi)
+Widget
+_XtFindRemapWidget(XEvent *event,
+                   Widget widget,
+                   EventMask mask,
+                   XtPerDisplayInput pdi)
 {
-    Widget		dspWidget = widget;
-
-    if (!pdi->traceDepth || !(widget == pdi->trace[0]))
-      {
-	  _XtFillAncestorList(&pdi->trace, &pdi->traceMax,
-			      &pdi->traceDepth, widget, NULL);
-	  pdi->focusWidget = NULL; /* invalidate the focus
-				      cache */
-      }
+    Widget dspWidget = widget;
+
+    if (!pdi->traceDepth || !(widget == pdi->trace[0])) {
+        _XtFillAncestorList(&pdi->trace, &pdi->traceMax,
+                            &pdi->traceDepth, widget, NULL);
+        pdi->focusWidget = NULL;        /* invalidate the focus
+                                           cache */
+    }
     if (mask & (KeyPressMask | KeyReleaseMask))
-	  dspWidget = _XtProcessKeyboardEvent((XKeyEvent*)event, widget, pdi);
-    else if (mask &(ButtonPressMask | ButtonReleaseMask))
-	  dspWidget = _XtProcessPointerEvent((XButtonEvent*)event, widget,pdi);
+        dspWidget = _XtProcessKeyboardEvent((XKeyEvent *) event, widget, pdi);
+    else if (mask & (ButtonPressMask | ButtonReleaseMask))
+        dspWidget = _XtProcessPointerEvent((XButtonEvent *) event, widget, pdi);
 
     return dspWidget;
 }
 
-void _XtUngrabBadGrabs(
-    XEvent	*event,
-    Widget	widget,
-    EventMask	mask,
-    XtPerDisplayInput pdi)
+void
+_XtUngrabBadGrabs(XEvent *event,
+                  Widget widget,
+                  EventMask mask,
+                  XtPerDisplayInput pdi)
 {
-    XKeyEvent	* ke = (XKeyEvent *) event;
+    XKeyEvent *ke = (XKeyEvent *) event;
 
-    if (mask & (KeyPressMask | KeyReleaseMask))
-      {
-	  if (IsServerGrab(pdi->keyboard.grabType) &&
-	      !_XtOnGrabList(pdi->keyboard.grab.widget,
-			     pdi->grabList))
-	    XtUngrabKeyboard(widget, ke->time);
-
-      }
-    else
-      {
-	  if (IsServerGrab(pdi->pointer.grabType) &&
-	      !_XtOnGrabList(pdi->pointer.grab.widget,
-			     pdi->grabList))
-	    XtUngrabPointer(widget, ke->time);
-      }
+    if (mask & (KeyPressMask | KeyReleaseMask)) {
+        if (IsServerGrab(pdi->keyboard.grabType) &&
+            !_XtOnGrabList(pdi->keyboard.grab.widget, pdi->grabList))
+            XtUngrabKeyboard(widget, ke->time);
+
+    }
+    else {
+        if (IsServerGrab(pdi->pointer.grabType) &&
+            !_XtOnGrabList(pdi->pointer.grab.widget, pdi->grabList))
+             XtUngrabPointer(widget, ke->time);
+    }
 }
diff --git a/src/Functions.c b/src/Functions.c
index f70553b..1e15f57 100644
--- a/src/Functions.c
+++ b/src/Functions.c
@@ -63,57 +63,58 @@ in this Software without prior written authorization from The Open Group.
  */
 
 #undef XtIsRectObj
-Boolean XtIsRectObj(Widget object)
+Boolean
+XtIsRectObj(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x02);
 }
 
-
 #undef XtIsWidget
-Boolean XtIsWidget(Widget object)
+Boolean
+XtIsWidget(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x04);
 }
 
-
 #undef XtIsComposite
-Boolean XtIsComposite(Widget object)
+Boolean
+XtIsComposite(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x08);
 }
 
-
 #undef XtIsConstraint
-Boolean XtIsConstraint(Widget object)
+Boolean
+XtIsConstraint(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x10);
 }
 
-
 #undef XtIsShell
-Boolean XtIsShell(Widget object)
+Boolean
+XtIsShell(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x20);
 }
 
-
 #undef XtIsOverrideShell
-Boolean XtIsOverrideShell(Widget object)
+Boolean
+XtIsOverrideShell(Widget object)
 {
-    return _XtIsSubclassOf(object, (WidgetClass)overrideShellWidgetClass,
-			   (WidgetClass)shellWidgetClass, 0x20);
+    return _XtIsSubclassOf(object, (WidgetClass) overrideShellWidgetClass,
+                           (WidgetClass) shellWidgetClass, 0x20);
 }
 
-
 #undef XtIsWMShell
-Boolean XtIsWMShell(Widget object)
+Boolean
+XtIsWMShell(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x40);
 }
 
-
 #undef XtIsVendorShell
-Boolean XtIsVendorShell(Widget object)
+Boolean
+XtIsVendorShell(Widget object)
 {
     Boolean retval;
 
@@ -124,93 +125,97 @@ Boolean XtIsVendorShell(Widget object)
  * We don't refer to vendorShell directly, because some shared libraries
  * bind local references tightly.
  */
-			   (WidgetClass)vendorShellWidgetClass,
+                             (WidgetClass) vendorShellWidgetClass,
 #endif
-			   transientShellWidgetClass->core_class.superclass,
-			   (WidgetClass)wmShellWidgetClass, 0x40);
+                             transientShellWidgetClass->core_class.superclass,
+                             (WidgetClass) wmShellWidgetClass, 0x40);
     UNLOCK_PROCESS;
     return retval;
 }
 
-
 #undef XtIsTransientShell
-Boolean XtIsTransientShell(Widget object)
+Boolean
+XtIsTransientShell(Widget object)
 {
-    return _XtIsSubclassOf(object, (WidgetClass)transientShellWidgetClass,
-			   (WidgetClass)wmShellWidgetClass, 0x40);
+    return _XtIsSubclassOf(object, (WidgetClass) transientShellWidgetClass,
+                           (WidgetClass) wmShellWidgetClass, 0x40);
 }
 
-
 #undef XtIsTopLevelShell
-Boolean XtIsTopLevelShell(Widget object)
+Boolean
+XtIsTopLevelShell(Widget object)
 {
     return _XtCheckSubclassFlag(object, 0x80);
 }
 
-
 #undef XtIsApplicationShell
-Boolean XtIsApplicationShell(Widget object)
+Boolean
+XtIsApplicationShell(Widget object)
 {
-    return _XtIsSubclassOf(object, (WidgetClass)applicationShellWidgetClass,
-			   (WidgetClass)topLevelShellWidgetClass, 0x80);
+    return _XtIsSubclassOf(object, (WidgetClass) applicationShellWidgetClass,
+                           (WidgetClass) topLevelShellWidgetClass, 0x80);
 }
 
 #undef XtIsSessionShell
-Boolean XtIsSessionShell(Widget object)
+Boolean
+XtIsSessionShell(Widget object)
 {
-    return _XtIsSubclassOf(object, (WidgetClass)sessionShellWidgetClass,
-			   (WidgetClass)topLevelShellWidgetClass, 0x80);
+    return _XtIsSubclassOf(object, (WidgetClass) sessionShellWidgetClass,
+                           (WidgetClass) topLevelShellWidgetClass, 0x80);
 }
 
 #undef XtMapWidget
-void XtMapWidget(Widget w)
+void
+XtMapWidget(Widget w)
 {
     Widget hookobj;
+
     WIDGET_TO_APPCON(w);
 
     LOCK_APP(app);
     XMapWindow(XtDisplay(w), XtWindow(w));
     hookobj = XtHooksOfDisplay(XtDisplay(w));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHmapWidget;
-	call_data.widget = w;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHmapWidget;
+        call_data.widget = w;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
 }
 
-
 #undef XtUnmapWidget
-void XtUnmapWidget(Widget w)
+void
+XtUnmapWidget(Widget w)
 {
     Widget hookobj;
+
     WIDGET_TO_APPCON(w);
 
     LOCK_APP(app);
     XUnmapWindow(XtDisplay(w), XtWindow(w));
     hookobj = XtHooksOfDisplay(XtDisplay(w));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHunmapWidget;
-	call_data.widget = w;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHunmapWidget;
+        call_data.widget = w;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
 }
 
-
 #undef XtNewString
-String XtNewString(String str)
+String
+XtNewString(String str)
 {
     if (str == NULL)
-	return NULL;
+        return NULL;
 
     return strdup(str);
 }
diff --git a/src/GCManager.c b/src/GCManager.c
index 52e32ae..6031248 100644
--- a/src/GCManager.c
+++ b/src/GCManager.c
@@ -73,51 +73,50 @@ in this Software without prior written authorization from The Open Group.
 #endif
 #include "IntrinsicI.h"
 
-
 typedef struct _GCrec {
-    unsigned char screen;	/* Screen for GC */
-    unsigned char depth;	/* Depth for GC */
-    char	  dashes;	/* Dashes value */
-    Pixmap	  clip_mask;	/* Clip_mask value */
-    Cardinal	  ref_count;    /* # of shareholders */
-    GC		  gc;		/* The GC itself. */
-    XtGCMask	  dynamic_mask;	/* Writable values */
-    XtGCMask	  unused_mask;	/* Unused values */
-    struct _GCrec *next;	/* Next GC for this widgetkind. */
+    unsigned char screen;       /* Screen for GC */
+    unsigned char depth;        /* Depth for GC */
+    char dashes;                /* Dashes value */
+    Pixmap clip_mask;           /* Clip_mask value */
+    Cardinal ref_count;         /* # of shareholders */
+    GC gc;                      /* The GC itself. */
+    XtGCMask dynamic_mask;      /* Writable values */
+    XtGCMask unused_mask;       /* Unused values */
+    struct _GCrec *next;        /* Next GC for this widgetkind. */
 } GCrec, *GCptr;
 
 #define GCVAL(bit,mask,val,default) ((bit&mask) ? val : default)
 
 #define CHECK(bit,comp,default) \
     if ((checkMask & bit) && \
-	(GCVAL(bit,valueMask,v->comp,default) != gcv.comp)) return False
+        (GCVAL(bit,valueMask,v->comp,default) != gcv.comp)) return False
 
 #define ALLGCVALS (GCFunction | GCPlaneMask | GCForeground | \
-		   GCBackground | GCLineWidth | GCLineStyle | \
-		   GCCapStyle | GCJoinStyle | GCFillStyle | \
-		   GCFillRule | GCTile | GCStipple | \
-		   GCTileStipXOrigin | GCTileStipYOrigin | \
-		   GCFont | GCSubwindowMode | GCGraphicsExposures | \
-		   GCClipXOrigin | GCClipYOrigin | GCDashOffset | \
-		   GCArcMode)
-
-static Bool Matches(
-    Display *dpy,
-    GCptr ptr,
-    register XtGCMask valueMask,
-    register XGCValues *v,
-    XtGCMask readOnlyMask,
-    XtGCMask dynamicMask)
+                   GCBackground | GCLineWidth | GCLineStyle | \
+                   GCCapStyle | GCJoinStyle | GCFillStyle | \
+                   GCFillRule | GCTile | GCStipple | \
+                   GCTileStipXOrigin | GCTileStipYOrigin | \
+                   GCFont | GCSubwindowMode | GCGraphicsExposures | \
+                   GCClipXOrigin | GCClipYOrigin | GCDashOffset | \
+                   GCArcMode)
+
+static Bool
+Matches(Display *dpy,
+        GCptr ptr,
+        register XtGCMask valueMask,
+        register XGCValues *v,
+        XtGCMask readOnlyMask,
+        XtGCMask dynamicMask)
 {
     XGCValues gcv;
     register XtGCMask checkMask;
 
     if (readOnlyMask & ptr->dynamic_mask)
-	return False;
-    if (((ptr->dynamic_mask|ptr->unused_mask) & dynamicMask) != dynamicMask)
-	return False;
+        return False;
+    if (((ptr->dynamic_mask | ptr->unused_mask) & dynamicMask) != dynamicMask)
+        return False;
     if (!XGetGCValues(dpy, ptr->gc, ALLGCVALS, &gcv))
-	return False;
+        return False;
     checkMask = readOnlyMask & ~ptr->unused_mask;
     CHECK(GCForeground, foreground, 0);
     CHECK(GCBackground, background, 1);
@@ -146,52 +145,51 @@ static Bool Matches(
     CHECK(GCDashList, dashes, 4);
     valueMask &= ptr->unused_mask | dynamicMask;
     if (valueMask) {
-	XChangeGC(dpy, ptr->gc, valueMask, v);
-	if (valueMask & GCDashList)
-	    ptr->dashes = v->dashes;
-	if (valueMask & GCClipMask)
-	    ptr->clip_mask = v->clip_mask;
+        XChangeGC(dpy, ptr->gc, valueMask, v);
+        if (valueMask & GCDashList)
+            ptr->dashes = v->dashes;
+        if (valueMask & GCClipMask)
+            ptr->clip_mask = v->clip_mask;
     }
     ptr->unused_mask &= ~(dynamicMask | readOnlyMask);
     ptr->dynamic_mask |= dynamicMask;
     return True;
-} /* Matches */
+}                               /* Matches */
 
 /* Called by CloseDisplay to free the per-display GC list */
-void _XtGClistFree(
-    Display *dpy,
-    register XtPerDisplay pd)
+void
+_XtGClistFree(Display *dpy, register XtPerDisplay pd)
 {
     GCptr GClist, next;
 
     GClist = pd->GClist;
     while (GClist) {
-	next = GClist->next;
-	XtFree((char*)GClist);
-	GClist = next;
+        next = GClist->next;
+        XtFree((char *) GClist);
+        GClist = next;
     }
     if (pd->pixmap_tab) {
-	int i;
-	for (i = ScreenCount(dpy); --i >= 0; ) {
-	    if (pd->pixmap_tab[i])
-		XtFree((char *)pd->pixmap_tab[i]);
-	}
-	XtFree((char *)pd->pixmap_tab);
+        int i;
+
+        for (i = ScreenCount(dpy); --i >= 0;) {
+            if (pd->pixmap_tab[i])
+                XtFree((char *) pd->pixmap_tab[i]);
+        }
+        XtFree((char *) pd->pixmap_tab);
     }
 }
 
-
 /*
  * Return a GC with the given values and characteristics.
  */
 
-GC XtAllocateGC(
-    register Widget widget,
-    Cardinal	    depth,
-    XtGCMask        valueMask,
-    XGCValues       *values,
-    XtGCMask        dynamicMask,
-    XtGCMask        unusedMask)
+GC
+XtAllocateGC(register Widget widget,
+             Cardinal depth,
+             XtGCMask valueMask,
+             XGCValues *values,
+             XtGCMask dynamicMask,
+             XtGCMask unusedMask)
 {
     register GCptr *prev;
     register GCptr cur;
@@ -202,14 +200,15 @@ GC XtAllocateGC(
     Drawable *pixmaps;
     XtGCMask readOnlyMask;
     GC retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     LOCK_PROCESS;
     if (!XtIsWidget(widget))
-	widget = _XtWindowedAncestor(widget);
+        widget = _XtWindowedAncestor(widget);
     if (!depth)
-	depth = widget->core.depth;
+        depth = widget->core.depth;
     screen = XtScreen(widget);
     dpy = DisplayOfScreen(screen);
     pd = _XtGetPerDisplay(dpy);
@@ -218,19 +217,19 @@ GC XtAllocateGC(
 
     /* Search for existing GC that matches exactly */
     for (prev = &pd->GClist; (cur = *prev); prev = &cur->next) {
-	if (cur->depth == depth &&
-	    ScreenOfDisplay(dpy, cur->screen) == screen &&
-	    Matches(dpy, cur, valueMask, values, readOnlyMask, dynamicMask)) {
+        if (cur->depth == depth &&
+            ScreenOfDisplay(dpy, cur->screen) == screen &&
+            Matches(dpy, cur, valueMask, values, readOnlyMask, dynamicMask)) {
             cur->ref_count++;
-	    /* Move this GC to front of list */
-	    *prev = cur->next;
-	    cur->next = pd->GClist;
-	    pd->GClist = cur;
-	    retval = cur->gc;
-	    UNLOCK_PROCESS;
-	    UNLOCK_APP(app);
-	    return retval;
-	}
+            /* Move this GC to front of list */
+            *prev = cur->next;
+            cur->next = pd->GClist;
+            pd->GClist = cur;
+            retval = cur->gc;
+            UNLOCK_PROCESS;
+            UNLOCK_APP(app);
+            return retval;
+        }
     }
 
     /* No matches, have to create a new one */
@@ -244,37 +243,41 @@ GC XtAllocateGC(
     cur->clip_mask = GCVAL(GCClipMask, valueMask, values->clip_mask, None);
     drawable = 0;
     if (depth == widget->core.depth)
-	drawable = XtWindow(widget);
+        drawable = XtWindow(widget);
     if (!drawable && depth == (Cardinal) DefaultDepthOfScreen(screen))
-	drawable = RootWindowOfScreen(screen);
+        drawable = RootWindowOfScreen(screen);
     if (!drawable) {
-	if (!pd->pixmap_tab) {
-	    int n;
-	    pd->pixmap_tab = (Drawable **)__XtMalloc((Cardinal)((unsigned)ScreenCount(dpy) *
-						   sizeof(Drawable *)));
-	    for (n = 0; n < ScreenCount(dpy); n++)
-		pd->pixmap_tab[n] = NULL;
-	}
-	pixmaps = pd->pixmap_tab[cur->screen];
-	if (!pixmaps) {
-	    int max, n, *depths;
-	    depths = XListDepths(dpy, cur->screen, &n);
-	    n--;
-	    max = depths[n];
-	    while (n--) {
-		if (depths[n] > max)
-		    max = depths[n];
-	    }
-	    XFree((char *)depths);
-	    pixmaps = (Drawable *)__XtCalloc((unsigned)max, sizeof(Drawable));
-	    pd->pixmap_tab[cur->screen] = pixmaps;
-	}
-	drawable = pixmaps[cur->depth - 1];
-	if (!drawable) {
-	    drawable = XCreatePixmap(dpy, RootWindowOfScreen(screen), 1, 1,
-				     cur->depth);
-	    pixmaps[cur->depth - 1] = drawable;
-	}
+        if (!pd->pixmap_tab) {
+            int n;
+
+            pd->pixmap_tab =
+                (Drawable **)
+                __XtMalloc((Cardinal)
+                           ((unsigned) ScreenCount(dpy) * sizeof(Drawable *)));
+            for (n = 0; n < ScreenCount(dpy); n++)
+                pd->pixmap_tab[n] = NULL;
+        }
+        pixmaps = pd->pixmap_tab[cur->screen];
+        if (!pixmaps) {
+            int max, n, *depths;
+
+            depths = XListDepths(dpy, cur->screen, &n);
+            n--;
+            max = depths[n];
+            while (n--) {
+                if (depths[n] > max)
+                    max = depths[n];
+            }
+            XFree((char *) depths);
+            pixmaps = (Drawable *) __XtCalloc((unsigned) max, sizeof(Drawable));
+            pd->pixmap_tab[cur->screen] = pixmaps;
+        }
+        drawable = pixmaps[cur->depth - 1];
+        if (!drawable) {
+            drawable = XCreatePixmap(dpy, RootWindowOfScreen(screen), 1, 1,
+                                     cur->depth);
+            pixmaps[cur->depth - 1] = drawable;
+        }
     }
     cur->gc = XCreateGC(dpy, drawable, valueMask, values);
     cur->next = pd->GClist;
@@ -283,27 +286,25 @@ GC XtAllocateGC(
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return retval;
-} /* XtAllocateGC */
+}                               /* XtAllocateGC */
 
 /*
  * Return a read-only GC with the given values.
  */
 
-GC XtGetGC(
-    register Widget widget,
-    XtGCMask        valueMask,
-    XGCValues       *values)
+GC
+XtGetGC(register Widget widget, XtGCMask valueMask, XGCValues *values)
 {
     return XtAllocateGC(widget, 0, valueMask, values, 0, 0);
-} /* XtGetGC */
+}                               /* XtGetGC */
 
-void  XtReleaseGC(
-    Widget      widget,
-    register GC gc)
+void
+XtReleaseGC(Widget widget, register GC gc)
 {
     register GCptr cur, *prev;
-    Display* dpy;
+    Display *dpy;
     XtPerDisplay pd;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -312,25 +313,26 @@ void  XtReleaseGC(
     pd = _XtGetPerDisplay(dpy);
 
     for (prev = &pd->GClist; (cur = *prev); prev = &cur->next) {
-	if (cur->gc == gc) {
-	    if (--(cur->ref_count) == 0) {
-		*prev = cur->next;
-		XFreeGC(dpy, gc);
-		XtFree((char *) cur);
-	    }
-	    break;
-	}
+        if (cur->gc == gc) {
+            if (--(cur->ref_count) == 0) {
+                *prev = cur->next;
+                XFreeGC(dpy, gc);
+                XtFree((char *) cur);
+            }
+            break;
+        }
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
-} /* XtReleaseGC */
+}                               /* XtReleaseGC */
 
 /*  The following interface is broken and supplied only for backwards
  *  compatibility.  It will work properly in all cases only if there
  *  is exactly 1 Display created by the application.
  */
 
-void XtDestroyGC(register GC gc)
+void
+XtDestroyGC(register GC gc)
 {
     GCptr cur, *prev;
     XtAppContext app;
@@ -340,22 +342,24 @@ void XtDestroyGC(register GC gc)
     /* This is awful; we have to search through all the lists
        to find the GC. */
     for (; app; app = app->next) {
-	int i;
-	for (i = app->count; i ;) {
-	    Display *dpy = app->list[--i];
-	    XtPerDisplay pd = _XtGetPerDisplay(dpy);
-	    for (prev = &pd->GClist; (cur = *prev); prev = &cur->next) {
-		if (cur->gc == gc) {
-		    if (--(cur->ref_count) == 0) {
-			*prev = cur->next;
-			XFreeGC(dpy, gc);
-			XtFree((char *) cur);
-		    }
-		    UNLOCK_PROCESS;
-		    return;
-		}
-	    }
-	}
+        int i;
+
+        for (i = app->count; i;) {
+            Display *dpy = app->list[--i];
+            XtPerDisplay pd = _XtGetPerDisplay(dpy);
+
+            for (prev = &pd->GClist; (cur = *prev); prev = &cur->next) {
+                if (cur->gc == gc) {
+                    if (--(cur->ref_count) == 0) {
+                        *prev = cur->next;
+                        XFreeGC(dpy, gc);
+                        XtFree((char *) cur);
+                    }
+                    UNLOCK_PROCESS;
+                    return;
+                }
+            }
+        }
     }
     UNLOCK_PROCESS;
-} /* XtDestroyGC */
+}                               /* XtDestroyGC */
diff --git a/src/Geometry.c b/src/Geometry.c
index 992141e..3704cb6 100644
--- a/src/Geometry.c
+++ b/src/Geometry.c
@@ -75,25 +75,23 @@ in this Software without prior written authorization from The Open Group.
 #include "ShellP.h"
 #include "ShellI.h"
 
-static void ClearRectObjAreas(
-    RectObj r,
-    XWindowChanges* old)
+static void
+ClearRectObjAreas(RectObj r, XWindowChanges *old)
 {
-    Widget pw = _XtWindowedAncestor((Widget)r);
+    Widget pw = _XtWindowedAncestor((Widget) r);
     int bw2;
 
     bw2 = old->border_width << 1;
-    XClearArea( XtDisplay(pw), XtWindow(pw),
-		old->x, old->y,
-		(unsigned)(old->width + bw2), (unsigned)(old->height + bw2),
-		TRUE );
+    XClearArea(XtDisplay(pw), XtWindow(pw),
+               old->x, old->y,
+               (unsigned) (old->width + bw2), (unsigned) (old->height + bw2),
+               TRUE);
 
     bw2 = r->rectangle.border_width << 1;
-    XClearArea( XtDisplay(pw), XtWindow(pw),
-		(int)r->rectangle.x, (int)r->rectangle.y,
-		(unsigned int)(r->rectangle.width + bw2),
-	        (unsigned int)(r->rectangle.height + bw2),
-		TRUE );
+    XClearArea(XtDisplay(pw), XtWindow(pw),
+               (int) r->rectangle.x, (int) r->rectangle.y,
+               (unsigned int) (r->rectangle.width + bw2),
+               (unsigned int) (r->rectangle.height + bw2), TRUE);
 }
 
 /*
@@ -102,17 +100,16 @@ static void ClearRectObjAreas(
  * XtGeometryDone to XtGeometryYes.
  *
  * clear_rect_obj - *** RETURNED ***
- *		    TRUE if the rect obj has been cleared, false otherwise.
+ *                  TRUE if the rect obj has been cleared, false otherwise.
  */
 
 XtGeometryResult
-_XtMakeGeometryRequest (
-    Widget widget,
-    XtWidgetGeometry *request,
-    XtWidgetGeometry *reply,
-    Boolean * clear_rect_obj)
+_XtMakeGeometryRequest(Widget widget,
+                       XtWidgetGeometry *request,
+                       XtWidgetGeometry *reply,
+                       Boolean *clear_rect_obj)
 {
-    XtWidgetGeometry    junk;
+    XtWidgetGeometry junk;
     XtGeometryHandler manager = (XtGeometryHandler) NULL;
     XtGeometryResult returnCode;
     Widget parent = widget->core.parent;
@@ -125,63 +122,71 @@ _XtMakeGeometryRequest (
     *clear_rect_obj = FALSE;
 
     CALLGEOTAT(_XtGeoTrace(widget,
-	"\"%s\" is making a %sgeometry request to its parent \"%s\".\n",
-		   XtName(widget),
-		   ((request->request_mode & XtCWQueryOnly))? "query only ":"",
-		   (XtParent(widget))?XtName(XtParent(widget)):"Root"));
+                           "\"%s\" is making a %sgeometry request to its parent \"%s\".\n",
+                           XtName(widget),
+                           ((request->request_mode & XtCWQueryOnly)) ?
+                           "query only " : "",
+                           (XtParent(widget)) ? XtName(XtParent(widget)) :
+                           "Root"));
     CALLGEOTAT(_XtGeoTab(1));
 
     if (XtIsShell(widget)) {
-	ShellClassExtension ext;
-	LOCK_PROCESS;
-	for (ext = (ShellClassExtension)((ShellWidgetClass)XtClass(widget))
-		   ->shell_class.extension;
-	     ext != NULL && ext->record_type != NULLQUARK;
-	     ext = (ShellClassExtension)ext->next_extension);
-
-	if (ext != NULL) {
-	    if (  ext->version == XtShellExtensionVersion
-		  && ext->record_size == sizeof(ShellClassExtensionRec)) {
-		manager = ext->root_geometry_manager;
-		rgm = True;
-	    } else {
-		String params[1];
-		Cardinal num_params = 1;
-		params[0] = XtClass(widget)->core_class.class_name;
-		XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-		     "invalidExtension", "xtMakeGeometryRequest",
-		     XtCXtToolkitError,
-		     "widget class %s has invalid ShellClassExtension record",
-		     params, &num_params);
-	    }
-	} else {
-	    XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-			  "internalError", "xtMakeGeometryRequest",
-			  XtCXtToolkitError,
-			  "internal error; ShellClassExtension is NULL",
-			  NULL, NULL);
-	}
-	managed = True;
-	parentRealized = TRUE;
-	UNLOCK_PROCESS;
-    } else /* not shell */ {
-	if (parent == NULL) {
-	    XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-			  "invalidParent","xtMakeGeometryRequest",
-			  XtCXtToolkitError,
-			  "non-shell has no parent in XtMakeGeometryRequest",
-			  NULL, NULL);
-	} else {
-	    managed = XtIsManaged(widget);
-	    parentRealized = XtIsRealized(parent);
-	    if (XtIsComposite(parent))
-	    {
-		LOCK_PROCESS;
-		manager = ((CompositeWidgetClass) (parent->core.widget_class))
-			  ->composite_class.geometry_manager;
-		UNLOCK_PROCESS;
-	    }
-	}
+        ShellClassExtension ext;
+
+        LOCK_PROCESS;
+        for (ext = (ShellClassExtension) ((ShellWidgetClass) XtClass(widget))
+             ->shell_class.extension;
+             ext != NULL && ext->record_type != NULLQUARK;
+             ext = (ShellClassExtension) ext->next_extension);
+
+        if (ext != NULL) {
+            if (ext->version == XtShellExtensionVersion
+                && ext->record_size == sizeof(ShellClassExtensionRec)) {
+                manager = ext->root_geometry_manager;
+                rgm = True;
+            }
+            else {
+                String params[1];
+                Cardinal num_params = 1;
+
+                params[0] = XtClass(widget)->core_class.class_name;
+                XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                              "invalidExtension", "xtMakeGeometryRequest",
+                              XtCXtToolkitError,
+                              "widget class %s has invalid ShellClassExtension record",
+                              params, &num_params);
+            }
+        }
+        else {
+            XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                          "internalError", "xtMakeGeometryRequest",
+                          XtCXtToolkitError,
+                          "internal error; ShellClassExtension is NULL",
+                          NULL, NULL);
+        }
+        managed = True;
+        parentRealized = TRUE;
+        UNLOCK_PROCESS;
+    }
+    else {                      /* not shell */
+
+        if (parent == NULL) {
+            XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                          "invalidParent", "xtMakeGeometryRequest",
+                          XtCXtToolkitError,
+                          "non-shell has no parent in XtMakeGeometryRequest",
+                          NULL, NULL);
+        }
+        else {
+            managed = XtIsManaged(widget);
+            parentRealized = XtIsRealized(parent);
+            if (XtIsComposite(parent)) {
+                LOCK_PROCESS;
+                manager = ((CompositeWidgetClass) (parent->core.widget_class))
+                    ->composite_class.geometry_manager;
+                UNLOCK_PROCESS;
+            }
+        }
     }
 
 #if 0
@@ -193,146 +198,144 @@ _XtMakeGeometryRequest (
      * should probably remain disabled.
      */
     if (parentRealized && managed) {
-	if (parent && !XtIsComposite(parent))
-	{
-	    /*
-	     * This shouldn't ever happen, we only test for this to pass
-	     * VSW5.  Normally managing the widget will catch this, but VSW5
-	     * does some really screwy stuff to get here.
-	     */
-	    XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-			  "invalidParent", "xtMakeGeometryRequest",
-			  XtCXtToolkitError,
-			  "XtMakeGeometryRequest - parent not composite",
-			  NULL, NULL);
-	}
-	else if (manager == (XtGeometryHandler) NULL)
-	{
-	    XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-			  "invalidGeometryManager","xtMakeGeometryRequest",
-			  XtCXtToolkitError,
-			  "XtMakeGeometryRequest - parent has no geometry manager",
-			  NULL, NULL);
-	}
+        if (parent && !XtIsComposite(parent)) {
+            /*
+             * This shouldn't ever happen, we only test for this to pass
+             * VSW5.  Normally managing the widget will catch this, but VSW5
+             * does some really screwy stuff to get here.
+             */
+            XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                          "invalidParent", "xtMakeGeometryRequest",
+                          XtCXtToolkitError,
+                          "XtMakeGeometryRequest - parent not composite",
+                          NULL, NULL);
+        }
+        else if (manager == (XtGeometryHandler) NULL) {
+            XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                          "invalidGeometryManager", "xtMakeGeometryRequest",
+                          XtCXtToolkitError,
+                          "XtMakeGeometryRequest - parent has no geometry manager",
+                          NULL, NULL);
+        }
     }
 #else
     if (!manager)
-	managed = False;
+        managed = False;
 #endif
 
     if (widget->core.being_destroyed) {
-	CALLGEOTAT(_XtGeoTab(-1));
-	CALLGEOTAT(_XtGeoTrace(widget,
-		       "It is being destroyed, just return XtGeometryNo.\n"));
-	return XtGeometryNo;
+        CALLGEOTAT(_XtGeoTab(-1));
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "It is being destroyed, just return XtGeometryNo.\n"));
+        return XtGeometryNo;
     }
 
     /* see if requesting anything to change */
     req.changeMask = 0;
     if (request->request_mode & CWStackMode
-	&& request->stack_mode != XtSMDontChange) {
-	    req.changeMask |= CWStackMode;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "Asking for a change in StackMode!\n"));
-	    if (request->request_mode & CWSibling) {
-		XtCheckSubclass(request->sibling, rectObjClass,
-				"XtMakeGeometryRequest");
-		req.changeMask |= CWSibling;
-	    }
-    }
-    if (request->request_mode & CWX
-	&& widget->core.x != request->x) {
-	CALLGEOTAT(_XtGeoTrace(widget,
-			       "Asking for a change in x: from %d to %d.\n",
-			       widget->core.x, request->x));
-	req.changeMask |= CWX;
-    }
-    if (request->request_mode & CWY
-	&& widget->core.y != request->y) {
-	CALLGEOTAT(_XtGeoTrace(widget,
-			       "Asking for a change in y: from %d to %d.\n",
-			       widget->core.y, request->y));
-	req.changeMask |= CWY;
-    }
-    if (request->request_mode & CWWidth
-	&& widget->core.width != request->width) {
-	CALLGEOTAT(_XtGeoTrace(widget,"Asking for a change in width: from %d to %d.\n",
-		       widget->core.width, request->width));
-	req.changeMask |= CWWidth;
+        && request->stack_mode != XtSMDontChange) {
+        req.changeMask |= CWStackMode;
+        CALLGEOTAT(_XtGeoTrace(widget, "Asking for a change in StackMode!\n"));
+        if (request->request_mode & CWSibling) {
+            XtCheckSubclass(request->sibling, rectObjClass,
+                            "XtMakeGeometryRequest");
+            req.changeMask |= CWSibling;
+        }
+    }
+    if (request->request_mode & CWX && widget->core.x != request->x) {
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Asking for a change in x: from %d to %d.\n",
+                               widget->core.x, request->x));
+        req.changeMask |= CWX;
+    }
+    if (request->request_mode & CWY && widget->core.y != request->y) {
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Asking for a change in y: from %d to %d.\n",
+                               widget->core.y, request->y));
+        req.changeMask |= CWY;
+    }
+    if (request->request_mode & CWWidth && widget->core.width != request->width) {
+        CALLGEOTAT(_XtGeoTrace
+                   (widget, "Asking for a change in width: from %d to %d.\n",
+                    widget->core.width, request->width));
+        req.changeMask |= CWWidth;
     }
     if (request->request_mode & CWHeight
-	&& widget->core.height != request->height) {
-	CALLGEOTAT(_XtGeoTrace(widget,
-			    "Asking for a change in height: from %d to %d.\n",
-			       widget->core.height, request->height));
-	req.changeMask |= CWHeight;
+        && widget->core.height != request->height) {
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Asking for a change in height: from %d to %d.\n",
+                               widget->core.height, request->height));
+        req.changeMask |= CWHeight;
     }
     if (request->request_mode & CWBorderWidth
-	&& widget->core.border_width != request->border_width){
-	CALLGEOTAT(_XtGeoTrace(widget,
-		       "Asking for a change in border_width: from %d to %d.\n",
-		       widget->core.border_width, request->border_width));
-	req.changeMask |= CWBorderWidth;
-    }
-    if (! req.changeMask) {
-	CALLGEOTAT(_XtGeoTrace(widget,
-		       "Asking for nothing new,\n"));
-	CALLGEOTAT(_XtGeoTab(-1));
-	CALLGEOTAT(_XtGeoTrace(widget,
-		       "just return XtGeometryYes.\n"));
-	return XtGeometryYes;
+        && widget->core.border_width != request->border_width) {
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Asking for a change in border_width: from %d to %d.\n",
+                               widget->core.border_width,
+                               request->border_width));
+        req.changeMask |= CWBorderWidth;
+    }
+    if (!req.changeMask) {
+        CALLGEOTAT(_XtGeoTrace(widget, "Asking for nothing new,\n"));
+        CALLGEOTAT(_XtGeoTab(-1));
+        CALLGEOTAT(_XtGeoTrace(widget, "just return XtGeometryYes.\n"));
+        return XtGeometryYes;
     }
     req.changeMask |= (request->request_mode & XtCWQueryOnly);
 
-    if ( !(req.changeMask & XtCWQueryOnly) && XtIsRealized(widget) ) {
-	/* keep record of the current geometry so we know what's changed */
-	req.changes.x = widget->core.x ;
-	req.changes.y = widget->core.y ;
-	req.changes.width = widget->core.width ;
-	req.changes.height = widget->core.height ;
-	req.changes.border_width = widget->core.border_width ;
+    if (!(req.changeMask & XtCWQueryOnly) && XtIsRealized(widget)) {
+        /* keep record of the current geometry so we know what's changed */
+        req.changes.x = widget->core.x;
+        req.changes.y = widget->core.y;
+        req.changes.width = widget->core.width;
+        req.changes.height = widget->core.height;
+        req.changes.border_width = widget->core.border_width;
     }
 
     if (!managed || !parentRealized) {
-	CALLGEOTAT(_XtGeoTrace(widget,
-			       "Not Managed or Parent not realized.\n"));
-	/* Don't get parent's manager involved--assume the answer is yes */
-	if (req.changeMask & XtCWQueryOnly) {
-	    /* He was just asking, don't change anything, just tell him yes */
-	    CALLGEOTAT(_XtGeoTrace(widget,"QueryOnly request\n"));
-	    CALLGEOTAT(_XtGeoTab(-1));
-	    CALLGEOTAT(_XtGeoTrace(widget,"just return XtGeometryYes.\n"));
-	    return XtGeometryYes;
-	} else {
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "Copy values from request to widget.\n"));
-	    /* copy values from request to widget */
-	    if (request->request_mode & CWX)
-		widget->core.x = request->x;
-	    if (request->request_mode & CWY)
-		widget->core.y = request->y;
-	    if (request->request_mode & CWWidth)
-		widget->core.width = request->width;
-	    if (request->request_mode & CWHeight)
-		widget->core.height = request->height;
-	    if (request->request_mode & CWBorderWidth)
-		widget->core.border_width = request->border_width;
-	    if (!parentRealized) {
-		CALLGEOTAT(_XtGeoTab(-1));
-		CALLGEOTAT(_XtGeoTrace(widget,"and return XtGeometryYes.\n"));
-		return XtGeometryYes;
-	    }
-	    else returnCode = XtGeometryYes;
-	}
-    } else {
-	/* go ask the widget's geometry manager */
-	CALLGEOTAT(_XtGeoTrace(widget,
-			       "Go ask the parent geometry manager.\n"));
-	if (reply == (XtWidgetGeometry *) NULL) {
-	    returnCode = (*manager)(widget, request, &junk);
-	} else {
-	    returnCode = (*manager)(widget, request, reply);
-	}
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Not Managed or Parent not realized.\n"));
+        /* Don't get parent's manager involved--assume the answer is yes */
+        if (req.changeMask & XtCWQueryOnly) {
+            /* He was just asking, don't change anything, just tell him yes */
+            CALLGEOTAT(_XtGeoTrace(widget, "QueryOnly request\n"));
+            CALLGEOTAT(_XtGeoTab(-1));
+            CALLGEOTAT(_XtGeoTrace(widget, "just return XtGeometryYes.\n"));
+            return XtGeometryYes;
+        }
+        else {
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "Copy values from request to widget.\n"));
+            /* copy values from request to widget */
+            if (request->request_mode & CWX)
+                widget->core.x = request->x;
+            if (request->request_mode & CWY)
+                widget->core.y = request->y;
+            if (request->request_mode & CWWidth)
+                widget->core.width = request->width;
+            if (request->request_mode & CWHeight)
+                widget->core.height = request->height;
+            if (request->request_mode & CWBorderWidth)
+                widget->core.border_width = request->border_width;
+            if (!parentRealized) {
+                CALLGEOTAT(_XtGeoTab(-1));
+                CALLGEOTAT(_XtGeoTrace(widget, "and return XtGeometryYes.\n"));
+                return XtGeometryYes;
+            }
+            else
+                returnCode = XtGeometryYes;
+        }
+    }
+    else {
+        /* go ask the widget's geometry manager */
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "Go ask the parent geometry manager.\n"));
+        if (reply == (XtWidgetGeometry *) NULL) {
+            returnCode = (*manager) (widget, request, &junk);
+        }
+        else {
+            returnCode = (*manager) (widget, request, reply);
+        }
     }
 
     /*
@@ -340,168 +343,180 @@ _XtMakeGeometryRequest (
      */
 
     if ((returnCode != XtGeometryYes) ||
-	(req.changeMask & XtCWQueryOnly) || !XtIsRealized(widget)) {
+        (req.changeMask & XtCWQueryOnly) || !XtIsRealized(widget)) {
 
 #ifdef XT_GEO_TATTLER
-	switch(returnCode){
-	case XtGeometryNo:
-	    CALLGEOTAT(_XtGeoTab(-1));
-	    CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryNo.\n",
-			  (XtParent(widget))?XtName(XtParent(widget)):"Root"));
+        switch (returnCode) {
+        case XtGeometryNo:
+            CALLGEOTAT(_XtGeoTab(-1));
+            CALLGEOTAT(_XtGeoTrace(widget, "\"%s\" returns XtGeometryNo.\n",
+                                   (XtParent(widget)) ? XtName(XtParent(widget))
+                                   : "Root"));
             /* check for no change */
-            break ;
-	case XtGeometryDone:
-	    CALLGEOTAT(_XtGeoTab(-1));
-	    CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryDone.\n",
-		        (XtParent(widget))?XtName(XtParent(widget)):"Root"));
+            break;
+        case XtGeometryDone:
+            CALLGEOTAT(_XtGeoTab(-1));
+            CALLGEOTAT(_XtGeoTrace(widget, "\"%s\" returns XtGeometryDone.\n",
+                                   (XtParent(widget)) ? XtName(XtParent(widget))
+                                   : "Root"));
             /* check for no change in queryonly */
-            break ;
-	case XtGeometryAlmost:
-	    CALLGEOTAT(_XtGeoTab(-1));
-	    CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryAlmost.\n",
-			 (XtParent(widget))?XtName(XtParent(widget)):"Root"));
-	    CALLGEOTAT(_XtGeoTab(1));
-	    CALLGEOTAT(_XtGeoTrace(widget,"Proposal: width %d height %d.\n",
-			   (reply)?reply->width:junk.width,
-			   (reply)?reply->height:junk.height));
-	    CALLGEOTAT(_XtGeoTab(-1));
+            break;
+        case XtGeometryAlmost:
+            CALLGEOTAT(_XtGeoTab(-1));
+            CALLGEOTAT(_XtGeoTrace(widget, "\"%s\" returns XtGeometryAlmost.\n",
+                                   (XtParent(widget)) ? XtName(XtParent(widget))
+                                   : "Root"));
+            CALLGEOTAT(_XtGeoTab(1));
+            CALLGEOTAT(_XtGeoTrace(widget, "Proposal: width %d height %d.\n",
+                                   (reply) ? reply->width : junk.width,
+                                   (reply) ? reply->height : junk.height));
+            CALLGEOTAT(_XtGeoTab(-1));
 
             /* check for no change */
-            break ;
-	case XtGeometryYes:
-	    if (req.changeMask & XtCWQueryOnly) {
-		CALLGEOTAT(_XtGeoTrace(widget,
-				"QueryOnly specified, no configuration.\n"));
-	    }
+            break;
+        case XtGeometryYes:
+            if (req.changeMask & XtCWQueryOnly) {
+                CALLGEOTAT(_XtGeoTrace(widget,
+                                       "QueryOnly specified, no configuration.\n"));
+            }
             if (!XtIsRealized(widget)) {
-		CALLGEOTAT(_XtGeoTrace(widget,
-				 "\"%s\" not realized, no configuration.\n",
-				 XtName(widget)));
-	    }
-	    CALLGEOTAT(_XtGeoTab(-1));
-            CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryYes.\n",
-                         (XtParent(widget))?XtName(XtParent(widget)):"Root"));
-	    break ;
-	}
+                CALLGEOTAT(_XtGeoTrace(widget,
+                                       "\"%s\" not realized, no configuration.\n",
+                                       XtName(widget)));
+            }
+            CALLGEOTAT(_XtGeoTab(-1));
+            CALLGEOTAT(_XtGeoTrace(widget, "\"%s\" returns XtGeometryYes.\n",
+                                   (XtParent(widget)) ? XtName(XtParent(widget))
+                                   : "Root"));
+            break;
+        }
 #endif
-	return returnCode;
+        return returnCode;
     }
 
     CALLGEOTAT(_XtGeoTab(-1));
-    CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" returns XtGeometryYes.\n",
-		   (XtParent(widget))?XtName(XtParent(widget)):"Root"));
-
-    if (XtIsWidget(widget)) {	/* reconfigure the window (if needed) */
-
-	if (rgm) return returnCode;
-
-	if (req.changes.x != widget->core.x) {
- 	    req.changeMask |= CWX;
- 	    req.changes.x = widget->core.x;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "x changing to %d\n",widget->core.x));
- 	}
- 	if (req.changes.y != widget->core.y) {
- 	    req.changeMask |= CWY;
- 	    req.changes.y = widget->core.y;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "y changing to %d\n",widget->core.y));
- 	}
- 	if (req.changes.width != widget->core.width) {
- 	    req.changeMask |= CWWidth;
- 	    req.changes.width = widget->core.width;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				 "width changing to %d\n",widget->core.width));
- 	}
- 	if (req.changes.height != widget->core.height) {
- 	    req.changeMask |= CWHeight;
- 	    req.changes.height = widget->core.height;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-                               "height changing to %d\n",widget->core.height));
- 	}
- 	if (req.changes.border_width != widget->core.border_width) {
- 	    req.changeMask |= CWBorderWidth;
- 	    req.changes.border_width = widget->core.border_width;
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "border_width changing to %d\n",
-				   widget->core.border_width));
- 	}
-	if (req.changeMask & CWStackMode) {
-	    req.changes.stack_mode = request->stack_mode;
-	    CALLGEOTAT(_XtGeoTrace(widget,"stack_mode changing\n"));
-	    if (req.changeMask & CWSibling) {
-		if (XtIsWidget(request->sibling))
-		    req.changes.sibling = XtWindow(request->sibling);
-		else
-		    req.changeMask = (XtGeometryMask) (req.changeMask & (unsigned long) (~(CWStackMode | CWSibling)));
-	    }
-	}
+    CALLGEOTAT(_XtGeoTrace(widget, "\"%s\" returns XtGeometryYes.\n",
+                           (XtParent(widget)) ? XtName(XtParent(widget)) :
+                           "Root"));
+
+    if (XtIsWidget(widget)) {   /* reconfigure the window (if needed) */
+
+        if (rgm)
+            return returnCode;
+
+        if (req.changes.x != widget->core.x) {
+            req.changeMask |= CWX;
+            req.changes.x = widget->core.x;
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "x changing to %d\n", widget->core.x));
+        }
+        if (req.changes.y != widget->core.y) {
+            req.changeMask |= CWY;
+            req.changes.y = widget->core.y;
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "y changing to %d\n", widget->core.y));
+        }
+        if (req.changes.width != widget->core.width) {
+            req.changeMask |= CWWidth;
+            req.changes.width = widget->core.width;
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "width changing to %d\n",
+                                   widget->core.width));
+        }
+        if (req.changes.height != widget->core.height) {
+            req.changeMask |= CWHeight;
+            req.changes.height = widget->core.height;
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "height changing to %d\n",
+                                   widget->core.height));
+        }
+        if (req.changes.border_width != widget->core.border_width) {
+            req.changeMask |= CWBorderWidth;
+            req.changes.border_width = widget->core.border_width;
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "border_width changing to %d\n",
+                                   widget->core.border_width));
+        }
+        if (req.changeMask & CWStackMode) {
+            req.changes.stack_mode = request->stack_mode;
+            CALLGEOTAT(_XtGeoTrace(widget, "stack_mode changing\n"));
+            if (req.changeMask & CWSibling) {
+                if (XtIsWidget(request->sibling))
+                    req.changes.sibling = XtWindow(request->sibling);
+                else
+                    req.changeMask =
+                        (XtGeometryMask) (req.changeMask & (unsigned long)
+                                          (~(CWStackMode | CWSibling)));
+            }
+        }
 
 #ifdef XT_GEO_TATTLER
         if (req.changeMask) {
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "XConfigure \"%s\"'s window.\n",
-				   XtName(widget)));
-	} else {
-	    CALLGEOTAT(_XtGeoTrace(widget,
-			     "No window configuration needed for \"%s\".\n",
-			     XtName(widget)));
-	}
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "XConfigure \"%s\"'s window.\n",
+                                   XtName(widget)));
+        }
+        else {
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "No window configuration needed for \"%s\".\n",
+                                   XtName(widget)));
+        }
 #endif
 
-	XConfigureWindow(XtDisplay(widget), XtWindow(widget),
-			 req.changeMask, &req.changes);
+        XConfigureWindow(XtDisplay(widget), XtWindow(widget),
+                         req.changeMask, &req.changes);
     }
-    else {			/* RectObj child of realized Widget */
-	*clear_rect_obj = TRUE;
-	CALLGEOTAT(_XtGeoTrace(widget,
-			       "ClearRectObj on \"%s\".\n",XtName(widget)));
+    else {                      /* RectObj child of realized Widget */
+        *clear_rect_obj = TRUE;
+        CALLGEOTAT(_XtGeoTrace(widget,
+                               "ClearRectObj on \"%s\".\n", XtName(widget)));
 
-	ClearRectObjAreas((RectObj)widget, &req.changes);
+        ClearRectObjAreas((RectObj) widget, &req.changes);
     }
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
-	req.type = XtHconfigure;
-	req.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.confighook_callbacks,
-		(XtPointer)&req);
+        req.type = XtHconfigure;
+        req.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.confighook_callbacks,
+                           (XtPointer) &req);
     }
 
     return returnCode;
-} /* _XtMakeGeometryRequest */
-
+}                               /* _XtMakeGeometryRequest */
 
 /* Public routines */
 
-XtGeometryResult XtMakeGeometryRequest (
-    Widget         widget,
-    XtWidgetGeometry *request,
-    XtWidgetGeometry *reply)
+XtGeometryResult
+XtMakeGeometryRequest(Widget widget,
+                      XtWidgetGeometry *request,
+                      XtWidgetGeometry *reply)
 {
     Boolean junk;
     XtGeometryResult r;
     XtGeometryHookDataRec call_data;
     Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (XtHasCallbacks(hookobj, XtNgeometryHook) == XtCallbackHasSome) {
-	call_data.type = XtHpreGeometry;
-	call_data.widget = widget;
-	call_data.request = request;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.geometryhook_callbacks,
-		(XtPointer)&call_data);
-	call_data.result = r =
-	    _XtMakeGeometryRequest(widget, request, reply, &junk);
-	call_data.type = XtHpostGeometry;
-	call_data.reply = reply;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.geometryhook_callbacks,
-		(XtPointer)&call_data);
-    } else {
-	r = _XtMakeGeometryRequest(widget, request, reply, &junk);
+        call_data.type = XtHpreGeometry;
+        call_data.widget = widget;
+        call_data.request = request;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.geometryhook_callbacks,
+                           (XtPointer) &call_data);
+        call_data.result = r =
+            _XtMakeGeometryRequest(widget, request, reply, &junk);
+        call_data.type = XtHpostGeometry;
+        call_data.reply = reply;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.geometryhook_callbacks,
+                           (XtPointer) &call_data);
+    }
+    else {
+        r = _XtMakeGeometryRequest(widget, request, reply, &junk);
     }
     UNLOCK_APP(app);
 
@@ -509,18 +524,18 @@ XtGeometryResult XtMakeGeometryRequest (
 }
 
 XtGeometryResult
-XtMakeResizeRequest(
-    Widget	widget,
-    _XtDimension width,
-    _XtDimension height,
-    Dimension	*replyWidth,
-    Dimension	*replyHeight)
+XtMakeResizeRequest(Widget widget,
+                    _XtDimension width,
+                    _XtDimension height,
+                    Dimension *replyWidth,
+                    Dimension *replyHeight)
 {
     XtWidgetGeometry request, reply;
     XtGeometryResult r;
     XtGeometryHookDataRec call_data;
     Boolean junk;
     Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -529,230 +544,239 @@ XtMakeResizeRequest(
     request.height = (Dimension) height;
 
     if (XtHasCallbacks(hookobj, XtNgeometryHook) == XtCallbackHasSome) {
-	call_data.type = XtHpreGeometry;
-	call_data.widget = widget;
-	call_data.request = &request;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.geometryhook_callbacks,
-		(XtPointer)&call_data);
-	call_data.result = r =
-	    _XtMakeGeometryRequest(widget, &request, &reply, &junk);
-	call_data.type = XtHpostGeometry;
-	call_data.reply = &reply;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.geometryhook_callbacks,
-		(XtPointer)&call_data);
-    } else {
-	r = _XtMakeGeometryRequest(widget, &request, &reply, &junk);
+        call_data.type = XtHpreGeometry;
+        call_data.widget = widget;
+        call_data.request = &request;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.geometryhook_callbacks,
+                           (XtPointer) &call_data);
+        call_data.result = r =
+            _XtMakeGeometryRequest(widget, &request, &reply, &junk);
+        call_data.type = XtHpostGeometry;
+        call_data.reply = &reply;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.geometryhook_callbacks,
+                           (XtPointer) &call_data);
+    }
+    else {
+        r = _XtMakeGeometryRequest(widget, &request, &reply, &junk);
     }
     if (replyWidth != NULL) {
-	if (r == XtGeometryAlmost && reply.request_mode & CWWidth)
-	    *replyWidth = reply.width;
-	else
-	    *replyWidth = (Dimension) width;
+        if (r == XtGeometryAlmost && reply.request_mode & CWWidth)
+            *replyWidth = reply.width;
+        else
+            *replyWidth = (Dimension) width;
     }
     if (replyHeight != NULL) {
-	if (r == XtGeometryAlmost && reply.request_mode & CWHeight)
-	    *replyHeight = reply.height;
-	else
-	    *replyHeight = (Dimension) height;
+        if (r == XtGeometryAlmost && reply.request_mode & CWHeight)
+            *replyHeight = reply.height;
+        else
+            *replyHeight = (Dimension) height;
     }
     UNLOCK_APP(app);
     return ((r == XtGeometryDone) ? XtGeometryYes : r);
-} /* XtMakeResizeRequest */
+}                               /* XtMakeResizeRequest */
 
-void XtResizeWindow(
-    Widget w)
+void
+XtResizeWindow(Widget w)
 {
     XtConfigureHookDataRec req;
+
     WIDGET_TO_APPCON(w);
 
     LOCK_APP(app);
     if (XtIsRealized(w)) {
         Widget hookobj;
 
-	req.changes.width = w->core.width;
-	req.changes.height = w->core.height;
-	req.changes.border_width = w->core.border_width;
-	req.changeMask = CWWidth | CWHeight | CWBorderWidth;
-	XConfigureWindow(XtDisplay(w), XtWindow(w),
-	    (unsigned) req.changeMask, &req.changes);
-	hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));
-	if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
-	    req.type = XtHconfigure;
-	    req.widget = w;
-	    XtCallCallbackList(hookobj,
-			((HookObject)hookobj)->hooks.confighook_callbacks,
-			(XtPointer)&req);
-	}
+        req.changes.width = w->core.width;
+        req.changes.height = w->core.height;
+        req.changes.border_width = w->core.border_width;
+        req.changeMask = CWWidth | CWHeight | CWBorderWidth;
+        XConfigureWindow(XtDisplay(w), XtWindow(w),
+                         (unsigned) req.changeMask, &req.changes);
+        hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));
+        if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
+            req.type = XtHconfigure;
+            req.widget = w;
+            XtCallCallbackList(hookobj,
+                               ((HookObject) hookobj)->hooks.
+                               confighook_callbacks, (XtPointer) &req);
+        }
     }
     UNLOCK_APP(app);
-} /* XtResizeWindow */
+}                               /* XtResizeWindow */
 
-void XtResizeWidget(
-    Widget w,
-    _XtDimension width,
-    _XtDimension height,
-    _XtDimension borderWidth)
+void
+XtResizeWidget(Widget w,
+               _XtDimension width,
+               _XtDimension height,
+               _XtDimension borderWidth)
 {
     XtConfigureWidget(w, w->core.x, w->core.y, width, height, borderWidth);
-} /* XtResizeWidget */
-
-void XtConfigureWidget(
-    Widget w,
-    _XtPosition x,
-    _XtPosition y,
-    _XtDimension width,
-    _XtDimension height,
-    _XtDimension borderWidth)
+}                               /* XtResizeWidget */
+
+void
+XtConfigureWidget(Widget w,
+                  _XtPosition x,
+                  _XtPosition y,
+                  _XtDimension width,
+                  _XtDimension height,
+                  _XtDimension borderWidth)
 {
     XtConfigureHookDataRec req;
     XWindowChanges old;
+
     WIDGET_TO_APPCON(w);
 
     CALLGEOTAT(_XtGeoTrace(w,
-                   "\"%s\" is being configured by its parent \"%s\"\n",
-		   XtName(w),
-		   (XtParent(w))?XtName(XtParent(w)):"Root"));
+                           "\"%s\" is being configured by its parent \"%s\"\n",
+                           XtName(w),
+                           (XtParent(w)) ? XtName(XtParent(w)) : "Root"));
     CALLGEOTAT(_XtGeoTab(1));
 
     LOCK_APP(app);
     req.changeMask = 0;
     if ((old.x = w->core.x) != x) {
-	CALLGEOTAT(_XtGeoTrace(w,"x move from %d to %d\n",w->core.x, x));
-	req.changes.x = w->core.x = (Position) x;
-	req.changeMask |= CWX;
+        CALLGEOTAT(_XtGeoTrace(w, "x move from %d to %d\n", w->core.x, x));
+        req.changes.x = w->core.x = (Position) x;
+        req.changeMask |= CWX;
     }
 
     if ((old.y = w->core.y) != y) {
-	CALLGEOTAT(_XtGeoTrace(w,"y move from %d to %d\n",w->core.y, y));
-	req.changes.y = w->core.y = (Position) y;
-	req.changeMask |= CWY;
+        CALLGEOTAT(_XtGeoTrace(w, "y move from %d to %d\n", w->core.y, y));
+        req.changes.y = w->core.y = (Position) y;
+        req.changeMask |= CWY;
     }
 
     if ((old.width = w->core.width) != width) {
-	CALLGEOTAT(_XtGeoTrace(w,
-			 "width move from %d to %d\n",w->core.width, width));
-	req.changes.width = w->core.width = (Dimension) width;
-	req.changeMask |= CWWidth;
+        CALLGEOTAT(_XtGeoTrace(w,
+                               "width move from %d to %d\n", w->core.width,
+                               width));
+        req.changes.width = w->core.width = (Dimension) width;
+        req.changeMask |= CWWidth;
     }
 
     if ((old.height = w->core.height) != height) {
-	CALLGEOTAT(_XtGeoTrace(w,
-		       "height move from %d to %d\n",w->core.height, height));
-	req.changes.height = w->core.height = (Dimension) height;
-	req.changeMask |= CWHeight;
+        CALLGEOTAT(_XtGeoTrace(w,
+                               "height move from %d to %d\n", w->core.height,
+                               height));
+        req.changes.height = w->core.height = (Dimension) height;
+        req.changeMask |= CWHeight;
     }
 
     if ((old.border_width = w->core.border_width) != borderWidth) {
-	CALLGEOTAT(_XtGeoTrace(w,"border_width move from %d to %d\n",
-		    w->core.border_width,borderWidth ));
-	req.changes.border_width = w->core.border_width = (Dimension) borderWidth;
-	req.changeMask |= CWBorderWidth;
+        CALLGEOTAT(_XtGeoTrace(w, "border_width move from %d to %d\n",
+                               w->core.border_width, borderWidth));
+        req.changes.border_width = w->core.border_width =
+            (Dimension) borderWidth;
+        req.changeMask |= CWBorderWidth;
     }
 
     if (req.changeMask != 0) {
         Widget hookobj;
 
-	if (XtIsRealized(w)) {
-	    if (XtIsWidget(w)) {
-		CALLGEOTAT(_XtGeoTrace(w,
-                                  "XConfigure \"%s\"'s window\n",XtName(w)));
-		XConfigureWindow(XtDisplay(w), XtWindow(w),
-				 req.changeMask, &req.changes);
-	    } else {
-		CALLGEOTAT(_XtGeoTrace(w,
-			       "ClearRectObj called on \"%s\"\n",XtName(w)));
-		ClearRectObjAreas((RectObj)w, &old);
-	    }
-	}
-	hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));
-	if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
-	    req.type = XtHconfigure;
-	    req.widget = w;
-	    XtCallCallbackList(hookobj,
-			((HookObject)hookobj)->hooks.confighook_callbacks,
-			(XtPointer)&req);
-	}
-	{
-	XtWidgetProc resize;
-
-	LOCK_PROCESS;
-	resize = XtClass(w)->core_class.resize;
-	UNLOCK_PROCESS;
-	if ((req.changeMask & (CWWidth | CWHeight)) &&
-	    resize != (XtWidgetProc) NULL) {
-	    CALLGEOTAT(_XtGeoTrace(w,"Resize proc is called.\n"));
-	    (*resize)(w);
-	 }
-	}
-    } else {
-	CALLGEOTAT(_XtGeoTrace(w,"No change in configuration\n"));
+        if (XtIsRealized(w)) {
+            if (XtIsWidget(w)) {
+                CALLGEOTAT(_XtGeoTrace(w,
+                                       "XConfigure \"%s\"'s window\n",
+                                       XtName(w)));
+                XConfigureWindow(XtDisplay(w), XtWindow(w), req.changeMask,
+                                 &req.changes);
+            }
+            else {
+                CALLGEOTAT(_XtGeoTrace(w,
+                                       "ClearRectObj called on \"%s\"\n",
+                                       XtName(w)));
+                ClearRectObjAreas((RectObj) w, &old);
+            }
+        }
+        hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));
+        if (XtHasCallbacks(hookobj, XtNconfigureHook) == XtCallbackHasSome) {
+            req.type = XtHconfigure;
+            req.widget = w;
+            XtCallCallbackList(hookobj,
+                               ((HookObject) hookobj)->hooks.
+                               confighook_callbacks, (XtPointer) &req);
+        }
+        {
+            XtWidgetProc resize;
+
+            LOCK_PROCESS;
+            resize = XtClass(w)->core_class.resize;
+            UNLOCK_PROCESS;
+            if ((req.changeMask & (CWWidth | CWHeight)) &&
+                resize != (XtWidgetProc) NULL) {
+                CALLGEOTAT(_XtGeoTrace(w, "Resize proc is called.\n"));
+                (*resize) (w);
+            }
+        }
+    }
+    else {
+        CALLGEOTAT(_XtGeoTrace(w, "No change in configuration\n"));
     }
 
     CALLGEOTAT(_XtGeoTab(-1));
     UNLOCK_APP(app);
-} /* XtConfigureWidget */
+}                               /* XtConfigureWidget */
 
-void XtMoveWidget(
-    Widget w,
-    _XtPosition x,
-    _XtPosition y)
+void
+XtMoveWidget(Widget w, _XtPosition x, _XtPosition y)
 {
     XtConfigureWidget(w, x, y, w->core.width, w->core.height,
-		      w->core.border_width);
-} /* XtMoveWidget */
-
-void XtTranslateCoords(
-    register Widget w,
-    _XtPosition x,
-    _XtPosition y,
-    register Position *rootx,	/* return */
-    register Position *rooty)	/* return */
+                      w->core.border_width);
+}                               /* XtMoveWidget */
+
+void
+XtTranslateCoords(register Widget w,
+                  _XtPosition x,
+                  _XtPosition y,
+                  register Position *rootx, /* return */
+                  register Position *rooty) /* return */
 {
     Position garbagex, garbagey;
     XtAppContext app = XtWidgetToApplicationContext(w);
 
     LOCK_APP(app);
-    if (rootx == NULL) rootx = &garbagex;
-    if (rooty == NULL) rooty = &garbagey;
+    if (rootx == NULL)
+        rootx = &garbagex;
+    if (rooty == NULL)
+        rooty = &garbagey;
 
     *rootx = (Position) x;
     *rooty = (Position) y;
 
-    for (; w != NULL && ! XtIsShell(w); w = w->core.parent) {
-	*rootx = (Position) (*rootx + w->core.x + w->core.border_width);
-	*rooty = (Position) (*rooty + w->core.y + w->core.border_width);
+    for (; w != NULL && !XtIsShell(w); w = w->core.parent) {
+        *rootx = (Position) (*rootx + w->core.x + w->core.border_width);
+        *rooty = (Position) (*rooty + w->core.y + w->core.border_width);
     }
 
     if (w == NULL)
         XtAppWarningMsg(app,
-		"invalidShell","xtTranslateCoords",XtCXtToolkitError,
-                "Widget has no shell ancestor",
-		NULL, NULL);
+                        "invalidShell", "xtTranslateCoords", XtCXtToolkitError,
+                        "Widget has no shell ancestor", NULL, NULL);
     else {
-	Position x2, y2;
-	_XtShellGetCoordinates( w, &x2, &y2 );
-	*rootx = (Position) (*rootx + x2 + w->core.border_width);
-	*rooty = (Position) (*rooty + y2 + w->core.border_width);
+        Position x2, y2;
+
+        _XtShellGetCoordinates(w, &x2, &y2);
+        *rootx = (Position) (*rootx + x2 + w->core.border_width);
+        *rooty = (Position) (*rooty + y2 + w->core.border_width);
     }
     UNLOCK_APP(app);
 }
 
-XtGeometryResult XtQueryGeometry(
-    Widget widget,
-    register XtWidgetGeometry *intended, /* parent's changes; may be NULL */
-    XtWidgetGeometry *reply)	/* child's preferred geometry; never NULL */
-{
+XtGeometryResult XtQueryGeometry(Widget widget,
+                                 register XtWidgetGeometry *intended, /* parent's changes; may be NULL */
+                                 XtWidgetGeometry *reply) {    /* child's preferred geometry; never NULL */
     XtWidgetGeometry null_intended;
     XtGeometryHandler query;
     XtGeometryResult result;
+
     WIDGET_TO_APPCON(widget);
 
     CALLGEOTAT(_XtGeoTrace(widget,
-		     "\"%s\" is asking its preferred geometry to \"%s\".\n",
-		     (XtParent(widget))?XtName(XtParent(widget)):"Root",
-		     XtName(widget)));
+                           "\"%s\" is asking its preferred geometry to \"%s\".\n",
+                           (XtParent(widget)) ? XtName(XtParent(widget)) :
+                           "Root", XtName(widget)));
     CALLGEOTAT(_XtGeoTab(1));
 
     LOCK_APP(app);
@@ -761,57 +785,62 @@ XtGeometryResult XtQueryGeometry(
     UNLOCK_PROCESS;
     reply->request_mode = 0;
     if (query != NULL) {
-	if (intended == NULL) {
-	    null_intended.request_mode = 0;
-	    intended = &null_intended;
+        if (intended == NULL) {
+            null_intended.request_mode = 0;
+            intended = &null_intended;
 #ifdef XT_GEO_TATTLER
-	    CALLGEOTAT(_XtGeoTrace(widget,"without any constraint.\n"));
-	} else {
-	    CALLGEOTAT(_XtGeoTrace(widget,
-				   "with the following constraints:\n"));
-
-	    if (intended->request_mode & CWX) {
-		CALLGEOTAT(_XtGeoTrace(widget," x = %d\n",intended->x));
-	    }
-	    if (intended->request_mode & CWY) {
-		CALLGEOTAT(_XtGeoTrace(widget," y = %d\n",intended->y));
-	    }
-	    if (intended->request_mode & CWWidth) {
-		CALLGEOTAT(_XtGeoTrace(widget,
-				       " width = %d\n",intended->width));
-	    }
-	    if (intended->request_mode & CWHeight) {
-		CALLGEOTAT(_XtGeoTrace(widget,
-				       " height = %d\n",intended->height));
-	    }
-	    if (intended->request_mode & CWBorderWidth) {
-		CALLGEOTAT(_XtGeoTrace(widget,
-			       " border_width = %d\n",intended->border_width));
-	    }
+            CALLGEOTAT(_XtGeoTrace(widget, "without any constraint.\n"));
+        }
+        else {
+            CALLGEOTAT(_XtGeoTrace(widget,
+                                   "with the following constraints:\n"));
+
+            if (intended->request_mode & CWX) {
+                CALLGEOTAT(_XtGeoTrace(widget, " x = %d\n", intended->x));
+            }
+            if (intended->request_mode & CWY) {
+                CALLGEOTAT(_XtGeoTrace(widget, " y = %d\n", intended->y));
+            }
+            if (intended->request_mode & CWWidth) {
+                CALLGEOTAT(_XtGeoTrace(widget,
+                                       " width = %d\n", intended->width));
+            }
+            if (intended->request_mode & CWHeight) {
+                CALLGEOTAT(_XtGeoTrace(widget,
+                                       " height = %d\n", intended->height));
+            }
+            if (intended->request_mode & CWBorderWidth) {
+                CALLGEOTAT(_XtGeoTrace(widget,
+                                       " border_width = %d\n",
+                                       intended->border_width));
+            }
 #endif
-	}
+        }
 
-	result = (*query) (widget, intended, reply);
+        result = (*query) (widget, intended, reply);
     }
     else {
-	CALLGEOTAT(_XtGeoTrace(widget,"\"%s\" has no QueryGeometry proc, return the current state\n",XtName(widget)));
+        CALLGEOTAT(_XtGeoTrace
+                   (widget,
+                    "\"%s\" has no QueryGeometry proc, return the current state\n",
+                    XtName(widget)));
 
-	result = XtGeometryYes;
+        result = XtGeometryYes;
     }
 
 #ifdef XT_GEO_TATTLER
 #define FillIn(mask, field) \
-	if (!(reply->request_mode & mask)) {\
-	      reply->field = widget->core.field;\
-	      _XtGeoTrace(widget," using core %s = %d.\n","field",\
-			                               widget->core.field);\
-	} else {\
-	      _XtGeoTrace(widget," replied %s = %d\n","field",\
-			                           reply->field);\
-	}
+        if (!(reply->request_mode & mask)) {\
+              reply->field = widget->core.field;\
+              _XtGeoTrace(widget," using core %s = %d.\n","field",\
+                                                       widget->core.field);\
+        } else {\
+              _XtGeoTrace(widget," replied %s = %d\n","field",\
+                                                   reply->field);\
+        }
 #else
 #define FillIn(mask, field) \
-	if (!(reply->request_mode & mask)) reply->field = widget->core.field;
+        if (!(reply->request_mode & mask)) reply->field = widget->core.field;
 #endif
 
     FillIn(CWX, x);
@@ -824,7 +853,7 @@ XtGeometryResult XtQueryGeometry(
 #undef FillIn
 
     if (!(reply->request_mode & CWStackMode))
-	reply->stack_mode = XtSMDontChange;
+        reply->stack_mode = XtSMDontChange;
     UNLOCK_APP(app);
     return result;
 }
diff --git a/src/GetActKey.c b/src/GetActKey.c
index cf1278e..7bfc2e0 100644
--- a/src/GetActKey.c
+++ b/src/GetActKey.c
@@ -1,5 +1,3 @@
-/*LINTLIBRARY*/
-
 /***********************************************************
 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
 
@@ -75,36 +73,36 @@ in this Software without prior written authorization from The Open Group.
 #endif
 #include "IntrinsicI.h"
 
-KeySym XtGetActionKeysym(
-    XEvent *event,
-    Modifiers *modifiers_return)
+KeySym
+XtGetActionKeysym(XEvent *event, Modifiers *modifiers_return)
 {
     TMKeyContext tm_context;
     Modifiers modifiers;
     KeySym keysym, retval;
 
     LOCK_PROCESS;
-    tm_context= _XtGetPerDisplay(event->xany.display)->tm_context;
+    tm_context = _XtGetPerDisplay(event->xany.display)->tm_context;
+
     if (event->xany.type != KeyPress && event->xany.type != KeyRelease) {
-	UNLOCK_PROCESS;
-	return NoSymbol;
+        UNLOCK_PROCESS;
+        return NoSymbol;
     }
     if (tm_context != NULL
-	&& event == tm_context->event
-	&& event->xany.serial == tm_context->serial ) {
-
-	if (modifiers_return != NULL)
-	    *modifiers_return = tm_context->modifiers;
-	retval = tm_context->keysym;
-	UNLOCK_PROCESS;
-	return retval;
+        && event == tm_context->event
+        && event->xany.serial == tm_context->serial) {
+
+        if (modifiers_return != NULL)
+            *modifiers_return = tm_context->modifiers;
+        retval = tm_context->keysym;
+        UNLOCK_PROCESS;
+        return retval;
     }
 
-    XtTranslateKeycode( event->xany.display, (KeyCode)event->xkey.keycode,
-		        event->xkey.state, &modifiers, &keysym );
+    XtTranslateKeycode(event->xany.display, (KeyCode)event->xkey.keycode,
+                       event->xkey.state, &modifiers, &keysym);
 
     if (modifiers_return != NULL)
-	*modifiers_return = event->xkey.state & modifiers;
+        *modifiers_return = event->xkey.state & modifiers;
 
     UNLOCK_PROCESS;
     return keysym;
diff --git a/src/GetResList.c b/src/GetResList.c
index 4c8fe0d..f649de5 100644
--- a/src/GetResList.c
+++ b/src/GetResList.c
@@ -78,124 +78,127 @@ in this Software without prior written authorization from The Open Group.
  * XtGetResourceList(), XtGetConstraintResourceList()
  */
 
-#define	TOXRMQUARK(p) ((XrmQuark)(long)(p))	/* avoid LP64 warnings */
+#define TOXRMQUARK(p) ((XrmQuark)(long)(p))     /* avoid LP64 warnings */
 
-void XtGetResourceList(
-	WidgetClass widget_class,
-	XtResourceList *resources,
-	Cardinal *num_resources)
+void
+XtGetResourceList(WidgetClass widget_class,
+                  XtResourceList *resources,
+                  Cardinal *num_resources)
 {
-	int size;
-	register Cardinal i, dest = 0;
-	register XtResourceList *list, dlist;
-
-	LOCK_PROCESS;
-	size = (int) (widget_class->core_class.num_resources * sizeof(XtResource));
-	*resources = (XtResourceList) __XtMalloc((unsigned) size);
-
-	if (!widget_class->core_class.class_inited) {
-	    /* Easy case */
-
-	    (void) memmove((char *) *resources,
-			   (char *)widget_class->core_class.resources, (size_t) size);
-	    *num_resources = widget_class->core_class.num_resources;
-	    UNLOCK_PROCESS;
-	    return;
-	}
-
-	/* Nope, it's the hard case */
-
-	list = (XtResourceList *) widget_class->core_class.resources;
-	dlist = *resources;
-	for (i = 0; i < widget_class->core_class.num_resources; i++) {
-	    if (list[i] != NULL) {
-		dlist[dest].resource_name = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_name));
-		dlist[dest].resource_class = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_class));
-		dlist[dest].resource_type = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_type));
-		dlist[dest].resource_size = list[i]->resource_size;
-		/* trust that resource_offset isn't that big */
-		dlist[dest].resource_offset = (Cardinal)
-			-((int)(list[i]->resource_offset + 1));
-		dlist[dest].default_type = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->default_type));
-		dlist[dest].default_addr = list[i]->default_addr;
-		dest++;
-	    }
-	}
-	*num_resources = dest;
-	UNLOCK_PROCESS;
-}
+    int size;
+    register Cardinal i, dest = 0;
+    register XtResourceList *list, dlist;
+
+    LOCK_PROCESS;
+    size = (int) (widget_class->core_class.num_resources * sizeof(XtResource));
+    *resources = (XtResourceList) __XtMalloc((unsigned) size);
+
+    if (!widget_class->core_class.class_inited) {
+        /* Easy case */
+
+        (void) memmove((char *) *resources,
+                       (char *) widget_class->core_class.resources,
+                       (size_t) size);
+        *num_resources = widget_class->core_class.num_resources;
+        UNLOCK_PROCESS;
+        return;
+    }
 
+    /* Nope, it's the hard case */
+
+    list = (XtResourceList *) widget_class->core_class.resources;
+    dlist = *resources;
+    for (i = 0; i < widget_class->core_class.num_resources; i++) {
+        if (list[i] != NULL) {
+            dlist[dest].resource_name = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_name));
+            dlist[dest].resource_class = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_class));
+            dlist[dest].resource_type = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_type));
+            dlist[dest].resource_size = list[i]->resource_size;
+            /* trust that resource_offset isn't that big */
+            dlist[dest].resource_offset = (Cardinal)
+                -((int) (list[i]->resource_offset + 1));
+            dlist[dest].default_type = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->default_type));
+            dlist[dest].default_addr = list[i]->default_addr;
+            dest++;
+        }
+    }
+    *num_resources = dest;
+    UNLOCK_PROCESS;
+}
 
-static Boolean ClassIsSubclassOf(WidgetClass class, WidgetClass superclass)
+static Boolean
+ClassIsSubclassOf(WidgetClass class, WidgetClass superclass)
 {
     for (; class != NULL; class = class->core_class.superclass) {
-	if (class == superclass) return True;
+        if (class == superclass)
+            return True;
     }
     return False;
 }
 
-void XtGetConstraintResourceList(
-	WidgetClass widget_class,
-	XtResourceList *resources,
-	Cardinal *num_resources)
+void
+XtGetConstraintResourceList(WidgetClass widget_class,
+                            XtResourceList *resources,
+                            Cardinal *num_resources)
 {
-	int size;
-	register Cardinal i, dest = 0;
-	register XtResourceList *list, dlist;
-	ConstraintWidgetClass class = (ConstraintWidgetClass)widget_class;
-
-	LOCK_PROCESS;
-	if (   (class->core_class.class_inited &&
-		!(class->core_class.class_inited & ConstraintClassFlag))
-	    || (!class->core_class.class_inited &&
-		!ClassIsSubclassOf(widget_class, constraintWidgetClass))
-	    || class->constraint_class.num_resources == 0) {
-
-	    *resources = NULL;
-	    *num_resources = 0;
-	    UNLOCK_PROCESS;
-	    return;
-	}
-
-	size = (int) (class->constraint_class.num_resources * sizeof(XtResource));
-	*resources = (XtResourceList) __XtMalloc((unsigned) size);
-
-	if (!class->core_class.class_inited) {
-	    /* Easy case */
-
-	    (void) memmove((char *) *resources,
-			   (char *)class->constraint_class.resources, (size_t) size);
-	    *num_resources = class->constraint_class.num_resources;
-	    UNLOCK_PROCESS;
-	    return;
-	}
-
-	/* Nope, it's the hard case */
-
-	list = (XtResourceList *) class->constraint_class.resources;
-	dlist = *resources;
-	for (i = 0; i < class->constraint_class.num_resources; i++) {
-	    if (list[i] != NULL) {
-		dlist[dest].resource_name = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_name));
-		dlist[dest].resource_class = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_class));
-		dlist[dest].resource_type = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->resource_type));
-		dlist[dest].resource_size = list[i]->resource_size;
-		/* trust that resource_offset isn't that big */
-		dlist[dest].resource_offset = (Cardinal)
-			-((int)(list[i]->resource_offset + 1));
-		dlist[dest].default_type = (String)
-			XrmQuarkToString(TOXRMQUARK(list[i]->default_type));
-		dlist[dest].default_addr = list[i]->default_addr;
-		dest++;
-	    }
-	}
-	*num_resources = dest;
-	UNLOCK_PROCESS;
+    int size;
+    register Cardinal i, dest = 0;
+    register XtResourceList *list, dlist;
+    ConstraintWidgetClass class = (ConstraintWidgetClass) widget_class;
+
+    LOCK_PROCESS;
+    if ((class->core_class.class_inited &&
+         !(class->core_class.class_inited & ConstraintClassFlag))
+        || (!class->core_class.class_inited &&
+            !ClassIsSubclassOf(widget_class, constraintWidgetClass))
+        || class->constraint_class.num_resources == 0) {
+
+        *resources = NULL;
+        *num_resources = 0;
+        UNLOCK_PROCESS;
+        return;
+    }
+
+    size = (int) (class->constraint_class.num_resources * sizeof(XtResource));
+    *resources = (XtResourceList) __XtMalloc((unsigned) size);
+
+    if (!class->core_class.class_inited) {
+        /* Easy case */
+
+        (void) memmove((char *) *resources,
+                       (char *) class->constraint_class.resources,
+                       (size_t) size);
+        *num_resources = class->constraint_class.num_resources;
+        UNLOCK_PROCESS;
+        return;
+    }
+
+    /* Nope, it's the hard case */
+
+    list = (XtResourceList *) class->constraint_class.resources;
+    dlist = *resources;
+    for (i = 0; i < class->constraint_class.num_resources; i++) {
+        if (list[i] != NULL) {
+            dlist[dest].resource_name = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_name));
+            dlist[dest].resource_class = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_class));
+            dlist[dest].resource_type = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->resource_type));
+            dlist[dest].resource_size = list[i]->resource_size;
+            /* trust that resource_offset isn't that big */
+            dlist[dest].resource_offset = (Cardinal)
+                -((int) (list[i]->resource_offset + 1));
+            dlist[dest].default_type = (String)
+                XrmQuarkToString(TOXRMQUARK(list[i]->default_type));
+            dlist[dest].default_addr = list[i]->default_addr;
+            dest++;
+        }
+    }
+    *num_resources = dest;
+    UNLOCK_PROCESS;
 }
diff --git a/src/GetValues.c b/src/GetValues.c
index c836366..3e8bfa0 100644
--- a/src/GetValues.c
+++ b/src/GetValues.c
@@ -1,5 +1,3 @@
-/*LINTLIBRARY*/
-
 /***********************************************************
 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
 
@@ -76,67 +74,65 @@ in this Software without prior written authorization from The Open Group.
 #include "IntrinsicI.h"
 #include "StringDefs.h"
 
-static int GetValues(
-  char*			base,		/* Base address to fetch values from */
-  XrmResourceList*      res,		/* The current resource values.      */
-  register Cardinal	num_resources,	/* number of items in resources      */
-  ArgList 		args,		/* The resource values requested     */
-  Cardinal		num_args)	/* number of items in arg list       */
-{
-    register ArgList		arg;
-    register Cardinal 		i;
-    register XrmName		argName;
-    register XrmResourceList*   xrmres;
-    int				translation_arg_num = -1;
+static int
+GetValues(char *base,                   /* Base address to fetch values from */
+          XrmResourceList *res,        /* The current resource values.      */
+          register Cardinal num_resources, /* number of items in resources   */
+          ArgList args,                 /* The resource values requested     */
+          Cardinal num_args)            /* number of items in arg list       */
+{                
+    register ArgList arg;
+    register Cardinal i;
+    register XrmName argName;
+    register XrmResourceList *xrmres;
+    int translation_arg_num = -1;
     static XrmQuark QCallback = NULLQUARK;
     static XrmQuark QTranslationTable = NULLQUARK;
 
     LOCK_PROCESS;
     if (QCallback == NULLQUARK) {
-	QCallback = XrmPermStringToQuark(XtRCallback);
-	QTranslationTable = XrmPermStringToQuark(XtRTranslationTable);
+        QCallback = XrmPermStringToQuark(XtRCallback);
+        QTranslationTable = XrmPermStringToQuark(XtRTranslationTable);
     }
     UNLOCK_PROCESS;
 
     /* Resource lists should be in compiled form already  */
 
-    for (arg = args ; num_args != 0; num_args--, arg++) {
-	argName = StringToName(arg->name);
-	for (xrmres = res, i = 0; i < num_resources; i++, xrmres++) {
-	    if (argName == (*xrmres)->xrm_name) {
-		/* hack; do special cases here instead of a get_values_hook
-		 * because get_values_hook looses info as to
-		 * whether arg->value == NULL for ancient compatibility
-		 * mode in _XtCopyToArg.  It helps performance, too...
-		 */
-		if ((*xrmres)->xrm_type == QCallback) {
-		    XtCallbackList callback = _XtGetCallbackList(
-			      (InternalCallbackList *)
-			      (base - (*xrmres)->xrm_offset - 1));
-		    _XtCopyToArg(
-			      (char*)&callback, &arg->value,
-			      (*xrmres)->xrm_size);
-		}
-		else if ((*xrmres)->xrm_type == QTranslationTable)
-		    translation_arg_num = (int) (arg - args);
-		else {
-		    _XtCopyToArg(
-			      base - (*xrmres)->xrm_offset - 1,
-			      &arg->value,
-			      (*xrmres)->xrm_size);
-		}
-		break;
-	    }
-	}
+    for (arg = args; num_args != 0; num_args--, arg++) {
+        argName = StringToName(arg->name);
+        for (xrmres = res, i = 0; i < num_resources; i++, xrmres++) {
+            if (argName == (*xrmres)->xrm_name) {
+                /* hack; do special cases here instead of a get_values_hook
+                 * because get_values_hook looses info as to
+                 * whether arg->value == NULL for ancient compatibility
+                 * mode in _XtCopyToArg.  It helps performance, too...
+                 */
+                if ((*xrmres)->xrm_type == QCallback) {
+                    XtCallbackList callback =
+                        _XtGetCallbackList((InternalCallbackList *)
+                                           (base - (*xrmres)->xrm_offset - 1));
+
+                    _XtCopyToArg((char *) &callback, &arg->value,
+                                 (*xrmres)->xrm_size);
+                }
+                else if ((*xrmres)->xrm_type == QTranslationTable)
+                    translation_arg_num = (int) (arg - args);
+                else {
+                    _XtCopyToArg(base - (*xrmres)->xrm_offset - 1,
+                                 &arg->value, (*xrmres)->xrm_size);
+                }
+                break;
+            }
+        }
     }
     return translation_arg_num;
-} /* GetValues */
+}                               /* GetValues */
 
-static void CallGetValuesHook(
-    WidgetClass	  widget_class,
-    Widget	  w,
-    ArgList	  args,
-    Cardinal	  num_args)
+static void
+CallGetValuesHook(WidgetClass widget_class,
+                  Widget w,
+                  ArgList args,
+                  Cardinal num_args)
 {
     WidgetClass superclass;
     XtArgsProc get_values_hook;
@@ -145,116 +141,119 @@ static void CallGetValuesHook(
     superclass = widget_class->core_class.superclass;
     UNLOCK_PROCESS;
     if (superclass != NULL)
-	CallGetValuesHook (superclass, w, args, num_args);
+        CallGetValuesHook(superclass, w, args, num_args);
 
     LOCK_PROCESS;
     get_values_hook = widget_class->core_class.get_values_hook;
     UNLOCK_PROCESS;
     if (get_values_hook != NULL)
-	(*get_values_hook) (w, args, &num_args);
+        (*get_values_hook) (w, args, &num_args);
 }
 
-
-
-static void CallConstraintGetValuesHook(
-    WidgetClass	  widget_class,
-    Widget	  w,
-    ArgList	  args,
-    Cardinal	  num_args)
+static void
+CallConstraintGetValuesHook(WidgetClass widget_class,
+                            Widget w,
+                            ArgList args,
+                            Cardinal num_args)
 {
     ConstraintClassExtension ext;
 
     LOCK_PROCESS;
-    if (widget_class->core_class.superclass
-	->core_class.class_inited & ConstraintClassFlag) {
-	CallConstraintGetValuesHook
-	    (widget_class->core_class.superclass, w, args, num_args);
+    if (widget_class->core_class.superclass->core_class.
+        class_inited & ConstraintClassFlag) {
+        CallConstraintGetValuesHook(widget_class->core_class.superclass, w,
+                                    args, num_args);
     }
 
-    for (ext = (ConstraintClassExtension)((ConstraintWidgetClass)widget_class)
-		 ->constraint_class.extension;
-	 ext != NULL && ext->record_type != NULLQUARK;
-	 ext = (ConstraintClassExtension)ext->next_extension);
+    for (ext = (ConstraintClassExtension) ((ConstraintWidgetClass) widget_class)
+         ->constraint_class.extension;
+         ext != NULL && ext->record_type != NULLQUARK;
+         ext = (ConstraintClassExtension) ext->next_extension);
 
     if (ext != NULL) {
-	if (  ext->version == XtConstraintExtensionVersion
-	      && ext->record_size == sizeof(ConstraintClassExtensionRec)) {
-	    if (ext->get_values_hook != NULL)
-		(*(ext->get_values_hook)) (w, args, &num_args);
-	} else {
-	    String params[1];
-	    Cardinal num_params = 1;
-	    params[0] = widget_class->core_class.class_name;
-	    XtAppWarningMsg(XtWidgetToApplicationContext(w),
-		 "invalidExtension", "xtCreateWidget", XtCXtToolkitError,
-		 "widget class %s has invalid ConstraintClassExtension record",
-		 params, &num_params);
-	}
+        if (ext->version == XtConstraintExtensionVersion
+            && ext->record_size == sizeof(ConstraintClassExtensionRec)) {
+            if (ext->get_values_hook != NULL)
+                (*(ext->get_values_hook)) (w, args, &num_args);
+        }
+        else {
+            String params[1];
+            Cardinal num_params = 1;
+
+            params[0] = widget_class->core_class.class_name;
+            XtAppWarningMsg(XtWidgetToApplicationContext(w),
+                            "invalidExtension", "xtCreateWidget",
+                            XtCXtToolkitError,
+                            "widget class %s has invalid ConstraintClassExtension record",
+                            params, &num_params);
+        }
     }
     UNLOCK_PROCESS;
 }
 
-
-void XtGetValues(
-    register Widget   w,
-    register ArgList  args,
-    register Cardinal num_args)
+void
+XtGetValues(register Widget w,
+            register ArgList args,
+            register Cardinal num_args)
 {
     WidgetClass wc;
     int targ;
     XtAppContext app = XtWidgetToApplicationContext(w);
 
-    if (num_args == 0) return;
+    if (num_args == 0)
+        return;
     if ((args == NULL) && (num_args != 0)) {
-	XtAppErrorMsg(app,
-		"invalidArgCount","xtGetValues",XtCXtToolkitError,
-            "Argument count > 0 on NULL argument list in XtGetValues",
-              NULL, NULL);
+        XtAppErrorMsg(app,
+                      "invalidArgCount", "xtGetValues", XtCXtToolkitError,
+                      "Argument count > 0 on NULL argument list in XtGetValues",
+                      NULL, NULL);
     }
 
     LOCK_APP(app);
     wc = XtClass(w);
     LOCK_PROCESS;
     /* Get widget values */
-    targ = GetValues((char*)w, (XrmResourceList *) wc->core_class.resources,
-	wc->core_class.num_resources, args, num_args);
+    targ = GetValues((char *) w, (XrmResourceList *) wc->core_class.resources,
+                     wc->core_class.num_resources, args, num_args);
     UNLOCK_PROCESS;
     if (targ != -1 && XtIsWidget(w)) {
-	XtTranslations translations = _XtGetTranslationValue(w);
-	_XtCopyToArg((char*)&translations, &args[targ].value,
-		     sizeof(XtTranslations));
+        XtTranslations translations = _XtGetTranslationValue(w);
+
+        _XtCopyToArg((char *) &translations, &args[targ].value,
+                     sizeof(XtTranslations));
     }
 
     /* Get constraint values if necessary */
     /* constraints may be NULL if constraint_size==0 */
     if (XtParent(w) != NULL && !XtIsShell(w) && XtIsConstraint(XtParent(w)) &&
-	w->core.constraints) {
-	ConstraintWidgetClass cwc
-	    = (ConstraintWidgetClass) XtClass(XtParent(w));
-	LOCK_PROCESS;
-	GetValues((char*)w->core.constraints,
-		  (XrmResourceList *)(cwc->constraint_class.resources),
-		  cwc->constraint_class.num_resources, args, num_args);
-	UNLOCK_PROCESS;
+        w->core.constraints) {
+        ConstraintWidgetClass cwc
+            = (ConstraintWidgetClass) XtClass(XtParent(w));
+        LOCK_PROCESS;
+        GetValues((char *) w->core.constraints,
+                  (XrmResourceList *) (cwc->constraint_class.resources),
+                  cwc->constraint_class.num_resources, args, num_args);
+        UNLOCK_PROCESS;
     }
     /* Notify any class procedures that we have performed get_values */
     CallGetValuesHook(wc, w, args, num_args);
 
     /* Notify constraint get_values if necessary */
     if (XtParent(w) != NULL && !XtIsShell(w) && XtIsConstraint(XtParent(w)))
-	CallConstraintGetValuesHook(XtClass(XtParent(w)), w, args,num_args);
+        CallConstraintGetValuesHook(XtClass(XtParent(w)), w, args, num_args);
     UNLOCK_APP(app);
-} /* XtGetValues */
-
-void XtGetSubvalues(
-  XtPointer	    base,           /* Base address to fetch values from */
-  XtResourceList    resources,      /* The current resource values.      */
-  Cardinal	    num_resources,  /* number of items in resources      */
-  ArgList	    args,           /* The resource values requested     */
-  Cardinal	    num_args)       /* number of items in arg list       */
+}                               /* XtGetValues */
+
+void
+XtGetSubvalues(XtPointer base,          /* Base address to fetch values from */
+               XtResourceList resources,/* The current resource values.      */
+               Cardinal num_resources,  /* number of items in resources      */
+               ArgList args,            /* The resource values requested */
+               Cardinal num_args)       /* number of items in arg list       */
 {
-    XrmResourceList* xrmres;
+    XrmResourceList *xrmres;
+
     xrmres = _XtCreateIndirectionTable(resources, num_resources);
-    GetValues((char*)base, xrmres, num_resources, args, num_args);
-    XtFree((char *)xrmres);
+    GetValues((char *) base, xrmres, num_resources, args, num_args);
+    XtFree((char *) xrmres);
 }
diff --git a/src/HookObj.c b/src/HookObj.c
index 8aefa53..9216774 100644
--- a/src/HookObj.c
+++ b/src/HookObj.c
@@ -35,6 +35,7 @@ in this Software without prior written authorization from The Open Group.
  *
  ******************************************************************/
 
+/* *INDENT-OFF* */
 static XtResource resources[] = {
   { XtNcreateHook, XtCCallback, XtRCallback, sizeof(XtPointer),
     XtOffsetOf(HookObjRec, hooks.createhook_callbacks),
@@ -56,79 +57,84 @@ static XtResource resources[] = {
   { XtNnumShells, XtCReadOnly, XtRCardinal, sizeof(Cardinal),
     XtOffsetOf(HookObjRec, hooks.num_shells), XtRImmediate, (XtPointer) 0 }
 };
+/* *INDENT-ON* */
 
 static void GetValuesHook(Widget widget, ArgList args, Cardinal *num_args);
 static void Initialize(Widget req, Widget new, ArgList args,
-			Cardinal *num_args);
+                       Cardinal *num_args);
 
+/* *INDENT-OFF* */
 externaldef(hookobjclassrec) HookObjClassRec hookObjClassRec = {
   { /* Object Class Part */
-    /* superclass	  */	(WidgetClass)&objectClassRec,
-    /* class_name	  */	"Hook",
-    /* widget_size	  */	sizeof(HookObjRec),
-    /* class_initialize   */    NULL,
-    /* class_part_initialize*/	NULL,
-    /* class_inited       */	FALSE,
-    /* initialize	  */	Initialize,
-    /* initialize_hook    */	NULL,
-    /* realize		  */	NULL,
-    /* actions		  */	NULL,
-    /* num_actions	  */	0,
-    /* resources	  */	resources,
-    /* num_resources	  */	XtNumber(resources),
-    /* xrm_class	  */	NULLQUARK,
-    /* compress_motion	  */	FALSE,
-    /* compress_exposure  */	TRUE,
-    /* compress_enterleave*/ 	FALSE,
-    /* visible_interest	  */	FALSE,
-    /* destroy		  */	NULL,
-    /* resize		  */	NULL,
-    /* expose		  */	NULL,
-    /* set_values	  */	NULL,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */	NULL,
-    /* get_values_hook    */	GetValuesHook,
-    /* accept_focus	  */	NULL,
-    /* version		  */	XtVersion,
-    /* callback_offsets   */    NULL,
-    /* tm_table           */    NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */	NULL,
-    /* extension	    */  NULL
+    /* superclass              */ (WidgetClass)&objectClassRec,
+    /* class_name              */ "Hook",
+    /* widget_size             */ sizeof(HookObjRec),
+    /* class_initialize        */ NULL,
+    /* class_part_initialize   */ NULL,
+    /* class_inited            */ FALSE,
+    /* initialize              */ Initialize,
+    /* initialize_hook         */ NULL,
+    /* realize                 */ NULL,
+    /* actions                 */ NULL,
+    /* num_actions             */ 0,
+    /* resources               */ resources,
+    /* num_resources           */ XtNumber(resources),
+    /* xrm_class               */ NULLQUARK,
+    /* compress_motion         */ FALSE,
+    /* compress_exposure       */ TRUE,
+    /* compress_enterleave     */ FALSE,
+    /* visible_interest        */ FALSE,
+    /* destroy                 */ NULL,
+    /* resize                  */ NULL,
+    /* expose                  */ NULL,
+    /* set_values              */ NULL,
+    /* set_values_hook         */ NULL,
+    /* set_values_almost       */ NULL,
+    /* get_values_hook         */ GetValuesHook,
+    /* accept_focus            */ NULL,
+    /* version                 */ XtVersion,
+    /* callback_offsets        */ NULL,
+    /* tm_table                */ NULL,
+    /* query_geometry          */ NULL,
+    /* display_accelerator     */ NULL,
+    /* extension               */ NULL
   },
   { /* HookObj Class Part */
-    /* unused               */	0
+    /* unused               */  0
   }
 };
+/* *INDENT-ON* */
 
-externaldef(hookObjectClass) WidgetClass hookObjectClass =
-	(WidgetClass)&hookObjClassRec;
+externaldef(hookObjectClass)
+WidgetClass hookObjectClass = (WidgetClass) &hookObjClassRec;
 
-static void FreeShellList(
-    Widget w,
-    XtPointer closure,
-    XtPointer call_data)
+static void
+FreeShellList(Widget w,
+              XtPointer closure _X_UNUSED,
+              XtPointer call_data _X_UNUSED)
 {
-    HookObject h = (HookObject)w;
+    HookObject h = (HookObject) w;
+
     if (h->hooks.shells != NULL)
-	XtFree((char*)h->hooks.shells);
+        XtFree((char *) h->hooks.shells);
 }
 
-static void Initialize(
-    Widget req,
-    Widget new,
-    ArgList args,
-    Cardinal* num_args)
+static void
+Initialize(Widget req _X_UNUSED,
+           Widget new,
+           ArgList args _X_UNUSED,
+           Cardinal *num_args _X_UNUSED)
 {
     HookObject w = (HookObject) new;
+
     w->hooks.max_shells = 0;
-    XtAddCallback (new, XtNdestroyCallback, FreeShellList, (XtPointer) NULL);
+    XtAddCallback(new, XtNdestroyCallback, FreeShellList, (XtPointer) NULL);
 }
 
-static void GetValuesHook(
-    Widget widget,
-    ArgList args,
-    Cardinal* num_args)
+static void
+GetValuesHook(Widget widget _X_UNUSED,
+              ArgList args _X_UNUSED,
+              Cardinal *num_args _X_UNUSED)
 {
     /* get the XtNshells and XtNnumShells pseudo-resources */
 }
diff --git a/src/Hooks.c b/src/Hooks.c
index 64e8355..3af4751 100644
--- a/src/Hooks.c
+++ b/src/Hooks.c
@@ -24,131 +24,129 @@ in this Software without prior written authorization from The Open Group.
 
 */
 
-/*LINTLIBRARY*/
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
 #include "CreateI.h"
 
-static void FreeBlockHookList(
-    Widget widget,		/* unused (and invalid) */
-    XtPointer closure,		/* ActionHook* */
-    XtPointer call_data)	/* unused */
+static void
+FreeBlockHookList(Widget widget _X_UNUSED,
+                  XtPointer closure, /* ActionHook* */
+                  XtPointer call_data _X_UNUSED)
 {
-    BlockHook list = *(BlockHook*)closure;
+    BlockHook list = *(BlockHook *) closure;
+
     while (list != NULL) {
-	BlockHook next = list->next;
-	XtFree( (XtPointer)list );
-	list = next;
+        BlockHook next = list->next;
+
+        XtFree((XtPointer) list);
+        list = next;
     }
 }
 
-
-XtBlockHookId XtAppAddBlockHook(
-    XtAppContext app,
-    XtBlockHookProc proc,
-    XtPointer closure)
+XtBlockHookId
+XtAppAddBlockHook(XtAppContext app, XtBlockHookProc proc, XtPointer closure)
 {
     BlockHook hook = XtNew(BlockHookRec);
+
     LOCK_APP(app);
     hook->next = app->block_hook_list;
     hook->app = app;
     hook->proc = proc;
     hook->closure = closure;
     if (app->block_hook_list == NULL) {
-	_XtAddCallback( &app->destroy_callbacks,
-		        FreeBlockHookList,
-		        (XtPointer)&app->block_hook_list
-		      );
+        _XtAddCallback(&app->destroy_callbacks,
+                       FreeBlockHookList, (XtPointer) &app->block_hook_list);
     }
     app->block_hook_list = hook;
     UNLOCK_APP(app);
-    return (XtBlockHookId)hook;
+    return (XtBlockHookId) hook;
 }
 
-
-void XtRemoveBlockHook(
-    XtBlockHookId id)
+void
+XtRemoveBlockHook(XtBlockHookId id)
 {
-    BlockHook *p, hook = (BlockHook)id;
+    BlockHook *p, hook = (BlockHook) id;
     XtAppContext app = hook->app;
+
     LOCK_APP(app);
     for (p = &app->block_hook_list; p != NULL && *p != hook; p = &(*p)->next);
     if (p == NULL) {
 #ifdef DEBUG
-	XtAppWarningMsg(app, "badId", "xtRemoveBlockHook", XtCXtToolkitError,
-			"XtRemoveBlockHook called with bad or old hook id",
-			NULL, NULL);
-#endif /*DEBUG*/
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app, "badId", "xtRemoveBlockHook", XtCXtToolkitError,
+                        "XtRemoveBlockHook called with bad or old hook id",
+                        NULL, NULL);
+#endif   /*DEBUG*/
+            UNLOCK_APP(app);
+        return;
     }
     *p = hook->next;
-    XtFree( (XtPointer)hook );
+    XtFree((XtPointer) hook);
     UNLOCK_APP(app);
 }
 
-static void DeleteShellFromHookObj(
-    Widget shell,
-    XtPointer closure,
-    XtPointer call_data)
+static void
+DeleteShellFromHookObj(Widget shell,
+                       XtPointer closure,
+                       XtPointer call_data _X_UNUSED)
 {
     /* app_con is locked when this function is called */
     Cardinal ii, jj;
     HookObject ho = (HookObject) closure;
 
     for (ii = 0; ii < ho->hooks.num_shells; ii++)
-	if (ho->hooks.shells[ii] == shell) {
-	    /* collapse the list */
-	    for (jj = ii; jj < ho->hooks.num_shells; jj++) {
-		if ((jj+1) < ho->hooks.num_shells)
-		    ho->hooks.shells[jj] = ho->hooks.shells[jj+1];
-	    }
-	    break;
-	}
+        if (ho->hooks.shells[ii] == shell) {
+            /* collapse the list */
+            for (jj = ii; jj < ho->hooks.num_shells; jj++) {
+                if ((jj + 1) < ho->hooks.num_shells)
+                    ho->hooks.shells[jj] = ho->hooks.shells[jj + 1];
+            }
+            break;
+        }
     ho->hooks.num_shells--;
 }
 
 #define SHELL_INCR 4
 
-void _XtAddShellToHookObj(
-    Widget shell)
+void
+_XtAddShellToHookObj(Widget shell)
 {
     /* app_con is locked when this function is called */
     HookObject ho = (HookObject) XtHooksOfDisplay(XtDisplay(shell));
 
     if (ho->hooks.num_shells == ho->hooks.max_shells) {
-	ho->hooks.max_shells += SHELL_INCR;
-	ho->hooks.shells =
-	    (WidgetList)XtRealloc((char*)ho->hooks.shells,
-		(Cardinal) (ho->hooks.max_shells * sizeof (Widget)));
+        ho->hooks.max_shells += SHELL_INCR;
+        ho->hooks.shells =
+            (WidgetList) XtRealloc((char *) ho->hooks.shells,
+                                   (Cardinal) (ho->hooks.max_shells *
+                                               sizeof(Widget)));
     }
     ho->hooks.shells[ho->hooks.num_shells++] = shell;
 
     XtAddCallback(shell, XtNdestroyCallback, DeleteShellFromHookObj,
-		  (XtPointer)ho);
+                  (XtPointer) ho);
 }
 
-Boolean _XtIsHookObject(
-    Widget widget)
+Boolean
+_XtIsHookObject(Widget widget)
 {
     return (widget->core.widget_class == hookObjectClass);
 }
 
-Widget XtHooksOfDisplay(
-    Display* dpy)
+Widget
+XtHooksOfDisplay(Display *dpy)
 {
     Widget retval;
     XtPerDisplay pd;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     pd = _XtGetPerDisplay(dpy);
     if (pd->hook_object == NULL)
-	pd->hook_object =
-	    _XtCreateHookObj((Screen*)DefaultScreenOfDisplay(dpy));
+        pd->hook_object =
+            _XtCreateHookObj((Screen *) DefaultScreenOfDisplay(dpy));
     retval = pd->hook_object;
     UNLOCK_APP(app);
     return retval;
diff --git a/src/Initialize.c b/src/Initialize.c
index 2adf1fd..8ae54b4 100644
--- a/src/Initialize.c
+++ b/src/Initialize.c
@@ -99,7 +99,7 @@ in this Software without prior written authorization from The Open Group.
 #define XtOpenApplication _XtOpenApplication
 #define XtAppInitialize _XtAppInitialize
 #define XtInitialize _XtInitialize
-#endif /* (SUNSHLIB || AIXSHLIB) && SHAREDCODE */
+#endif                          /* (SUNSHLIB || AIXSHLIB) && SHAREDCODE */
 
 /*
  * hpux
@@ -126,76 +126,77 @@ in this Software without prior written authorization from The Open Group.
  policy, which the toolkit avoids but I hate differing programs at this level.
 */
 
+/* *INDENT-OFF* */
 static XrmOptionDescRec const opTable[] = {
-{"+rv",		"*reverseVideo", XrmoptionNoArg,	(XtPointer) "off"},
-{"+synchronous","*synchronous",	XrmoptionNoArg,		(XtPointer) "off"},
-{"-background",	"*background",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-bd",		"*borderColor",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-bg",		"*background",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-bordercolor","*borderColor",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-borderwidth",".borderWidth",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-bw",		".borderWidth",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-display",	".display",     XrmoptionSepArg,	(XtPointer) NULL},
-{"-fg",		"*foreground",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-fn",		"*font",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-font",	"*font",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-foreground",	"*foreground",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-geometry",	".geometry",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-iconic",	".iconic",	XrmoptionNoArg,		(XtPointer) "on"},
-{"-name",	".name",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-reverse",	"*reverseVideo", XrmoptionNoArg,	(XtPointer) "on"},
-{"-rv",		"*reverseVideo", XrmoptionNoArg,	(XtPointer) "on"},
-{"-selectionTimeout",
-		".selectionTimeout", XrmoptionSepArg,	(XtPointer) NULL},
-{"-synchronous","*synchronous",	XrmoptionNoArg,		(XtPointer) "on"},
-{"-title",	".title",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-xnllanguage",".xnlLanguage",	XrmoptionSepArg,	(XtPointer) NULL},
-{"-xrm",	NULL,		XrmoptionResArg,	(XtPointer) NULL},
-{"-xtsessionID",".sessionID",	XrmoptionSepArg,	(XtPointer) NULL},
+{"+rv",               "*reverseVideo",     XrmoptionNoArg,   (XtPointer) "off"},
+{"+synchronous",      "*synchronous",      XrmoptionNoArg,   (XtPointer) "off"},
+{"-background",       "*background",       XrmoptionSepArg,  (XtPointer) NULL},
+{"-bd",               "*borderColor",      XrmoptionSepArg,  (XtPointer) NULL},
+{"-bg",               "*background",       XrmoptionSepArg,  (XtPointer) NULL},
+{"-bordercolor",      "*borderColor",      XrmoptionSepArg,  (XtPointer) NULL},
+{"-borderwidth",      ".borderWidth",      XrmoptionSepArg,  (XtPointer) NULL},
+{"-bw",               ".borderWidth",      XrmoptionSepArg,  (XtPointer) NULL},
+{"-display",          ".display",          XrmoptionSepArg,  (XtPointer) NULL},
+{"-fg",               "*foreground",       XrmoptionSepArg,  (XtPointer) NULL},
+{"-fn",               "*font",             XrmoptionSepArg,  (XtPointer) NULL},
+{"-font",             "*font",             XrmoptionSepArg,  (XtPointer) NULL},
+{"-foreground",       "*foreground",       XrmoptionSepArg,  (XtPointer) NULL},
+{"-geometry",         ".geometry",         XrmoptionSepArg,  (XtPointer) NULL},
+{"-iconic",           ".iconic",           XrmoptionNoArg,   (XtPointer) "on"},
+{"-name",             ".name",             XrmoptionSepArg,  (XtPointer) NULL},
+{"-reverse",          "*reverseVideo",     XrmoptionNoArg,   (XtPointer) "on"},
+{"-rv",               "*reverseVideo",     XrmoptionNoArg,   (XtPointer) "on"},
+{"-selectionTimeout", ".selectionTimeout", XrmoptionSepArg,  (XtPointer) NULL},
+{"-synchronous",      "*synchronous",      XrmoptionNoArg,   (XtPointer) "on"},
+{"-title",            ".title",            XrmoptionSepArg,  (XtPointer) NULL},
+{"-xnllanguage",      ".xnlLanguage",      XrmoptionSepArg,  (XtPointer) NULL},
+{"-xrm",              NULL,                XrmoptionResArg,  (XtPointer) NULL},
+{"-xtsessionID",      ".sessionID",        XrmoptionSepArg,  (XtPointer) NULL},
 };
-
+/* *INDENT-ON* */
 
 /*
  * GetHostname - emulates gethostname() on non-bsd systems.
  */
 
-static void GetHostname (
-    char *buf,
-    int maxlen)
+static void
+GetHostname(char *buf, int maxlen)
 {
 #ifdef USE_UNAME
     int len;
     struct utsname name;
 
     if (maxlen <= 0 || buf == NULL)
-	return;
-
-    uname (&name);
-    len = strlen (name.nodename);
-    if (len >= maxlen) len = maxlen;
-    (void) strncpy (buf, name.nodename, len-1);
-    buf[len-1] = '\0';
+        return;
+
+    uname(&name);
+    len = strlen(name.nodename);
+    if (len >= maxlen)
+        len = maxlen;
+    (void) strncpy(buf, name.nodename, len - 1);
+    buf[len - 1] = '\0';
 #else
     if (maxlen <= 0 || buf == NULL)
-	return;
+        return;
 
     buf[0] = '\0';
-    (void) gethostname (buf, (size_t) maxlen);
-    buf [maxlen - 1] = '\0';
+    (void) gethostname(buf, (size_t) maxlen);
+    buf[maxlen - 1] = '\0';
 #endif
 }
 
-
 #ifdef SUNSHLIB
-void _XtInherit(void)
+void
+_XtInherit(void)
 {
     extern void __XtInherit();
+
     __XtInherit();
 }
+
 #define _XtInherit __XtInherit
 #endif
 
-
 #if defined (WIN32) || defined(__CYGWIN__)
 /*
  * The Symbol _XtInherit is used in two different manners.
@@ -223,7 +224,7 @@ void _XtInherit(void)
  *      nop
  *
  * _imp_foo: .long <index of foo in dll export table, is
- *		    set to the real address by the runtime linker>
+ *                  set to the real address by the runtime linker>
  *
  * Now it is clear why the clients symbol foo isn't the same
  * as in the dll and we can think about how to deal which
@@ -246,14 +247,14 @@ void _XtInherit(void)
  */
 
 #ifdef __x86_64__
-asm (".section .trampoline, \"dwx\" \n\
+asm(".section .trampoline, \"dwx\" \n\
  .globl _XtInherit        \n\
  _XtInherit:              \n\
     jmp *_y(%rip)         \n\
 _y: .quad __XtInherit     \n\
     .text                 \n");
 #else
-asm (".data\n\
+asm(".data\n\
  .globl __XtInherit        \n\
  __XtInherit:      jmp *_y \n\
   _y: .long ___XtInherit   \n\
@@ -263,23 +264,22 @@ asm (".data\n\
 #define _XtInherit __XtInherit
 #endif
 
-
-void _XtInherit(void)
+void
+_XtInherit(void)
 {
-    XtErrorMsg("invalidProcedure","inheritanceProc",XtCXtToolkitError,
-            "Unresolved inheritance operation",
-              NULL, NULL);
+    XtErrorMsg("invalidProcedure", "inheritanceProc", XtCXtToolkitError,
+               "Unresolved inheritance operation", NULL, NULL);
 }
 
-
-void XtToolkitInitialize(void)
+void
+XtToolkitInitialize(void)
 {
     static Boolean initialized = False;
 
     LOCK_PROCESS;
     if (initialized) {
-	UNLOCK_PROCESS;
-	return;
+        UNLOCK_PROCESS;
+        return;
     }
     initialized = True;
     UNLOCK_PROCESS;
@@ -293,69 +293,70 @@ void XtToolkitInitialize(void)
     _XtTranslateInitialize();
 
     /* Some apps rely on old (broken) XtAppPeekEvent behavior */
-    if(getenv("XTAPPPEEKEVENT_SKIPTIMER"))
-	XtAppPeekEvent_SkipTimer = True;
+    if (getenv("XTAPPPEEKEVENT_SKIPTIMER"))
+        XtAppPeekEvent_SkipTimer = True;
     else
-	XtAppPeekEvent_SkipTimer = False;
+        XtAppPeekEvent_SkipTimer = False;
 }
 
-
-String _XtGetUserName(
-    _XtString dest,
-    int len)
+String
+_XtGetUserName(_XtString dest, int len)
 {
 #ifdef WIN32
     String ptr = NULL;
 
     if ((ptr = getenv("USERNAME"))) {
-	(void) strncpy (dest, ptr, len-1);
-	dest[len-1] = '\0';
-    } else
-	*dest = '\0';
+        (void) strncpy(dest, ptr, len - 1);
+        dest[len - 1] = '\0';
+    }
+    else
+        *dest = '\0';
 #else
 #ifdef X_NEEDS_PWPARAMS
     _Xgetpwparams pwparams;
 #endif
     struct passwd *pw;
-    char* ptr;
+    char *ptr;
 
     if ((ptr = getenv("USER"))) {
-	(void) strncpy (dest, ptr, (size_t) (len-1));
-	dest[len-1] = '\0';
-    } else {
-	if ((pw = _XGetpwuid(getuid(),pwparams)) != NULL) {
-	    (void) strncpy (dest, pw->pw_name, (size_t)(len-1));
-	    dest[len-1] = '\0';
-	} else
-	    *dest = '\0';
+        (void) strncpy(dest, ptr, (size_t) (len - 1));
+        dest[len - 1] = '\0';
+    }
+    else {
+        if ((pw = _XGetpwuid(getuid(), pwparams)) != NULL) {
+            (void) strncpy(dest, pw->pw_name, (size_t) (len - 1));
+            dest[len - 1] = '\0';
+        }
+        else
+            *dest = '\0';
     }
 #endif
     return dest;
 }
 
-
-static String GetRootDirName(
-    _XtString dest,
-    int len)
+static String
+GetRootDirName(_XtString dest, int len)
 {
 #ifdef WIN32
     register char *ptr1;
     register char *ptr2 = NULL;
     int len1 = 0, len2 = 0;
 
-    if (ptr1 = getenv("HOME")) {	/* old, deprecated */
-	len1 = strlen (ptr1);
-    } else if ((ptr1 = getenv("HOMEDRIVE")) && (ptr2 = getenv("HOMEDIR"))) {
-	len1 = strlen (ptr1);
-	len2 = strlen (ptr2);
-    } else if (ptr2 = getenv("USERNAME")) {
-	len1 = strlen (ptr1 = "/users/");
-	len2 = strlen (ptr2);
+    if (ptr1 = getenv("HOME")) {        /* old, deprecated */
+        len1 = strlen(ptr1);
+    }
+    else if ((ptr1 = getenv("HOMEDRIVE")) && (ptr2 = getenv("HOMEDIR"))) {
+        len1 = strlen(ptr1);
+        len2 = strlen(ptr2);
+    }
+    else if (ptr2 = getenv("USERNAME")) {
+        len1 = strlen(ptr1 = "/users/");
+        len2 = strlen(ptr2);
     }
     if ((len1 + len2 + 1) < len)
-	sprintf (dest, "%s%s", ptr1, (ptr2) ? ptr2 : "");
+        sprintf(dest, "%s%s", ptr1, (ptr2) ? ptr2 : "");
     else
-	*dest = '\0';
+        *dest = '\0';
 #else
 #ifdef X_NEEDS_PWPARAMS
     _Xgetpwparams pwparams;
@@ -363,171 +364,174 @@ static String GetRootDirName(
     static char *ptr;
 
     if (len <= 0 || dest == NULL)
-	return NULL;
+        return NULL;
 
     if ((ptr = getenv("HOME"))) {
-	(void) strncpy (dest, ptr, (size_t)(len-1));
-	dest[len-1] = '\0';
-    } else {
+        (void) strncpy(dest, ptr, (size_t) (len - 1));
+        dest[len - 1] = '\0';
+    }
+    else {
         struct passwd *pw;
-	if ((ptr = getenv("USER")))
-	    pw = _XGetpwnam(ptr,pwparams);
-	else
- 	    pw = _XGetpwuid(getuid(),pwparams);
-	if (pw != NULL) {
-	    (void) strncpy (dest, pw->pw_dir, (size_t)(len-1));
-	    dest[len-1] = '\0';
-	} else
-	    *dest = '\0';
+
+        if ((ptr = getenv("USER")))
+            pw = _XGetpwnam(ptr, pwparams);
+        else
+            pw = _XGetpwuid(getuid(), pwparams);
+        if (pw != NULL) {
+            (void) strncpy(dest, pw->pw_dir, (size_t) (len - 1));
+            dest[len - 1] = '\0';
+        }
+        else
+            *dest = '\0';
     }
 #endif
     return dest;
 }
 
-static void CombineAppUserDefaults(
-    Display *dpy,
-    XrmDatabase *pdb)
+static void
+CombineAppUserDefaults(Display *dpy, XrmDatabase *pdb)
 {
-    char* filename;
-    char* path = NULL;
+    char *filename;
+    char *path = NULL;
     Boolean deallocate = False;
 
     if (!(path = getenv("XUSERFILESEARCHPATH"))) {
 #if !defined(WIN32) || !defined(__MINGW32__)
-	char *old_path;
-	char homedir[PATH_MAX];
-	GetRootDirName(homedir, PATH_MAX);
-	if (!(old_path = getenv("XAPPLRESDIR"))) {
-	    XtAsprintf(&path,
-		       "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N",
-		       homedir, homedir, homedir, homedir, homedir, homedir);
-	} else {
-	    XtAsprintf(&path,
-		       "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N:%s/%%N",
-		       old_path, old_path, old_path, homedir,
-		       old_path, old_path, old_path, homedir);
-	}
-	deallocate = True;
+        char *old_path;
+        char homedir[PATH_MAX];
+
+        GetRootDirName(homedir, PATH_MAX);
+        if (!(old_path = getenv("XAPPLRESDIR"))) {
+            XtAsprintf(&path,
+                       "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N",
+                       homedir, homedir, homedir, homedir, homedir, homedir);
+        }
+        else {
+            XtAsprintf(&path,
+                       "%s/%%L/%%N%%C:%s/%%l/%%N%%C:%s/%%N%%C:%s/%%N%%C:%s/%%L/%%N:%s/%%l/%%N:%s/%%N:%s/%%N",
+                       old_path, old_path, old_path, homedir,
+                       old_path, old_path, old_path, homedir);
+        }
+        deallocate = True;
 #endif
     }
 
     filename = XtResolvePathname(dpy, NULL, NULL, NULL, path, NULL, 0, NULL);
     if (filename) {
-	(void)XrmCombineFileDatabase(filename, pdb, False);
-	XtFree(filename);
+        (void) XrmCombineFileDatabase(filename, pdb, False);
+        XtFree(filename);
     }
 
     if (deallocate)
-	XtFree(path);
+        XtFree(path);
 }
 
-static void CombineUserDefaults(
-    Display *dpy,
-    XrmDatabase *pdb)
+static void
+CombineUserDefaults(Display *dpy, XrmDatabase *pdb)
 {
     char *dpy_defaults = XResourceManagerString(dpy);
 
     if (dpy_defaults) {
-	XrmCombineDatabase(XrmGetStringDatabase(dpy_defaults), pdb, False);
-    } else {
+        XrmCombineDatabase(XrmGetStringDatabase(dpy_defaults), pdb, False);
+    }
+    else {
 #ifdef __MINGW32__
-	const char *slashDotXdefaults = "/Xdefaults";
+        const char *slashDotXdefaults = "/Xdefaults";
 #else
-	const char *slashDotXdefaults = "/.Xdefaults";
+        const char *slashDotXdefaults = "/.Xdefaults";
 #endif
-	char filename[PATH_MAX];
-	(void) GetRootDirName(filename,
-			PATH_MAX - (int)strlen (slashDotXdefaults) - 1);
-	(void) strcat(filename, slashDotXdefaults);
-	(void)XrmCombineFileDatabase(filename, pdb, False);
+        char filename[PATH_MAX];
+
+        (void) GetRootDirName(filename,
+                              PATH_MAX - (int) strlen(slashDotXdefaults) - 1);
+        (void) strcat(filename, slashDotXdefaults);
+        (void) XrmCombineFileDatabase(filename, pdb, False);
     }
 }
 
-/*ARGSUSED*/
-static Bool StoreDBEntry(
-    XrmDatabase		*db,
-    XrmBindingList      bindings,
-    XrmQuarkList	quarks,
-    XrmRepresentation   *type,
-    XrmValuePtr		value,
-    XPointer		data)
+static Bool
+StoreDBEntry(XrmDatabase *db _X_UNUSED,
+             XrmBindingList bindings,
+             XrmQuarkList quarks,
+             XrmRepresentation *type,
+             XrmValuePtr value,
+             XPointer data)
 {
-    XrmQPutResource((XrmDatabase *)data, bindings, quarks, *type, value);
+    XrmQPutResource((XrmDatabase *) data, bindings, quarks, *type, value);
     return False;
 }
 
-static XrmDatabase CopyDB(XrmDatabase db)
+static XrmDatabase
+CopyDB(XrmDatabase db)
 {
     XrmDatabase copy = NULL;
     XrmQuark empty = NULLQUARK;
 
     XrmEnumerateDatabase(db, &empty, &empty, XrmEnumAllLevels,
-			 StoreDBEntry, (XPointer)&copy);
+                         StoreDBEntry, (XPointer) &copy);
     return copy;
 }
 
-/*ARGSUSED*/
-static String _XtDefaultLanguageProc(
-    Display   *dpy,	/* unused */
-    String     xnl,
-    XtPointer  closure)	/* unused */
+static String
+_XtDefaultLanguageProc(Display *dpy _X_UNUSED,
+                       String xnl,
+                       XtPointer closure _X_UNUSED)
 {
-    if (! setlocale(LC_ALL, xnl))
-	XtWarning("locale not supported by C library, locale unchanged");
+    if (!setlocale(LC_ALL, xnl))
+        XtWarning("locale not supported by C library, locale unchanged");
 
-    if (! XSupportsLocale()) {
-	XtWarning("locale not supported by Xlib, locale set to C");
-	setlocale(LC_ALL, "C");
+    if (!XSupportsLocale()) {
+        XtWarning("locale not supported by Xlib, locale set to C");
+        setlocale(LC_ALL, "C");
     }
-    if (! XSetLocaleModifiers(""))
-	XtWarning("X locale modifiers not supported, using default");
+    if (!XSetLocaleModifiers(""))
+        XtWarning("X locale modifiers not supported, using default");
 
-    return setlocale(LC_ALL, NULL); /* re-query in case overwritten */
+    return setlocale(LC_ALL, NULL);     /* re-query in case overwritten */
 }
 
-XtLanguageProc XtSetLanguageProc(
-    XtAppContext      app,
-    XtLanguageProc    proc,
-    XtPointer         closure)
+XtLanguageProc
+XtSetLanguageProc(XtAppContext app, XtLanguageProc proc, XtPointer closure)
 {
-    XtLanguageProc    old;
+    XtLanguageProc old;
 
     if (!proc) {
-	proc = _XtDefaultLanguageProc;
-	closure = NULL;
+        proc = _XtDefaultLanguageProc;
+        closure = NULL;
     }
 
     if (app) {
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	/* set langProcRec only for this application context */
+        LOCK_APP(app);
+        LOCK_PROCESS;
+        /* set langProcRec only for this application context */
         old = app->langProcRec.proc;
         app->langProcRec.proc = proc;
         app->langProcRec.closure = closure;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-    } else {
-	/* set langProcRec for all application contexts */
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+    }
+    else {
+        /* set langProcRec for all application contexts */
         ProcessContext process;
 
-	LOCK_PROCESS;
+        LOCK_PROCESS;
         process = _XtGetProcessContext();
         old = process->globalLangProcRec.proc;
-	process->globalLangProcRec.proc = proc;
-	process->globalLangProcRec.closure = closure;
+        process->globalLangProcRec.proc = proc;
+        process->globalLangProcRec.closure = closure;
         app = process->appContextList;
         while (app) {
             app->langProcRec.proc = proc;
             app->langProcRec.closure = closure;
-	    app = app->next;
+            app = app->next;
         }
-	UNLOCK_PROCESS;
+        UNLOCK_PROCESS;
     }
     return (old ? old : _XtDefaultLanguageProc);
 }
 
-XrmDatabase XtScreenDatabase(
-    Screen *screen)
+XrmDatabase
+XtScreenDatabase(Screen *screen)
 {
     int scrno;
     Bool doing_def;
@@ -536,92 +540,101 @@ XrmDatabase XtScreenDatabase(
     Status do_fallback;
     char *scr_resources;
     Display *dpy = DisplayOfScreen(screen);
+
     DPY_TO_APPCON(dpy);
+    if (dpy == NULL) {
+        XtErrorMsg("nullDisplay",
+                   "XtScreenDatabase", XtCXtToolkitError,
+                   "XtScreenDatabase requires a non-NULL display",
+                   NULL, NULL);
+    }
 
     LOCK_APP(app);
     LOCK_PROCESS;
     if (screen == DefaultScreenOfDisplay(dpy)) {
-	scrno = DefaultScreen(dpy);
-	doing_def = True;
-    } else {
-	scrno = XScreenNumberOfScreen(screen);
-	doing_def = False;
+        scrno = DefaultScreen(dpy);
+        doing_def = True;
+    }
+    else {
+        scrno = XScreenNumberOfScreen(screen);
+        doing_def = False;
     }
     pd = _XtGetPerDisplay(dpy);
     if ((db = pd->per_screen_db[scrno])) {
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-	return (doing_def ? XrmGetDatabase(dpy) : db);
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return (doing_def ? XrmGetDatabase(dpy) : db);
     }
     scr_resources = XScreenResourceString(screen);
 
     if (ScreenCount(dpy) == 1) {
-	db = pd->cmd_db;
-	pd->cmd_db = NULL;
-    } else {
-	db = CopyDB(pd->cmd_db);
+        db = pd->cmd_db;
+        pd->cmd_db = NULL;
+    }
+    else {
+        db = CopyDB(pd->cmd_db);
     }
-    {   /* Environment defaults */
-	char	filenamebuf[PATH_MAX];
-	char	*filename;
+    {                           /* Environment defaults */
+        char filenamebuf[PATH_MAX];
+        char *filename;
+
+        if (!(filename = getenv("XENVIRONMENT"))) {
+            int len;
 
-	if (!(filename = getenv("XENVIRONMENT"))) {
-	    int len;
 #ifdef __MINGW32__
-	    const char *slashDotXdefaultsDash = "/Xdefaults-";
+            const char *slashDotXdefaultsDash = "/Xdefaults-";
 #else
-	    const char *slashDotXdefaultsDash = "/.Xdefaults-";
+            const char *slashDotXdefaultsDash = "/.Xdefaults-";
 #endif
 
-	    (void) GetRootDirName(filename = filenamebuf,
-			PATH_MAX - (int)strlen (slashDotXdefaultsDash) - 1);
-	    (void) strcat(filename, slashDotXdefaultsDash);
-	    len = (int)strlen(filename);
-	    GetHostname (filename+len, PATH_MAX-len);
-	}
-	(void)XrmCombineFileDatabase(filename, &db, False);
+            (void) GetRootDirName(filename = filenamebuf,
+                                  PATH_MAX -
+                                  (int) strlen(slashDotXdefaultsDash) - 1);
+            (void) strcat(filename, slashDotXdefaultsDash);
+            len = (int) strlen(filename);
+            GetHostname(filename + len, PATH_MAX - len);
+        }
+        (void) XrmCombineFileDatabase(filename, &db, False);
     }
-    if (scr_resources)
-    {   /* Screen defaults */
-	XrmCombineDatabase(XrmGetStringDatabase(scr_resources), &db, False);
-	XFree(scr_resources);
+    if (scr_resources) {        /* Screen defaults */
+        XrmCombineDatabase(XrmGetStringDatabase(scr_resources), &db, False);
+        XFree(scr_resources);
     }
     /* Server or host defaults */
     if (!pd->server_db)
-	CombineUserDefaults(dpy, &db);
+        CombineUserDefaults(dpy, &db);
     else {
-	(void) XrmCombineDatabase(pd->server_db, &db, False);
-	pd->server_db = NULL;
+        (void) XrmCombineDatabase(pd->server_db, &db, False);
+        pd->server_db = NULL;
     }
 
     if (!db)
-	db = XrmGetStringDatabase("");
+        db = XrmGetStringDatabase("");
     pd->per_screen_db[scrno] = db;
     olddb = XrmGetDatabase(dpy);
     /* set database now, for XtResolvePathname to use */
     XrmSetDatabase(dpy, db);
     CombineAppUserDefaults(dpy, &db);
     do_fallback = 1;
-    {   /* System app-defaults */
-	char	*filename;
-
-	if ((filename = XtResolvePathname(dpy, "app-defaults",
-					 NULL, NULL, NULL, NULL, 0, NULL))) {
-	    do_fallback = !XrmCombineFileDatabase(filename, &db, False);
-	    XtFree(filename);
-	}
+    {                           /* System app-defaults */
+        char *filename;
+
+        if ((filename = XtResolvePathname(dpy, "app-defaults",
+                                          NULL, NULL, NULL, NULL, 0, NULL))) {
+            do_fallback = !XrmCombineFileDatabase(filename, &db, False);
+            XtFree(filename);
+        }
     }
     /* now restore old database, if need be */
     if (!doing_def)
-	XrmSetDatabase(dpy, olddb);
-    if (do_fallback && pd->appContext->fallback_resources)
-    {   /* Fallback defaults */
+        XrmSetDatabase(dpy, olddb);
+    if (do_fallback && pd->appContext->fallback_resources) {    /* Fallback defaults */
         XrmDatabase fdb = NULL;
-	String *res;
+        String *res;
 
-	for (res = pd->appContext->fallback_resources; *res; res++)
-	    XrmPutLineResource(&fdb, *res);
-	(void)XrmCombineDatabase(fdb, &db, False);
+        for (res = pd->appContext->fallback_resources; *res; res++)
+            XrmPutLineResource(&fdb, *res);
+        (void) XrmCombineDatabase(fdb, &db, False);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
@@ -639,13 +652,13 @@ XrmDatabase XtScreenDatabase(
  * Caller is responsible for freeing the returned option table.
  */
 
-static void _MergeOptionTables(
-    const XrmOptionDescRec *src1,
-    Cardinal num_src1,
-    const XrmOptionDescRec *src2,
-    Cardinal num_src2,
-    XrmOptionDescRec **dst,
-    Cardinal *num_dst)
+static void
+_MergeOptionTables(const XrmOptionDescRec *src1,
+                   Cardinal num_src1,
+                   const XrmOptionDescRec *src2,
+                   Cardinal num_src2,
+                   XrmOptionDescRec **dst,
+                   Cardinal *num_dst)
 {
     XrmOptionDescRec *table, *endP;
     XrmOptionDescRec *opt1, *dstP;
@@ -653,76 +666,76 @@ static void _MergeOptionTables(
     int i1;
     Cardinal i2;
     int dst_len, order;
-    enum {Check, NotSorted, IsSorted} sort_order = Check;
+    enum { Check, NotSorted, IsSorted } sort_order = Check;
 
-    *dst = table = (XrmOptionDescRec*)
-	__XtMalloc( (Cardinal)(sizeof(XrmOptionDescRec) * (num_src1 + num_src2) ));
+    *dst = table = (XrmOptionDescRec *)
+        __XtMalloc((Cardinal)
+                   (sizeof(XrmOptionDescRec) * (num_src1 + num_src2)));
 
-    (void) memmove(table, src1, sizeof(XrmOptionDescRec) * num_src1 );
+    (void) memmove(table, src1, sizeof(XrmOptionDescRec) * num_src1);
     if (num_src2 == 0) {
-	*num_dst = num_src1;
-	return;
+        *num_dst = num_src1;
+        return;
     }
-    endP = &table[dst_len = (int)num_src1];
-    for (opt2 = src2, i2= 0; i2 < num_src2; opt2++, i2++) {
+    endP = &table[dst_len = (int) num_src1];
+    for (opt2 = src2, i2 = 0; i2 < num_src2; opt2++, i2++) {
         XrmOptionDescRec *whereP;
         Boolean found;
 
-	found = False;
-	whereP = endP-1;	/* assume new option goes at the end */
-	for (opt1 = table, i1 = 0; i1 < dst_len; opt1++, i1++) {
-	    /* have to walk the entire new table so new list is ordered
-	       (if src1 was ordered) */
-	    if (sort_order == Check && i1 > 0
-		&& strcmp(opt1->option, (opt1-1)->option) < 0)
-		sort_order = NotSorted;
-	    if ((order = strcmp(opt1->option, opt2->option)) == 0) {
-		/* same option names; just overwrite opt1 with opt2 */
-		*opt1 = *opt2;
-		found = True;
-		break;
-		}
-	    /* else */
-	    if (sort_order == IsSorted && order > 0) {
-		/* insert before opt1 to preserve order */
-		/* shift rest of table forward to make room for new entry */
-		for (dstP = endP++; dstP > opt1; dstP--)
-		    *dstP = *(dstP-1);
-		*opt1 = *opt2;
-		dst_len++;
-		found = True;
-		break;
-	    }
-	    /* else */
-	    if (order < 0)
-		/* opt2 sorts after opt1, so remember this position */
-		whereP = opt1;
-	}
-	if (sort_order == Check && i1 == dst_len)
-	    sort_order = IsSorted;
-	if (!found) {
-	   /* when we get here, whereP points to the last entry in the
-	      destination that sorts before "opt2".  Shift rest of table
-	      forward and insert "opt2" after whereP. */
-	    whereP++;
-	    for (dstP = endP++; dstP > whereP; dstP--)
-		*dstP = *(dstP-1);
-	    *whereP = *opt2;
-	    dst_len++;
-	}
+        found = False;
+        whereP = endP - 1;      /* assume new option goes at the end */
+        for (opt1 = table, i1 = 0; i1 < dst_len; opt1++, i1++) {
+            /* have to walk the entire new table so new list is ordered
+               (if src1 was ordered) */
+            if (sort_order == Check && i1 > 0
+                && strcmp(opt1->option, (opt1 - 1)->option) < 0)
+                sort_order = NotSorted;
+            if ((order = strcmp(opt1->option, opt2->option)) == 0) {
+                /* same option names; just overwrite opt1 with opt2 */
+                *opt1 = *opt2;
+                found = True;
+                break;
+            }
+            /* else */
+            if (sort_order == IsSorted && order > 0) {
+                /* insert before opt1 to preserve order */
+                /* shift rest of table forward to make room for new entry */
+                for (dstP = endP++; dstP > opt1; dstP--)
+                    *dstP = *(dstP - 1);
+                *opt1 = *opt2;
+                dst_len++;
+                found = True;
+                break;
+            }
+            /* else */
+            if (order < 0)
+                /* opt2 sorts after opt1, so remember this position */
+                whereP = opt1;
+        }
+        if (sort_order == Check && i1 == dst_len)
+            sort_order = IsSorted;
+        if (!found) {
+            /* when we get here, whereP points to the last entry in the
+               destination that sorts before "opt2".  Shift rest of table
+               forward and insert "opt2" after whereP. */
+            whereP++;
+            for (dstP = endP++; dstP > whereP; dstP--)
+                *dstP = *(dstP - 1);
+            *whereP = *opt2;
+            dst_len++;
+        }
     }
-    *num_dst = (Cardinal)dst_len;
+    *num_dst = (Cardinal) dst_len;
 }
 
-
 /* NOTE: name, class, and type must be permanent strings */
-static Boolean _GetResource(
-    Display *dpy,
-    XrmSearchList list,
-    String name,
-    String class,
-    String type,
-    XrmValue* value)
+static Boolean
+_GetResource(Display *dpy,
+             XrmSearchList list,
+             String name,
+             String class,
+             String type,
+             XrmValue *value)
 {
     XrmRepresentation db_type;
     XrmValue db_value;
@@ -731,36 +744,37 @@ static Boolean _GetResource(
     XrmRepresentation Qtype = XrmPermStringToQuark(type);
 
     if (XrmQGetSearchResource(list, Qname, Qclass, &db_type, &db_value)) {
-	if (db_type == Qtype) {
-	    if (Qtype == _XtQString)
-		*(String*)value->addr = db_value.addr;
-	    else
-		(void) memmove(value->addr, db_value.addr, value->size );
-	    return True;
-	} else {
-	    WidgetRec widget; /* hack, hack */
-	    memset( &widget, 0, sizeof(widget) );
-	    widget.core.self = &widget;
-	    widget.core.widget_class = coreWidgetClass;
-	    widget.core.screen = (Screen*)DefaultScreenOfDisplay(dpy);
-	    XtInitializeWidgetClass(coreWidgetClass);
-	    if (_XtConvert(&widget,db_type,&db_value,Qtype,value,NULL)) {
-		return True;
-	    }
-	}
+        if (db_type == Qtype) {
+            if (Qtype == _XtQString)
+                *(String *) value->addr = db_value.addr;
+            else
+                (void) memmove(value->addr, db_value.addr, value->size);
+            return True;
+        }
+        else {
+            WidgetRec widget;   /* hack, hack */
+
+            memset(&widget, 0, sizeof(widget));
+            widget.core.self = &widget;
+            widget.core.widget_class = coreWidgetClass;
+            widget.core.screen = (Screen *) DefaultScreenOfDisplay(dpy);
+            XtInitializeWidgetClass(coreWidgetClass);
+            if (_XtConvert(&widget, db_type, &db_value, Qtype, value, NULL)) {
+                return True;
+            }
+        }
     }
     return False;
 }
 
-XrmDatabase _XtPreparseCommandLine(
-    XrmOptionDescRec *urlist,
-    Cardinal num_urs,
-    int argc,
-    _XtString *argv,
-    /* return */
-    String *applName,
-    String *displayName,
-    String *language)
+XrmDatabase
+_XtPreparseCommandLine(XrmOptionDescRec *urlist,
+                       Cardinal num_urs,
+                       int argc,
+                       _XtString *argv, /* return */
+                       String *applName,
+                       String *displayName,
+                       String *language)
 {
     XrmDatabase db = NULL;
     XrmOptionDescRec *options;
@@ -772,42 +786,41 @@ XrmDatabase _XtPreparseCommandLine(
     _XtString *targv;
     int targc = argc;
 
-    targv = (_XtString *) __XtMalloc((Cardinal)(sizeof(_XtString*) * (size_t)argc));
+    targv = (_XtString *)
+        __XtMalloc((Cardinal) (sizeof(_XtString *) * (size_t) argc));
     (void) memmove(targv, argv, sizeof(char *) * (size_t) argc);
     _MergeOptionTables(opTable, XtNumber(opTable), urlist, num_urs,
-		       &options, &num_options);
+                       &options, &num_options);
     name_list[0] = class_list[0] = XrmPermStringToQuark(".");
     name_list[2] = class_list[2] = NULLQUARK;
     XrmParseCommand(&db, options, (int) num_options, ".", &targc, targv);
     if (applName) {
-	name_list[1] = XrmPermStringToQuark("name");
-	if (XrmQGetResource(db, name_list, name_list, &type, &val) &&
-	    type == _XtQString)
-	    *applName = val.addr;
+        name_list[1] = XrmPermStringToQuark("name");
+        if (XrmQGetResource(db, name_list, name_list, &type, &val) &&
+            type == _XtQString)
+            *applName = val.addr;
     }
     if (displayName) {
-	name_list[1] = XrmPermStringToQuark("display");
-	if (XrmQGetResource(db, name_list, name_list, &type, &val) &&
-	    type == _XtQString)
-	    *displayName = val.addr;
+        name_list[1] = XrmPermStringToQuark("display");
+        if (XrmQGetResource(db, name_list, name_list, &type, &val) &&
+            type == _XtQString)
+            *displayName = val.addr;
     }
     if (language) {
-	name_list[1] = XrmPermStringToQuark("xnlLanguage");
-	class_list[1] = XrmPermStringToQuark("XnlLanguage");
-	if (XrmQGetResource(db, name_list, class_list, &type, &val) &&
-	    type == _XtQString)
-	    *language = val.addr;
+        name_list[1] = XrmPermStringToQuark("xnlLanguage");
+        class_list[1] = XrmPermStringToQuark("XnlLanguage");
+        if (XrmQGetResource(db, name_list, class_list, &type, &val) &&
+            type == _XtQString)
+            *language = val.addr;
     }
 
-    XtFree((char *)targv);
-    XtFree((char *)options);
+    XtFree((char *) targv);
+    XtFree((char *) options);
     return db;
 }
 
-
-static void GetLanguage(
-    Display *dpy,
-    XtPerDisplay pd)
+static void
+GetLanguage(Display *dpy, XtPerDisplay pd)
 {
     XrmRepresentation type;
     XrmValue value;
@@ -815,251 +828,254 @@ static void GetLanguage(
     XrmName class_list[3];
 
     LOCK_PROCESS;
-    if (! pd->language) {
-	name_list[0] = pd->name;
-	name_list[1] = XrmPermStringToQuark("xnlLanguage");
-	class_list[0] = pd->class;
-	class_list[1] = XrmPermStringToQuark("XnlLanguage");
-	name_list[2] = class_list[2] = NULLQUARK;
-	if (!pd->server_db)
-	    CombineUserDefaults(dpy, &pd->server_db);
-	if (pd->server_db &&
-	    XrmQGetResource(pd->server_db,name_list,class_list, &type, &value)
-	    && type == _XtQString)
-	    pd->language = (char *) value.addr;
+    if (!pd->language) {
+        name_list[0] = pd->name;
+        name_list[1] = XrmPermStringToQuark("xnlLanguage");
+        class_list[0] = pd->class;
+        class_list[1] = XrmPermStringToQuark("XnlLanguage");
+        name_list[2] = class_list[2] = NULLQUARK;
+        if (!pd->server_db)
+            CombineUserDefaults(dpy, &pd->server_db);
+        if (pd->server_db &&
+            XrmQGetResource(pd->server_db, name_list, class_list, &type, &value)
+            && type == _XtQString)
+            pd->language = (char *) value.addr;
     }
 
     if (pd->appContext->langProcRec.proc) {
-	if (! pd->language) pd->language = "";
-	pd->language = (*pd->appContext->langProcRec.proc)
-	    (dpy, pd->language, pd->appContext->langProcRec.closure);
+        if (!pd->language)
+            pd->language = "";
+        pd->language = (*pd->appContext->langProcRec.proc)
+            (dpy, pd->language, pd->appContext->langProcRec.closure);
     }
-    else if (! pd->language || pd->language[0] == '\0') /* R4 compatibility */
-	pd->language = getenv("LANG");
+    else if (!pd->language || pd->language[0] == '\0')  /* R4 compatibility */
+        pd->language = getenv("LANG");
 
-    if (pd->language) pd->language = XtNewString(pd->language);
+    if (pd->language)
+        pd->language = XtNewString(pd->language);
     UNLOCK_PROCESS;
 }
 
-static void ProcessInternalConnection (
-    XtPointer client_data,
-    int* fd,
-    XtInputId* id)
+static void
+ProcessInternalConnection(XtPointer client_data,
+                          int *fd,
+                          XtInputId *id _X_UNUSED)
 {
-    XProcessInternalConnection ((Display *) client_data, *fd);
+    XProcessInternalConnection((Display *) client_data, *fd);
 }
 
-static void ConnectionWatch (
-    Display* dpy,
-    XPointer client_data,
-    int fd,
-    Bool opening,
-    XPointer* watch_data)
+static void
+ConnectionWatch(Display *dpy,
+                XPointer client_data,
+                int fd,
+                Bool opening,
+                XPointer *watch_data)
 {
-    XtInputId* iptr;
+    XtInputId *iptr;
     XtAppContext app = XtDisplayToApplicationContext(dpy);
 
     if (opening) {
-	iptr = (XtInputId *) __XtMalloc(sizeof(XtInputId));
-	*iptr = XtAppAddInput(app, fd, (XtPointer) XtInputReadMask,
-			      ProcessInternalConnection, client_data);
-	*watch_data = (XPointer) iptr;
-    } else {
-	iptr = (XtInputId *) *watch_data;
-	XtRemoveInput(*iptr);
+        iptr = (XtInputId *) __XtMalloc(sizeof(XtInputId));
+        *iptr = XtAppAddInput(app, fd, (XtPointer) XtInputReadMask,
+                              ProcessInternalConnection, client_data);
+        *watch_data = (XPointer) iptr;
+    }
+    else {
+        iptr = (XtInputId *) *watch_data;
+        XtRemoveInput(*iptr);
         (void) XtFree(*watch_data);
     }
 }
 
-void _XtDisplayInitialize(
-	Display *dpy,
-        XtPerDisplay pd,
-	_Xconst char* name,
-	XrmOptionDescRec *urlist,
-	Cardinal num_urs,
-	int *argc,
-	char **argv)
+void
+_XtDisplayInitialize(Display *dpy,
+                     XtPerDisplay pd,
+                     _Xconst char *name,
+                     XrmOptionDescRec *urlist,
+                     Cardinal num_urs,
+                     int *argc,
+                     char **argv)
 {
-	Boolean tmp_bool;
-	XrmValue value;
-	XrmOptionDescRec *options;
-	Cardinal num_options;
-	XrmDatabase db;
-	XrmName name_list[2];
-	XrmClass class_list[2];
-	XrmHashTable* search_list;
-	int search_list_size = SEARCH_LIST_SIZE;
-
-	GetLanguage(dpy, pd);
-
-	/* Parse the command line and remove Xt arguments from argv */
-	_MergeOptionTables( opTable, XtNumber(opTable), urlist, num_urs,
-			    &options, &num_options );
-	XrmParseCommand(&pd->cmd_db, options, (int) num_options, name, argc, argv);
-
-	db = XtScreenDatabase(DefaultScreenOfDisplay(dpy));
-
-	if (!(search_list = (XrmHashTable*)
-		       ALLOCATE_LOCAL( SEARCH_LIST_SIZE*sizeof(XrmHashTable))))
-	    _XtAllocError(NULL);
-	name_list[0] = pd->name;
-	class_list[0] = pd->class;
-	name_list[1] = NULLQUARK;
-	class_list[1] = NULLQUARK;
-
-	while (!XrmQGetSearchList(db, name_list, class_list,
-				  search_list, search_list_size)) {
-	    XrmHashTable* old = search_list;
-	    Cardinal size = (Cardinal) ((size_t)(search_list_size *= 2)*sizeof(XrmHashTable));
-	    if (!(search_list = (XrmHashTable*)ALLOCATE_LOCAL(size)))
-		_XtAllocError(NULL);
-	    (void) memmove((char*)search_list, (char*)old, (size>>1) );
-	    DEALLOCATE_LOCAL(old);
-	}
-
-	value.size = sizeof(tmp_bool);
-	value.addr = (XtPointer)&tmp_bool;
-	if (_GetResource(dpy, search_list, "synchronous", "Synchronous",
-			 XtRBoolean, &value)) {
-	    int i;
-	    Display **dpyP = pd->appContext->list;
-	    pd->appContext->sync = tmp_bool;
-	    for (i = pd->appContext->count; i; dpyP++, i--) {
-		(void) XSynchronize(*dpyP, (Bool)tmp_bool);
-	    }
-	} else {
-	    (void) XSynchronize(dpy, (Bool)pd->appContext->sync);
-	}
-
-	if (_GetResource(dpy, search_list, "reverseVideo", "ReverseVideo",
-			 XtRBoolean, &value)
-	        && tmp_bool) {
-	    pd->rv = True;
-	}
-
-	value.size = sizeof(pd->multi_click_time);
-	value.addr = (XtPointer)&pd->multi_click_time;
-	if (!_GetResource(dpy, search_list,
-			  "multiClickTime", "MultiClickTime",
-			  XtRInt, &value)) {
-	    pd->multi_click_time = 200;
-	}
-
-	value.size = sizeof(pd->appContext->selectionTimeout);
-	value.addr = (XtPointer)&pd->appContext->selectionTimeout;
-	(void)_GetResource(dpy, search_list,
-			   "selectionTimeout", "SelectionTimeout",
-			   XtRInt, &value);
+    Boolean tmp_bool;
+    XrmValue value;
+    XrmOptionDescRec *options;
+    Cardinal num_options;
+    XrmDatabase db;
+    XrmName name_list[2];
+    XrmClass class_list[2];
+    XrmHashTable *search_list;
+    int search_list_size = SEARCH_LIST_SIZE;
+
+    GetLanguage(dpy, pd);
+
+    /* Parse the command line and remove Xt arguments from argv */
+    _MergeOptionTables(opTable, XtNumber(opTable), urlist, num_urs,
+                       &options, &num_options);
+    XrmParseCommand(&pd->cmd_db, options, (int) num_options, name, argc, argv);
+
+    db = XtScreenDatabase(DefaultScreenOfDisplay(dpy));
+
+    if (!(search_list = (XrmHashTable *)
+          ALLOCATE_LOCAL(SEARCH_LIST_SIZE * sizeof(XrmHashTable))))
+        _XtAllocError(NULL);
+    name_list[0] = pd->name;
+    class_list[0] = pd->class;
+    name_list[1] = NULLQUARK;
+    class_list[1] = NULLQUARK;
+
+    while (!XrmQGetSearchList(db, name_list, class_list,
+                              search_list, search_list_size)) {
+        XrmHashTable *old = search_list;
+        Cardinal size =
+            (Cardinal) ((size_t) (search_list_size *= 2) *
+                        sizeof(XrmHashTable));
+        if (!(search_list = (XrmHashTable *) ALLOCATE_LOCAL(size)))
+            _XtAllocError(NULL);
+        (void) memmove((char *) search_list, (char *) old, (size >> 1));
+        DEALLOCATE_LOCAL(old);
+    }
+
+    value.size = sizeof(tmp_bool);
+    value.addr = (XtPointer) &tmp_bool;
+    if (_GetResource(dpy, search_list, "synchronous", "Synchronous",
+                     XtRBoolean, &value)) {
+        int i;
+        Display **dpyP = pd->appContext->list;
+
+        pd->appContext->sync = tmp_bool;
+        for (i = pd->appContext->count; i; dpyP++, i--) {
+            (void) XSynchronize(*dpyP, (Bool) tmp_bool);
+        }
+    }
+    else {
+        (void) XSynchronize(dpy, (Bool) pd->appContext->sync);
+    }
+
+    if (_GetResource(dpy, search_list, "reverseVideo", "ReverseVideo",
+                     XtRBoolean, &value)
+        && tmp_bool) {
+        pd->rv = True;
+    }
+
+    value.size = sizeof(pd->multi_click_time);
+    value.addr = (XtPointer) &pd->multi_click_time;
+    if (!_GetResource(dpy, search_list,
+                      "multiClickTime", "MultiClickTime", XtRInt, &value)) {
+        pd->multi_click_time = 200;
+    }
+
+    value.size = sizeof(pd->appContext->selectionTimeout);
+    value.addr = (XtPointer) &pd->appContext->selectionTimeout;
+    (void) _GetResource(dpy, search_list,
+                        "selectionTimeout", "SelectionTimeout", XtRInt, &value);
 
 #ifndef NO_IDENTIFY_WINDOWS
-	value.size = sizeof(pd->appContext->identify_windows);
-	value.addr = (XtPointer)&pd->appContext->identify_windows;
-	(void)_GetResource(dpy, search_list,
-			   "xtIdentifyWindows", "XtDebug",
-			   XtRBoolean, &value);
+    value.size = sizeof(pd->appContext->identify_windows);
+    value.addr = (XtPointer) &pd->appContext->identify_windows;
+    (void) _GetResource(dpy, search_list,
+                        "xtIdentifyWindows", "XtDebug", XtRBoolean, &value);
 #endif
 
-	XAddConnectionWatch(dpy, ConnectionWatch, (XPointer) dpy);
+    XAddConnectionWatch(dpy, ConnectionWatch, (XPointer) dpy);
 
-	XtFree( (XtPointer)options );
-	DEALLOCATE_LOCAL( search_list );
+    XtFree((XtPointer) options);
+    DEALLOCATE_LOCAL(search_list);
 }
 
-/*	Function Name: XtAppSetFallbackResources
- *	Description: Sets the fallback resource list that will be loaded
+/*      Function Name: XtAppSetFallbackResources
+ *      Description: Sets the fallback resource list that will be loaded
  *                   at display initialization time.
- *	Arguments: app_context - the app context.
+ *      Arguments: app_context - the app context.
  *                 specification_list - the resource specification list.
- *	Returns: none.
+ *      Returns: none.
  */
 
 void
-XtAppSetFallbackResources(
-    XtAppContext app_context,
-    String *specification_list)
+XtAppSetFallbackResources(XtAppContext app_context, String *specification_list)
 {
     LOCK_APP(app_context);
     app_context->fallback_resources = specification_list;
     UNLOCK_APP(app_context);
 }
 
-
-Widget XtOpenApplication(XtAppContext *app_context_return,
-			 _Xconst char *application_class,
-			 XrmOptionDescRec *options, Cardinal num_options,
-			 int *argc_in_out, _XtString *argv_in_out,
-			 String *fallback_resources, WidgetClass widget_class,
-			 ArgList args_in, Cardinal num_args_in)
+Widget
+XtOpenApplication(XtAppContext *app_context_return,
+                  _Xconst char *application_class,
+                  XrmOptionDescRec *options,
+                  Cardinal num_options,
+                  int *argc_in_out,
+                  _XtString *argv_in_out,
+                  String *fallback_resources,
+                  WidgetClass widget_class,
+                  ArgList args_in,
+                  Cardinal num_args_in)
 {
     XtAppContext app_con;
-    Display * dpy;
+    Display *dpy;
     register int saved_argc = *argc_in_out;
     Widget root;
     Arg args[3], *merged_args;
     Cardinal num = 0;
 
-    XtToolkitInitialize(); /* cannot be moved into _XtAppInit */
+    XtToolkitInitialize();      /* cannot be moved into _XtAppInit */
 
-    dpy = _XtAppInit(&app_con, (String)application_class, options, num_options,
-		     argc_in_out, &argv_in_out, fallback_resources);
+    dpy = _XtAppInit(&app_con, (String) application_class, options, num_options,
+                     argc_in_out, &argv_in_out, fallback_resources);
 
     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++;
+    XtSetArg(args[num], XtNscreen, DefaultScreenOfDisplay(dpy));
+    num++;
+    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;
 
     root = XtAppCreateShell(NULL, application_class, widget_class, dpy,
-			    merged_args, num);
+                            merged_args, num);
 
     if (app_context_return)
-	*app_context_return = app_con;
+        *app_context_return = app_con;
 
-    XtFree((XtPointer)merged_args);
-    XtFree((XtPointer)argv_in_out);
+    XtFree((XtPointer) merged_args);
+    XtFree((XtPointer) argv_in_out);
     UNLOCK_APP(app_con);
     return root;
 }
 
-
 Widget
-XtAppInitialize(
-    XtAppContext * app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescRec *options,
-    Cardinal num_options,
-    int *argc_in_out,
-    _XtString *argv_in_out,
-    String *fallback_resources,
-    ArgList args_in,
-    Cardinal num_args_in)
+XtAppInitialize(XtAppContext *app_context_return,
+                _Xconst char *application_class,
+                XrmOptionDescRec *options,
+                Cardinal num_options,
+                int *argc_in_out,
+                _XtString *argv_in_out,
+                String *fallback_resources,
+                ArgList args_in,
+                Cardinal num_args_in)
 {
     return XtOpenApplication(app_context_return, application_class,
-			     options, num_options,
-			     argc_in_out, argv_in_out, fallback_resources,
-			     applicationShellWidgetClass,
-			     args_in, num_args_in);
+                             options, num_options,
+                             argc_in_out, argv_in_out, fallback_resources,
+                             applicationShellWidgetClass, args_in, num_args_in);
 }
 
-
-/*ARGSUSED*/
 Widget
-XtInitialize(
-    _Xconst _XtString name,
-    _Xconst _XtString classname,
-    XrmOptionDescRec *options,
-    Cardinal num_options,
-    int *argc,
-    _XtString *argv)
+XtInitialize(_Xconst _XtString name _X_UNUSED,
+             _Xconst _XtString classname,
+             XrmOptionDescRec *options,
+             Cardinal num_options,
+             int *argc,
+             _XtString *argv)
 {
     Widget root;
     XtAppContext app_con;
     register ProcessContext process = _XtGetProcessContext();
 
     root = XtAppInitialize(&app_con, classname, options, num_options,
-			   argc, argv, NULL, NULL, (Cardinal) 0);
+                           argc, argv, NULL, NULL, (Cardinal) 0);
 
     LOCK_PROCESS;
     process->defaultAppContext = app_con;
diff --git a/src/Intrinsic.c b/src/Intrinsic.c
index c9624ec..07ccc78 100644
--- a/src/Intrinsic.c
+++ b/src/Intrinsic.c
@@ -74,15 +74,15 @@ in this Software without prior written authorization from The Open Group.
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
-#include "VarargsI.h"        /* for geoTattler */
+#include "VarargsI.h"           /* for geoTattler */
 #ifndef NO_IDENTIFY_WINDOWS
 #include <X11/Xatom.h>
 #endif
 #ifndef VMS
 #include <sys/stat.h>
-#endif /* VMS */
+#endif                          /* VMS */
 #ifdef WIN32
-#include <direct.h>            /* for _getdrives() */
+#include <direct.h>             /* for _getdrives() */
 #endif
 
 #include <stdio.h>
@@ -90,93 +90,89 @@ in this Software without prior written authorization from The Open Group.
 
 String XtCXtToolkitError = "XtToolkitError";
 
-Boolean XtIsSubclass(
-    Widget    widget,
-    WidgetClass myWidgetClass)
+Boolean
+XtIsSubclass(Widget widget, WidgetClass myWidgetClass)
 {
     register WidgetClass w;
     Boolean retval = FALSE;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     LOCK_PROCESS;
     for (w = widget->core.widget_class; w != NULL; w = w->core_class.superclass)
-	if (w == myWidgetClass) {
-	    retval = TRUE;
-	    break;
-	}
+        if (w == myWidgetClass) {
+            retval = TRUE;
+            break;
+        }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
     return retval;
-} /* XtIsSubclass */
-
+}                               /* XtIsSubclass */
 
-Boolean _XtCheckSubclassFlag(
-    Widget object,
-    _XtXtEnum flag)
+Boolean
+_XtCheckSubclassFlag(Widget object, _XtXtEnum flag)
 {
     Boolean retval;
 
     LOCK_PROCESS;
     if (object->core.widget_class->core_class.class_inited & flag)
-	retval = TRUE;
+        retval = TRUE;
     else
-	retval = FALSE;
+        retval = FALSE;
     UNLOCK_PROCESS;
     return retval;
 } /*_XtVerifySubclass */
 
-
-Boolean _XtIsSubclassOf(
-    Widget object,
-    WidgetClass myWidgetClass,
-    WidgetClass superClass,
-    _XtXtEnum flag)
+Boolean
+_XtIsSubclassOf(Widget object,
+                WidgetClass myWidgetClass,
+                WidgetClass superClass,
+                _XtXtEnum flag)
 {
     LOCK_PROCESS;
     if (!(object->core.widget_class->core_class.class_inited & flag)) {
-	UNLOCK_PROCESS;
-	return False;
-    } else {
-	register WidgetClass c = object->core.widget_class;
-	while (c != superClass) {
-	    if (c == myWidgetClass) {
-		UNLOCK_PROCESS;
-		return True;
-	    }
-	    c = c->core_class.superclass;
-	}
-	UNLOCK_PROCESS;
-	return False;
+        UNLOCK_PROCESS;
+        return False;
+    }
+    else {
+        register WidgetClass c = object->core.widget_class;
+
+        while (c != superClass) {
+            if (c == myWidgetClass) {
+                UNLOCK_PROCESS;
+                return True;
+            }
+            c = c->core_class.superclass;
+        }
+        UNLOCK_PROCESS;
+        return False;
     }
 } /*_XtIsSubclassOf */
 
-
-XtPointer XtGetClassExtension(
-    WidgetClass	object_class,
-    Cardinal	byte_offset,
-    XrmQuark	type,
-    long	version,
-    Cardinal	record_size)
+XtPointer
+XtGetClassExtension(WidgetClass object_class,
+                    Cardinal byte_offset,
+                    XrmQuark type, long version, Cardinal record_size)
 {
     ObjectClassExtension ext;
+
     LOCK_PROCESS;
 
-    ext = *(ObjectClassExtension *)((char *)object_class + byte_offset);
+    ext = *(ObjectClassExtension *) ((char *) object_class + byte_offset);
     while (ext && (ext->record_type != type || ext->version < version
-		   || ext->record_size < record_size)) {
-	ext = (ObjectClassExtension) ext->next_extension;
+                   || ext->record_size < record_size)) {
+        ext = (ObjectClassExtension) ext->next_extension;
     }
 
     UNLOCK_PROCESS;
     return (XtPointer) ext;
 }
 
-
-static void ComputeWindowAttributes(
-    Widget		 widget,
-    XtValueMask		 *value_mask,
-    XSetWindowAttributes *values)
+static void
+ComputeWindowAttributes(Widget widget,
+                        XtValueMask *value_mask,
+                        XSetWindowAttributes *values)
 {
     XtExposeProc expose;
 
@@ -184,46 +180,51 @@ static void ComputeWindowAttributes(
     (*values).event_mask = (long) XtBuildEventMask(widget);
     (*values).colormap = widget->core.colormap;
     if (widget->core.background_pixmap != XtUnspecifiedPixmap) {
-	*value_mask |= CWBackPixmap;
-	(*values).background_pixmap = widget->core.background_pixmap;
-    } else {
-	*value_mask |= CWBackPixel;
-	(*values).background_pixel = widget->core.background_pixel;
+        *value_mask |= CWBackPixmap;
+        (*values).background_pixmap = widget->core.background_pixmap;
+    }
+    else {
+        *value_mask |= CWBackPixel;
+        (*values).background_pixel = widget->core.background_pixel;
     }
     if (widget->core.border_pixmap != XtUnspecifiedPixmap) {
-	*value_mask |= CWBorderPixmap;
-	(*values).border_pixmap = widget->core.border_pixmap;
-    } else {
-	*value_mask |= CWBorderPixel;
-	(*values).border_pixel = widget->core.border_pixel;
+        *value_mask |= CWBorderPixmap;
+        (*values).border_pixmap = widget->core.border_pixmap;
+    }
+    else {
+        *value_mask |= CWBorderPixel;
+        (*values).border_pixel = widget->core.border_pixel;
     }
     LOCK_PROCESS;
     expose = widget->core.widget_class->core_class.expose;
     UNLOCK_PROCESS;
     if (expose == (XtExposeProc) NULL) {
-	/* Try to avoid redisplay upon resize by making bit_gravity the same
-	   as the default win_gravity */
-	*value_mask |= CWBitGravity;
-	(*values).bit_gravity = NorthWestGravity;
+        /* Try to avoid redisplay upon resize by making bit_gravity the same
+           as the default win_gravity */
+        *value_mask |= CWBitGravity;
+        (*values).bit_gravity = NorthWestGravity;
     }
-} /* ComputeWindowAttributes */
+}                               /* ComputeWindowAttributes */
 
-static void CallChangeManaged(
-    register Widget		widget)
+static void
+CallChangeManaged(register Widget widget)
 {
-    register Cardinal		i;
-    XtWidgetProc		change_managed;
-    register WidgetList		children;
-    int    			managed_children = 0;
+    register Cardinal i;
+    XtWidgetProc change_managed;
+    register WidgetList children;
+    int managed_children = 0;
 
     register CompositePtr cpPtr;
     register CompositePartPtr clPtr;
 
-    if (XtIsComposite (widget)) {
-	cpPtr = (CompositePtr)&((CompositeWidget) widget)->composite;
-        clPtr = (CompositePartPtr)&((CompositeWidgetClass)
-                   widget->core.widget_class)->composite_class;
-    } else return;
+    if (XtIsComposite(widget)) {
+        cpPtr = (CompositePtr) &((CompositeWidget) widget)->composite;
+        clPtr = (CompositePartPtr) &((CompositeWidgetClass)
+                                      widget->core.
+                                      widget_class)->composite_class;
+    }
+    else
+        return;
 
     children = cpPtr->children;
     LOCK_PROCESS;
@@ -232,118 +233,120 @@ static void CallChangeManaged(
 
     /* CallChangeManaged for all children */
     for (i = cpPtr->num_children; i != 0; --i) {
-	CallChangeManaged (children[i-1]);
-	if (XtIsManaged(children[i-1])) managed_children++;
+        CallChangeManaged(children[i - 1]);
+        if (XtIsManaged(children[i - 1]))
+            managed_children++;
     }
 
     if (change_managed != NULL && managed_children != 0) {
-	CALLGEOTAT(_XtGeoTrace(widget,"Call \"%s\"[%d,%d]'s changemanaged\n",
-		       XtName(widget),
-		       widget->core.width, widget->core.height));
-	(*change_managed) (widget);
+        CALLGEOTAT(_XtGeoTrace(widget, "Call \"%s\"[%d,%d]'s changemanaged\n",
+                               XtName(widget),
+                               widget->core.width, widget->core.height));
+        (*change_managed) (widget);
     }
-} /* CallChangeManaged */
-
+}                               /* CallChangeManaged */
 
-static void MapChildren(
-    CompositePart *cwp)
+static void
+MapChildren(CompositePart *cwp)
 {
     Cardinal i;
     WidgetList children;
 
     children = cwp->children;
-    for (i = 0; i <  cwp->num_children; i++) {
+    for (i = 0; i < cwp->num_children; i++) {
         Widget child = children[i];
-	if (XtIsWidget (child)){
-	    if (child->core.managed && child->core.mapped_when_managed) {
-		XtMapWidget (children[i]);
-	    }
-	}
-    }
-} /* MapChildren */
 
+        if (XtIsWidget(child)) {
+            if (child->core.managed && child->core.mapped_when_managed) {
+                XtMapWidget(children[i]);
+            }
+        }
+    }
+}                               /* MapChildren */
 
-static Boolean ShouldMapAllChildren(
-    CompositePart *cwp)
+static Boolean
+ShouldMapAllChildren(CompositePart *cwp)
 {
     Cardinal i;
     WidgetList children;
 
     children = cwp->children;
     for (i = 0; i < cwp->num_children; i++) {
-	Widget child = children[i];
-	if (XtIsWidget(child)) {
-	    if (XtIsRealized(child) && (! (child->core.managed
-					  && child->core.mapped_when_managed))){
-		    return False;
-	    }
-	}
+        Widget child = children[i];
+
+        if (XtIsWidget(child)) {
+            if (XtIsRealized(child) && (!(child->core.managed
+                                          && child->core.
+                                          mapped_when_managed))) {
+                return False;
+            }
+        }
     }
 
     return True;
-} /* ShouldMapAllChildren */
-
+}                               /* ShouldMapAllChildren */
 
-static void RealizeWidget(
-    Widget			widget)
+static void
+RealizeWidget(Widget widget)
 {
-    XtValueMask			value_mask;
-    XSetWindowAttributes	values;
-    XtRealizeProc		realize;
-    Window			window;
-    Display*			display;
-    String			class_name;
-    Widget			hookobj;
-
-    if (!XtIsWidget(widget) || XtIsRealized(widget)) return;
+    XtValueMask value_mask;
+    XSetWindowAttributes values;
+    XtRealizeProc realize;
+    Window window;
+    Display *display;
+    String class_name;
+    Widget hookobj;
+
+    if (!XtIsWidget(widget) || XtIsRealized(widget))
+        return;
     display = XtDisplay(widget);
+
     _XtInstallTranslations(widget);
 
-    ComputeWindowAttributes (widget, &value_mask, &values);
+    ComputeWindowAttributes(widget, &value_mask, &values);
     LOCK_PROCESS;
     realize = widget->core.widget_class->core_class.realize;
     class_name = widget->core.widget_class->core_class.class_name;
     UNLOCK_PROCESS;
     if (realize == NULL)
-	XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-		      "invalidProcedure","realizeProc",XtCXtToolkitError,
-		      "No realize class procedure defined",
-		      NULL, NULL);
+        XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                      "invalidProcedure", "realizeProc", XtCXtToolkitError,
+                      "No realize class procedure defined", NULL, NULL);
     else {
-	CALLGEOTAT(_XtGeoTrace(widget,"Call \"%s\"[%d,%d]'s realize proc\n",
-		       XtName(widget),
-		       widget->core.width, widget->core.height));
-	(*realize) (widget, &value_mask, &values);
+        CALLGEOTAT(_XtGeoTrace(widget, "Call \"%s\"[%d,%d]'s realize proc\n",
+                               XtName(widget),
+                               widget->core.width, widget->core.height));
+        (*realize) (widget, &value_mask, &values);
     }
     window = XtWindow(widget);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
-    if (XtHasCallbacks(hookobj,XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHrealizeWidget;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+    if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHrealizeWidget;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 #ifndef NO_IDENTIFY_WINDOWS
     if (_XtGetPerDisplay(display)->appContext->identify_windows) {
-	int len_nm, len_cl;
-	char *s;
-
-	len_nm = widget->core.name ? (int) strlen(widget->core.name) : 0;
-	len_cl = (int) strlen(class_name);
-	s = __XtMalloc((unsigned) (len_nm + len_cl + 2));
-	s[0] = '\0';
-	if (len_nm)
-	    strcpy(s, widget->core.name);
-	strcpy(s + len_nm + 1, class_name);
-	XChangeProperty(display, window,
-			XInternAtom(display, "_MIT_OBJ_CLASS",
-				    False),
-			XA_STRING, 8, PropModeReplace, (unsigned char *) s,
-			len_nm + len_cl + 2);
-	XtFree(s);
+        int len_nm, len_cl;
+        char *s;
+
+        len_nm = widget->core.name ? (int) strlen(widget->core.name) : 0;
+        len_cl = (int) strlen(class_name);
+        s = __XtMalloc((unsigned) (len_nm + len_cl + 2));
+        s[0] = '\0';
+        if (len_nm)
+            strcpy(s, widget->core.name);
+        strcpy(s + len_nm + 1, class_name);
+        XChangeProperty(display, window,
+                        XInternAtom(display, "_MIT_OBJ_CLASS",
+                                    False),
+                        XA_STRING, 8, PropModeReplace, (unsigned char *) s,
+                        len_nm + len_cl + 2);
+        XtFree(s);
     }
 #endif
 #ifdef notdef
@@ -353,79 +356,82 @@ static void RealizeWidget(
     _XtRegisterGrabs(widget);
     /* reregister any grabs added with XtGrab{Button,Key} */
     _XtRegisterPassiveGrabs(widget);
-    XtRegisterDrawable (display, window, widget);
+    XtRegisterDrawable(display, window, widget);
+
     _XtExtensionSelect(widget);
 
-    if (XtIsComposite (widget)) {
-	Cardinal		i;
-	CompositePart *cwp = &(((CompositeWidget)widget)->composite);
-	WidgetList children = cwp->children;
-	/* Realize all children */
-	for (i = cwp->num_children; i != 0; --i) {
-	    RealizeWidget (children[i-1]);
-	}
-	/* Map children that are managed and mapped_when_managed */
-
-	if (cwp->num_children != 0) {
-	    if (ShouldMapAllChildren(cwp)) {
-		XMapSubwindows (display, window);
-	    } else {
-		MapChildren(cwp);
-	    }
-	}
+    if (XtIsComposite(widget)) {
+        Cardinal i;
+        CompositePart *cwp = &(((CompositeWidget) widget)->composite);
+        WidgetList children = cwp->children;
+
+        /* Realize all children */
+        for (i = cwp->num_children; i != 0; --i) {
+            RealizeWidget(children[i - 1]);
+        }
+        /* Map children that are managed and mapped_when_managed */
+
+        if (cwp->num_children != 0) {
+            if (ShouldMapAllChildren(cwp)) {
+                XMapSubwindows(display, window);
+            }
+            else {
+                MapChildren(cwp);
+            }
+        }
     }
 
     /* If this is the application's popup shell, map it */
     if (widget->core.parent == NULL && widget->core.mapped_when_managed) {
-	XtMapWidget (widget);
+        XtMapWidget(widget);
     }
-} /* RealizeWidget */
+}                               /* RealizeWidget */
 
-void XtRealizeWidget (
-    Widget		widget)
+void
+XtRealizeWidget(Widget widget)
 {
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    if (XtIsRealized (widget)) {
-	UNLOCK_APP(app);
-	return;
+    if (XtIsRealized(widget)) {
+        UNLOCK_APP(app);
+        return;
     }
     CallChangeManaged(widget);
     RealizeWidget(widget);
     UNLOCK_APP(app);
-} /* XtRealizeWidget */
+}                               /* XtRealizeWidget */
 
-
-static void UnrealizeWidget(
-    Widget		widget)
+static void
+UnrealizeWidget(Widget widget)
 {
-    CompositeWidget	cw;
+    CompositeWidget cw;
 
-    if (!XtIsWidget(widget) || !XtIsRealized(widget)) return;
+    if (!XtIsWidget(widget) || !XtIsRealized(widget))
+        return;
 
     /* If this is the application's popup shell, unmap it? */
     /* no, the window is being destroyed */
 
     /* Recurse on children */
-    if (XtIsComposite (widget)) {
-	Cardinal i;
-	WidgetList children;
-
-	cw = (CompositeWidget) widget;
-	children = cw->composite.children;
-	/* Unrealize all children */
-	for (i = cw->composite.num_children; i != 0; --i) {
-	    UnrealizeWidget (children[i-1]);
-	}
-	/* Unmap children that are managed and mapped_when_managed? */
-	/* No, it's ok to be managed and unrealized as long as your parent */
-	/* is unrealized. XtUnrealize widget makes sure the "top" widget */
-	/* is unmanaged, we can ignore all descendents */
+    if (XtIsComposite(widget)) {
+        Cardinal i;
+        WidgetList children;
+
+        cw = (CompositeWidget) widget;
+        children = cw->composite.children;
+        /* Unrealize all children */
+        for (i = cw->composite.num_children; i != 0; --i) {
+            UnrealizeWidget(children[i - 1]);
+        }
+        /* Unmap children that are managed and mapped_when_managed? */
+        /* No, it's ok to be managed and unrealized as long as your parent */
+        /* is unrealized. XtUnrealize widget makes sure the "top" widget */
+        /* is unmanaged, we can ignore all descendents */
     }
 
     if (XtHasCallbacks(widget, XtNunrealizeCallback) == XtCallbackHasSome)
-	XtCallCallbacks(widget, XtNunrealizeCallback, NULL);
+        XtCallCallbacks(widget, XtNunrealizeCallback, NULL);
 
     /* Unregister window */
     XtUnregisterDrawable(XtDisplay(widget), XtWindow(widget));
@@ -440,215 +446,234 @@ static void UnrealizeWidget(
      * the translation table is changed while the widget is unrealized.
      */
     _XtRemoveTranslations(widget);
-} /* UnrealizeWidget */
-
+}                               /* UnrealizeWidget */
 
-void XtUnrealizeWidget (
-    Widget		widget)
+void
+XtUnrealizeWidget(Widget widget)
 {
     Window window;
     Widget hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     window = XtWindow(widget);
-    if (! XtIsRealized (widget)) {
-	UNLOCK_APP(app);
-	return;
+    if (!XtIsRealized(widget)) {
+        UNLOCK_APP(app);
+        return;
     }
     if (widget->core.managed && widget->core.parent != NULL)
-	XtUnmanageChild(widget);
+        XtUnmanageChild(widget);
     UnrealizeWidget(widget);
     if (window != None)
-	XDestroyWindow(XtDisplay(widget), window);
+        XDestroyWindow(XtDisplay(widget), window);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHunrealizeWidget;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHunrealizeWidget;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtUnrealizeWidget */
-
+}                               /* XtUnrealizeWidget */
 
-void XtCreateWindow(
-    Widget		 widget,
-    unsigned int	 window_class,
-    Visual		 *visual,
-    XtValueMask		 value_mask,
-    XSetWindowAttributes *attributes)
+void
+XtCreateWindow(Widget widget,
+               unsigned int window_class,
+               Visual *visual,
+               XtValueMask value_mask,
+               XSetWindowAttributes *attributes)
 {
     XtAppContext app = XtWidgetToApplicationContext(widget);
 
     LOCK_APP(app);
     if (widget->core.window == None) {
-	if (widget->core.width == 0 || widget->core.height == 0) {
-	    Cardinal count = 1;
-	    XtAppErrorMsg(app,
-		       "invalidDimension", "xtCreateWindow", XtCXtToolkitError,
-		       "Widget %s has zero width and/or height",
-		       &widget->core.name, &count);
-	}
-	widget->core.window =
-	    XCreateWindow (
-		XtDisplay (widget),
-		(widget->core.parent ?
-		    widget->core.parent->core.window :
-		    widget->core.screen->root),
-		(int)widget->core.x, (int)widget->core.y,
-		(unsigned)widget->core.width, (unsigned)widget->core.height,
-		(unsigned)widget->core.border_width, (int) widget->core.depth,
-		window_class, visual, value_mask, attributes);
+        if (widget->core.width == 0 || widget->core.height == 0) {
+            Cardinal count = 1;
+
+            XtAppErrorMsg(app,
+                          "invalidDimension", "xtCreateWindow",
+                          XtCXtToolkitError,
+                          "Widget %s has zero width and/or height",
+                          &widget->core.name, &count);
+        }
+        widget->core.window =
+            XCreateWindow(XtDisplay(widget),
+                          (widget->core.parent ?
+                           widget->core.parent->core.window :
+                           widget->core.screen->root),
+                          (int) widget->core.x, (int) widget->core.y,
+                          (unsigned) widget->core.width,
+                          (unsigned) widget->core.height,
+                          (unsigned) widget->core.border_width,
+                          (int) widget->core.depth, window_class, visual,
+                          value_mask, attributes);
     }
     UNLOCK_APP(app);
-} /* XtCreateWindow */
-
+}                               /* XtCreateWindow */
 
 /* ---------------- XtNameToWidget ----------------- */
 
-static Widget NameListToWidget(
-    Widget root,
-    XrmNameList     names,
-    XrmBindingList  bindings,
-    int in_depth, int *out_depth, int *found_depth);
-
-typedef Widget (*NameMatchProc)(XrmNameList,
-    XrmBindingList,
-    WidgetList, Cardinal, int, int *, int *);
-
-static Widget MatchExactChildren(
-    XrmNameList     names,
-    XrmBindingList  bindings,
-    register WidgetList children,
-    register Cardinal num,
-    int in_depth, int *out_depth, int *found_depth)
+static Widget NameListToWidget(Widget root,
+                               XrmNameList names,
+                               XrmBindingList bindings,
+                               int in_depth, int *out_depth, int *found_depth);
+
+typedef Widget(*NameMatchProc) (XrmNameList,
+                                XrmBindingList,
+                                WidgetList, Cardinal, int, int *, int *);
+
+static Widget
+MatchExactChildren(XrmNameList names,
+                   XrmBindingList bindings,
+                   register WidgetList children,
+                   register Cardinal num,
+                   int in_depth,
+                   int *out_depth,
+                   int *found_depth)
 {
-    register Cardinal   i;
-    register XrmName    name = *names;
+    register Cardinal i;
+    register XrmName name = *names;
     Widget w, result = NULL;
     int d, min = 10000;
 
     for (i = 0; i < num; i++) {
-	if (name == children[i]->core.xrm_name) {
-	    w = NameListToWidget(children[i], &names[1], &bindings[1],
-		    in_depth+1, &d, found_depth);
-	    if (w != NULL && d < min) {result = w; min = d;}
-	}
+        if (name == children[i]->core.xrm_name) {
+            w = NameListToWidget(children[i], &names[1], &bindings[1],
+                                 in_depth + 1, &d, found_depth);
+            if (w != NULL && d < min) {
+                result = w;
+                min = d;
+            }
+        }
     }
     *out_depth = min;
     return result;
 }
 
-static Widget MatchWildChildren(
-    XrmNameList     names,
-    XrmBindingList  bindings,
-    register WidgetList children,
-    register Cardinal num,
-    int in_depth, int *out_depth, int *found_depth)
+static Widget
+MatchWildChildren(XrmNameList names,
+                  XrmBindingList bindings,
+                  register WidgetList children,
+                  register Cardinal num,
+                  int in_depth,
+                  int *out_depth,
+                  int *found_depth)
 {
-    register Cardinal   i;
+    register Cardinal i;
     Widget w, result = NULL;
     int d, min = 10000;
 
     for (i = 0; i < num; i++) {
-	w = NameListToWidget(children[i], names, bindings,
-		in_depth+1, &d, found_depth);
-	if (w != NULL && d < min) {result = w; min = d;}
+        w = NameListToWidget(children[i], names, bindings,
+                             in_depth + 1, &d, found_depth);
+        if (w != NULL && d < min) {
+            result = w;
+            min = d;
+        }
     }
     *out_depth = min;
     return result;
 }
 
-static Widget SearchChildren(
-    Widget root,
-    XrmNameList     names,
-    XrmBindingList  bindings,
-    NameMatchProc matchproc,
-    int in_depth, int *out_depth, int *found_depth)
+static Widget
+SearchChildren(Widget root,
+               XrmNameList names,
+               XrmBindingList bindings,
+               NameMatchProc matchproc,
+               int in_depth,
+               int *out_depth,
+               int *found_depth)
 {
     Widget w1 = NULL, w2;
     int d1, d2;
 
     if (XtIsComposite(root)) {
-	w1 = (*matchproc)(names, bindings,
-		((CompositeWidget) root)->composite.children,
-		((CompositeWidget) root)->composite.num_children,
-		in_depth, &d1, found_depth);
-    } else d1 = 10000;
-    w2 = (*matchproc)(names, bindings, root->core.popup_list,
-	    root->core.num_popups, in_depth, &d2, found_depth);
+        w1 = (*matchproc) (names, bindings,
+                           ((CompositeWidget) root)->composite.children,
+                           ((CompositeWidget) root)->composite.num_children,
+                           in_depth, &d1, found_depth);
+    }
+    else
+        d1 = 10000;
+    w2 = (*matchproc) (names, bindings, root->core.popup_list,
+                       root->core.num_popups, in_depth, &d2, found_depth);
     *out_depth = (d1 < d2 ? d1 : d2);
     return (d1 < d2 ? w1 : w2);
 }
 
-static Widget NameListToWidget(
-    register Widget root,
-    XrmNameList     names,
-    XrmBindingList  bindings,
-    int in_depth, int *out_depth, int *found_depth)
+static Widget
+NameListToWidget(register Widget root,
+                 XrmNameList names,
+                 XrmBindingList bindings,
+                 int in_depth,
+                 int *out_depth,
+                 int *found_depth)
 {
     int d1, d2;
 
     if (in_depth >= *found_depth) {
-	*out_depth = 10000;
-	return NULL;
+        *out_depth = 10000;
+        return NULL;
     }
 
     if (names[0] == NULLQUARK) {
-	*out_depth = *found_depth = in_depth;
-	return root;
+        *out_depth = *found_depth = in_depth;
+        return root;
     }
 
-    if (! XtIsWidget(root)) {
-	*out_depth = 10000;
-	return NULL;
+    if (!XtIsWidget(root)) {
+        *out_depth = 10000;
+        return NULL;
     }
 
     if (*bindings == XrmBindTightly) {
-	return SearchChildren(root, names, bindings, MatchExactChildren,
-		in_depth, out_depth, found_depth);
-
-    } else {	/* XrmBindLoosely */
-	Widget w1, w2;
-
-	w1 = SearchChildren(root, names, bindings, MatchExactChildren,
-		in_depth, &d1, found_depth);
-	w2 = SearchChildren(root, names, bindings, MatchWildChildren,
-		in_depth, &d2, found_depth);
-	*out_depth = (d1 < d2 ? d1 : d2);
-	return (d1 < d2 ? w1 : w2);
+        return SearchChildren(root, names, bindings, MatchExactChildren,
+                              in_depth, out_depth, found_depth);
+
+    }
+    else {                      /* XrmBindLoosely */
+        Widget w1, w2;
+
+        w1 = SearchChildren(root, names, bindings, MatchExactChildren,
+                            in_depth, &d1, found_depth);
+        w2 = SearchChildren(root, names, bindings, MatchWildChildren,
+                            in_depth, &d2, found_depth);
+        *out_depth = (d1 < d2 ? d1 : d2);
+        return (d1 < d2 ? w1 : w2);
     }
-} /* NameListToWidget */
+}                               /* NameListToWidget */
 
-Widget XtNameToWidget(
-    Widget root,
-    _Xconst char* name)
+Widget
+XtNameToWidget(Widget root, _Xconst char *name)
 {
     XrmName *names;
     XrmBinding *bindings;
     int len, depth, found = 10000;
     Widget result;
+
     WIDGET_TO_APPCON(root);
 
     len = (int) strlen(name);
-    if (len == 0) return NULL;
+    if (len == 0)
+        return NULL;
 
     LOCK_APP(app);
-    names = (XrmName *) ALLOCATE_LOCAL((unsigned) (len+1) * sizeof(XrmName));
+    names = (XrmName *) ALLOCATE_LOCAL((unsigned) (len + 1) * sizeof(XrmName));
     bindings = (XrmBinding *)
-	ALLOCATE_LOCAL((unsigned) (len+1) * sizeof(XrmBinding));
-    if (names == NULL || bindings == NULL) _XtAllocError(NULL);
+        ALLOCATE_LOCAL((unsigned) (len + 1) * sizeof(XrmBinding));
+    if (names == NULL || bindings == NULL)
+        _XtAllocError(NULL);
 
     XrmStringToBindingQuarkList(name, bindings, names);
     if (names[0] == NULLQUARK) {
-	DEALLOCATE_LOCAL((char *) bindings);
-	DEALLOCATE_LOCAL((char *) names);
-	UNLOCK_APP(app);
-	return NULL;
+        DEALLOCATE_LOCAL((char *) bindings);
+        DEALLOCATE_LOCAL((char *) names);
+        UNLOCK_APP(app);
+        return NULL;
     }
 
     result = NameListToWidget(root, names, bindings, 0, &depth, &found);
@@ -657,64 +682,63 @@ Widget XtNameToWidget(
     DEALLOCATE_LOCAL((char *) names);
     UNLOCK_APP(app);
     return result;
-} /* XtNameToWidget */
+}                               /* XtNameToWidget */
 
 /* Define user versions of intrinsics macros */
 
 #undef XtDisplayOfObject
-Display *XtDisplayOfObject(
-     Widget object)
+Display *
+XtDisplayOfObject(Widget object)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     if (XtIsSubclass(object, hookObjectClass))
-	return DisplayOfScreen(((HookObject)object)->hooks.screen);
+        return DisplayOfScreen(((HookObject) object)->hooks.screen);
     return XtDisplay(XtIsWidget(object) ? object : _XtWindowedAncestor(object));
 }
 
 #undef XtDisplay
-Display *XtDisplay(
-	Widget widget)
+Display *
+XtDisplay(Widget widget)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     return DisplayOfScreen(widget->core.screen);
 }
 
 #undef XtScreenOfObject
-Screen *XtScreenOfObject(
-     Widget object)
+Screen *
+XtScreenOfObject(Widget object)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     if (XtIsSubclass(object, hookObjectClass))
-	return ((HookObject)object)->hooks.screen;
+        return ((HookObject) object)->hooks.screen;
     return XtScreen(XtIsWidget(object) ? object : _XtWindowedAncestor(object));
 }
 
 #undef XtScreen
-Screen *XtScreen(
-	Widget widget)
+Screen *
+XtScreen(Widget widget)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     return widget->core.screen;
 }
 
 #undef XtWindowOfObject
-Window XtWindowOfObject(
-     Widget object)
+Window
+XtWindowOfObject(Widget object)
 {
     return XtWindow(XtIsWidget(object) ? object : _XtWindowedAncestor(object));
 }
 
-
 #undef XtWindow
-Window XtWindow(
-	Widget widget)
+Window
+XtWindow(Widget widget)
 {
     return widget->core.window;
 }
 
 #undef XtSuperclass
-WidgetClass XtSuperclass(
-    Widget widget)
+WidgetClass
+XtSuperclass(Widget widget)
 {
     WidgetClass retval;
 
@@ -725,8 +749,8 @@ WidgetClass XtSuperclass(
 }
 
 #undef XtClass
-WidgetClass XtClass(
-    Widget widget)
+WidgetClass
+XtClass(Widget widget)
 {
     WidgetClass retval;
 
@@ -737,46 +761,49 @@ WidgetClass XtClass(
 }
 
 #undef XtIsManaged
-Boolean XtIsManaged(
-	Widget object)
+Boolean
+XtIsManaged(Widget object)
 {
     Boolean retval;
+
     WIDGET_TO_APPCON(object);
 
     LOCK_APP(app);
     if (XtIsRectObj(object))
-	retval = object->core.managed;
+        retval = object->core.managed;
     else
-	retval = False;
+        retval = False;
     UNLOCK_APP(app);
     return retval;
 }
 
 #undef XtIsRealized
-Boolean XtIsRealized (
-    Widget   object)
+Boolean
+XtIsRealized(Widget object)
 {
     Boolean retval;
+
     WIDGET_TO_APPCON(object);
 
     LOCK_APP(app);
     retval = XtWindowOfObject(object) != None;
     UNLOCK_APP(app);
     return retval;
-} /* XtIsRealized */
+}                               /* XtIsRealized */
 
 #undef XtIsSensitive
-Boolean XtIsSensitive(
-	Widget	object)
+Boolean
+XtIsSensitive(Widget object)
 {
     Boolean retval;
+
     WIDGET_TO_APPCON(object);
 
     LOCK_APP(app);
     if (XtIsRectObj(object))
-	retval = object->core.sensitive && object->core.ancestor_sensitive;
+        retval = object->core.sensitive && object->core.ancestor_sensitive;
     else
-	retval = False;
+        retval = False;
     UNLOCK_APP(app);
     return retval;
 }
@@ -784,106 +811,101 @@ Boolean XtIsSensitive(
 /*
  * Internal routine; must be called only after XtIsWidget returns false
  */
-Widget _XtWindowedAncestor(
-    register Widget object)
+Widget
+_XtWindowedAncestor(register Widget object)
 {
     Widget obj = object;
+
     for (object = XtParent(object); object && !XtIsWidget(object);)
-	object = XtParent(object);
+        object = XtParent(object);
 
     if (object == NULL) {
-	String params = XtName(obj);
-	Cardinal num_params = 1;
-	XtErrorMsg("noWidgetAncestor", "windowedAncestor", XtCXtToolkitError,
-		   "Object \"%s\" does not have windowed ancestor",
-		   &params, &num_params);
+        String params = XtName(obj);
+        Cardinal num_params = 1;
+
+        XtErrorMsg("noWidgetAncestor", "windowedAncestor", XtCXtToolkitError,
+                   "Object \"%s\" does not have windowed ancestor",
+                   &params, &num_params);
     }
 
     return object;
 }
 
 #undef XtParent
-Widget XtParent(
-    Widget widget)
+Widget
+XtParent(Widget widget)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     return widget->core.parent;
 }
 
 #undef XtName
-String XtName(
-     Widget object)
+String
+XtName(Widget object)
 {
     /* Attempts to LockApp() here will generate endless recursive loops */
     return XrmQuarkToString(object->core.xrm_name);
 }
 
-
-Boolean XtIsObject(
-    Widget object)
+Boolean
+XtIsObject(Widget object)
 {
     WidgetClass wc;
     String class_name;
 
     /* perform basic sanity checks */
     if (object->core.self != object || object->core.xrm_name == NULLQUARK)
-	return False;
+        return False;
 
     LOCK_PROCESS;
     wc = object->core.widget_class;
     if (wc->core_class.class_name == NULL ||
-	wc->core_class.xrm_class == NULLQUARK ||
-	(class_name = XrmClassToString(wc->core_class.xrm_class)) == NULL ||
-	strcmp(wc->core_class.class_name, class_name) != 0) {
-	    UNLOCK_PROCESS;
-	    return False;
-	}
+        wc->core_class.xrm_class == NULLQUARK ||
+        (class_name = XrmClassToString(wc->core_class.xrm_class)) == NULL ||
+        strcmp(wc->core_class.class_name, class_name) != 0) {
+        UNLOCK_PROCESS;
+        return False;
+    }
     UNLOCK_PROCESS;
 
     if (XtIsWidget(object)) {
-	if (object->core.name == NULL ||
-	    (class_name = XrmNameToString(object->core.xrm_name)) == NULL ||
-	    strcmp(object->core.name, class_name) != 0)
-	    return False;
+        if (object->core.name == NULL ||
+            (class_name = XrmNameToString(object->core.xrm_name)) == NULL ||
+            strcmp(object->core.name, class_name) != 0)
+            return False;
     }
     return True;
 }
 
 #if defined(WIN32)
-static int access_file (
-    char* path,
-    char* pathbuf,
-    int len_pathbuf,
-    char** pathret)
+static int
+access_file(char *path, char *pathbuf, int len_pathbuf, char **pathret)
 {
-    if (access (path, F_OK) == 0) {
-	if (strlen (path) < len_pathbuf)
-	    *pathret = pathbuf;
-	else
-	    *pathret = XtMalloc (strlen (path));
-	if (*pathret) {
-	    strcpy (*pathret, path);
-	    return 1;
-	}
+    if (access(path, F_OK) == 0) {
+        if (strlen(path) < len_pathbuf)
+            *pathret = pathbuf;
+        else
+            *pathret = XtMalloc(strlen(path));
+        if (*pathret) {
+            strcpy(*pathret, path);
+            return 1;
+        }
     }
     return 0;
 }
 
-static int AccessFile (
-    char* path,
-    char* pathbuf,
-    int len_pathbuf,
-    char** pathret)
+static int
+AccessFile(char *path, char *pathbuf, int len_pathbuf, char **pathret)
 {
     unsigned long drives;
     int i, len;
-    char* drive;
+    char *drive;
     char buf[MAX_PATH];
-    char* bufp;
+    char *bufp;
 
     /* just try the "raw" name first and see if it works */
-    if (access_file (path, pathbuf, len_pathbuf, pathret))
-	return 1;
+    if (access_file(path, pathbuf, len_pathbuf, pathret))
+        return 1;
 
 #if defined(WIN32) && defined(__MINGW32__)
     /* don't try others */
@@ -891,166 +913,171 @@ static int AccessFile (
 #endif
 
     /* try the places set in the environment */
-    drive = getenv ("_XBASEDRIVE");
+    drive = getenv("_XBASEDRIVE");
     if (!drive)
-	drive = "C:";
-    len = strlen (drive) + strlen (path);
-    bufp = XtStackAlloc (len + 1, buf);
-    strcpy (bufp, drive);
-    strcat (bufp, path);
-    if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
-	XtStackFree (bufp, buf);
-	return 1;
+        drive = "C:";
+    len = strlen(drive) + strlen(path);
+    bufp = XtStackAlloc(len + 1, buf);
+    strcpy(bufp, drive);
+    strcat(bufp, path);
+    if (access_file(bufp, pathbuf, len_pathbuf, pathret)) {
+        XtStackFree(bufp, buf);
+        return 1;
     }
 
     /* one last place to look */
-    drive = getenv ("HOMEDRIVE");
+    drive = getenv("HOMEDRIVE");
     if (drive) {
-	len = strlen (drive) + strlen (path);
-	bufp = XtStackAlloc (len + 1, buf);
-	strcpy (bufp, drive);
-	strcat (bufp, path);
-	if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
-	    XtStackFree (bufp, buf);
-	    return 1;
-	}
+        len = strlen(drive) + strlen(path);
+        bufp = XtStackAlloc(len + 1, buf);
+        strcpy(bufp, drive);
+        strcat(bufp, path);
+        if (access_file(bufp, pathbuf, len_pathbuf, pathret)) {
+            XtStackFree(bufp, buf);
+            return 1;
+        }
     }
 
     /* does OS/2 (with or with gcc-emx) have getdrives()? */
     /* tried everywhere else, go fishing */
-    drives = _getdrives ();
+    drives = _getdrives();
 #define C_DRIVE ('C' - 'A')
 #define Z_DRIVE ('Z' - 'A')
-    for (i = C_DRIVE; i <= Z_DRIVE; i++) { /* don't check on A: or B: */
-	if ((1 << i) & drives) {
-	    len = 2 + strlen (path);
-	    bufp = XtStackAlloc (len + 1, buf);
-	    *bufp = 'A' + i;
-	    *(bufp + 1) = ':';
-	    *(bufp + 2) = '\0';
-	    strcat (bufp, path);
-	    if (access_file (bufp, pathbuf, len_pathbuf, pathret)) {
-		XtStackFree (bufp, buf);
-		return 1;
-	    }
-	}
+    for (i = C_DRIVE; i <= Z_DRIVE; i++) {      /* don't check on A: or B: */
+        if ((1 << i) & drives) {
+            len = 2 + strlen(path);
+            bufp = XtStackAlloc(len + 1, buf);
+            *bufp = 'A' + i;
+            *(bufp + 1) = ':';
+            *(bufp + 2) = '\0';
+            strcat(bufp, path);
+            if (access_file(bufp, pathbuf, len_pathbuf, pathret)) {
+                XtStackFree(bufp, buf);
+                return 1;
+            }
+        }
     }
     return 0;
 }
 #endif
 
-static Boolean TestFile(
-    String path)
+static Boolean
+TestFile(String path)
 {
 #ifndef VMS
     int ret = 0;
     struct stat status;
+
 #if defined(WIN32)
     char buf[MAX_PATH];
-    char* bufp;
+    char *bufp;
     int len;
-    UINT olderror = SetErrorMode (SEM_FAILCRITICALERRORS);
+    UINT olderror = SetErrorMode(SEM_FAILCRITICALERRORS);
 
-    if (AccessFile (path, buf, MAX_PATH, &bufp))
-	path = bufp;
+    if (AccessFile(path, buf, MAX_PATH, &bufp))
+        path = bufp;
 
-    (void) SetErrorMode (olderror);
+    (void) SetErrorMode(olderror);
 #endif
-    ret = (access(path, R_OK) == 0 &&		/* exists and is readable */
-	    stat(path, &status) == 0 &&		/* get the status */
+    ret = (access(path, R_OK) == 0 &&   /* exists and is readable */
+           stat(path, &status) == 0 &&  /* get the status */
 #ifndef X_NOT_POSIX
-	    S_ISDIR(status.st_mode) == 0);	/* not a directory */
+           S_ISDIR(status.st_mode) == 0);       /* not a directory */
 #else
-	    (status.st_mode & S_IFMT) != S_IFDIR);	/* not a directory */
-#endif /* X_NOT_POSIX else */
+           (status.st_mode & S_IFMT) != S_IFDIR);       /* not a directory */
+#endif                          /* X_NOT_POSIX else */
     return (Boolean) ret;
-#else /* VMS */
-    return TRUE;	/* Who knows what to do here? */
-#endif /* VMS */
+#else                           /* VMS */
+    return TRUE;                /* Who knows what to do here? */
+#endif                          /* VMS */
 }
 
 /* return of TRUE = resolved string fit, FALSE = didn't fit.  Not
    null-terminated and not collapsed if it didn't fit */
 
-static Boolean Resolve(
-    register _Xconst char *source,	/* The source string */
-    register int len,		/* The length in bytes of *source */
-    Substitution sub,	/* Array of string values to substitute */
-    Cardinal num,	/* Number of substitution entries */
-    char *buf,		/* Where to put the resolved string; */
-    char collapse)	/* Character to collapse */
-{
+static Boolean Resolve(register _Xconst char *source,   /* The source string */
+                       register int len,        /* The length in bytes of *source */
+                       Substitution sub,        /* Array of string values to substitute */
+                       Cardinal num,    /* Number of substitution entries */
+                       char *buf,       /* Where to put the resolved string; */
+                       char collapse) { /* Character to collapse */
     register int bytesLeft = PATH_MAX;
-    register char* bp = buf;
+    register char *bp = buf;
+
 #ifndef DONT_COLLAPSE
     Boolean atBeginning = TRUE;
     Boolean prevIsCollapse = FALSE;
 
 #define PUT(ch) \
     { \
-	if (--bytesLeft == 0) return FALSE; \
+        if (--bytesLeft == 0) return FALSE; \
         if (prevIsCollapse) \
-	    if ((*bp = ch) != collapse) { \
-		prevIsCollapse = FALSE; \
-		bp++; \
-	    } \
-	    else bytesLeft++; \
+            if ((*bp = ch) != collapse) { \
+                prevIsCollapse = FALSE; \
+                bp++; \
+            } \
+            else bytesLeft++; \
         else if ((*bp++ = ch) == collapse && !atBeginning) \
-	    prevIsCollapse = TRUE; \
+            prevIsCollapse = TRUE; \
     }
-#else /* DONT_COLLAPSE */
+#else                           /* DONT_COLLAPSE */
 
 #define PUT(ch) \
     { \
-	if (--bytesLeft == 0) return FALSE; \
-	*bp++ = ch; \
+        if (--bytesLeft == 0) return FALSE; \
+        *bp++ = ch; \
     }
-#endif /* DONT_COLLAPSE */
+#endif                          /* DONT_COLLAPSE */
 #define escape '%'
 
     while (len--) {
 #ifndef DONT_COLLAPSE
-	if (*source == collapse) {
-	    PUT(*source);
-	    source++;
-	    continue;
-	}
-	else
-#endif /* DONT_COLLAPSE */
-	    if (*source != escape) {
-		PUT(*source);
-	}
-	else {
-	    source++;
-	    if (len-- == 0) {
-		PUT(escape);
-		break;
-	    }
-
-	    if (*source == ':' || *source == escape)
-		PUT(*source)
-	    else {
-		/* Match the character against the match array */
-		register Cardinal j;
-
-		for (j = 0; j < num && sub[j].match != *source; j++) {}
-
-		/* Substitute the substitution string */
-
-		if (j >= num) PUT(*source)
-		else if (sub[j].substitution != NULL) {
-		    char *sp = sub[j].substitution;
-		    while (*sp) {
-			PUT(*sp);
-			sp++;
-		    }
-		}
-	    }
-	}
-	source++;
+        if (*source == collapse) {
+            PUT(*source);
+            source++;
+            continue;
+        }
+        else
+#endif                          /* DONT_COLLAPSE */
+        if (*source != escape) {
+            PUT(*source);
+        }
+        else {
+            source++;
+            if (len-- == 0) {
+                PUT(escape);
+                break;
+            }
+
+            if (*source == ':' || *source == escape) {
+                PUT(*source);
+            }
+            else {
+                /* Match the character against the match array */
+                register Cardinal j;
+
+                for (j = 0; j < num && sub[j].match != *source; j++) {
+                }
+
+                /* Substitute the substitution string */
+
+                if (j >= num) {
+                    PUT(*source);
+                }
+                else if (sub[j].substitution != NULL) {
+                    char *sp = sub[j].substitution;
+
+                    while (*sp) {
+                        PUT(*sp);
+                        sp++;
+                    }
+                }
+            }
+        }
+        source++;
 #ifndef DONT_COLLAPSE
-	atBeginning = FALSE;
-#endif /* DONT_COLLAPSE */
+        atBeginning = FALSE;
+#endif                          /* DONT_COLLAPSE */
     }
     PUT('\0');
 
@@ -1059,73 +1086,74 @@ static Boolean Resolve(
 #undef escape
 }
 
-
-_XtString XtFindFile(
-    _Xconst _XtString path,
-    Substitution substitutions,
-    Cardinal num_substitutions,
-    XtFilePredicate predicate)
+_XtString
+XtFindFile(_Xconst _XtString path,
+           Substitution substitutions,
+           Cardinal num_substitutions,
+           XtFilePredicate predicate)
 {
     char *buf, *buf1, *buf2;
     _Xconst _XtString colon;
     int len;
     Boolean firstTime = TRUE;
 
-    buf1 = __XtMalloc((unsigned)PATH_MAX);
-    buf2 = __XtMalloc((unsigned)PATH_MAX);
+    buf1 = __XtMalloc((unsigned) PATH_MAX);
+    buf2 = __XtMalloc((unsigned) PATH_MAX);
     buf = buf1;
 
-    if (predicate == NULL) predicate = TestFile;
+    if (predicate == NULL)
+        predicate = TestFile;
 
     while (1) {
-	colon = path;
-	/* skip leading colons */
-	while (*colon) {
-	    if (*colon != ':') break;
-	    colon++;
-	    path++;
-	}
-	/* now look for an un-escaped colon */
-	for ( ; *colon ; colon++) {
-	    if (*colon == '%' && *(path+1)) {
-		colon++;	/* bump it an extra time to skip %. */
-		continue;
-	    }
-	    if (*colon == ':')
-		break;
-	}
-	len = (int) (colon - path);
-	if (Resolve(path, len, substitutions, num_substitutions,
-		    buf, '/')) {
-	    if (firstTime || strcmp(buf1,buf2) != 0) {
+        colon = path;
+        /* skip leading colons */
+        while (*colon) {
+            if (*colon != ':')
+                break;
+            colon++;
+            path++;
+        }
+        /* now look for an un-escaped colon */
+        for (; *colon; colon++) {
+            if (*colon == '%' && *(path + 1)) {
+                colon++;        /* bump it an extra time to skip %. */
+                continue;
+            }
+            if (*colon == ':')
+                break;
+        }
+        len = (int) (colon - path);
+        if (Resolve(path, len, substitutions, num_substitutions, buf, '/')) {
+            if (firstTime || strcmp(buf1, buf2) != 0) {
 #ifdef XNL_DEBUG
-		printf("Testing file %s\n", buf);
-#endif /* XNL_DEBUG */
-		/* Check out the file */
-		if ((*predicate) (buf)) {
-		    /* We've found it, return it */
+                printf("Testing file %s\n", buf);
+#endif                          /* XNL_DEBUG */
+                /* Check out the file */
+                if ((*predicate) (buf)) {
+                    /* We've found it, return it */
 #ifdef XNL_DEBUG
-		    printf("File found.\n");
-#endif /* XNL_DEBUG */
-		    if (buf == buf1) {
-			XtFree(buf2);
-			return buf1;
-		    }
-		    XtFree(buf1);
-		    return buf2;
-		}
-		if (buf == buf1)
-		    buf = buf2;
-		else
-		    buf = buf1;
-		firstTime = FALSE;
-	    }
-	}
-
-	/* Nope...any more paths? */
-
-	if (*colon == '\0') break;
-	path = colon+1;
+                    printf("File found.\n");
+#endif                          /* XNL_DEBUG */
+                    if (buf == buf1) {
+                        XtFree(buf2);
+                        return buf1;
+                    }
+                    XtFree(buf1);
+                    return buf2;
+                }
+                if (buf == buf1)
+                    buf = buf2;
+                else
+                    buf = buf1;
+                firstTime = FALSE;
+            }
+        }
+
+        /* Nope...any more paths? */
+
+        if (*colon == '\0')
+            break;
+        path = colon + 1;
     }
 
     /* No file found */
@@ -1135,128 +1163,129 @@ _XtString XtFindFile(
     return NULL;
 }
 
-
 /* The implementation of this routine is operating system dependent */
 /* Should match the code in Xlib _XlcMapOSLocaleName */
 
-static String ExtractLocaleName(
-    String	lang)
+static String
+ExtractLocaleName(String lang)
 {
 
 #if defined(hpux) || defined(CSRG_BASED) || defined(sun) || defined(SVR4) || defined(sgi) || defined(__osf__) || defined(AIXV3) || defined(ultrix) || defined(WIN32) || defined (linux)
-# ifdef hpux
+#ifdef hpux
 /*
  * We need to discriminated between HPUX 9 and HPUX 10. The equivalent
  * code in Xlib in SetLocale.c does include locale.h via X11/Xlocale.h.
  */
-#  include <locale.h>
-#  ifndef _LastCategory
-   /* HPUX 9 and earlier */
-#   define SKIPCOUNT 2
-#   define STARTCHAR ':'
-#   define ENDCHAR ';'
-#  else
+#include <locale.h>
+#ifndef _LastCategory
+    /* HPUX 9 and earlier */
+#define SKIPCOUNT 2
+#define STARTCHAR ':'
+#define ENDCHAR ';'
+#else
     /* HPUX 10 */
-#   define ENDCHAR ' '
-#  endif
-# else
-#  ifdef ultrix
-#   define SKIPCOUNT 2
-#   define STARTCHAR '\001'
-#   define ENDCHAR '\001'
-#  else
-#   ifdef WIN32
-#    define SKIPCOUNT 1
-#    define STARTCHAR '='
-#    define ENDCHAR ';'
-#    define WHITEFILL
-#   else
-#    if defined(__osf__) || (defined(AIXV3) && !defined(AIXV4))
-#     define STARTCHAR ' '
-#     define ENDCHAR ' '
-#    else
-#     if defined(linux)
-#      define STARTSTR "LC_CTYPE="
-#      define ENDCHAR ';'
-#     else
-#      if !defined(sun) || defined(SVR4)
-#       define STARTCHAR '/'
-#       define ENDCHAR '/'
-#      endif
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-    String          start;
-    String          end;
-    int             len;
-# ifdef SKIPCOUNT
-    int		    n;
-# endif
-    static char*    buf = NULL;
-# ifdef WHITEFILL
+#define ENDCHAR ' '
+#endif
+#else
+#ifdef ultrix
+#define SKIPCOUNT 2
+#define STARTCHAR '\001'
+#define ENDCHAR '\001'
+#else
+#ifdef WIN32
+#define SKIPCOUNT 1
+#define STARTCHAR '='
+#define ENDCHAR ';'
+#define WHITEFILL
+#else
+#if defined(__osf__) || (defined(AIXV3) && !defined(AIXV4))
+#define STARTCHAR ' '
+#define ENDCHAR ' '
+#else
+#if defined(linux)
+#define STARTSTR "LC_CTYPE="
+#define ENDCHAR ';'
+#else
+#if !defined(sun) || defined(SVR4)
+#define STARTCHAR '/'
+#define ENDCHAR '/'
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+
+    String start;
+    String end;
+    int len;
+
+#ifdef SKIPCOUNT
+    int n;
+#endif
+    static char *buf = NULL;
+
+#ifdef WHITEFILL
     char *temp;
-# endif
+#endif
 
     start = lang;
-# ifdef SKIPCOUNT
+#ifdef SKIPCOUNT
     for (n = SKIPCOUNT;
-	 --n >= 0 && start && (start = strchr (start, STARTCHAR));
-	 start++)
-	;
+         --n >= 0 && start && (start = strchr(start, STARTCHAR)); start++);
     if (!start)
-	start = lang;
-# endif
-# ifdef STARTCHAR
-    if (start && (start = strchr (start, STARTCHAR)))
-# elif  defined (STARTSTR)
-    if (start && (start = strstr (start,STARTSTR)))
-# endif
+        start = lang;
+#endif
+#ifdef STARTCHAR
+    if (start && (start = strchr(start, STARTCHAR)))
+#elif  defined (STARTSTR)
+    if (start && (start = strstr(start, STARTSTR)))
+#endif
     {
-# ifdef STARTCHAR
-	start++;
-# elif defined (STARTSTR)
-	start += strlen(STARTSTR);
-# endif
-
-	if ((end = strchr (start, ENDCHAR))) {
-	    len = (int) (end - start);
-	    XtFree (buf);
-	    buf = XtMalloc ((Cardinal)(len + 1));
-	    if (buf == NULL) return NULL;
-	    strncpy(buf, start, (size_t) len);
-	    *(buf + len) = '\0';
-# ifdef WHITEFILL
-	    for (temp = buf; (temp = strchr(temp, ' ')) != NULL; )
-		*temp++ = '-';
-# endif
-	    return buf;
-	} else  /* if no ENDCHAR is found we are at the end of the line */
-	    return start;
+#ifdef STARTCHAR
+        start++;
+#elif defined (STARTSTR)
+        start += strlen(STARTSTR);
+#endif
+
+        if ((end = strchr(start, ENDCHAR))) {
+            len = (int) (end - start);
+            XtFree(buf);
+            buf = XtMalloc((Cardinal) (len + 1));
+            if (buf == NULL)
+                return NULL;
+            strncpy(buf, start, (size_t) len);
+            *(buf + len) = '\0';
+#ifdef WHITEFILL
+            for (temp = buf; (temp = strchr(temp, ' ')) != NULL;)
+                *temp++ = '-';
+#endif
+            return buf;
+        }
+        else                    /* if no ENDCHAR is found we are at the end of the line */
+            return start;
     }
-# ifdef WHITEFILL
+#ifdef WHITEFILL
     if (strchr(lang, ' ')) {
-	XtFree (buf);
-	buf = strdup (lang);
-	if (buf == NULL) return NULL;
-	for (temp = buf; (temp = strchr(temp, ' ')) != NULL; )
-	    *temp++ = '-';
-	return buf;
+        XtFree(buf);
+        buf = strdup(lang);
+        if (buf == NULL)
+            return NULL;
+        for (temp = buf; (temp = strchr(temp, ' ')) != NULL;)
+            *temp++ = '-';
+        return buf;
     }
-# endif
-# undef STARTCHAR
-# undef ENDCHAR
-# undef WHITEFILL
+#endif
+#undef STARTCHAR
+#undef ENDCHAR
+#undef WHITEFILL
 #endif
 
     return lang;
 }
 
-static void FillInLangSubs(
-    Substitution subs,
-    XtPerDisplay pd)
+static void
+FillInLangSubs(Substitution subs, XtPerDisplay pd)
 {
     int len;
     String string;
@@ -1265,24 +1294,23 @@ static void FillInLangSubs(
     char *ch;
 
     if (pd->language == NULL ||
-	(pd->language != NULL && pd->language[0] == '\0')) {
-	subs[0].substitution = subs[1].substitution =
-		subs[2].substitution = subs[3].substitution = NULL;
-	return;
+        (pd->language != NULL && pd->language[0] == '\0')) {
+        subs[0].substitution = subs[1].substitution =
+            subs[2].substitution = subs[3].substitution = NULL;
+        return;
     }
 
     string = ExtractLocaleName(pd->language);
 
-    if (string == NULL ||
-	(string != NULL && string[0] == '\0')) {
-	subs[0].substitution = subs[1].substitution =
-		subs[2].substitution = subs[3].substitution = NULL;
-	return;
+    if (string == NULL || (string != NULL && string[0] == '\0')) {
+        subs[0].substitution = subs[1].substitution =
+            subs[2].substitution = subs[3].substitution = NULL;
+        return;
     }
 
     len = (int) strlen(string) + 1;
     subs[0].substitution = (_XtString) string;
-    p1 = subs[1].substitution = __XtMalloc((Cardinal) (3*len));
+    p1 = subs[1].substitution = __XtMalloc((Cardinal) (3 * len));
     p2 = subs[2].substitution = subs[1].substitution + len;
     p3 = subs[3].substitution = subs[2].substitution + len;
 
@@ -1294,22 +1322,26 @@ static void FillInLangSubs(
 
     ch = strchr(string, '_');
     if (ch != NULL) {
-	len = (int) (ch - string);
-	(void) strncpy(p1, string, (size_t) len);
-	p1[len] = '\0';
-	string = ch + 1;
-	rest = &p2;
-    } else rest = &p1;
+        len = (int) (ch - string);
+        (void) strncpy(p1, string, (size_t) len);
+        p1[len] = '\0';
+        string = ch + 1;
+        rest = &p2;
+    }
+    else
+        rest = &p1;
 
     /* Rest points to where we put the first part */
 
     ch = strchr(string, '.');
     if (ch != NULL) {
-	len = (int) (ch - string);
-	strncpy(*rest, string, (size_t) len);
-	(*rest)[len] = '\0';
-	(void) strcpy(p3, ch+1);
-    } else (void) strcpy(*rest, string);
+        len = (int) (ch - string);
+        strncpy(*rest, string, (size_t) len);
+        (*rest)[len] = '\0';
+        (void) strcpy(p3, ch + 1);
+    }
+    else
+        (void) strcpy(*rest, string);
 }
 
 /*
@@ -1318,7 +1350,8 @@ static void FillInLangSubs(
  * The exact value should be documented in the implementation
  * notes for any Xt implementation.
  */
-static const char *implementation_default_path(void)
+static const char *
+implementation_default_path(void)
 {
 #if defined(WIN32)
     static char xfilesearchpath[] = "";
@@ -1330,6 +1363,7 @@ static const char *implementation_default_path(void)
 }
 
 
+/* *INDENT-OFF* */
 static SubstitutionRec defaultSubs[] = {
     {'N', NULL},
     {'T', NULL},
@@ -1340,17 +1374,17 @@ static SubstitutionRec defaultSubs[] = {
     {'t', NULL},
     {'c', NULL}
 };
-
-
-_XtString XtResolvePathname(
-    Display *dpy,
-    _Xconst char* type,
-    _Xconst char* filename,
-    _Xconst char* suffix,
-    _Xconst char* path,
-    Substitution substitutions,
-    Cardinal num_substitutions,
-    XtFilePredicate predicate)
+/* *INDENT-ON* */
+
+_XtString
+XtResolvePathname(Display *dpy,
+                  _Xconst char *type,
+                  _Xconst char *filename,
+                  _Xconst char *suffix,
+                  _Xconst char *path,
+                  Substitution substitutions,
+                  Cardinal num_substitutions,
+                  XtFilePredicate predicate)
 {
     XtPerDisplay pd;
     static const char *defaultPath = NULL;
@@ -1370,31 +1404,34 @@ _XtString XtResolvePathname(
     pd = _XtGetPerDisplay(dpy);
     if (path == NULL) {
 #ifndef VMS
-	if (defaultPath == NULL) {
-	    defaultPath = getenv("XFILESEARCHPATH");
-	    if (defaultPath == NULL)
-		defaultPath = impl_default;
-	}
-	path = defaultPath;
-#endif /* VMS */
+        if (defaultPath == NULL) {
+            defaultPath = getenv("XFILESEARCHPATH");
+            if (defaultPath == NULL)
+                defaultPath = impl_default;
+        }
+        path = defaultPath;
+#endif                          /* VMS */
     }
 
     if (path == NULL)
-	path = "";	/* NULL would kill us later */
+        path = "";              /* NULL would kill us later */
 
     if (filename == NULL) {
-	filename = XrmClassToString(pd->class);
+        filename = XrmClassToString(pd->class);
     }
 
     bytesAllocd = bytesLeft = 1000;
-    massagedPath = ALLOCATE_LOCAL((size_t)bytesAllocd);
-    if (massagedPath == NULL) _XtAllocError(NULL);
+    massagedPath = ALLOCATE_LOCAL((size_t) bytesAllocd);
+    if (massagedPath == NULL)
+        _XtAllocError(NULL);
 
     if (path[0] == ':') {
-	strcpy(massagedPath, "%N%S");
-	ch = &massagedPath[4];
-	bytesLeft -= 4;
-    } else ch = massagedPath;
+        strcpy(massagedPath, "%N%S");
+        ch = &massagedPath[4];
+        bytesLeft -= 4;
+    }
+    else
+        ch = massagedPath;
 
     /* Insert %N%S between adjacent colons
      * and default path for %D.
@@ -1402,64 +1439,71 @@ _XtString XtResolvePathname(
      */
 
     while (*path != '\0') {
-	if (bytesLeft < idef_len) {
-	    int bytesUsed = bytesAllocd - bytesLeft;
-	    char *new;
-	    bytesAllocd +=1000;
-	    new = __XtMalloc((Cardinal) bytesAllocd);
-	    strncpy( new, massagedPath, (size_t) bytesUsed );
-	    ch = new + bytesUsed;
-	    if (pathMallocd)
-		XtFree(massagedPath);
-	    else
-		DEALLOCATE_LOCAL(massagedPath);
-	    pathMallocd = True;
-	    massagedPath = new;
-	    bytesLeft = bytesAllocd - bytesUsed;
-	}
-	if (*path == '%' && *(path+1) == ':') {
-	    *ch++ = '%';
-	    *ch++ = ':';
-	    path += 2;
-	    bytesLeft -= 2;
-	    continue;
-	}
-	if (*path == ':' && *(path+1) == ':') {
-	    strcpy(ch, ":%N%S:");
-	    ch += 6;
-	    bytesLeft -= 6;
-	    while (*path == ':') path++;
-	    continue;
-	}
-	if (*path == '%' && *(path+1) == 'D') {
-	    strcpy(ch, impl_default);
-	    ch += idef_len;
-	    bytesLeft -= idef_len;
-	    path += 2;
-	    continue;
-	}
-	*ch++ = *path++;
-	bytesLeft--;
+        if (bytesLeft < idef_len) {
+            int bytesUsed = bytesAllocd - bytesLeft;
+            char *new;
+
+            bytesAllocd += 1000;
+            new = __XtMalloc((Cardinal) bytesAllocd);
+            strncpy(new, massagedPath, (size_t) bytesUsed);
+            ch = new + bytesUsed;
+            if (pathMallocd)
+                XtFree(massagedPath);
+            else
+                DEALLOCATE_LOCAL(massagedPath);
+            pathMallocd = True;
+            massagedPath = new;
+            bytesLeft = bytesAllocd - bytesUsed;
+        }
+        if (*path == '%' && *(path + 1) == ':') {
+            *ch++ = '%';
+            *ch++ = ':';
+            path += 2;
+            bytesLeft -= 2;
+            continue;
+        }
+        if (*path == ':' && *(path + 1) == ':') {
+            strcpy(ch, ":%N%S:");
+            ch += 6;
+            bytesLeft -= 6;
+            while (*path == ':')
+                path++;
+            continue;
+        }
+        if (*path == '%' && *(path + 1) == 'D') {
+            strcpy(ch, impl_default);
+            ch += idef_len;
+            bytesLeft -= idef_len;
+            path += 2;
+            continue;
+        }
+        *ch++ = *path++;
+        bytesLeft--;
     }
     *ch = '\0';
 #ifdef XNL_DEBUG
     printf("Massaged path: %s\n", massagedPath);
-#endif /* XNL_DEBUG */
+#endif                          /* XNL_DEBUG */
 
     if (num_substitutions == 0)
-	merged_substitutions = defaultSubs;
+        merged_substitutions = defaultSubs;
     else {
-	int i = XtNumber(defaultSubs);
-	Substitution sub, def;
-	merged_substitutions = sub = (Substitution)
-	    ALLOCATE_LOCAL((unsigned)(num_substitutions+(Cardinal)i)*sizeof(SubstitutionRec));
-	if (sub == NULL) _XtAllocError(NULL);
-	for (def = defaultSubs; i--; sub++, def++) sub->match = def->match;
-	for (i = (int) num_substitutions; i--; ) *sub++ = *substitutions++;
+        int i = XtNumber(defaultSubs);
+        Substitution sub, def;
+
+        merged_substitutions = sub = (Substitution)
+            ALLOCATE_LOCAL((unsigned) (num_substitutions + (Cardinal) i) *
+                           sizeof(SubstitutionRec));
+        if (sub == NULL)
+            _XtAllocError(NULL);
+        for (def = defaultSubs; i--; sub++, def++)
+            sub->match = def->match;
+        for (i = (int) num_substitutions; i--;)
+            *sub++ = *substitutions++;
     }
-    merged_substitutions[0].substitution = (_XtString)filename;
-    merged_substitutions[1].substitution = (_XtString)type;
-    merged_substitutions[2].substitution = (_XtString)suffix;
+    merged_substitutions[0].substitution = (_XtString) filename;
+    merged_substitutions[1].substitution = (_XtString) type;
+    merged_substitutions[2].substitution = (_XtString) suffix;
     name_list[0] = pd->name;
     name_list[1] = XrmPermStringToQuark("customization");
     name_list[2] = NULLQUARK;
@@ -1467,39 +1511,36 @@ _XtString XtResolvePathname(
     class_list[1] = XrmPermStringToQuark("Customization");
     class_list[2] = NULLQUARK;
     if (XrmQGetResource(XrmGetDatabase(dpy), name_list, class_list,
-			&db_type, &value) &&
-	db_type == _XtQString)
-	merged_substitutions[3].substitution = (char *)value.addr;
+                        &db_type, &value) && db_type == _XtQString)
+        merged_substitutions[3].substitution = (char *) value.addr;
     else
-	merged_substitutions[3].substitution = NULL;
+        merged_substitutions[3].substitution = NULL;
     FillInLangSubs(&merged_substitutions[4], pd);
 
     result = XtFindFile(massagedPath, merged_substitutions,
-			num_substitutions + XtNumber(defaultSubs),
-			predicate);
+                        num_substitutions + XtNumber(defaultSubs), predicate);
 
     if (merged_substitutions[5].substitution != NULL)
-	XtFree( (XtPointer)merged_substitutions[5].substitution );
+        XtFree((XtPointer) merged_substitutions[5].substitution);
 
     if (merged_substitutions != defaultSubs)
-	DEALLOCATE_LOCAL(merged_substitutions);
+        DEALLOCATE_LOCAL(merged_substitutions);
 
     if (pathMallocd)
-	XtFree(massagedPath);
+        XtFree(massagedPath);
     else
-	DEALLOCATE_LOCAL(massagedPath);
+        DEALLOCATE_LOCAL(massagedPath);
 
     UNLOCK_PROCESS;
     return result;
 }
 
-
-Boolean XtCallAcceptFocus(
-    Widget widget,
-    Time *time)
+Boolean
+XtCallAcceptFocus(Widget widget, Time *time)
 {
     XtAcceptFocusProc ac;
     Boolean retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -1508,9 +1549,9 @@ Boolean XtCallAcceptFocus(
     UNLOCK_PROCESS;
 
     if (ac != NULL)
-	retval = (*ac) (widget, time);
+        retval = (*ac) (widget, time);
     else
-	retval = FALSE;
+        retval = FALSE;
     UNLOCK_APP(app);
     return retval;
 }
@@ -1541,52 +1582,55 @@ Boolean XtCallAcceptFocus(
 #define XtNgeoTattler "geoTattler"
 #define XtCGeoTattler "GeoTattler"
 
-typedef struct { Boolean   geo_tattler ;} GeoDataRec ;
+typedef struct {
+    Boolean geo_tattler;
+} GeoDataRec;
 
+/* *INDENT-OFF* */
 static XtResource geo_resources[] = {
     { XtNgeoTattler, XtCGeoTattler, XtRBoolean, sizeof(Boolean),
       XtOffsetOf(GeoDataRec, geo_tattler),
       XtRImmediate, (XtPointer) False }
 };
+/* *INDENT-ON* */
 
 /************************************************************************
   This function uses XtGetSubresources to find out if a widget
   needs to be geo-spied by the caller. */
-static Boolean IsTattled (Widget widget)
+static Boolean
+IsTattled(Widget widget)
 {
-    GeoDataRec geo_data ;
+    GeoDataRec geo_data;
 
-    XtGetSubresources(widget, (XtPointer)&geo_data,
-                      (String)NULL, (String)NULL,
-		      geo_resources, XtNumber(geo_resources),
-		      NULL, 0);
+    XtGetSubresources(widget, (XtPointer) &geo_data,
+                      (String) NULL, (String) NULL,
+                      geo_resources, XtNumber(geo_resources), NULL, 0);
 
     return geo_data.geo_tattler;
 
-}  /* IsTattled */
+}                               /* IsTattled */
 
-static int n_tab = 0 ;  /* not MT for now */
+static int n_tab = 0;           /* not MT for now */
 
 void
-_XtGeoTab (int direction)  /* +1 or -1 */
-{
-    n_tab += direction ;
+_XtGeoTab(int direction)
+{                               /* +1 or -1 */
+    n_tab += direction;
 }
 
-
 void
-_XtGeoTrace (Widget widget, const char *fmt, ...)
+_XtGeoTrace(Widget widget, const char *fmt, ...)
 {
     if (IsTattled(widget)) {
-	va_list args;
-	int i ;
-
-	va_start(args, fmt);
-	for (i=0; i<n_tab; i++) printf("     ");
-	(void) vprintf(fmt, args);
-	va_end(args);
+        va_list args;
+        int i;
+
+        va_start(args, fmt);
+        for (i = 0; i < n_tab; i++)
+            printf("     ");
+        (void) vprintf(fmt, args);
+        va_end(args);
     }
 }
 
-#endif /* XT_GEO_TATTLER */
-
+#endif                          /* XT_GEO_TATTLER */
diff --git a/src/Keyboard.c b/src/Keyboard.c
index 7697275..da6fa11 100644
--- a/src/Keyboard.c
+++ b/src/Keyboard.c
@@ -83,142 +83,133 @@ in this Software without prior written authorization from The Open Group.
 #define _GetWindowedAncestor(w) (XtIsWidget(w) ? w : _XtWindowedAncestor(w))
 
 /* InActiveSubtree cache of the current focus source and its ancestors */
-static Widget	*pathTrace = NULL;
-static int	pathTraceDepth = 0;
-static int	pathTraceMax = 0;
+static Widget *pathTrace = NULL;
+static int pathTraceDepth = 0;
+static int pathTraceMax = 0;
 
 /* FindKeyDestination cache of focus destination and ancestors up to source */
-static Widget	*pseudoTrace = NULL;
-static int	pseudoTraceDepth = 0;
-static int	pseudoTraceMax = 0;
+static Widget *pseudoTrace = NULL;
+static int pseudoTraceDepth = 0;
+static int pseudoTraceMax = 0;
 
-void _XtClearAncestorCache(Widget widget)
+void
+_XtClearAncestorCache(Widget widget)
 {
     /* the caller must lock the process lock */
     if (pathTraceDepth && pathTrace[0] == widget)
-	pathTraceDepth = 0;
+        pathTraceDepth = 0;
 }
 
-static XtServerGrabPtr CheckServerGrabs(
-    XEvent	*event,
-    Widget	*trace,
-    Cardinal	traceDepth)
+static XtServerGrabPtr
+CheckServerGrabs(XEvent *event, Widget *trace, Cardinal traceDepth)
 {
-    Cardinal		i;
-
-    for (i = traceDepth;  i > 0; i--)
-      {
-	XtServerGrabPtr grab;
-	if ((grab = _XtCheckServerGrabsOnWidget(event, trace[i-1], KEYBOARD)))
-	   return (grab);
-     }
-    return (XtServerGrabPtr)0;
+    Cardinal i;
+
+    for (i = traceDepth; i > 0; i--) {
+        XtServerGrabPtr grab;
+
+        if ((grab = _XtCheckServerGrabsOnWidget(event, trace[i - 1], KEYBOARD)))
+            return (grab);
+    }
+    return (XtServerGrabPtr) 0;
 }
 
-static Boolean IsParent(Widget a, Widget b)
+static Boolean
+IsParent(Widget a, Widget b)
 {
     for (b = XtParent(b); b; b = XtParent(b)) {
-      if (b == a) return TRUE;
-      if (XtIsShell(b)) return FALSE;
+        if (b == a)
+            return TRUE;
+        if (XtIsShell(b))
+            return FALSE;
     }
     return FALSE;
 }
 
 #define RelRtn(lca, type) {*relTypeRtn = type; return lca;}
 
-static Widget CommonAncestor(
-    register Widget a,
-    register Widget b,
-    XtGeneology  * relTypeRtn)
+static Widget
+CommonAncestor(register Widget a, register Widget b, XtGeneology *relTypeRtn)
 {
-    if (a == b)
-      {
-	  RelRtn(a, XtMySelf)
-	}
-    else if (IsParent(a, b))
-      {
-	  RelRtn(a, XtMyAncestor)
-	}
-    else if (IsParent(b, a))
-      {
-	  RelRtn(b, XtMyDescendant)
-	}
+    if (a == b) {
+        RelRtn(a, XtMySelf)
+    }
+    else if (IsParent(a, b)) {
+        RelRtn(a, XtMyAncestor)
+    }
+    else if (IsParent(b, a)) {
+        RelRtn(b, XtMyDescendant)
+    }
     else
-      for (b = XtParent(b);
-	   b && !XtIsShell(b);
-	   b = XtParent(b))
-	if (IsParent(b, a))
-	  {
-	      RelRtn(b, XtMyCousin)
-	    }
+        for (b = XtParent(b); b && !XtIsShell(b); b = XtParent(b))
+            if (IsParent(b, a)) {
+                RelRtn(b, XtMyCousin)
+            }
     RelRtn(NULL, XtUnrelated)
 }
-#undef RelRtn
-
-
-
 
+#undef RelRtn
 
-static Widget _FindFocusWidget(
-    Widget 	widget,
-    Widget	*trace,
-    int		traceDepth,
-    Boolean	activeCheck,
-    Boolean	*isTarget)
+static Widget
+_FindFocusWidget(Widget widget,
+                 Widget *trace,
+                 int traceDepth,
+                 Boolean activeCheck,
+                 Boolean *isTarget)
 {
     int src;
     Widget dst;
-    XtPerWidgetInput	pwi = NULL;
+    XtPerWidgetInput pwi = NULL;
 
     /* For each ancestor, starting at the top, see if it's forwarded */
 
-
     /* first check the trace list till done or we go to branch */
-    for (src = traceDepth-1, dst = widget; src > 0;)
-      {
-	  if ((pwi = _XtGetPerWidgetInput(trace[src], FALSE)))
-	    {
-		if (pwi->focusKid)
-		  {
-		      dst = pwi->focusKid;
-		      for (src--; src > 0 && trace[src] != dst; src--) {}
-		  }
-		else dst = trace[--src];
-	    }
-	  else dst = trace[--src];
-      }
+    for (src = traceDepth - 1, dst = widget; src > 0;) {
+        if ((pwi = _XtGetPerWidgetInput(trace[src], FALSE))) {
+            if (pwi->focusKid) {
+                dst = pwi->focusKid;
+                for (src--; src > 0 && trace[src] != dst; src--) {
+                }
+            }
+            else
+                dst = trace[--src];
+        }
+        else
+            dst = trace[--src];
+    }
 
     if (isTarget) {
-	if (pwi && pwi->focusKid == widget)
-	    *isTarget = TRUE;
-	else
-	    *isTarget = FALSE;
+        if (pwi && pwi->focusKid == widget)
+            *isTarget = TRUE;
+        else
+            *isTarget = FALSE;
     }
 
     if (!activeCheck)
-      while (XtIsWidget(dst)
-	     && (pwi = _XtGetPerWidgetInput(dst, FALSE))
-	     && pwi->focusKid)
-	dst = pwi->focusKid;
+        while (XtIsWidget(dst)
+               && (pwi = _XtGetPerWidgetInput(dst, FALSE))
+               && pwi->focusKid)
+            dst = pwi->focusKid;
 
     return dst;
 }
 
-
-static Widget FindFocusWidget(
-    Widget		widget,
-    XtPerDisplayInput 	pdi)
+static Widget
+FindFocusWidget(Widget widget, XtPerDisplayInput pdi)
 {
     if (pdi->focusWidget)
-      return  pdi->focusWidget;
+        return pdi->focusWidget;
     else
-      return _FindFocusWidget(widget, pdi->trace, pdi->traceDepth, FALSE, NULL);
+        return _FindFocusWidget(widget, pdi->trace, pdi->traceDepth, FALSE,
+                                NULL);
 }
 
-Widget XtGetKeyboardFocusWidget(Widget widget)
+Widget
+XtGetKeyboardFocusWidget(Widget widget)
 {
     XtPerDisplayInput pdi;
     Widget retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -228,9 +219,8 @@ Widget XtGetKeyboardFocusWidget(Widget widget)
     return retval;
 }
 
-static Boolean IsOutside(
-    XKeyEvent	*e,
-    Widget	w)
+static Boolean
+IsOutside(XKeyEvent *e, Widget w)
 {
     Position left, right, top, bottom;
 
@@ -242,392 +232,346 @@ static Boolean IsOutside(
     XtTranslateCoords(w, 0, 0, &left, &top);
     /* We need to take borders into consideration */
     left = (Position) (left - w->core.border_width);
-    top =  (Position) (top - w->core.border_width);
-    right = (Position) (left +  w->core.width + w->core.border_width);
-    bottom = (Position) (top +  w->core.height + w->core.border_width);
+    top = (Position) (top - w->core.border_width);
+    right = (Position) (left + w->core.width + w->core.border_width);
+    bottom = (Position) (top + w->core.height + w->core.border_width);
 
-    if (
-	(e->x_root < left) || (e->y_root < top) ||
+    if ((e->x_root < left) || (e->y_root < top) ||
         (e->x_root > right) || (e->y_root > bottom))
-      return TRUE;
+        return TRUE;
     else
-      return FALSE;
+        return FALSE;
 }
 
-static Widget 	FindKeyDestination(
-    Widget		widget,
-    XKeyEvent		*event,
-    XtServerGrabPtr	prevGrab,
-    XtServerGrabType 	prevGrabType,
-    XtServerGrabPtr	devGrab,
-    XtServerGrabType	devGrabType,
-    XtPerDisplayInput	pdi)
+static Widget
+FindKeyDestination(Widget widget,
+                   XKeyEvent *event,
+                   XtServerGrabPtr prevGrab,
+                   XtServerGrabType prevGrabType,
+                   XtServerGrabPtr devGrab,
+                   XtServerGrabType devGrabType,
+                   XtPerDisplayInput pdi)
 {
 
-    Widget		dspWidget;
-    Widget		focusWidget;
+    Widget dspWidget;
+    Widget focusWidget;
 
     LOCK_PROCESS;
     dspWidget =
-      focusWidget =
-	pdi->focusWidget =
-	  _GetWindowedAncestor(FindFocusWidget(widget, pdi));
-
+        focusWidget =
+        pdi->focusWidget = _GetWindowedAncestor(FindFocusWidget(widget, pdi));
 
     /*
      * If a grab is active from a previous activation then dispatch
      * based on owner_events ala protocol but with focus being
      * determined by XtSetKeyboardFocus.
      */
-    if 	(IsAnyGrab(prevGrabType))
-      {
-	  if (prevGrab->ownerEvents)
-	    dspWidget = focusWidget;
-	  else
-	    dspWidget = prevGrab->widget;
-      }
-    else
-      {
-	  /*
-           * If the focus widget is the event widget or a descendant
-	   * then we can avoid the rest of this. Else ugh...
-	   */
-	  if (focusWidget != widget)
-	    {
-		XtGeneology 	ewRelFw; /* relationship of event widget to
-					    focusWidget */
-		Widget		lca;
-
-		lca = CommonAncestor(widget, focusWidget, &ewRelFw);
-
-		/*
-		 * if the event widget is an ancestor of focus due to the pointer
-		 * and/or the grab being in an ancestor and it's a passive grab
-		 * send to grab widget.
-		 * we are also dispatching to widget if ownerEvents and the event
-		 * is outside the client
-		 */
-		if ((ewRelFw == XtMyAncestor) &&
-		    (devGrabType == XtPassiveServerGrab))
-		     {
-			 if (IsOutside(event, widget) ||
-			     event->type ==KeyPress
-			     )
-			   dspWidget = devGrab->widget;
-		     }
-		else
-		  {
-		      /*
-		       * if the grab widget is not an ancestor of the focus
-		       * release the grab in order to avoid locking. There
-		       * is a possible case  in that ownerEvents true will fall
-		       * through and if synch is set and the event widget
-		       * could turn it off we'll lock. check for it ? why not
-		       */
-		      if ((ewRelFw != XtMyAncestor)
-			  && (devGrabType == XtPassiveServerGrab)
-			  && (!IsAnyGrab(prevGrabType))
-			  )
-			{
-			    XtUngrabKeyboard(devGrab->widget,
-					     event->time);
-			}
-		      /*
-		       * if there isn't a grab with then check
-		       * for a logical grab that would have been activated
-		       * if the server was using Xt focus instead of server
-		       * focus
-		       */
-		      if (
-			  (event->type != KeyPress) ||
-			  (event->keycode == 0) /* Xlib XIM composed input */
-			  )
-			dspWidget = focusWidget;
-		      else
-			{
-			    XtServerGrabPtr	grab;
-
-			    if (!pseudoTraceDepth ||
-				!(focusWidget == pseudoTrace[0]) ||
-				!(lca == pseudoTrace[pseudoTraceDepth]))
-			      {
-				  /*
-				   * fill ancestor list from lca
-				   * (non-inclusive)to focusWidget by
-				   * passing in lca as breakWidget
-				   */
-				  _XtFillAncestorList(&pseudoTrace,
-						   &pseudoTraceMax,
-						   &pseudoTraceDepth,
-						   focusWidget,
-						   lca);
-				  /* ignore lca */
-				  pseudoTraceDepth--;
-			      }
-			    if ((grab = CheckServerGrabs((XEvent*)event,
-							pseudoTrace,
-							(Cardinal)pseudoTraceDepth)))
-			      {
-				  XtDevice device = &pdi->keyboard;
-
-				  device->grabType = XtPseudoPassiveServerGrab;
-				  pdi->activatingKey = (KeyCode) event->keycode;
-				  device->grab = *grab;
-
-				  if (grab
-				      )
-				    dspWidget = grab->widget;
-				  else
-				    dspWidget = focusWidget;
-			      }
-			}
-		  }
-	    }
-      }
+    if (IsAnyGrab(prevGrabType)) {
+        if (prevGrab->ownerEvents)
+            dspWidget = focusWidget;
+        else
+            dspWidget = prevGrab->widget;
+    }
+    else {
+        /*
+         * If the focus widget is the event widget or a descendant
+         * then we can avoid the rest of this. Else ugh...
+         */
+        if (focusWidget != widget) {
+            XtGeneology ewRelFw;        /* relationship of event widget to
+                                           focusWidget */
+            Widget lca;
+
+            lca = CommonAncestor(widget, focusWidget, &ewRelFw);
+
+            /*
+             * if the event widget is an ancestor of focus due to the pointer
+             * and/or the grab being in an ancestor and it's a passive grab
+             * send to grab widget.
+             * we are also dispatching to widget if ownerEvents and the event
+             * is outside the client
+             */
+            if ((ewRelFw == XtMyAncestor) &&
+                (devGrabType == XtPassiveServerGrab)) {
+                if (IsOutside(event, widget) || event->type == KeyPress)
+                    dspWidget = devGrab->widget;
+            }
+            else {
+                /*
+                 * if the grab widget is not an ancestor of the focus
+                 * release the grab in order to avoid locking. There
+                 * is a possible case  in that ownerEvents true will fall
+                 * through and if synch is set and the event widget
+                 * could turn it off we'll lock. check for it ? why not
+                 */
+                if ((ewRelFw != XtMyAncestor)
+                    && (devGrabType == XtPassiveServerGrab)
+                    && (!IsAnyGrab(prevGrabType))
+                    ) {
+                    XtUngrabKeyboard(devGrab->widget, event->time);
+                }
+                /*
+                 * if there isn't a grab with then check
+                 * for a logical grab that would have been activated
+                 * if the server was using Xt focus instead of server
+                 * focus
+                 */
+                if ((event->type != KeyPress) || (event->keycode == 0)  /* Xlib XIM composed input */
+                    )
+                    dspWidget = focusWidget;
+                else {
+                    XtServerGrabPtr grab;
+
+                    if (!pseudoTraceDepth ||
+                        !(focusWidget == pseudoTrace[0]) ||
+                        !(lca == pseudoTrace[pseudoTraceDepth])) {
+                        /*
+                         * fill ancestor list from lca
+                         * (non-inclusive)to focusWidget by
+                         * passing in lca as breakWidget
+                         */
+                        _XtFillAncestorList(&pseudoTrace,
+                                            &pseudoTraceMax,
+                                            &pseudoTraceDepth,
+                                            focusWidget, lca);
+                        /* ignore lca */
+                        pseudoTraceDepth--;
+                    }
+                    if ((grab = CheckServerGrabs((XEvent *) event,
+                                                 pseudoTrace,
+                                                 (Cardinal) pseudoTraceDepth)))
+                    {
+                        XtDevice device = &pdi->keyboard;
+
+                        device->grabType = XtPseudoPassiveServerGrab;
+                        pdi->activatingKey = (KeyCode) event->keycode;
+                        device->grab = *grab;
+
+                        if (grab)
+                            dspWidget = grab->widget;
+                        else
+                            dspWidget = focusWidget;
+                    }
+                }
+            }
+        }
+    }
     UNLOCK_PROCESS;
     return dspWidget;
 }
 
-Widget _XtProcessKeyboardEvent(
-    XKeyEvent  *event,
-    Widget widget,
-    XtPerDisplayInput pdi)
+Widget
+_XtProcessKeyboardEvent(XKeyEvent *event, Widget widget, XtPerDisplayInput pdi)
 {
-    XtDevice		device = &pdi->keyboard;
-    XtServerGrabPtr	devGrab = &device->grab;
-    XtServerGrabRec	prevGrabRec;
-    XtServerGrabType	prevGrabType = device->grabType;
-    Widget		dspWidget = NULL;
-    Boolean		deactivateGrab = FALSE;
+    XtDevice device = &pdi->keyboard;
+    XtServerGrabPtr devGrab = &device->grab;
+    XtServerGrabRec prevGrabRec;
+    XtServerGrabType prevGrabType = device->grabType;
+    Widget dspWidget = NULL;
+    Boolean deactivateGrab = FALSE;
 
     prevGrabRec = *devGrab;
 
-    switch (event->type)
-      {
-	case KeyPress:
-	  {
-	      XtServerGrabPtr	newGrab;
-
-	      if (event->keycode != 0 && /* Xlib XIM composed input */
-		  !IsServerGrab(device->grabType) &&
-		  (newGrab = CheckServerGrabs((XEvent*)event,
-					      pdi->trace,
-					      (Cardinal) pdi->traceDepth)))
-		{
-		    /*
-		     * honor pseudo-grab from prior event by X
-		     * unlocking keyboard. Not Xt Unlock !
-		     */
-		    if (IsPseudoGrab(prevGrabType))
-		      XUngrabKeyboard(XtDisplay(newGrab->widget),
-				      event->time);
-		    else
-		      {
-			  /* Activate the grab */
-			  device->grab = *newGrab;
-			  pdi->activatingKey = (KeyCode) event->keycode;
-			  device->grabType = XtPassiveServerGrab;
-		      }
-		}
-	    }
-	  break;
-
-	case KeyRelease:
-	  {
-	      if (IsEitherPassiveGrab(device->grabType) &&
-		  (event->keycode == pdi->activatingKey))
-		deactivateGrab = TRUE;
-	  }
-	  break;
-      }
+    switch (event->type) {
+    case KeyPress:
+    {
+        XtServerGrabPtr newGrab;
+
+        if (event->keycode != 0 &&      /* Xlib XIM composed input */
+            !IsServerGrab(device->grabType) &&
+            (newGrab = CheckServerGrabs((XEvent *) event,
+                                        pdi->trace,
+                                        (Cardinal) pdi->traceDepth))) {
+            /*
+             * honor pseudo-grab from prior event by X
+             * unlocking keyboard. Not Xt Unlock !
+             */
+            if (IsPseudoGrab(prevGrabType))
+                XUngrabKeyboard(XtDisplay(newGrab->widget), event->time);
+            else {
+                /* Activate the grab */
+                device->grab = *newGrab;
+                pdi->activatingKey = (KeyCode) event->keycode;
+                device->grabType = XtPassiveServerGrab;
+            }
+        }
+    }
+        break;
+
+    case KeyRelease:
+    {
+        if (IsEitherPassiveGrab(device->grabType) &&
+            (event->keycode == pdi->activatingKey))
+            deactivateGrab = TRUE;
+    }
+        break;
+    }
     dspWidget = FindKeyDestination(widget, event,
-				   &prevGrabRec, prevGrabType,
-				   devGrab, device->grabType,
-				   pdi);
-    if (deactivateGrab)
-      {
-	  /* Deactivate the grab */
-	  device->grabType = XtNoServerGrab;
-	  pdi->activatingKey = 0;
-      }
+                                   &prevGrabRec, prevGrabType,
+                                   devGrab, device->grabType, pdi);
+    if (deactivateGrab) {
+        /* Deactivate the grab */
+        device->grabType = XtNoServerGrab;
+        pdi->activatingKey = 0;
+    }
     return dspWidget;
 }
 
-static Widget GetShell(Widget widget)
+static Widget
+GetShell(Widget widget)
 {
-    Widget	shell;
+    Widget shell;
 
-    for (shell = widget;
-	 shell && !XtIsShell(shell);
-	 shell = XtParent(shell)){}
+    for (shell = widget; shell && !XtIsShell(shell); shell = XtParent(shell)) {
+    }
     return shell;
 }
 
-
 /*
  * Check that widget really has Xt focus due to it having recieved an
  * event
  */
-typedef enum {NotActive = 0, IsActive, IsTarget} ActiveType;
-static ActiveType InActiveSubtree(Widget widget)
+typedef enum { NotActive = 0, IsActive, IsTarget } ActiveType;
+
+static ActiveType
+InActiveSubtree(Widget widget)
 {
-    Boolean		isTarget;
-    ActiveType		retval;
+    Boolean isTarget;
+    ActiveType retval;
 
     LOCK_PROCESS;
     if (!pathTraceDepth || widget != pathTrace[0]) {
-	_XtFillAncestorList(&pathTrace,
-			    &pathTraceMax,
-			    &pathTraceDepth,
-			    widget,
-			    NULL);
+        _XtFillAncestorList(&pathTrace,
+                            &pathTraceMax, &pathTraceDepth, widget, NULL);
     }
     if (widget == _FindFocusWidget(widget,
-				   pathTrace,
-				   pathTraceDepth,
-				   TRUE,
-				   &isTarget))
-	retval = (isTarget ? IsTarget : IsActive);
+                                   pathTrace, pathTraceDepth, TRUE, &isTarget))
+        retval = (isTarget ? IsTarget : IsActive);
     else
-	retval = NotActive;
+        retval = NotActive;
     UNLOCK_PROCESS;
     return retval;
 }
 
-
-
-
-/* ARGSUSED */
-void _XtHandleFocus(
-    Widget widget,
-    XtPointer client_data,	/* child who wants focus */
-    XEvent *event,
-    Boolean *cont)		/* unused */
+void
+_XtHandleFocus(Widget widget,
+               XtPointer client_data, /* child who wants focus */
+               XEvent *event,
+               Boolean *cont _X_UNUSED)
 {
-    XtPerDisplayInput 	pdi = _XtGetPerDisplayInput(XtDisplay(widget));
-    XtPerWidgetInput	pwi = (XtPerWidgetInput)client_data;
-    XtGeneology		oldFocalPoint = pwi->focalPoint;
-    XtGeneology		newFocalPoint = pwi->focalPoint;
+    XtPerDisplayInput pdi = _XtGetPerDisplayInput(XtDisplay(widget));
+    XtPerWidgetInput pwi = (XtPerWidgetInput) client_data;
+    XtGeneology oldFocalPoint = pwi->focalPoint;
+    XtGeneology newFocalPoint = pwi->focalPoint;
 
-    switch( event->type ) {
+    switch (event->type) {
 
-      case KeyPress:
-      case KeyRelease:
-	/*
-	 * We're getting the keyevents used to guarantee propagating
+    case KeyPress:
+    case KeyRelease:
+        /*
+         * We're getting the keyevents used to guarantee propagating
          * child interest ala ForwardEvent in R3
-	 */
-	return;
-
-      case EnterNotify:
-      case LeaveNotify:
-
-	/*
-	 * If operating in a focus driven model, then enter and
-	 * leave events do not affect the keyboard focus.
-	 */
-	if ((event->xcrossing.detail != NotifyInferior)
-	    &&	(event->xcrossing.focus))
-	  {
-	      switch (oldFocalPoint)
-		{
-		  case XtMyAncestor:
-		    if (event->type == LeaveNotify)
-		      newFocalPoint = XtUnrelated;
-		    break;
-		  case XtUnrelated:
-		    if (event->type == EnterNotify)
-		      newFocalPoint = XtMyAncestor;
-		    break;
-		  case XtMySelf:
-		    break;
-		  case XtMyDescendant:
-		    break;
-
-		}
-	  }
-	break;
-      case FocusIn:
-	switch (event->xfocus.detail)
-	  {
-	    case NotifyNonlinear:
-	    case NotifyAncestor:
-	    case NotifyInferior:
-	      newFocalPoint = XtMySelf;
-	      break;
-	    case NotifyNonlinearVirtual:
-	    case NotifyVirtual:
-	      newFocalPoint = XtMyDescendant;
-	      break;
-	    case NotifyPointer:
-	      newFocalPoint = XtMyAncestor;
-	      break;
-	  }
-	break;
-      case FocusOut:
-	switch (event->xfocus.detail)
-	  {
-	    case NotifyPointer:
-	    case NotifyNonlinear:
-	    case NotifyAncestor:
-	    case NotifyNonlinearVirtual:
-	    case NotifyVirtual:
-	      newFocalPoint = XtUnrelated;
-	      break;
-	    case NotifyInferior:
-	      return;
-	  }
-	break;
+         */
+        return;
+
+    case EnterNotify:
+    case LeaveNotify:
+
+        /*
+         * If operating in a focus driven model, then enter and
+         * leave events do not affect the keyboard focus.
+         */
+        if ((event->xcrossing.detail != NotifyInferior)
+            && (event->xcrossing.focus)) {
+            switch (oldFocalPoint) {
+            case XtMyAncestor:
+                if (event->type == LeaveNotify)
+                    newFocalPoint = XtUnrelated;
+                break;
+            case XtUnrelated:
+                if (event->type == EnterNotify)
+                    newFocalPoint = XtMyAncestor;
+                break;
+            case XtMySelf:
+                break;
+            case XtMyDescendant:
+                break;
+
+            }
+        }
+        break;
+    case FocusIn:
+        switch (event->xfocus.detail) {
+        case NotifyNonlinear:
+        case NotifyAncestor:
+        case NotifyInferior:
+            newFocalPoint = XtMySelf;
+            break;
+        case NotifyNonlinearVirtual:
+        case NotifyVirtual:
+            newFocalPoint = XtMyDescendant;
+            break;
+        case NotifyPointer:
+            newFocalPoint = XtMyAncestor;
+            break;
+        }
+        break;
+    case FocusOut:
+        switch (event->xfocus.detail) {
+        case NotifyPointer:
+        case NotifyNonlinear:
+        case NotifyAncestor:
+        case NotifyNonlinearVirtual:
+        case NotifyVirtual:
+            newFocalPoint = XtUnrelated;
+            break;
+        case NotifyInferior:
+            return;
+        }
+        break;
     }
 
-    if (newFocalPoint != oldFocalPoint)
-      {
-	  Boolean 	add;
-	  Widget	descendant = pwi->focusKid;
-
-	  pwi->focalPoint = newFocalPoint;
-
-	  if ((oldFocalPoint == XtUnrelated) &&
-	      InActiveSubtree(widget) != NotActive)
-	    {
-		pdi->focusWidget = NULL; /* invalidate the cache */
-		pwi->haveFocus = TRUE;
-		add = TRUE;
-	    }
-	  else if (newFocalPoint == XtUnrelated)
-	    {
-		pdi->focusWidget = NULL; /* invalidate the cache */
-		pwi->haveFocus = FALSE;
-		add = FALSE;
-	    }
-	  else
-	    return;
-
-	  if (descendant)
-	    {
-		if (add)
-		  {
-		      _XtSendFocusEvent(descendant, FocusIn);
-		  }
-		else
-		  {
-		      _XtSendFocusEvent(descendant, FocusOut);
-		  }
-	    }
-      }
+    if (newFocalPoint != oldFocalPoint) {
+        Boolean add;
+        Widget descendant = pwi->focusKid;
+
+        pwi->focalPoint = newFocalPoint;
+
+        if ((oldFocalPoint == XtUnrelated) &&
+            InActiveSubtree(widget) != NotActive) {
+            pdi->focusWidget = NULL;    /* invalidate the cache */
+            pwi->haveFocus = TRUE;
+            add = TRUE;
+        }
+        else if (newFocalPoint == XtUnrelated) {
+            pdi->focusWidget = NULL;    /* invalidate the cache */
+            pwi->haveFocus = FALSE;
+            add = FALSE;
+        }
+        else
+            return;
+
+        if (descendant) {
+            if (add) {
+                _XtSendFocusEvent(descendant, FocusIn);
+            }
+            else {
+                _XtSendFocusEvent(descendant, FocusOut);
+            }
+        }
+    }
 }
 
-
-static void AddFocusHandler(
-    Widget widget,
-    Widget descendant,
-    XtPerWidgetInput pwi,
-    XtPerWidgetInput psi,
-    XtPerDisplayInput pdi,
-    EventMask oldEventMask)
+static void
+AddFocusHandler(Widget widget,
+                Widget descendant,
+                XtPerWidgetInput pwi,
+                XtPerWidgetInput psi,
+                XtPerDisplayInput pdi,
+                EventMask oldEventMask)
 {
-    EventMask	 	eventMask, targetEventMask;
-    Widget		target;
+    EventMask eventMask, targetEventMask;
+    Widget target;
 
     /*
      * widget must now select for key events if the descendant is
@@ -642,17 +586,17 @@ static void AddFocusHandler(
     eventMask |= FocusChangeMask | EnterWindowMask | LeaveWindowMask;
 
     if (oldEventMask) {
-	oldEventMask &= KeyPressMask | KeyReleaseMask;
-	oldEventMask |= FocusChangeMask | EnterWindowMask | LeaveWindowMask;
+        oldEventMask &= KeyPressMask | KeyReleaseMask;
+        oldEventMask |= FocusChangeMask | EnterWindowMask | LeaveWindowMask;
 
-	if (oldEventMask != eventMask)
-	    XtRemoveEventHandler(widget, (oldEventMask & ~eventMask),
-				 False, _XtHandleFocus, (XtPointer)pwi);
+        if (oldEventMask != eventMask)
+            XtRemoveEventHandler(widget, (oldEventMask & ~eventMask),
+                                 False, _XtHandleFocus, (XtPointer) pwi);
     }
 
     if (oldEventMask != eventMask)
-	XtAddEventHandler(widget, eventMask, False,
-			  _XtHandleFocus, (XtPointer)pwi);
+        XtAddEventHandler(widget, eventMask, False,
+                          _XtHandleFocus, (XtPointer) pwi);
 
     /* What follows is too much grief to go through if the
      * target doesn't actually care about focus change events,
@@ -661,106 +605,105 @@ static void AddFocusHandler(
      */
 
     if (!(targetEventMask & FocusChangeMask)) {
-	pdi->focusWidget = NULL;
-	return;
+        pdi->focusWidget = NULL;
+        return;
     }
 
     if (XtIsRealized(widget) && !pwi->haveFocus) {
-	if (psi->haveFocus) {
-	    Window root, child;
-	    int root_x, root_y, win_x, win_y;
-	    int left, right, top, bottom;
-	    unsigned int modMask;
-	    ActiveType act;
-
-	    /*
-	     * If the shell has the focus but the source widget
-	     * doesn't, it may only be because the source widget
-	     * wasn't previously tracking focus or crossing events.
-	     * If the target wants focus events, we have to
-	     * now determine whether the source has the focus.
-	     */
-
-	    if ((act = InActiveSubtree(widget)) == IsTarget)
-		pwi->haveFocus = TRUE;
-	    else if (act == IsActive) {
-		/*
-		 * An ancestor contains the focus, so if source
-		 * contains the pointer, then source has the focus.
-		 */
-
-		if (XQueryPointer(XtDisplay(widget), XtWindow(widget),
-				  &root, &child,
-				  &root_x, &root_y, &win_x, &win_y, &modMask))
-		{
-		    /* We need to take borders into consideration */
-		    left = top = -((int) widget->core.border_width);
-		    right = (int) (widget->core.width + (widget->core.border_width << 1));
-		    bottom = (int) (widget->core.height + (widget->core.border_width << 1));
-
-		    if (win_x >= left && win_x < right &&
-			win_y >= top && win_y < bottom)
-			pwi->haveFocus = TRUE;
-		}
-	    }
-	}
+        if (psi->haveFocus) {
+            Window root, child;
+            int root_x, root_y, win_x, win_y;
+            int left, right, top, bottom;
+            unsigned int modMask;
+            ActiveType act;
+
+            /*
+             * If the shell has the focus but the source widget
+             * doesn't, it may only be because the source widget
+             * wasn't previously tracking focus or crossing events.
+             * If the target wants focus events, we have to
+             * now determine whether the source has the focus.
+             */
+
+            if ((act = InActiveSubtree(widget)) == IsTarget)
+                pwi->haveFocus = TRUE;
+            else if (act == IsActive) {
+                /*
+                 * An ancestor contains the focus, so if source
+                 * contains the pointer, then source has the focus.
+                 */
+
+                if (XQueryPointer(XtDisplay(widget), XtWindow(widget),
+                                  &root, &child,
+                                  &root_x, &root_y, &win_x, &win_y, &modMask)) {
+                    /* We need to take borders into consideration */
+                    left = top = -((int) widget->core.border_width);
+                    right =
+                        (int) (widget->core.width +
+                               (widget->core.border_width << 1));
+                    bottom =
+                        (int) (widget->core.height +
+                               (widget->core.border_width << 1));
+
+                    if (win_x >= left && win_x < right &&
+                        win_y >= top && win_y < bottom)
+                        pwi->haveFocus = TRUE;
+                }
+            }
+        }
     }
     if (pwi->haveFocus) {
-	  pdi->focusWidget = NULL; /* invalidate the cache */
-	  _XtSendFocusEvent(target, FocusIn);
+        pdi->focusWidget = NULL;        /* invalidate the cache */
+        _XtSendFocusEvent(target, FocusIn);
     }
 }
 
-
-/* ARGSUSED */
-static void QueryEventMask(
-    Widget widget,		/* child who gets focus */
-    XtPointer client_data,	/* ancestor giving it */
-    XEvent *event,
-    Boolean *cont)		/* unused */
+static void
+QueryEventMask(Widget widget,           /* child who gets focus */
+               XtPointer client_data,   /* ancestor giving it */
+               XEvent *event _X_UNUSED,
+               Boolean *cont _X_UNUSED)
 {
     /* widget was once the target of an XtSetKeyboardFocus but
      * was unrealized at the time.   Make sure ancestor still wants
      * focus set here then install the handler now that we know the
      * complete event mask.
      */
-    Widget ancestor = (Widget)client_data;
+    Widget ancestor = (Widget) client_data;
     XtPerWidgetInput pwi = _XtGetPerWidgetInput(ancestor, FALSE);
 
     if (pwi) {
-	Widget target = pwi->queryEventDescendant;
-
-	/* use of 'target' is non-standard hackery;
-	   allows focus to non-widget */
-	if ( pwi->focusKid == target ) {
-	    AddFocusHandler(ancestor, target, pwi,
-			    _XtGetPerWidgetInput(GetShell(ancestor), TRUE),
-			    _XtGetPerDisplayInput(XtDisplay(ancestor)),
-			    (EventMask)0);
-	}
-	XtRemoveEventHandler(widget, XtAllEvents, True,
-			     QueryEventMask, client_data);
-	pwi->map_handler_added = FALSE;
+        Widget target = pwi->queryEventDescendant;
+
+        /* use of 'target' is non-standard hackery;
+           allows focus to non-widget */
+        if (pwi->focusKid == target) {
+            AddFocusHandler(ancestor, target, pwi,
+                            _XtGetPerWidgetInput(GetShell(ancestor), TRUE),
+                            _XtGetPerDisplayInput(XtDisplay(ancestor)),
+                            (EventMask) 0);
+        }
+        XtRemoveEventHandler(widget, XtAllEvents, True,
+                             QueryEventMask, client_data);
+        pwi->map_handler_added = FALSE;
     }
 }
 
-
-/* ARGSUSED */
-static void FocusDestroyCallback(
-    Widget  widget,
-    XtPointer closure,		/* Widget */
-    XtPointer call_data)
+static void
+FocusDestroyCallback(Widget widget _X_UNUSED,
+                     XtPointer closure, /* Widget */
+                     XtPointer call_data _X_UNUSED)
 {
-    XtSetKeyboardFocus((Widget)closure, NULL);
+    XtSetKeyboardFocus((Widget) closure, NULL);
 }
 
-void XtSetKeyboardFocus(
-    Widget widget,
-    Widget descendant)
+void
+XtSetKeyboardFocus(Widget widget, Widget descendant)
 {
     XtPerDisplayInput pdi;
     XtPerWidgetInput pwi;
     Widget oldDesc, oldTarget, target, hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -769,96 +712,94 @@ void XtSetKeyboardFocus(
     pwi = _XtGetPerWidgetInput(widget, TRUE);
     oldDesc = pwi->focusKid;
 
-    if (descendant == widget) descendant = (Widget)None;
+    if (descendant == widget)
+        descendant = (Widget) None;
 
     target = descendant ? _GetWindowedAncestor(descendant) : NULL;
     oldTarget = oldDesc ? _GetWindowedAncestor(oldDesc) : NULL;
 
     if (descendant != oldDesc) {
 
-	/* update the forward path */
-	pwi->focusKid = descendant;
-
-
-	/* all the rest handles focus ins and focus outs and misc gunk */
-
-	if (oldDesc) {
-	    /* invalidate FindKeyDestination's ancestor list */
-	    if (pseudoTraceDepth && oldTarget == pseudoTrace[0])
-		pseudoTraceDepth = 0;
-
-	    XtRemoveCallback(oldDesc, XtNdestroyCallback,
-			     FocusDestroyCallback, (XtPointer)widget);
-
-	    if (!oldTarget->core.being_destroyed) {
-		if (pwi->map_handler_added) {
-		    XtRemoveEventHandler(oldTarget, XtAllEvents, True,
-					 QueryEventMask, (XtPointer)widget);
-		    pwi->map_handler_added = FALSE;
-		}
-		if (pwi->haveFocus) {
-		    _XtSendFocusEvent( oldTarget, FocusOut);
-		}
-	    }
-	    else if (pwi->map_handler_added) {
-		pwi->map_handler_added = FALSE;
-	    }
-
-	    if (pwi->haveFocus)
-		pdi->focusWidget = NULL; /* invalidate cache */
-
-	    /*
-	     * If there was a forward path then remove the handler if
-	     * the path is being set to null and it isn't a shell.
-	     * shells always have a handler for tracking focus for the
-	     * hierarchy.
-	     *
-	     * Keep the pwi record on the assumption that the client
-	     * will continue to dynamically assign focus for this widget.
-	     */
-	    if (!XtIsShell(widget) && !descendant) {
-	      XtRemoveEventHandler(widget, XtAllEvents, True,
-				   _XtHandleFocus, (XtPointer)pwi);
-	      pwi->haveFocus = FALSE;
-	  }
-	}
-
-	if (descendant) {
-	    Widget shell = GetShell(widget);
-	    XtPerWidgetInput psi = _XtGetPerWidgetInput(shell, TRUE);
-	    XtAddCallback (descendant, XtNdestroyCallback,
-			   FocusDestroyCallback, (XtPointer) widget);
-
-	    AddFocusHandler(widget, descendant, pwi, psi, pdi,
-			    oldTarget ? XtBuildEventMask(oldTarget) : 0);
-
-	    if (widget != shell)
-		XtAddEventHandler(
-			shell,
-			FocusChangeMask | EnterWindowMask | LeaveWindowMask,
-			False,
-			_XtHandleFocus,
-			(XtPointer)psi
-		       );
-
-	    if (! XtIsRealized(target)) {
-		XtAddEventHandler(target, (EventMask)StructureNotifyMask,
-				  False, QueryEventMask, (XtPointer)widget);
-		pwi->map_handler_added = TRUE;
-		pwi->queryEventDescendant = descendant;
-	    }
-	}
+        /* update the forward path */
+        pwi->focusKid = descendant;
+
+        /* all the rest handles focus ins and focus outs and misc gunk */
+
+        if (oldDesc) {
+            /* invalidate FindKeyDestination's ancestor list */
+            if (pseudoTraceDepth && oldTarget == pseudoTrace[0])
+                pseudoTraceDepth = 0;
+
+            XtRemoveCallback(oldDesc, XtNdestroyCallback,
+                             FocusDestroyCallback, (XtPointer) widget);
+
+            if (!oldTarget->core.being_destroyed) {
+                if (pwi->map_handler_added) {
+                    XtRemoveEventHandler(oldTarget, XtAllEvents, True,
+                                         QueryEventMask, (XtPointer) widget);
+                    pwi->map_handler_added = FALSE;
+                }
+                if (pwi->haveFocus) {
+                    _XtSendFocusEvent(oldTarget, FocusOut);
+                }
+            }
+            else if (pwi->map_handler_added) {
+                pwi->map_handler_added = FALSE;
+            }
+
+            if (pwi->haveFocus)
+                pdi->focusWidget = NULL;        /* invalidate cache */
+
+            /*
+             * If there was a forward path then remove the handler if
+             * the path is being set to null and it isn't a shell.
+             * shells always have a handler for tracking focus for the
+             * hierarchy.
+             *
+             * Keep the pwi record on the assumption that the client
+             * will continue to dynamically assign focus for this widget.
+             */
+            if (!XtIsShell(widget) && !descendant) {
+                XtRemoveEventHandler(widget, XtAllEvents, True,
+                                     _XtHandleFocus, (XtPointer) pwi);
+                pwi->haveFocus = FALSE;
+            }
+        }
+
+        if (descendant) {
+            Widget shell = GetShell(widget);
+            XtPerWidgetInput psi = _XtGetPerWidgetInput(shell, TRUE);
+
+            XtAddCallback(descendant, XtNdestroyCallback,
+                          FocusDestroyCallback, (XtPointer) widget);
+
+            AddFocusHandler(widget, descendant, pwi, psi, pdi,
+                            oldTarget ? XtBuildEventMask(oldTarget) : 0);
+
+            if (widget != shell)
+                XtAddEventHandler(shell,
+                                  FocusChangeMask | EnterWindowMask |
+                                  LeaveWindowMask, False, _XtHandleFocus,
+                                  (XtPointer) psi);
+
+            if (!XtIsRealized(target)) {
+                XtAddEventHandler(target, (EventMask) StructureNotifyMask,
+                                  False, QueryEventMask, (XtPointer) widget);
+                pwi->map_handler_added = TRUE;
+                pwi->queryEventDescendant = descendant;
+            }
+        }
     }
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHsetKeyboardFocus;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) descendant;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHsetKeyboardFocus;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) descendant;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
diff --git a/src/Makefile.am b/src/Makefile.am
index 7f8ba6d..a26e10d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -96,10 +96,13 @@ all-local: $(BUILT_FILES)
 
 $(BUILT_HEADER): $(BUILT_SOURCE)
 
-$(BUILT_SOURCE):
+$(BUILT_SOURCE): $(top_builddir)/util/makestrs$(EXEEXT) 
 	$(AM_V_GEN)$(top_builddir)/util/makestrs -i $(top_srcdir) $(STRINGSABIOPTIONS) < $(STRING_LIST) > StringDefs.c
 	$(AM_V_at)$(MKDIR_P) $(top_builddir)/src
 	$(AM_V_at)$(MKDIR_P) $(top_builddir)/include/X11
 	$(AM_V_at)cp StringDefs.h $(top_builddir)/include/X11
 	$(AM_V_at)cp Shell.h $(top_builddir)/include/X11
 	$(AM_V_at)rm StringDefs.h Shell.h
+
+$(top_builddir)/util/makestrs$(EXEEXT) :
+	$(am__cd) $(@D) && $(MAKE) $(AM_MAKEFLAGS) $(@F)
diff --git a/src/Manage.c b/src/Manage.c
index 96bacbb..77f3d9f 100644
--- a/src/Manage.c
+++ b/src/Manage.c
@@ -78,99 +78,104 @@ static _Xconst _XtString XtNxtUnmanageChildren = "xtUnmanageChildren";
 static _Xconst _XtString XtNxtManageChildren = "xtManageChildren";
 static _Xconst _XtString XtNxtChangeManagedSet = "xtChangeManagedSet";
 
-static void UnmanageChildren(
-    WidgetList children,
-    Cardinal num_children,
-    Widget parent,
-    Cardinal* num_unique_children,
-    Boolean call_change_managed,
-    _Xconst _XtString caller_func)
+static void
+UnmanageChildren(WidgetList children,
+                 Cardinal num_children,
+                 Widget parent,
+                 Cardinal *num_unique_children,
+                 Boolean call_change_managed,
+                 _Xconst _XtString caller_func)
 {
-    Widget		child;
-    Cardinal		i;
-    XtWidgetProc	change_managed = NULL;
-    Bool		parent_realized = False;
+    Widget child;
+    Cardinal i;
+    XtWidgetProc change_managed = NULL;
+    Bool parent_realized = False;
 
     *num_unique_children = 0;
 
     if (XtIsComposite((Widget) parent)) {
-	LOCK_PROCESS;
+        LOCK_PROCESS;
         change_managed = ((CompositeWidgetClass) parent->core.widget_class)
-		    ->composite_class.change_managed;
-	UNLOCK_PROCESS;
-	parent_realized = XtIsRealized((Widget)parent);
-    } else {
-        XtAppErrorMsg(XtWidgetToApplicationContext((Widget)parent),
-		      "invalidParent",caller_func, XtCXtToolkitError,
-		   "Attempt to unmanage a child when parent is not Composite",
-		      NULL, NULL);
+            ->composite_class.change_managed;
+        UNLOCK_PROCESS;
+        parent_realized = XtIsRealized((Widget) parent);
+    }
+    else {
+        XtAppErrorMsg(XtWidgetToApplicationContext((Widget) parent),
+                      "invalidParent", caller_func, XtCXtToolkitError,
+                      "Attempt to unmanage a child when parent is not Composite",
+                      NULL, NULL);
     }
 
     for (i = 0; i < num_children; i++) {
-	child = children[i];
-	if (child == NULL) {
-	    XtAppWarningMsg(XtWidgetToApplicationContext(parent),
-		  XtNinvalidChild,caller_func,XtCXtToolkitError,
-                  "Null child passed to XtUnmanageChildren",
-		  NULL, NULL);
-	    return;
-	}
+        child = children[i];
+        if (child == NULL) {
+            XtAppWarningMsg(XtWidgetToApplicationContext(parent),
+                            XtNinvalidChild, caller_func, XtCXtToolkitError,
+                            "Null child passed to XtUnmanageChildren",
+                            NULL, NULL);
+            return;
+        }
         if (child->core.parent != parent) {
-	   XtAppWarningMsg(XtWidgetToApplicationContext(parent),
-		   "ambiguousParent",caller_func,XtCXtToolkitError,
-           "Not all children have same parent in UnmanageChildren",
-             NULL, NULL);
-	} else
-        if (child->core.managed) {
+            XtAppWarningMsg(XtWidgetToApplicationContext(parent),
+                            "ambiguousParent", caller_func, XtCXtToolkitError,
+                            "Not all children have same parent in UnmanageChildren",
+                            NULL, NULL);
+        }
+        else if (child->core.managed) {
             (*num_unique_children)++;
-	    CALLGEOTAT(_XtGeoTrace(child,"Child \"%s\" is marked unmanaged\n",
-			   XtName(child)));
-	    child->core.managed = FALSE;
+            CALLGEOTAT(_XtGeoTrace(child, "Child \"%s\" is marked unmanaged\n",
+                                   XtName(child)));
+            child->core.managed = FALSE;
             if (XtIsWidget(child)
-		&& XtIsRealized(child)
-		&& child->core.mapped_when_managed)
-                    XtUnmapWidget(child);
-            else
-	    { /* RectObj child */
-		Widget pw = child->core.parent;
-		RectObj r = (RectObj) child;
-		while ((pw!=NULL) && (!XtIsWidget(pw))) pw = pw->core.parent;
-		if ((pw!=NULL) && XtIsRealized (pw))
-		    XClearArea (XtDisplay (pw), XtWindow (pw),
-			r->rectangle.x, r->rectangle.y,
-			(unsigned) (r->rectangle.width + (r->rectangle.border_width << 1)),
-			(unsigned) (r->rectangle.height + (r->rectangle.border_width << 1)),
-			TRUE);
-	    }
+                && XtIsRealized(child)
+                && child->core.mapped_when_managed)
+                XtUnmapWidget(child);
+            else {              /* RectObj child */
+                Widget pw = child->core.parent;
+                RectObj r = (RectObj) child;
+
+                while ((pw != NULL) && (!XtIsWidget(pw)))
+                    pw = pw->core.parent;
+                if ((pw != NULL) && XtIsRealized(pw))
+                    XClearArea(XtDisplay(pw), XtWindow(pw),
+                               r->rectangle.x, r->rectangle.y,
+                               (unsigned) (r->rectangle.width +
+                                           (r->rectangle.border_width << 1)),
+                               (unsigned) (r->rectangle.height +
+                                           (r->rectangle.border_width << 1)),
+                               TRUE);
+            }
 
         }
     }
     if (call_change_managed && *num_unique_children != 0 &&
-	change_managed != NULL && parent_realized) {
-	CALLGEOTAT(_XtGeoTrace((Widget)parent,
-		       "Call parent: \"%s\"[%d,%d]'s changemanaged proc\n",
-		       XtName((Widget)parent),
-		       parent->core.width,parent->core.height));
-	(*change_managed) (parent);
+        change_managed != NULL && parent_realized) {
+        CALLGEOTAT(_XtGeoTrace((Widget) parent,
+                               "Call parent: \"%s\"[%d,%d]'s changemanaged proc\n",
+                               XtName((Widget) parent),
+                               parent->core.width, parent->core.height));
+        (*change_managed) (parent);
     }
-} /* UnmanageChildren */
+}                               /* UnmanageChildren */
 
-void XtUnmanageChildren (
-    WidgetList children,
-    Cardinal num_children)
+void
+XtUnmanageChildren(WidgetList children, Cardinal num_children)
 {
     Widget parent, hookobj;
     Cardinal ii;
+
 #ifdef XTHREADS
     XtAppContext app;
 #endif
 
-    if (num_children == 0) return;
+    if (num_children == 0)
+        return;
     if (children[0] == NULL) {
-	XtWarningMsg(XtNinvalidChild,XtNxtUnmanageChildren,XtCXtToolkitError,
-		     "Null child found in argument list to unmanage",
-		     NULL, NULL);
-	return;
+        XtWarningMsg(XtNinvalidChild, XtNxtUnmanageChildren, XtCXtToolkitError,
+                     "Null child found in argument list to unmanage",
+                     NULL, NULL);
+        return;
     }
 #ifdef XTHREADS
     app = XtWidgetToApplicationContext(children[0]);
@@ -178,155 +183,166 @@ void XtUnmanageChildren (
     LOCK_APP(app);
     parent = children[0]->core.parent;
     if (parent->core.being_destroyed) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
     UnmanageChildren(children, num_children, parent, &ii,
-		     (Boolean)True, XtNxtUnmanageChildren);
+                     (Boolean) True, XtNxtUnmanageChildren);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(children[0]));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHunmanageChildren;
-	call_data.widget = parent;
-	call_data.event_data = (XtPointer) children;
-	call_data.num_event_data = num_children;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHunmanageChildren;
+        call_data.widget = parent;
+        call_data.event_data = (XtPointer) children;
+        call_data.num_event_data = num_children;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtUnmanageChildren */
+}                               /* XtUnmanageChildren */
 
-void XtUnmanageChild(
-    Widget child)
+void
+XtUnmanageChild(Widget child)
 {
-    XtUnmanageChildren(&child, (Cardinal)1);
-} /* XtUnmanageChild */
-
-
-static void ManageChildren(
-    WidgetList  children,
-    Cardinal    num_children,
-    Widget	parent,
-    Boolean	call_change_managed,
-    _Xconst _XtString	caller_func)
+    XtUnmanageChildren(&child, (Cardinal) 1);
+}                               /* XtUnmanageChild */
+
+static void
+ManageChildren(WidgetList children,
+               Cardinal num_children,
+               Widget parent,
+               Boolean call_change_managed,
+               _Xconst _XtString caller_func)
 {
 #define MAXCHILDREN 100
-    Widget		child;
-    Cardinal		num_unique_children, i;
-    XtWidgetProc	change_managed = NULL;
-    WidgetList		unique_children;
-    Widget		cache[MAXCHILDREN];
-    Bool		parent_realized = False;
+    Widget child;
+    Cardinal num_unique_children, i;
+    XtWidgetProc change_managed = NULL;
+    WidgetList unique_children;
+    Widget cache[MAXCHILDREN];
+    Bool parent_realized = False;
 
     if (XtIsComposite((Widget) parent)) {
-	LOCK_PROCESS;
+        LOCK_PROCESS;
         change_managed = ((CompositeWidgetClass) parent->core.widget_class)
-		    ->composite_class.change_managed;
-	UNLOCK_PROCESS;
-	parent_realized = XtIsRealized((Widget)parent);
-    } else {
-	XtAppErrorMsg(XtWidgetToApplicationContext((Widget)parent),
-		"invalidParent",caller_func, XtCXtToolkitError,
-	    "Attempt to manage a child when parent is not Composite",
-	    NULL, NULL);
+            ->composite_class.change_managed;
+        UNLOCK_PROCESS;
+        parent_realized = XtIsRealized((Widget) parent);
+    }
+    else {
+        XtAppErrorMsg(XtWidgetToApplicationContext((Widget) parent),
+                      "invalidParent", caller_func, XtCXtToolkitError,
+                      "Attempt to manage a child when parent is not Composite",
+                      NULL, NULL);
     }
 
     /* Construct new list of children that really need to be operated upon. */
     if (num_children <= MAXCHILDREN) {
-	unique_children = cache;
-    } else {
-	unique_children = (WidgetList) __XtMalloc((Cardinal) ((size_t)num_children * sizeof(Widget)));
+        unique_children = cache;
+    }
+    else {
+        unique_children = (WidgetList)
+            __XtMalloc((Cardinal) ((size_t) num_children * sizeof(Widget)));
     }
     num_unique_children = 0;
     for (i = 0; i < num_children; i++) {
-	child = children[i];
-	if (child == NULL) {
-	    XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
-		XtNinvalidChild,caller_func,XtCXtToolkitError,
-		"null child passed to ManageChildren",
-		NULL, NULL);
-	    if (unique_children != cache) XtFree((char *) unique_children);
-	    return;
-	}
+        child = children[i];
+        if (child == NULL) {
+            XtAppWarningMsg(XtWidgetToApplicationContext((Widget) parent),
+                            XtNinvalidChild, caller_func, XtCXtToolkitError,
+                            "null child passed to ManageChildren", NULL, NULL);
+            if (unique_children != cache)
+                XtFree((char *) unique_children);
+            return;
+        }
 #ifdef DEBUG
-	if (!XtIsRectObj(child)) {
-	    String params[2];
-	    Cardinal num_params = 2;
-	    params[0] = XtName(child);
-	    params[1] = child->core.widget_class->core_class.class_name;
-	    XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
-			    "notRectObj",caller_func,XtCXtToolkitError,
-			    "child \"%s\", class %s is not a RectObj",
-			    params, &num_params);
-	    continue;
-	}
-#endif /*DEBUG*/
-        if (child->core.parent != parent) {
-	    XtAppWarningMsg(XtWidgetToApplicationContext((Widget)parent),
-		    "ambiguousParent",caller_func,XtCXtToolkitError,
-		"Not all children have same parent in XtManageChildren",
-		NULL, NULL);
-	} else if (! child->core.managed && !child->core.being_destroyed) {
-	    unique_children[num_unique_children++] = child;
-	    CALLGEOTAT(_XtGeoTrace(child,
-			   "Child \"%s\"[%d,%d] is marked managed\n",
-			   XtName(child),
-			   child->core.width,child->core.height));
-	    child->core.managed = TRUE;
-	}
+        if (!XtIsRectObj(child)) {
+            String params[2];
+            Cardinal num_params = 2;
+
+            params[0] = XtName(child);
+            params[1] = child->core.widget_class->core_class.class_name;
+            XtAppWarningMsg(XtWidgetToApplicationContext((Widget) parent),
+                            "notRectObj", caller_func, XtCXtToolkitError,
+                            "child \"%s\", class %s is not a RectObj",
+                            params, &num_params);
+            continue;
+        }
+#endif   /*DEBUG*/
+            if (child->core.parent != parent) {
+            XtAppWarningMsg(XtWidgetToApplicationContext((Widget) parent),
+                            "ambiguousParent", caller_func, XtCXtToolkitError,
+                            "Not all children have same parent in XtManageChildren",
+                            NULL, NULL);
+        }
+        else if (!child->core.managed && !child->core.being_destroyed) {
+            unique_children[num_unique_children++] = child;
+            CALLGEOTAT(_XtGeoTrace(child,
+                                   "Child \"%s\"[%d,%d] is marked managed\n",
+                                   XtName(child),
+                                   child->core.width, child->core.height));
+            child->core.managed = TRUE;
+        }
     }
 
     if ((call_change_managed || num_unique_children != 0) && parent_realized) {
-	/* Compute geometry of new managed set of children. */
-	if (change_managed != NULL) {
-	    CALLGEOTAT(_XtGeoTrace((Widget)parent,
-			   "Call parent: \"%s\"[%d,%d]'s changemanaged\n",
-			   XtName((Widget)parent),
-			   parent->core.width,parent->core.height));
-	    (*change_managed) ((Widget)parent);
-	}
-
-	/* Realize each child if necessary, then map if necessary */
-	for (i = 0; i < num_unique_children; i++) {
-	    child = unique_children[i];
-	    if (XtIsWidget(child)) {
-		if (! XtIsRealized(child)) XtRealizeWidget(child);
-		if (child->core.mapped_when_managed) XtMapWidget(child);
-	    } else { /* RectObj child */
-		Widget pw = child->core.parent;
-		RectObj r = (RectObj) child;
-		while ((pw!=NULL) && (!XtIsWidget(pw)))
-		    pw = pw->core.parent;
-		if (pw != NULL)
-		    XClearArea (XtDisplay (pw), XtWindow (pw),
-		    r->rectangle.x, r->rectangle.y,
-		    (unsigned) (r->rectangle.width + (r->rectangle.border_width << 1)),
-		    (unsigned) (r->rectangle.height + (r->rectangle.border_width << 1)),
-		    TRUE);
+        /* Compute geometry of new managed set of children. */
+        if (change_managed != NULL) {
+            CALLGEOTAT(_XtGeoTrace((Widget) parent,
+                                   "Call parent: \"%s\"[%d,%d]'s changemanaged\n",
+                                   XtName((Widget) parent),
+                                   parent->core.width, parent->core.height));
+            (*change_managed) ((Widget) parent);
+        }
+
+        /* Realize each child if necessary, then map if necessary */
+        for (i = 0; i < num_unique_children; i++) {
+            child = unique_children[i];
+            if (XtIsWidget(child)) {
+                if (!XtIsRealized(child))
+                    XtRealizeWidget(child);
+                if (child->core.mapped_when_managed)
+                    XtMapWidget(child);
+            }
+            else {              /* RectObj child */
+                Widget pw = child->core.parent;
+                RectObj r = (RectObj) child;
+
+                while ((pw != NULL) && (!XtIsWidget(pw)))
+                    pw = pw->core.parent;
+                if (pw != NULL)
+                    XClearArea(XtDisplay(pw), XtWindow(pw),
+                               r->rectangle.x, r->rectangle.y,
+                               (unsigned) (r->rectangle.width +
+                                           (r->rectangle.border_width << 1)),
+                               (unsigned) (r->rectangle.height +
+                                           (r->rectangle.border_width << 1)),
+                               TRUE);
             }
         }
     }
 
-    if (unique_children != cache) XtFree((char *) unique_children);
-} /* ManageChildren */
+    if (unique_children != cache)
+        XtFree((char *) unique_children);
+}                               /* ManageChildren */
 
-void XtManageChildren(
-    WidgetList children,
-    Cardinal num_children)
+void
+XtManageChildren(WidgetList children, Cardinal num_children)
 {
     Widget parent, hookobj;
+
 #ifdef XTHREADS
     XtAppContext app;
 #endif
 
-    if (num_children == 0) return;
+    if (num_children == 0)
+        return;
     if (children[0] == NULL) {
-	XtWarningMsg(XtNinvalidChild, XtNxtManageChildren, XtCXtToolkitError,
-		     "null child passed to XtManageChildren",
-		     NULL, NULL);
-	return;
+        XtWarningMsg(XtNinvalidChild, XtNxtManageChildren, XtCXtToolkitError,
+                     "null child passed to XtManageChildren", NULL, NULL);
+        return;
     }
 #ifdef XTHREADS
     app = XtWidgetToApplicationContext(children[0]);
@@ -334,82 +350,83 @@ void XtManageChildren(
     LOCK_APP(app);
     parent = children[0]->core.parent;
     if (parent->core.being_destroyed) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
-    ManageChildren(children, num_children, parent, (Boolean)False,
-		   XtNxtManageChildren);
+    ManageChildren(children, num_children, parent, (Boolean) False,
+                   XtNxtManageChildren);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(children[0]));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHmanageChildren;
-	call_data.widget = parent;
-	call_data.event_data = (XtPointer) children;
-	call_data.num_event_data = num_children;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHmanageChildren;
+        call_data.widget = parent;
+        call_data.event_data = (XtPointer) children;
+        call_data.num_event_data = num_children;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtManageChildren */
+}                               /* XtManageChildren */
 
-void XtManageChild(
-    Widget child)
+void
+XtManageChild(Widget child)
 {
     XtManageChildren(&child, (Cardinal) 1);
-} /* XtManageChild */
+}                               /* XtManageChild */
 
-
-void XtSetMappedWhenManaged(
-    Widget widget,
-    _XtBoolean mapped_when_managed)
+void
+XtSetMappedWhenManaged(Widget widget, _XtBoolean mapped_when_managed)
 {
     Widget hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (widget->core.mapped_when_managed == mapped_when_managed) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
     widget->core.mapped_when_managed = (Boolean) mapped_when_managed;
 
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHsetMappedWhenManaged;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) (unsigned long) mapped_when_managed;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHsetMappedWhenManaged;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) (unsigned long) mapped_when_managed;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 
-    if (! XtIsManaged(widget)) {
-	UNLOCK_APP(app);
-	return;
+    if (!XtIsManaged(widget)) {
+        UNLOCK_APP(app);
+        return;
     }
 
     if (mapped_when_managed) {
-	/* Didn't used to be mapped when managed.		*/
-	if (XtIsRealized(widget)) XtMapWidget(widget);
-    } else {
-	/* Used to be mapped when managed.			*/
-	if (XtIsRealized(widget)) XtUnmapWidget(widget);
+        /* Didn't used to be mapped when managed.               */
+        if (XtIsRealized(widget))
+            XtMapWidget(widget);
+    }
+    else {
+        /* Used to be mapped when managed.                      */
+        if (XtIsRealized(widget))
+            XtUnmapWidget(widget);
     }
     UNLOCK_APP(app);
-} /* XtSetMappedWhenManaged */
-
-
-void XtChangeManagedSet(
-    WidgetList unmanage_children,
-    Cardinal num_unmanage,
-    XtDoChangeProc do_change_proc,
-    XtPointer client_data,
-    WidgetList manage_children,
-    Cardinal num_manage)
+}                               /* XtSetMappedWhenManaged */
+
+void
+XtChangeManagedSet(WidgetList unmanage_children,
+                   Cardinal num_unmanage,
+                   XtDoChangeProc do_change_proc,
+                   XtPointer client_data,
+                   WidgetList manage_children,
+                   Cardinal num_manage)
 {
     WidgetList childp;
     Widget parent;
@@ -421,7 +438,7 @@ void XtChangeManagedSet(
     XtChangeHookDataRec call_data;
 
     if (num_unmanage == 0 && num_manage == 0)
-	return;
+        return;
 
     /* specification doesn't state that library will check for NULL in list */
 
@@ -431,68 +448,71 @@ void XtChangeManagedSet(
 
     parent = XtParent(*childp);
     childp = unmanage_children;
-    for (i = (int) num_unmanage; --i >= 0 && XtParent(*childp) == parent; childp++);
+    for (i = (int) num_unmanage; --i >= 0 && XtParent(*childp) == parent;
+         childp++);
     call_out = (i >= 0);
     childp = manage_children;
-    for (i = (int) num_manage;   --i >= 0 && XtParent(*childp) == parent; childp++);
+    for (i = (int) num_manage; --i >= 0 && XtParent(*childp) == parent;
+         childp++);
     if (call_out || i >= 0) {
-	XtAppWarningMsg(app, "ambiguousParent", XtNxtChangeManagedSet,
-			XtCXtToolkitError, "Not all children have same parent",
-			NULL, NULL);
+        XtAppWarningMsg(app, "ambiguousParent", XtNxtChangeManagedSet,
+                        XtCXtToolkitError, "Not all children have same parent",
+                        NULL, NULL);
     }
-    if (! XtIsComposite(parent)) {
-	UNLOCK_APP(app);
-	XtAppErrorMsg(app, "invalidParent", XtNxtChangeManagedSet,
-		      XtCXtToolkitError,
-		      "Attempt to manage a child when parent is not Composite",
-		      NULL, NULL);
+    if (!XtIsComposite(parent)) {
+        UNLOCK_APP(app);
+        XtAppErrorMsg(app, "invalidParent", XtNxtChangeManagedSet,
+                      XtCXtToolkitError,
+                      "Attempt to manage a child when parent is not Composite",
+                      NULL, NULL);
     }
     if (parent->core.being_destroyed) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
 
     call_out = False;
     if (do_change_proc) {
-	CompositeClassExtension ext = (CompositeClassExtension)
-	    XtGetClassExtension(parent->core.widget_class,
-				XtOffsetOf(CompositeClassRec,
-					   composite_class.extension),
-				NULLQUARK, XtCompositeExtensionVersion,
-				sizeof(CompositeClassExtensionRec));
-	if (!ext || !ext->allows_change_managed_set)
-	    call_out = True;
+        CompositeClassExtension ext = (CompositeClassExtension)
+            XtGetClassExtension(parent->core.widget_class,
+                                XtOffsetOf(CompositeClassRec,
+                                           composite_class.extension),
+                                NULLQUARK, XtCompositeExtensionVersion,
+                                sizeof(CompositeClassExtensionRec));
+
+        if (!ext || !ext->allows_change_managed_set)
+            call_out = True;
     }
 
     UnmanageChildren(unmanage_children, num_unmanage, parent,
-		     &some_unmanaged, call_out, XtNxtChangeManagedSet);
+                     &some_unmanaged, call_out, XtNxtChangeManagedSet);
 
     hookobj = XtHooksOfDisplay(XtDisplay(parent));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	call_data.type = XtHunmanageSet;
-	call_data.widget = parent;
-	call_data.event_data = (XtPointer) unmanage_children;
-	call_data.num_event_data = num_unmanage;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer) &call_data);
+        call_data.type = XtHunmanageSet;
+        call_data.widget = parent;
+        call_data.event_data = (XtPointer) unmanage_children;
+        call_data.num_event_data = num_unmanage;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 
     if (do_change_proc)
-	(*do_change_proc)(parent, unmanage_children, &num_unmanage,
-			  manage_children, &num_manage, client_data);
+        (*do_change_proc) (parent, unmanage_children, &num_unmanage,
+                           manage_children, &num_manage, client_data);
 
     call_out = (some_unmanaged && !call_out);
     ManageChildren(manage_children, num_manage, parent, call_out,
-		   XtNxtChangeManagedSet);
+                   XtNxtChangeManagedSet);
 
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	call_data.type = XtHmanageSet;
-	call_data.event_data = (XtPointer) manage_children;
-	call_data.num_event_data = num_manage;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer) &call_data);
+        call_data.type = XtHmanageSet;
+        call_data.event_data = (XtPointer) manage_children;
+        call_data.num_event_data = num_manage;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
-} /* XtChangeManagedSet */
+}                               /* XtChangeManagedSet */
diff --git a/src/NextEvent.c b/src/NextEvent.c
index a686bb3..6999c4f 100644
--- a/src/NextEvent.c
+++ b/src/NextEvent.c
@@ -79,64 +79,63 @@ in this Software without prior written authorization from The Open Group.
 typedef long suseconds_t;
 #endif
 
-static TimerEventRec* freeTimerRecs;
-static WorkProcRec* freeWorkRecs;
-static SignalEventRec* freeSignalRecs;
+static TimerEventRec *freeTimerRecs;
+static WorkProcRec *freeWorkRecs;
+static SignalEventRec *freeSignalRecs;
 
 /* Some systems running NTP daemons are known to return strange usec
  * values from gettimeofday.
  */
 
 #ifndef NEEDS_NTPD_FIXUP
-# if defined(sun) || defined(MOTOROLA) || (defined(__osf__) && defined(__alpha))
-#  define NEEDS_NTPD_FIXUP 1
-# else
-#  define NEEDS_NTPD_FIXUP 0
-# endif
+#if defined(sun) || defined(MOTOROLA) || (defined(__osf__) && defined(__alpha))
+#define NEEDS_NTPD_FIXUP 1
+#else
+#define NEEDS_NTPD_FIXUP 0
+#endif
 #endif
 
 #if NEEDS_NTPD_FIXUP
 #define FIXUP_TIMEVAL(t) { \
-	while ((t).tv_usec >= 1000000) { \
-	    (t).tv_usec -= 1000000; \
-	    (t).tv_sec++; \
-	} \
-	while ((t).tv_usec < 0) { \
-	    if ((t).tv_sec > 0) { \
-		(t).tv_usec += 1000000; \
-		(t).tv_sec--; \
-	    } else { \
-		(t).tv_usec = 0; \
-		break; \
-	    } \
-	}}
+        while ((t).tv_usec >= 1000000) { \
+            (t).tv_usec -= 1000000; \
+            (t).tv_sec++; \
+        } \
+        while ((t).tv_usec < 0) { \
+            if ((t).tv_sec > 0) { \
+                (t).tv_usec += 1000000; \
+                (t).tv_sec--; \
+            } else { \
+                (t).tv_usec = 0; \
+                break; \
+            } \
+        }}
 #else
 #define FIXUP_TIMEVAL(t)
-#endif /*NEEDS_NTPD_FIXUP*/
+#endif                          /*NEEDS_NTPD_FIXUP */
 
 /*
  * Private routines
  */
 #define ADD_TIME(dest, src1, src2) { \
-	if(((dest).tv_usec = (src1).tv_usec + (src2).tv_usec) >= 1000000) {\
-	      (dest).tv_usec -= 1000000;\
-	      (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1 ; \
-	} else { (dest).tv_sec = (src1).tv_sec + (src2).tv_sec ; \
-	   if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
-	    (dest).tv_sec --;(dest).tv_usec += 1000000; } } }
-
+        if(((dest).tv_usec = (src1).tv_usec + (src2).tv_usec) >= 1000000) {\
+              (dest).tv_usec -= 1000000;\
+              (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1 ; \
+        } else { (dest).tv_sec = (src1).tv_sec + (src2).tv_sec ; \
+           if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
+            (dest).tv_sec --;(dest).tv_usec += 1000000; } } }
 
 #define TIMEDELTA(dest, src1, src2) { \
-	if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) {\
-	      (dest).tv_usec += 1000000;\
-	      (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1;\
-	} else 	(dest).tv_sec = (src1).tv_sec - (src2).tv_sec;  }
+        if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) {\
+              (dest).tv_usec += 1000000;\
+              (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1;\
+        } else  (dest).tv_sec = (src1).tv_sec - (src2).tv_sec;  }
 
 #define IS_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
-	|| (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec > (t1).tv_usec)))
+        || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec > (t1).tv_usec)))
 
 #define IS_AT_OR_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
-	|| (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec >= (t1).tv_usec)))
+        || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec >= (t1).tv_usec)))
 
 #ifdef USE_POLL
 #ifndef XT_DEFAULT_FDLIST_SIZE
@@ -144,20 +143,23 @@ static SignalEventRec* freeSignalRecs;
 #endif
 #endif
 
-static void AdjustHowLong (
-	unsigned long *howlong,
-	struct timeval *start_time)
+static void
+AdjustHowLong(unsigned long *howlong, struct timeval *start_time)
 {
-	struct timeval new_time, time_spent, lstart_time;
-
-	lstart_time = *start_time;
-	X_GETTIMEOFDAY (&new_time);
-	FIXUP_TIMEVAL(new_time);
-	TIMEDELTA(time_spent, new_time, lstart_time);
-	if(*howlong <= (unsigned long)(time_spent.tv_sec*1000+time_spent.tv_usec/1000))
-	    *howlong = (unsigned long)0;  /* Timed out */
-	else
-	    *howlong = (*howlong - (unsigned long)(time_spent.tv_sec*1000+time_spent.tv_usec/1000));
+    struct timeval new_time, time_spent, lstart_time;
+
+    lstart_time = *start_time;
+    X_GETTIMEOFDAY(&new_time);
+    FIXUP_TIMEVAL(new_time);
+    TIMEDELTA(time_spent, new_time, lstart_time);
+    if (*howlong <=
+        (unsigned long) (time_spent.tv_sec * 1000 + time_spent.tv_usec / 1000))
+        *howlong = (unsigned long) 0;   /* Timed out */
+    else
+        *howlong =
+            (*howlong -
+             (unsigned long) (time_spent.tv_sec * 1000 +
+                              time_spent.tv_usec / 1000));
 }
 
 typedef struct {
@@ -174,7 +176,8 @@ typedef struct {
 #endif
 } wait_times_t, *wait_times_ptr_t;
 
-static struct timeval  zero_time = { 0 , 0};
+static struct timeval zero_time = { 0, 0 };
+
 #ifdef USE_POLL
 #define X_BLOCK -1
 #define X_DONT_BLOCK 0
@@ -182,44 +185,47 @@ static struct timeval  zero_time = { 0 , 0};
 static fd_set zero_fd;
 #endif
 
-static void InitTimes (
-    Boolean block,
-    unsigned long* howlong,
-    wait_times_ptr_t wt)
+static void
+InitTimes(Boolean block,
+          unsigned long *howlong,
+          wait_times_ptr_t wt)
 {
     if (block) {
-	X_GETTIMEOFDAY (&wt->cur_time);
-	FIXUP_TIMEVAL(wt->cur_time);
-	wt->start_time = wt->cur_time;
-	if(howlong == NULL) { /* special case for ever */
+        X_GETTIMEOFDAY(&wt->cur_time);
+        FIXUP_TIMEVAL(wt->cur_time);
+        wt->start_time = wt->cur_time;
+        if (howlong == NULL) {  /* special case for ever */
 #ifdef USE_POLL
-	    wt->poll_wait = X_BLOCK;
+            wt->poll_wait = X_BLOCK;
 #else
-	    wt->wait_time_ptr = NULL;
+            wt->wait_time_ptr = NULL;
 #endif
-	} else { /* block until at most */
-	    wt->max_wait_time.tv_sec = (time_t) (*howlong/1000);
-	    wt->max_wait_time.tv_usec = (suseconds_t) ((*howlong %1000)*1000);
+        }
+        else {                  /* block until at most */
+            wt->max_wait_time.tv_sec = (time_t) (*howlong / 1000);
+            wt->max_wait_time.tv_usec =
+                (suseconds_t) ((*howlong % 1000) * 1000);
 #ifdef USE_POLL
-	    wt->poll_wait = (int) *howlong;
+            wt->poll_wait = (int) *howlong;
 #else
-	    wt->wait_time_ptr = &wt->max_wait_time;
+            wt->wait_time_ptr = &wt->max_wait_time;
 #endif
-	}
-    } else {  /* don't block */
-	wt->max_wait_time = zero_time;
+        }
+    }
+    else {                      /* don't block */
+        wt->max_wait_time = zero_time;
 #ifdef USE_POLL
-	wt->poll_wait = X_DONT_BLOCK;
+        wt->poll_wait = X_DONT_BLOCK;
 #else
-	wt->wait_time_ptr = &wt->max_wait_time;
+        wt->wait_time_ptr = &wt->max_wait_time;
 #endif
     }
 }
 
 typedef struct {
 #ifdef USE_POLL
-    struct pollfd* fdlist;
-    struct pollfd* stack;
+    struct pollfd *fdlist;
+    struct pollfd *stack;
     int fdlistlen, num_dpys;
 #else
     fd_set rmask, wmask, emask;
@@ -227,13 +233,14 @@ typedef struct {
 #endif
 } wait_fds_t, *wait_fds_ptr_t;
 
-static void InitFds (
-    XtAppContext app,
-    Boolean ignoreEvents,
-    Boolean ignoreInputs,
-    wait_fds_ptr_t wf)
+static void
+InitFds(XtAppContext app,
+        Boolean ignoreEvents,
+        Boolean ignoreInputs,
+        wait_fds_ptr_t wf)
 {
     int ii;
+
     app->rebuild_fdlist = FALSE;
 #ifdef USE_POLL
 #ifndef POLLRDNORM
@@ -257,256 +264,269 @@ static void InitFds (
 #define XPOLL_EXCEPT 0
 
     if (!ignoreEvents)
-	wf->fdlistlen = wf->num_dpys = app->count;
+        wf->fdlistlen = wf->num_dpys = app->count;
     else
-	wf->fdlistlen = wf->num_dpys = 0;
+        wf->fdlistlen = wf->num_dpys = 0;
 
     if (!ignoreInputs && app->input_list != NULL) {
-	for (ii = 0; ii < (int) app->input_max; ii++)
-	    if (app->input_list[ii] != NULL)
-		wf->fdlistlen++;
+        for (ii = 0; ii < (int) app->input_max; ii++)
+            if (app->input_list[ii] != NULL)
+                wf->fdlistlen++;
     }
 
     if (!wf->fdlist || wf->fdlist == wf->stack) {
-	wf->fdlist = (struct pollfd*)
-	    XtStackAlloc (sizeof (struct pollfd) * (size_t)wf->fdlistlen, wf->stack);
-    } else {
-	wf->fdlist = (struct pollfd*)
-	    XtRealloc ((char*) wf->fdlist,
-		       (Cardinal) (sizeof (struct pollfd) * (size_t)wf->fdlistlen));
+        wf->fdlist = (struct pollfd *)
+            XtStackAlloc(sizeof(struct pollfd) * (size_t) wf->fdlistlen,
+                         wf->stack);
+    }
+    else {
+        wf->fdlist = (struct pollfd *)
+            XtRealloc((char *) wf->fdlist,
+                      (Cardinal) (sizeof(struct pollfd) *
+                                  (size_t) wf->fdlistlen));
     }
 
     if (wf->fdlistlen) {
-	struct pollfd* fdlp = wf->fdlist;
-	InputEvent* iep;
-
-	if (!ignoreEvents)
-	    for (ii = 0 ; ii < wf->num_dpys; ii++, fdlp++) {
-		fdlp->fd = ConnectionNumber (app->list[ii]);
-		fdlp->events = POLLIN;
-	    }
-	if (!ignoreInputs && app->input_list != NULL)
-	    for (ii = 0; ii < app->input_max; ii++)
-		if (app->input_list[ii] != NULL) {
-		    iep = app->input_list[ii];
-		    fdlp->fd = ii;
-		    fdlp->events = 0;
-		    for ( ; iep; iep = iep->ie_next) {
-			if (iep->ie_condition & XtInputReadMask)
-			    fdlp->events |= XPOLL_READ;
-			if (iep->ie_condition & XtInputWriteMask)
-			    fdlp->events |= XPOLL_WRITE;
-			if (iep->ie_condition & XtInputExceptMask)
-			    fdlp->events |= XPOLL_EXCEPT;
-		    }
-		    fdlp++;
-		}
+        struct pollfd *fdlp = wf->fdlist;
+        InputEvent *iep;
+
+        if (!ignoreEvents)
+            for (ii = 0; ii < wf->num_dpys; ii++, fdlp++) {
+                fdlp->fd = ConnectionNumber(app->list[ii]);
+                fdlp->events = POLLIN;
+            }
+        if (!ignoreInputs && app->input_list != NULL)
+            for (ii = 0; ii < app->input_max; ii++)
+                if (app->input_list[ii] != NULL) {
+                    iep = app->input_list[ii];
+                    fdlp->fd = ii;
+                    fdlp->events = 0;
+                    for (; iep; iep = iep->ie_next) {
+                        if (iep->ie_condition & XtInputReadMask)
+                            fdlp->events |= XPOLL_READ;
+                        if (iep->ie_condition & XtInputWriteMask)
+                            fdlp->events |= XPOLL_WRITE;
+                        if (iep->ie_condition & XtInputExceptMask)
+                            fdlp->events |= XPOLL_EXCEPT;
+                    }
+                    fdlp++;
+                }
     }
 #else
     wf->nfds = app->fds.nfds;
-    if( !ignoreInputs ) {
-	wf->rmask = app->fds.rmask;
-	wf->wmask = app->fds.wmask;
-	wf->emask = app->fds.emask;
-     } else
-	wf->rmask = wf->wmask = wf->emask = zero_fd;
-
-     if (!ignoreEvents)
-	for (ii = 0; ii < app->count; ii++) {
-	    FD_SET (ConnectionNumber(app->list[ii]), &wf->rmask);
-	}
+    if (!ignoreInputs) {
+        wf->rmask = app->fds.rmask;
+        wf->wmask = app->fds.wmask;
+        wf->emask = app->fds.emask;
+    }
+    else
+        wf->rmask = wf->wmask = wf->emask = zero_fd;
+
+    if (!ignoreEvents)
+        for (ii = 0; ii < app->count; ii++) {
+            FD_SET(ConnectionNumber(app->list[ii]), &wf->rmask);
+        }
 #endif
 }
 
-static void AdjustTimes (
-    XtAppContext app,
-    Boolean block,
-    unsigned long* howlong,
-    Boolean ignoreTimers,
-    wait_times_ptr_t wt)
+static void
+AdjustTimes(XtAppContext app,
+            Boolean block,
+            unsigned long *howlong,
+            Boolean ignoreTimers,
+            wait_times_ptr_t wt)
 {
     if (app->timerQueue != NULL && !ignoreTimers && block) {
 #ifdef USE_POLL
-	if (IS_AFTER (wt->cur_time, app->timerQueue->te_timer_value)) {
-	    TIMEDELTA (wt->wait_time, app->timerQueue->te_timer_value, wt->cur_time);
-	    if (howlong == NULL || IS_AFTER (wt->wait_time, wt->max_wait_time))
-		wt->poll_wait = (int) (wt->wait_time.tv_sec * 1000 + wt->wait_time.tv_usec / 1000);
-	    else
-		wt->poll_wait = (int) (wt->max_wait_time.tv_sec * 1000 + wt->max_wait_time.tv_usec / 1000);
-	} else
-	    wt->poll_wait = X_DONT_BLOCK;
+        if (IS_AFTER(wt->cur_time, app->timerQueue->te_timer_value)) {
+            TIMEDELTA(wt->wait_time, app->timerQueue->te_timer_value,
+                      wt->cur_time);
+            if (howlong == NULL || IS_AFTER(wt->wait_time, wt->max_wait_time))
+                wt->poll_wait =
+                    (int) (wt->wait_time.tv_sec * 1000 +
+                           wt->wait_time.tv_usec / 1000);
+            else
+                wt->poll_wait =
+                    (int) (wt->max_wait_time.tv_sec * 1000 +
+                           wt->max_wait_time.tv_usec / 1000);
+        }
+        else
+            wt->poll_wait = X_DONT_BLOCK;
 #else
-	if (IS_AFTER (wt->cur_time, app->timerQueue->te_timer_value)) {
-	    TIMEDELTA (wt->wait_time, app->timerQueue->te_timer_value, wt->cur_time);
-	    if (howlong == NULL || IS_AFTER (wt->wait_time, wt->max_wait_time))
-		wt->wait_time_ptr = &wt->wait_time;
-	    else
-		wt->wait_time_ptr = &wt->max_wait_time;
-	} else
-	    wt->wait_time_ptr = &zero_time;
+        if (IS_AFTER(wt->cur_time, app->timerQueue->te_timer_value)) {
+            TIMEDELTA(wt->wait_time, app->timerQueue->te_timer_value,
+                      wt->cur_time);
+            if (howlong == NULL || IS_AFTER(wt->wait_time, wt->max_wait_time))
+                wt->wait_time_ptr = &wt->wait_time;
+            else
+                wt->wait_time_ptr = &wt->max_wait_time;
+        }
+        else
+            wt->wait_time_ptr = &zero_time;
 #endif
     }
 }
 
-
-static int IoWait (
-    wait_times_ptr_t wt,
-    wait_fds_ptr_t wf)
+static int
+IoWait(wait_times_ptr_t wt, wait_fds_ptr_t wf)
 {
 #ifdef USE_POLL
-    return poll (wf->fdlist, (nfds_t) wf->fdlistlen, wt->poll_wait);
+    return poll(wf->fdlist, (nfds_t) wf->fdlistlen, wt->poll_wait);
 #else
     return Select (wf->nfds, &wf->rmask, &wf->wmask, &wf->emask,
-		   wt->wait_time_ptr);
+                   wt->wait_time_ptr);
 #endif
 }
 
-
-static void FindInputs (
-    XtAppContext app,
-    wait_fds_ptr_t wf,
-    int nfds,
-    Boolean ignoreEvents,
-    Boolean ignoreInputs,
-    int* dpy_no,
-    int* found_input)
+static void
+FindInputs(XtAppContext app,
+           wait_fds_ptr_t wf,
+           int nfds _X_UNUSED,
+           Boolean ignoreEvents,
+           Boolean ignoreInputs,
+           int *dpy_no,
+           int *found_input)
 {
     InputEvent *ep;
     int ii;
-#ifdef USE_POLL /* { check ready file descriptors block */
-    struct pollfd* fdlp;
+
+#ifdef USE_POLL                 /* { check ready file descriptors block */
+    struct pollfd *fdlp;
 
     *dpy_no = -1;
     *found_input = False;
 
     if (!ignoreEvents) {
-	fdlp = wf->fdlist;
-	for (ii = 0; ii < wf->num_dpys; ii++, fdlp++) {
-	    if (*dpy_no == -1 && fdlp->revents & (POLLIN|POLLHUP|POLLERR) &&
+        fdlp = wf->fdlist;
+        for (ii = 0; ii < wf->num_dpys; ii++, fdlp++) {
+            if (*dpy_no == -1 && fdlp->revents & (POLLIN | POLLHUP | POLLERR) &&
 #ifdef XTHREADS
-		!(fdlp->revents & POLLNVAL) &&
+                !(fdlp->revents & POLLNVAL) &&
 #endif
-		XEventsQueued (app->list[ii], QueuedAfterReading)) {
-		*dpy_no = ii;
-		break;
-	    }
-	}
+                XEventsQueued(app->list[ii], QueuedAfterReading)) {
+                *dpy_no = ii;
+                break;
+            }
+        }
     }
 
     if (!ignoreInputs) {
-	fdlp = &wf->fdlist[wf->num_dpys];
-	for (ii = wf->num_dpys; ii < wf->fdlistlen; ii++, fdlp++) {
-	    XtInputMask condition = 0;
-	    if (fdlp->revents) {
-		if (fdlp->revents & (XPOLL_READ|POLLHUP|POLLERR)
+        fdlp = &wf->fdlist[wf->num_dpys];
+        for (ii = wf->num_dpys; ii < wf->fdlistlen; ii++, fdlp++) {
+            XtInputMask condition = 0;
+
+            if (fdlp->revents) {
+                if (fdlp->revents & (XPOLL_READ | POLLHUP | POLLERR)
 #ifdef XTHREADS
-		    && !(fdlp->revents & POLLNVAL)
+                    && !(fdlp->revents & POLLNVAL)
 #endif
-		)
-		    condition = XtInputReadMask;
-		if (fdlp->revents & XPOLL_WRITE)
-		    condition |= XtInputWriteMask;
-		if (fdlp->revents & XPOLL_EXCEPT)
-		    condition |= XtInputExceptMask;
-	    }
-	    if (condition) {
-		*found_input = True;
-		for (ep = app->input_list[fdlp->fd]; ep; ep = ep->ie_next)
-		    if (condition & ep->ie_condition) {
-			InputEvent	*oq;
-			/* make sure this input isn't already marked outstanding */
-			for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
-			    if (oq == ep)
-				break;
-			if (!oq)
-			{
-			    ep->ie_oq = app->outstandingQueue;
-			    app->outstandingQueue = ep;
-			}
-		    }
-	    }
-	}
+                    )
+                    condition = XtInputReadMask;
+                if (fdlp->revents & XPOLL_WRITE)
+                    condition |= XtInputWriteMask;
+                if (fdlp->revents & XPOLL_EXCEPT)
+                    condition |= XtInputExceptMask;
+            }
+            if (condition) {
+                *found_input = True;
+                for (ep = app->input_list[fdlp->fd]; ep; ep = ep->ie_next)
+                    if (condition & ep->ie_condition) {
+                        InputEvent *oq;
+
+                        /* make sure this input isn't already marked outstanding */
+                        for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
+                            if (oq == ep)
+                                break;
+                        if (!oq) {
+                            ep->ie_oq = app->outstandingQueue;
+                            app->outstandingQueue = ep;
+                        }
+                    }
+            }
+        }
     }
-#else /* }{ */
+#else                           /* }{ */
 #ifdef XTHREADS
     fd_set rmask;
 #endif
     int dd;
+
     *dpy_no = -1;
     *found_input = False;
 
 #ifdef XTHREADS
     rmask = app->fds.rmask;
-    for (dd = app->count; dd-- > 0; )
-	FD_SET (ConnectionNumber (app->list[dd]), &rmask);
+    for (dd = app->count; dd-- > 0;)
+        FD_SET(ConnectionNumber(app->list[dd]), &rmask);
 #endif
 
     for (ii = 0; ii < wf->nfds && nfds > 0; ii++) {
-	XtInputMask condition = 0;
+        XtInputMask condition = 0;
 
-	if (FD_ISSET (ii, &wf->rmask)
+        if (FD_ISSET(ii, &wf->rmask)
 #ifdef XTHREADS
-	    && FD_ISSET (ii, &rmask)
+            && FD_ISSET(ii, &rmask)
 #endif
-	) {
-	    nfds--;
-	    if (!ignoreEvents) {
-		for (dd = 0; dd < app->count; dd++) {
-		    if (ii == ConnectionNumber (app->list[dd])) {
-			if (*dpy_no == -1) {
-			    if (XEventsQueued (app->list[dd], QueuedAfterReading ))
-				*dpy_no = dd;
-				/*
-				 * An error event could have arrived
-				 * without any real events, or events
-				 * could have been swallowed by Xlib,
-				 * or the connection may be broken.
-				 * We can't tell the difference, so
-				 * assume Xlib will eventually discover
-				 * a broken connection.
-				 */
-			}
-			goto ENDILOOP;
-		    }
-		}
-	    }
-	    condition = XtInputReadMask;
-	}
-	if (FD_ISSET (ii, &wf->wmask)
+            ) {
+            nfds--;
+            if (!ignoreEvents) {
+                for (dd = 0; dd < app->count; dd++) {
+                    if (ii == ConnectionNumber(app->list[dd])) {
+                        if (*dpy_no == -1) {
+                            if (XEventsQueued
+                                (app->list[dd], QueuedAfterReading))
+                                *dpy_no = dd;
+                            /*
+                             * An error event could have arrived
+                             * without any real events, or events
+                             * could have been swallowed by Xlib,
+                             * or the connection may be broken.
+                             * We can't tell the difference, so
+                             * assume Xlib will eventually discover
+                             * a broken connection.
+                             */
+                        }
+                        goto ENDILOOP;
+                    }
+                }
+            }
+            condition = XtInputReadMask;
+        }
+        if (FD_ISSET(ii, &wf->wmask)
 #ifdef XTHREADS
-	    && FD_ISSET (ii, &app->fds.wmask)
+            && FD_ISSET(ii, &app->fds.wmask)
 #endif
-	) {
-	    condition |= XtInputWriteMask;
-	    nfds--;
-	}
-	if (FD_ISSET (ii, &wf->emask)
+            ) {
+            condition |= XtInputWriteMask;
+            nfds--;
+        }
+        if (FD_ISSET(ii, &wf->emask)
 #ifdef XTHREADS
-	    && FD_ISSET (ii, &app->fds.emask)
+            && FD_ISSET(ii, &app->fds.emask)
 #endif
-	) {
-	    condition |= XtInputExceptMask;
-	    nfds--;
-	}
-	if (condition) {
-	    for (ep = app->input_list[ii]; ep; ep = ep->ie_next)
-		if (condition & ep->ie_condition) {
-		    /* make sure this input isn't already marked outstanding */
-		    InputEvent	*oq;
-		    for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
-			if (oq == ep)
-			    break;
-		    if (!oq)
-		    {
-			ep->ie_oq = app->outstandingQueue;
-			app->outstandingQueue = ep;
-		    }
-		}
-	    *found_input = True;
-	}
-ENDILOOP:   ;
-    } /* endfor */
-#endif /* } */
+            ) {
+            condition |= XtInputExceptMask;
+            nfds--;
+        }
+        if (condition) {
+            for (ep = app->input_list[ii]; ep; ep = ep->ie_next)
+                if (condition & ep->ie_condition) {
+                    /* make sure this input isn't already marked outstanding */
+                    InputEvent *oq;
+
+                    for (oq = app->outstandingQueue; oq; oq = oq->ie_oq)
+                        if (oq == ep)
+                            break;
+                    if (!oq) {
+                        ep->ie_oq = app->outstandingQueue;
+                        app->outstandingQueue = ep;
+                    }
+                }
+            *found_input = True;
+        }
+ ENDILOOP:;
+    }                           /* endfor */
+#endif                          /* } */
 }
 
 /*
@@ -521,8 +541,8 @@ ENDILOOP:   ;
  *
  * _XtWaitForSomething( appContext,
  *                      ignoreEvent, ignoreTimers, ignoreInputs, ignoreSignals,
- *			block, drop_lock, howlong)
- * XtAppContext app;	     (Displays to check wait on)
+ *                      block, drop_lock, howlong)
+ * XtAppContext app;         (Displays to check wait on)
  *
  * Boolean ignoreEvents;     (Don't return if XEvents are available
  *                              Also implies forget XEvents exist)
@@ -533,13 +553,13 @@ ENDILOOP:   ;
  *
  * Boolean ignoreSignals;    (Ditto for signals)
  *
- * Boolean block;	     (Okay to block)
+ * Boolean block;            (Okay to block)
  *
  * Boolean drop_lock         (drop lock before going into select/poll)
  *
- * TimeVal howlong;	     (howlong to wait for if blocking and not
- *				doing Timers... Null means forever.
- *				Maybe should mean shortest of both)
+ * TimeVal howlong;          (howlong to wait for if blocking and not
+ *                              doing Timers... Null means forever.
+ *                              Maybe should mean shortest of both)
  * Returns display for which input is available, if any
  * and if ignoreEvents==False, else returns -1
  *
@@ -552,19 +572,20 @@ ENDILOOP:   ;
  * entering select/poll. It is illegal for drop_lock to be FALSE if
  * ignoreTimers, ignoreInputs, or ignoreSignals is FALSE.
  */
-int _XtWaitForSomething(
-    XtAppContext app,
-    _XtBoolean ignoreEvents,
-    _XtBoolean ignoreTimers,
-    _XtBoolean ignoreInputs,
-    _XtBoolean ignoreSignals,
-    _XtBoolean block,
-    _XtBoolean drop_lock,	/* only needed with XTHREADS */
-    unsigned long *howlong)
+int
+_XtWaitForSomething(XtAppContext app,
+                    _XtBoolean ignoreEvents,
+                    _XtBoolean ignoreTimers,
+                    _XtBoolean ignoreInputs,
+                    _XtBoolean ignoreSignals,
+                    _XtBoolean block,
+                    _XtBoolean drop_lock, /* only needed with XTHREADS */
+                    unsigned long *howlong)
 {
     wait_times_t wt;
     wait_fds_t wf;
     int nfds, dpy_no, found_input, dd;
+
 #ifdef XTHREADS
     Boolean push_thread = TRUE;
     Boolean pushed_thread = FALSE;
@@ -578,12 +599,12 @@ int _XtWaitForSomething(
     /* assert ((ignoreTimers && ignoreInputs && ignoreSignals) || drop_lock); */
     /* If not multi-threaded, never drop lock */
     if (app->lock == (ThreadAppProc) NULL)
-	drop_lock = FALSE;
+        drop_lock = FALSE;
 #else
-    drop_lock=drop_lock;	/* avoid unsed warning */
+    drop_lock = drop_lock;      /* avoid unsed warning */
 #endif
 
-    InitTimes ((Boolean) block, howlong, &wt);
+    InitTimes((Boolean) block, howlong, &wt);
 
 #ifdef USE_POLL
     wf.fdlist = NULL;
@@ -591,152 +612,162 @@ int _XtWaitForSomething(
     wf.fdlistlen = wf.num_dpys = 0;
 #endif
 
-WaitLoop:
+ WaitLoop:
     app->rebuild_fdlist = TRUE;
 
     while (1) {
-	AdjustTimes (app, (Boolean) block, howlong, (Boolean) ignoreTimers, &wt);
-
-	if (block && app->block_hook_list) {
-	    BlockHook hook;
-	    for (hook = app->block_hook_list;
-		 hook != NULL;
-		 hook = hook->next)
-		(*hook->proc) (hook->closure);
-
-	    if (!ignoreEvents)
-		/* see if the hook(s) generated any protocol */
-		for (dd = 0; dd < app->count; dd++)
-		    if (XEventsQueued(app->list[dd], QueuedAlready)) {
+        AdjustTimes(app, (Boolean) block, howlong, (Boolean) ignoreTimers, &wt);
+
+        if (block && app->block_hook_list) {
+            BlockHook hook;
+
+            for (hook = app->block_hook_list; hook != NULL; hook = hook->next)
+                (*hook->proc) (hook->closure);
+
+            if (!ignoreEvents)
+                /* see if the hook(s) generated any protocol */
+                for (dd = 0; dd < app->count; dd++)
+                    if (XEventsQueued(app->list[dd], QueuedAlready)) {
 #ifdef USE_POLL
-			XtStackFree ((XtPointer) wf.fdlist, fdlist);
+                        XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-			return dd;
-		    }
-	}
-
-	if (app->rebuild_fdlist)
-	    InitFds (app, (Boolean) ignoreEvents, (Boolean) ignoreInputs, &wf);
-
-#ifdef XTHREADS /* { */
-	if (drop_lock) {
-	    YIELD_APP_LOCK(app, &push_thread, &pushed_thread, &level);
-	    nfds = IoWait (&wt, &wf);
-	    RESTORE_APP_LOCK(app, level, &pushed_thread);
-	} else
-#endif /* } */
-	nfds = IoWait (&wt, &wf);
-	if (nfds == -1) {
-	    /*
-	     *  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);
+                        return dd;
+                    }
+        }
+
+        if (app->rebuild_fdlist)
+            InitFds(app, (Boolean) ignoreEvents, (Boolean) ignoreInputs, &wf);
+
+#ifdef XTHREADS                 /* { */
+        if (drop_lock) {
+            YIELD_APP_LOCK(app, &push_thread, &pushed_thread, &level);
+            nfds = IoWait(&wt, &wf);
+            RESTORE_APP_LOCK(app, level, &pushed_thread);
+        }
+        else
+#endif                          /* } */
+            nfds = IoWait(&wt, &wf);
+        if (nfds == -1) {
+            /*
+             *  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);
 #ifdef USE_POLL
-			    XtStackFree ((XtPointer) wf.fdlist, fdlist);
+                            XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-			    return -1;
-			}
-			se_ptr = se_ptr->se_next;
-		    }
-		}
-
-		if (!ignoreEvents)
-		    /* get Xlib to detect a bad connection */
-		    for (dd = 0; dd < app->count; dd++)
-			if (XEventsQueued(app->list[dd], QueuedAfterReading)) {
+                            return -1;
+                        }
+                        se_ptr = se_ptr->se_next;
+                    }
+                }
+
+                if (!ignoreEvents)
+                    /* get Xlib to detect a bad connection */
+                    for (dd = 0; dd < app->count; dd++)
+                        if (XEventsQueued(app->list[dd], QueuedAfterReading)) {
 #ifdef USE_POLL
-			    XtStackFree ((XtPointer) wf.fdlist, fdlist);
+                            XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-			    return dd;
-			}
+                            return dd;
+                        }
 
-		if (block) {
+                if (block) {
 #ifdef USE_POLL
-		    if (wt.poll_wait == X_BLOCK)
+                    if (wt.poll_wait == X_BLOCK)
 #else
-		    if (wt.wait_time_ptr == NULL)
+                    if (wt.wait_time_ptr == NULL)
 #endif
-			continue;
-		    X_GETTIMEOFDAY (&wt.new_time);
-		    FIXUP_TIMEVAL (wt.new_time);
-		    TIMEDELTA (wt.time_spent, wt.new_time, wt.cur_time);
-		    wt.cur_time = wt.new_time;
+                        continue;
+                    X_GETTIMEOFDAY(&wt.new_time);
+                    FIXUP_TIMEVAL(wt.new_time);
+                    TIMEDELTA(wt.time_spent, wt.new_time, wt.cur_time);
+                    wt.cur_time = wt.new_time;
 #ifdef USE_POLL
-		    if ((wt.time_spent.tv_sec * 1000 + wt.time_spent.tv_usec / 1000) < wt.poll_wait) {
-			wt.poll_wait -= (int)(wt.time_spent.tv_sec * 1000 + wt.time_spent.tv_usec / 1000);
-			continue;
-		    } else
+                    if ((wt.time_spent.tv_sec * 1000 +
+                         wt.time_spent.tv_usec / 1000) < wt.poll_wait) {
+                        wt.poll_wait -=
+                            (int) (wt.time_spent.tv_sec * 1000 +
+                                   wt.time_spent.tv_usec / 1000);
+                        continue;
+                    }
+                    else
 #else
-		    if (IS_AFTER (wt.time_spent, *wt.wait_time_ptr)) {
-			TIMEDELTA (wt.wait_time, *wt.wait_time_ptr, wt.time_spent);
-			wt.wait_time_ptr = &wt.wait_time;
-			continue;
-		    } else
+                    if (IS_AFTER(wt.time_spent, *wt.wait_time_ptr)) {
+                        TIMEDELTA(wt.wait_time, *wt.wait_time_ptr,
+                                  wt.time_spent);
+                        wt.wait_time_ptr = &wt.wait_time;
+                        continue;
+                    }
+                    else
 #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;
-	    }
-	} /* timed out or input available */
-	break;
+                        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;
+            }
+        }                       /* timed out or input available */
+        break;
     }
 
     if (nfds == 0) {
-	/* Timed out */
-	if (howlong)
-	    *howlong = (unsigned long)0;
+        /* Timed out */
+        if (howlong)
+            *howlong = (unsigned long) 0;
 #ifdef USE_POLL
-	XtStackFree ((XtPointer) wf.fdlist, fdlist);
+        XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-	return -1;
+        return -1;
     }
 
     if (block && howlong != NULL)
-	AdjustHowLong (howlong, &wt.start_time);
+        AdjustHowLong(howlong, &wt.start_time);
 
     if (ignoreInputs && ignoreEvents) {
 #ifdef USE_POLL
-	XtStackFree ((XtPointer) wf.fdlist, fdlist);
+        XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-	return -1;
-    } else
-	FindInputs (app, &wf, nfds,
-		    (Boolean) ignoreEvents, (Boolean) ignoreInputs,
-		    &dpy_no, &found_input);
+        return -1;
+    }
+    else
+        FindInputs(app, &wf, nfds,
+                   (Boolean) ignoreEvents, (Boolean) ignoreInputs,
+                   &dpy_no, &found_input);
 
     if (dpy_no >= 0 || found_input) {
 #ifdef USE_POLL
-	XtStackFree ((XtPointer) wf.fdlist, fdlist);
+        XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
-	return dpy_no;
+        return dpy_no;
     }
     if (block)
         goto WaitLoop;
     else {
 #ifdef USE_POLL
-	XtStackFree ((XtPointer) wf.fdlist, fdlist);
+        XtStackFree((XtPointer) wf.fdlist, fdlist);
 #endif
         return -1;
     }
@@ -755,452 +786,473 @@ WaitLoop:
  * Public Routines
  */
 
-XtIntervalId XtAddTimeOut(
-	unsigned long interval,
-	XtTimerCallbackProc proc,
-	XtPointer closure)
+XtIntervalId
+XtAddTimeOut(unsigned long interval,
+             XtTimerCallbackProc proc,
+             XtPointer closure)
 {
-	return XtAppAddTimeOut(_XtDefaultAppContext(),
-		interval, proc, closure);
+    return XtAppAddTimeOut(_XtDefaultAppContext(), interval, proc, closure);
 }
 
-static void QueueTimerEvent(
-    XtAppContext app,
-    TimerEventRec *ptr)
+static void
+QueueTimerEvent(XtAppContext app, TimerEventRec *ptr)
 {
-        TimerEventRec *t,**tt;
-        tt = &app->timerQueue;
-        t  = *tt;
-        while (t != NULL &&
-                IS_AFTER(t->te_timer_value, ptr->te_timer_value)) {
-          tt = &t->te_next;
-          t  = *tt;
-         }
-         ptr->te_next = t;
-         *tt = ptr;
+    TimerEventRec *t, **tt;
+
+    tt = &app->timerQueue;
+    t = *tt;
+    while (t != NULL && IS_AFTER(t->te_timer_value, ptr->te_timer_value)) {
+        tt = &t->te_next;
+        t = *tt;
+    }
+    ptr->te_next = t;
+    *tt = ptr;
 }
 
-XtIntervalId XtAppAddTimeOut(
-	XtAppContext app,
-	unsigned long interval,
-	XtTimerCallbackProc proc,
-	XtPointer closure)
+XtIntervalId
+XtAppAddTimeOut(XtAppContext app,
+                unsigned long interval,
+                XtTimerCallbackProc proc,
+                XtPointer closure)
 {
-	TimerEventRec *tptr;
-	struct timeval current_time;
-
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	if (freeTimerRecs) {
-	    tptr = freeTimerRecs;
-	    freeTimerRecs = tptr->te_next;
-	}
-	else tptr = XtNew(TimerEventRec);
-	UNLOCK_PROCESS;
-
-	tptr->te_next = NULL;
-	tptr->te_closure = closure;
-	tptr->te_proc = proc;
-	tptr->app = app;
-	tptr->te_timer_value.tv_sec = (time_t) (interval/1000);
-	tptr->te_timer_value.tv_usec = (suseconds_t) ((interval%1000)*1000);
-        X_GETTIMEOFDAY (&current_time);
-	FIXUP_TIMEVAL(current_time);
-        ADD_TIME(tptr->te_timer_value,tptr->te_timer_value,current_time);
-	QueueTimerEvent(app, tptr);
-	UNLOCK_APP(app);
-	return( (XtIntervalId) tptr);
+    TimerEventRec *tptr;
+    struct timeval current_time;
+
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    if (freeTimerRecs) {
+        tptr = freeTimerRecs;
+        freeTimerRecs = tptr->te_next;
+    }
+    else
+        tptr = XtNew(TimerEventRec);
+
+    UNLOCK_PROCESS;
+    tptr->te_next = NULL;
+    tptr->te_closure = closure;
+    tptr->te_proc = proc;
+    tptr->app = app;
+    tptr->te_timer_value.tv_sec = (time_t) (interval / 1000);
+    tptr->te_timer_value.tv_usec = (suseconds_t) ((interval % 1000) * 1000);
+    X_GETTIMEOFDAY(&current_time);
+    FIXUP_TIMEVAL(current_time);
+    ADD_TIME(tptr->te_timer_value, tptr->te_timer_value, current_time);
+    QueueTimerEvent(app, tptr);
+    UNLOCK_APP(app);
+
+    return ((XtIntervalId) tptr);
 }
 
-void  XtRemoveTimeOut(
-	XtIntervalId id)
+void
+XtRemoveTimeOut(XtIntervalId id)
 {
-	TimerEventRec *t, *last, *tid = (TimerEventRec *) id;
-	XtAppContext app = tid->app;
-
-	/* find it */
-	LOCK_APP(app);
-	for(t = app->timerQueue, last = NULL;
-	    t != NULL && t != tid;
-	    t = t->te_next) last = t;
-
-	if (t == NULL) {
-	    UNLOCK_APP(app);
-	    return; /* couldn't find it */
-	}
-	if(last == NULL) { /* first one on the list */
-	    app->timerQueue = t->te_next;
-	} else last->te_next = t->te_next;
-
-	LOCK_PROCESS;
-	t->te_next = freeTimerRecs;
-	freeTimerRecs = t;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
+    TimerEventRec *t, *last, *tid = (TimerEventRec *) id;
+    XtAppContext app = tid->app;
+
+    /* find it */
+    LOCK_APP(app);
+    for (t = app->timerQueue, last = NULL;
+         t != NULL && t != tid; t = t->te_next)
+        last = t;
+
+    if (t == NULL) {
+        UNLOCK_APP(app);
+        return;                 /* couldn't find it */
+    }
+    if (last == NULL) {         /* first one on the list */
+        app->timerQueue = t->te_next;
+    }
+    else
+        last->te_next = t->te_next;
+
+    LOCK_PROCESS;
+    t->te_next = freeTimerRecs;
+    freeTimerRecs = t;
+    UNLOCK_PROCESS;
+    UNLOCK_APP(app);
 }
 
-XtWorkProcId XtAddWorkProc(
-	XtWorkProc proc,
-	XtPointer closure)
+XtWorkProcId
+XtAddWorkProc(XtWorkProc proc, XtPointer closure)
 {
-	return XtAppAddWorkProc(_XtDefaultAppContext(), proc, closure);
+    return XtAppAddWorkProc(_XtDefaultAppContext(), proc, closure);
 }
 
-XtWorkProcId XtAppAddWorkProc(
-	XtAppContext app,
-	XtWorkProc proc,
-	XtPointer closure)
+XtWorkProcId
+XtAppAddWorkProc(XtAppContext app, XtWorkProc proc, XtPointer closure)
 {
-	WorkProcRec *wptr;
-
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	if (freeWorkRecs) {
-	    wptr = freeWorkRecs;
-	    freeWorkRecs = wptr->next;
-	} else wptr = XtNew(WorkProcRec);
-	UNLOCK_PROCESS;
-	wptr->next = app->workQueue;
-	wptr->closure = closure;
-	wptr->proc = proc;
-	wptr->app = app;
-	app->workQueue = wptr;
-	UNLOCK_APP(app);
-	return (XtWorkProcId) wptr;
+    WorkProcRec *wptr;
+
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    if (freeWorkRecs) {
+        wptr = freeWorkRecs;
+        freeWorkRecs = wptr->next;
+    }
+    else
+        wptr = XtNew(WorkProcRec);
+
+    UNLOCK_PROCESS;
+    wptr->next = app->workQueue;
+    wptr->closure = closure;
+    wptr->proc = proc;
+    wptr->app = app;
+    app->workQueue = wptr;
+    UNLOCK_APP(app);
+
+    return (XtWorkProcId) wptr;
 }
 
-void  XtRemoveWorkProc(
-	XtWorkProcId id)
+void
+XtRemoveWorkProc(XtWorkProcId id)
 {
-	WorkProcRec *wid= (WorkProcRec *) id, *w, *last;
-	XtAppContext app = wid->app;
-
-	LOCK_APP(app);
-	/* find it */
-	for(w = app->workQueue, last = NULL;
-	    w != NULL && w != wid; w = w->next) last = w;
-
-	if (w == NULL) {
-	    UNLOCK_APP(app);
-	    return; /* couldn't find it */
-	}
-
-	if(last == NULL) app->workQueue = w->next;
-	else last->next = w->next;
-	LOCK_PROCESS;
-	w->next = freeWorkRecs;
-	freeWorkRecs = w;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
+    WorkProcRec *wid = (WorkProcRec *) id, *w, *last;
+    XtAppContext app = wid->app;
+
+    LOCK_APP(app);
+    /* find it */
+    for (w = app->workQueue, last = NULL; w != NULL && w != wid; w = w->next)
+        last = w;
+
+    if (w == NULL) {
+        UNLOCK_APP(app);
+        return;                 /* couldn't find it */
+    }
+
+    if (last == NULL)
+        app->workQueue = w->next;
+    else
+        last->next = w->next;
+    LOCK_PROCESS;
+    w->next = freeWorkRecs;
+    freeWorkRecs = w;
+    UNLOCK_PROCESS;
+    UNLOCK_APP(app);
 }
 
-XtSignalId XtAddSignal(
-	XtSignalCallbackProc proc,
-	XtPointer closure)
+XtSignalId
+XtAddSignal(XtSignalCallbackProc proc, XtPointer closure)
 {
-	return XtAppAddSignal(_XtDefaultAppContext(), proc, closure);
+    return XtAppAddSignal(_XtDefaultAppContext(), proc, closure);
 }
 
-XtSignalId XtAppAddSignal(
-	XtAppContext app,
-	XtSignalCallbackProc proc,
-	XtPointer closure)
+XtSignalId
+XtAppAddSignal(XtAppContext app, XtSignalCallbackProc proc, XtPointer closure)
 {
-	SignalEventRec *sptr;
-
-	LOCK_APP(app);
-	LOCK_PROCESS;
-	if (freeSignalRecs) {
-	    sptr = freeSignalRecs;
-	    freeSignalRecs = sptr->se_next;
-	} else
-	    sptr = XtNew(SignalEventRec);
-	UNLOCK_PROCESS;
-	sptr->se_next = app->signalQueue;
-	sptr->se_closure = closure;
-	sptr->se_proc = proc;
-	sptr->app = app;
-	sptr->se_notice = FALSE;
-	app->signalQueue = sptr;
-	UNLOCK_APP(app);
-	return (XtSignalId) sptr;
+    SignalEventRec *sptr;
+
+    LOCK_APP(app);
+    LOCK_PROCESS;
+    if (freeSignalRecs) {
+        sptr = freeSignalRecs;
+        freeSignalRecs = sptr->se_next;
+    }
+    else
+        sptr = XtNew(SignalEventRec);
+
+    UNLOCK_PROCESS;
+    sptr->se_next = app->signalQueue;
+    sptr->se_closure = closure;
+    sptr->se_proc = proc;
+    sptr->app = app;
+    sptr->se_notice = FALSE;
+    app->signalQueue = sptr;
+    UNLOCK_APP(app);
+    return (XtSignalId) sptr;
 }
 
-void XtRemoveSignal(
-	XtSignalId id)
+void
+XtRemoveSignal(XtSignalId id)
 {
-	SignalEventRec *sid = (SignalEventRec*) id, *s, *last = NULL;
-	XtAppContext app = sid->app;
-
-	LOCK_APP(app);
-	for (s = app->signalQueue; s != NULL && s != sid; s = s->se_next)
-	    last = s;
-	if (s == NULL) {
-	    UNLOCK_APP(app);
-	    return;
-	}
-	if (last == NULL)
-	    app->signalQueue = s->se_next;
-	else
-	    last->se_next = s->se_next;
-	LOCK_PROCESS;
-	s->se_next = freeSignalRecs;
-	freeSignalRecs = s;
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
+    SignalEventRec *sid = (SignalEventRec *) id, *s, *last = NULL;
+    XtAppContext app = sid->app;
+
+    LOCK_APP(app);
+    for (s = app->signalQueue; s != NULL && s != sid; s = s->se_next)
+        last = s;
+    if (s == NULL) {
+        UNLOCK_APP(app);
+        return;
+    }
+    if (last == NULL)
+        app->signalQueue = s->se_next;
+    else
+        last->se_next = s->se_next;
+    LOCK_PROCESS;
+    s->se_next = freeSignalRecs;
+    freeSignalRecs = s;
+    UNLOCK_PROCESS;
+    UNLOCK_APP(app);
 }
 
-void XtNoticeSignal(
-	XtSignalId id)
+void
+XtNoticeSignal(XtSignalId id)
 {
-	/*
-	 * It would be overkill to lock the app to set this flag.
-	 * In the worst case, 2..n threads would be modifying this
-	 * flag. The last one wins. Since signals occur asynchronously
-	 * anyway, this can occur with or without threads.
-	 *
-	 * The other issue is that thread t1 sets the flag in a
-	 * signalrec that has been deleted in thread t2. We rely
-	 * on a detail of the implementation, i.e. free'd signalrecs
-	 * aren't really free'd, they're just moved to a list of
-	 * free recs, so deref'ing one won't hurt anything.
-	 *
-	 * Lastly, and perhaps most importantly, since POSIX threads
-	 * says that the handling of asynchronous signals in a synchronous
-	 * threads environment is undefined. Therefor it would be an
-	 * error for both signals and threads to be in use in the same
-	 * program.
-	 */
-	SignalEventRec *sid = (SignalEventRec*) id;
-	sid->se_notice = TRUE;
+    /*
+     * It would be overkill to lock the app to set this flag.
+     * In the worst case, 2..n threads would be modifying this
+     * flag. The last one wins. Since signals occur asynchronously
+     * anyway, this can occur with or without threads.
+     *
+     * The other issue is that thread t1 sets the flag in a
+     * signalrec that has been deleted in thread t2. We rely
+     * on a detail of the implementation, i.e. free'd signalrecs
+     * aren't really free'd, they're just moved to a list of
+     * free recs, so deref'ing one won't hurt anything.
+     *
+     * Lastly, and perhaps most importantly, since POSIX threads
+     * says that the handling of asynchronous signals in a synchronous
+     * threads environment is undefined. Therefor it would be an
+     * error for both signals and threads to be in use in the same
+     * program.
+     */
+    SignalEventRec *sid = (SignalEventRec *) id;
+
+    sid->se_notice = TRUE;
 }
 
-XtInputId XtAddInput(
-	int source,
-	XtPointer Condition,
-	XtInputCallbackProc proc,
-	XtPointer closure)
+XtInputId
+XtAddInput(int source,
+           XtPointer Condition,
+           XtInputCallbackProc proc,
+           XtPointer closure)
 {
-	return XtAppAddInput(_XtDefaultAppContext(),
-		source, Condition, proc, closure);
+    return XtAppAddInput(_XtDefaultAppContext(),
+                         source, Condition, proc, closure);
 }
 
-XtInputId XtAppAddInput(
-	XtAppContext app,
-	int source,
-	XtPointer Condition,
-	XtInputCallbackProc proc,
-	XtPointer closure)
+XtInputId
+XtAppAddInput(XtAppContext app,
+              int source,
+              XtPointer Condition,
+              XtInputCallbackProc proc,
+              XtPointer closure)
 {
-	InputEvent* sptr;
-	XtInputMask condition = (XtInputMask) Condition;
-
-	LOCK_APP(app);
-	if (!condition ||
-	    condition & (unsigned long)(~(XtInputReadMask|XtInputWriteMask|XtInputExceptMask)))
-	    XtAppErrorMsg(app,"invalidParameter","xtAddInput",XtCXtToolkitError,
-			  "invalid condition passed to XtAppAddInput",
-			  NULL, NULL);
-
-	if (app->input_max <= source) {
-	    Cardinal n = (Cardinal) (source + 1);
-	    int ii;
-	    app->input_list = (InputEvent**)XtRealloc((char*) app->input_list,
-						      (Cardinal)((size_t)n * sizeof(InputEvent*)));
-	    for (ii = app->input_max; ii < (int) n; ii++)
-		app->input_list[ii] = (InputEvent*) NULL;
-	    app->input_max = (short) n;
-	}
-	sptr = XtNew(InputEvent);
-	sptr->ie_proc = proc;
-	sptr->ie_closure = closure;
-	sptr->app = app;
-	sptr->ie_oq = NULL;
-	sptr->ie_source = source;
-	sptr->ie_condition = condition;
-	sptr->ie_next = app->input_list[source];
-	app->input_list[source] = sptr;
+    InputEvent *sptr;
+    XtInputMask condition = (XtInputMask) Condition;
+
+    LOCK_APP(app);
+    if (!condition ||
+        condition & (unsigned
+                     long) (~(XtInputReadMask | XtInputWriteMask |
+                              XtInputExceptMask)))
+        XtAppErrorMsg(app, "invalidParameter", "xtAddInput", XtCXtToolkitError,
+                      "invalid condition passed to XtAppAddInput", NULL, NULL);
+
+    if (app->input_max <= source) {
+        Cardinal n = (Cardinal) (source + 1);
+        int ii;
+
+        app->input_list = (InputEvent **) XtRealloc((char *) app->input_list,
+                                                    (Cardinal) ((size_t) n *
+                                                                sizeof
+                                                                (InputEvent
+                                                                 *)));
+        for (ii = app->input_max; ii < (int) n; ii++)
+            app->input_list[ii] = (InputEvent *) NULL;
+        app->input_max = (short) n;
+    }
+    sptr = XtNew(InputEvent);
+
+    sptr->ie_proc = proc;
+    sptr->ie_closure = closure;
+    sptr->app = app;
+    sptr->ie_oq = NULL;
+    sptr->ie_source = source;
+    sptr->ie_condition = condition;
+    sptr->ie_next = app->input_list[source];
+    app->input_list[source] = sptr;
 
 #ifdef USE_POLL
-	if (sptr->ie_next == NULL)
-	    app->fds.nfds++;
+    if (sptr->ie_next == NULL)
+        app->fds.nfds++;
 #else
-	if (condition & XtInputReadMask)   FD_SET(source, &app->fds.rmask);
-	if (condition & XtInputWriteMask)  FD_SET(source, &app->fds.wmask);
-	if (condition & XtInputExceptMask) FD_SET(source, &app->fds.emask);
-
-	if (app->fds.nfds < (source+1)) app->fds.nfds = source+1;
+    if (condition & XtInputReadMask)
+        FD_SET(source, &app->fds.rmask);
+    if (condition & XtInputWriteMask)
+        FD_SET(source, &app->fds.wmask);
+    if (condition & XtInputExceptMask)
+        FD_SET(source, &app->fds.emask);
+
+    if (app->fds.nfds < (source + 1))
+        app->fds.nfds = source + 1;
 #endif
-	app->input_count++;
-	app->rebuild_fdlist = TRUE;
-	UNLOCK_APP(app);
-	return((XtInputId)sptr);
+    app->input_count++;
+    app->rebuild_fdlist = TRUE;
+    UNLOCK_APP(app);
+    return ((XtInputId) sptr);
 }
 
-void XtRemoveInput(
-	register XtInputId  id)
+void
+XtRemoveInput(register XtInputId id)
 {
-  	register InputEvent *sptr, *lptr;
-	XtAppContext app = ((InputEvent *)id)->app;
-	register int source = ((InputEvent *)id)->ie_source;
-	Boolean found = False;
-
-	LOCK_APP(app);
-	sptr = app->outstandingQueue;
-	lptr = NULL;
-	for (; sptr != NULL; sptr = sptr->ie_oq) {
-	    if (sptr == (InputEvent *)id) {
-		if (lptr == NULL) app->outstandingQueue = sptr->ie_oq;
-		else lptr->ie_oq = sptr->ie_oq;
-	    }
-	    lptr = sptr;
-	}
-
-	if(app->input_list && (sptr = app->input_list[source]) != NULL) {
-		for( lptr = NULL ; sptr; sptr = sptr->ie_next ){
-			if(sptr == (InputEvent *) id) {
+    register InputEvent *sptr, *lptr;
+    XtAppContext app = ((InputEvent *) id)->app;
+    register int source = ((InputEvent *) id)->ie_source;
+    Boolean found = False;
+
+    LOCK_APP(app);
+    sptr = app->outstandingQueue;
+    lptr = NULL;
+    for (; sptr != NULL; sptr = sptr->ie_oq) {
+        if (sptr == (InputEvent *) id) {
+            if (lptr == NULL)
+                app->outstandingQueue = sptr->ie_oq;
+            else
+                lptr->ie_oq = sptr->ie_oq;
+        }
+        lptr = sptr;
+    }
+
+    if (app->input_list && (sptr = app->input_list[source]) != NULL) {
+        for (lptr = NULL; sptr; sptr = sptr->ie_next) {
+            if (sptr == (InputEvent *) id) {
 #ifndef USE_POLL
-				XtInputMask condition = 0;
+                XtInputMask condition = 0;
 #endif
-				if(lptr == NULL) {
-				    app->input_list[source] = sptr->ie_next;
-				} else {
-				    lptr->ie_next = sptr->ie_next;
-				}
+                if (lptr == NULL) {
+                    app->input_list[source] = sptr->ie_next;
+                }
+                else {
+                    lptr->ie_next = sptr->ie_next;
+                }
 #ifndef USE_POLL
-				for (lptr = app->input_list[source];
-				     lptr; lptr = lptr->ie_next)
-				    condition |= lptr->ie_condition;
-				if ((sptr->ie_condition & XtInputReadMask) &&
-				    !(condition & XtInputReadMask))
-				   FD_CLR(source, &app->fds.rmask);
-				if ((sptr->ie_condition & XtInputWriteMask) &&
-				    !(condition & XtInputWriteMask))
-				   FD_CLR(source, &app->fds.wmask);
-				if ((sptr->ie_condition & XtInputExceptMask) &&
-				    !(condition & XtInputExceptMask))
-				   FD_CLR(source, &app->fds.emask);
+                for (lptr = app->input_list[source]; lptr; lptr = lptr->ie_next)
+                    condition |= lptr->ie_condition;
+                if ((sptr->ie_condition & XtInputReadMask) &&
+                    !(condition & XtInputReadMask))
+                    FD_CLR(source, &app->fds.rmask);
+                if ((sptr->ie_condition & XtInputWriteMask) &&
+                    !(condition & XtInputWriteMask))
+                    FD_CLR(source, &app->fds.wmask);
+                if ((sptr->ie_condition & XtInputExceptMask) &&
+                    !(condition & XtInputExceptMask))
+                    FD_CLR(source, &app->fds.emask);
 #endif
-				XtFree((char *) sptr);
-				found = True;
-				break;
-			}
-			lptr = sptr;
-		}
-	}
-
-	if (found) {
-	    app->input_count--;
+                XtFree((char *) sptr);
+                found = True;
+                break;
+            }
+            lptr = sptr;
+        }
+    }
+
+    if (found) {
+        app->input_count--;
 #ifdef USE_POLL
-	    if (app->input_list[source] == NULL)
-		app->fds.nfds--;
+        if (app->input_list[source] == NULL)
+            app->fds.nfds--;
 #endif
-	    app->rebuild_fdlist = TRUE;
-	} else
-	    XtAppWarningMsg(app, "invalidProcedure","inputHandler",
-			    XtCXtToolkitError,
-			    "XtRemoveInput: Input handler not found",
-			    NULL, NULL);
-	UNLOCK_APP(app);
+        app->rebuild_fdlist = TRUE;
+    }
+    else
+        XtAppWarningMsg(app, "invalidProcedure", "inputHandler",
+                        XtCXtToolkitError,
+                        "XtRemoveInput: Input handler not found", NULL, NULL);
+    UNLOCK_APP(app);
 }
 
-void _XtRemoveAllInputs(
-    XtAppContext app)
+void
+_XtRemoveAllInputs(XtAppContext app)
 {
     int i;
+
     for (i = 0; i < app->input_max; i++) {
-	InputEvent* ep = app->input_list[i];
-	while (ep) {
-	    InputEvent *next = ep->ie_next;
-	    XtFree( (char*)ep );
-	    ep = next;
-	}
+        InputEvent *ep = app->input_list[i];
+
+        while (ep) {
+            InputEvent *next = ep->ie_next;
+
+            XtFree((char *) ep);
+            ep = next;
+        }
     }
     XtFree((char *) app->input_list);
 }
 
 /* Do alternate input and timer callbacks if there are any */
 
-static void DoOtherSources(
-	XtAppContext app)
+static void
+DoOtherSources(XtAppContext app)
 {
-	TimerEventRec *te_ptr;
-	InputEvent *ie_ptr;
-	struct timeval  cur_time;
+    TimerEventRec *te_ptr;
+    InputEvent *ie_ptr;
+    struct timeval cur_time;
 
 #define DrainQueue() \
-	for (ie_ptr = app->outstandingQueue; ie_ptr != NULL;) { \
-	    app->outstandingQueue = ie_ptr->ie_oq;		\
-	    ie_ptr ->ie_oq = NULL;				\
-	    IeCallProc(ie_ptr);					\
-	    ie_ptr = app->outstandingQueue;			\
-	}
+        for (ie_ptr = app->outstandingQueue; ie_ptr != NULL;) { \
+            app->outstandingQueue = ie_ptr->ie_oq;              \
+            ie_ptr ->ie_oq = NULL;                              \
+            IeCallProc(ie_ptr);                                 \
+            ie_ptr = app->outstandingQueue;                     \
+        }
 /*enddef*/
-	DrainQueue();
-	if (app->input_count > 0) {
-	    /* Call _XtWaitForSomething to get input queued up */
-	    (void) _XtWaitForSomething (app,
-					TRUE, TRUE, FALSE, TRUE,
-					FALSE,
-					TRUE,
-					(unsigned long *)NULL);
-	    DrainQueue();
-	}
-	if (app->timerQueue != NULL) {	/* check timeout queue */
-	    X_GETTIMEOFDAY (&cur_time);
-	    FIXUP_TIMEVAL(cur_time);
-	    while(IS_AT_OR_AFTER (app->timerQueue->te_timer_value, cur_time)) {
-		te_ptr = app->timerQueue;
-		app->timerQueue = te_ptr->te_next;
-		te_ptr->te_next = NULL;
-		if (te_ptr->te_proc != NULL)
-		    TeCallProc(te_ptr);
-		LOCK_PROCESS;
-		te_ptr->te_next = freeTimerRecs;
-		freeTimerRecs = te_ptr;
-		UNLOCK_PROCESS;
-		if (app->timerQueue == NULL) break;
-	    }
-	}
-	if (app->signalQueue != NULL) {
-	    SignalEventRec *se_ptr = app->signalQueue;
-	    while (se_ptr != NULL) {
-		if (se_ptr->se_notice) {
-		    se_ptr->se_notice = FALSE;
-		    if (se_ptr->se_proc != NULL)
-			SeCallProc(se_ptr);
-		}
-		se_ptr = se_ptr->se_next;
-	    }
-	}
+    DrainQueue();
+    if (app->input_count > 0) {
+        /* Call _XtWaitForSomething to get input queued up */
+        (void) _XtWaitForSomething(app,
+                                   TRUE, TRUE, FALSE, TRUE,
+                                   FALSE, TRUE, (unsigned long *) NULL);
+        DrainQueue();
+    }
+    if (app->timerQueue != NULL) {      /* check timeout queue */
+        X_GETTIMEOFDAY(&cur_time);
+        FIXUP_TIMEVAL(cur_time);
+        while (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) {
+            te_ptr = app->timerQueue;
+            app->timerQueue = te_ptr->te_next;
+            te_ptr->te_next = NULL;
+            if (te_ptr->te_proc != NULL)
+                TeCallProc(te_ptr);
+            LOCK_PROCESS;
+            te_ptr->te_next = freeTimerRecs;
+            freeTimerRecs = te_ptr;
+            UNLOCK_PROCESS;
+            if (app->timerQueue == NULL)
+                break;
+        }
+    }
+    if (app->signalQueue != NULL) {
+        SignalEventRec *se_ptr = app->signalQueue;
+
+        while (se_ptr != NULL) {
+            if (se_ptr->se_notice) {
+                se_ptr->se_notice = FALSE;
+                if (se_ptr->se_proc != NULL)
+                    SeCallProc(se_ptr);
+            }
+            se_ptr = se_ptr->se_next;
+        }
+    }
 #undef DrainQueue
 }
 
 /* If there are any work procs, call them.  Return whether we did so */
 
-static Boolean CallWorkProc(
-	XtAppContext app)
+static Boolean
+CallWorkProc(XtAppContext app)
 {
-	register WorkProcRec *w = app->workQueue;
-	Boolean delete;
-
-	if (w == NULL) return FALSE;
-
-	app->workQueue = w->next;
-
-	delete = (*(w->proc)) (w->closure);
-
-	if (delete) {
-	    LOCK_PROCESS;
-	    w->next = freeWorkRecs;
-	    freeWorkRecs = w;
-	    UNLOCK_PROCESS;
-	}
-	else {
-	    w->next = app->workQueue;
-	    app->workQueue = w;
-	}
-	return TRUE;
+    register WorkProcRec *w = app->workQueue;
+    Boolean delete;
+
+    if (w == NULL)
+        return FALSE;
+
+    app->workQueue = w->next;
+
+    delete = (*(w->proc)) (w->closure);
+
+    if (delete) {
+        LOCK_PROCESS;
+        w->next = freeWorkRecs;
+        freeWorkRecs = w;
+        UNLOCK_PROCESS;
+    }
+    else {
+        w->next = app->workQueue;
+        app->workQueue = w;
+    }
+    return TRUE;
 }
 
 /*
@@ -1208,406 +1260,411 @@ static Boolean CallWorkProc(
  * return next event;
  */
 
-void XtNextEvent(
-	XEvent *event)
+void
+XtNextEvent(XEvent *event)
 {
-	XtAppNextEvent(_XtDefaultAppContext(), event);
+    XtAppNextEvent(_XtDefaultAppContext(), event);
 }
 
-void _XtRefreshMapping(
-    XEvent* event,
-    _XtBoolean dispatch)
+void
+_XtRefreshMapping(XEvent *event, _XtBoolean dispatch)
 {
     XtPerDisplay pd;
 
     LOCK_PROCESS;
     pd = _XtGetPerDisplay(event->xmapping.display);
+
     if (event->xmapping.request != MappingPointer &&
-	pd && pd->keysyms && (event->xmapping.serial >= pd->keysyms_serial))
-	_XtBuildKeysymTables( event->xmapping.display, pd );
+        pd && pd->keysyms && (event->xmapping.serial >= pd->keysyms_serial))
+        _XtBuildKeysymTables(event->xmapping.display, pd);
+
     XRefreshKeyboardMapping(&event->xmapping);
     if (dispatch && pd && pd->mapping_callbacks)
-	XtCallCallbackList((Widget) NULL,
-			   (XtCallbackList)pd->mapping_callbacks,
-			   (XtPointer)event );
+        XtCallCallbackList((Widget) NULL,
+                           (XtCallbackList) pd->mapping_callbacks,
+                           (XtPointer) event);
     UNLOCK_PROCESS;
 }
 
-void XtAppNextEvent(
-	XtAppContext app,
-	XEvent *event)
+void
+XtAppNextEvent(XtAppContext app, XEvent *event)
 {
     int i, d;
 
     LOCK_APP(app);
     for (;;) {
-	if (app->count == 0)
-	    DoOtherSources(app);
-	else {
-	    for (i = 1; i <= app->count; i++) {
-		d = (i + app->last) % app->count;
-		if (d == 0) DoOtherSources(app);
-		if (XEventsQueued(app->list[d], QueuedAfterReading))
-		    goto GotEvent;
-	    }
-	    for (i = 1; i <= app->count; i++) {
-		d = (i + app->last) % app->count;
-		if (XEventsQueued(app->list[d], QueuedAfterFlush))
-		    goto GotEvent;
-	    }
-	}
-
-	/* We're ready to wait...if there is a work proc, call it */
-	if (CallWorkProc(app)) continue;
-
-	d = _XtWaitForSomething (app,
-				 FALSE, FALSE, FALSE, FALSE,
-				 TRUE,
-				 TRUE,
-				 (unsigned long *) NULL);
-
-	if (d != -1) {
-	  GotEvent:
-	    XNextEvent (app->list[d], event);
-	    app->last = (short) d;
-	    if (event->xany.type == MappingNotify)
-		_XtRefreshMapping(event, False);
-	    UNLOCK_APP(app);
-	    return;
-	}
-
-    } /* for */
+        if (app->count == 0)
+            DoOtherSources(app);
+        else {
+            for (i = 1; i <= app->count; i++) {
+                d = (i + app->last) % app->count;
+                if (d == 0)
+                    DoOtherSources(app);
+                if (XEventsQueued(app->list[d], QueuedAfterReading))
+                    goto GotEvent;
+            }
+            for (i = 1; i <= app->count; i++) {
+                d = (i + app->last) % app->count;
+                if (XEventsQueued(app->list[d], QueuedAfterFlush))
+                    goto GotEvent;
+            }
+        }
+
+        /* We're ready to wait...if there is a work proc, call it */
+        if (CallWorkProc(app))
+            continue;
+
+        d = _XtWaitForSomething(app,
+                                FALSE, FALSE, FALSE, FALSE,
+                                TRUE, TRUE, (unsigned long *) NULL);
+
+        if (d != -1) {
+ GotEvent:
+            XNextEvent(app->list[d], event);
+            app->last = (short) d;
+            if (event->xany.type == MappingNotify)
+                _XtRefreshMapping(event, False);
+            UNLOCK_APP(app);
+            return;
+        }
+
+    }                           /* for */
 }
 
-void XtProcessEvent(
-	XtInputMask mask)
+void
+XtProcessEvent(XtInputMask mask)
 {
-	XtAppProcessEvent(_XtDefaultAppContext(), mask);
+    XtAppProcessEvent(_XtDefaultAppContext(), mask);
 }
 
-void XtAppProcessEvent(
-	XtAppContext app,
-	XtInputMask mask)
+void
+XtAppProcessEvent(XtAppContext app, XtInputMask mask)
 {
-	int i, d;
-	XEvent event;
-	struct timeval cur_time;
-
-	LOCK_APP(app);
-	if (mask == 0) {
-	    UNLOCK_APP(app);
-	    return;
-	}
-
-	for (;;) {
-
-	    if (mask & XtIMSignal && app->signalQueue != NULL) {
-		SignalEventRec *se_ptr = app->signalQueue;
-		while (se_ptr != NULL) {
-		    if (se_ptr->se_notice) {
-			se_ptr->se_notice = FALSE;
-			SeCallProc(se_ptr);
-			UNLOCK_APP(app);
-			return;
-		    }
-		    se_ptr = se_ptr->se_next;
-		}
-	    }
-
-	    if (mask & XtIMTimer && app->timerQueue != NULL) {
-		X_GETTIMEOFDAY (&cur_time);
-		FIXUP_TIMEVAL(cur_time);
-		if (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)){
-		    TimerEventRec *te_ptr = app->timerQueue;
-		    app->timerQueue = app->timerQueue->te_next;
-		    te_ptr->te_next = NULL;
-                    if (te_ptr->te_proc != NULL)
-		        TeCallProc(te_ptr);
-		    LOCK_PROCESS;
-		    te_ptr->te_next = freeTimerRecs;
-		    freeTimerRecs = te_ptr;
-		    UNLOCK_PROCESS;
-		    UNLOCK_APP(app);
-		    return;
-		}
-	    }
-
-	    if (mask & XtIMAlternateInput) {
-		if (app->input_count > 0 && app->outstandingQueue == NULL) {
-		    /* Call _XtWaitForSomething to get input queued up */
-		    (void) _XtWaitForSomething (app,
-						TRUE, TRUE, FALSE, TRUE,
-						FALSE,
-						TRUE,
-						(unsigned long *)NULL);
-		}
-		if (app->outstandingQueue != NULL) {
-		    InputEvent *ie_ptr = app->outstandingQueue;
-		    app->outstandingQueue = ie_ptr->ie_oq;
-		    ie_ptr->ie_oq = NULL;
-		    IeCallProc(ie_ptr);
-		    UNLOCK_APP(app);
-		    return;
-		}
-	    }
-
-	    if (mask & XtIMXEvent) {
-		for (i = 1; i <= app->count; i++) {
-		    d = (i + app->last) % app->count;
-		    if (XEventsQueued(app->list[d], QueuedAfterReading))
-			goto GotEvent;
-		}
-		for (i = 1; i <= app->count; i++) {
-		    d = (i + app->last) % app->count;
-		    if (XEventsQueued(app->list[d], QueuedAfterFlush))
-			goto GotEvent;
-		}
-	    }
-
-	    /* Nothing to do...wait for something */
-
-	    if (CallWorkProc(app)) continue;
-
-	    d = _XtWaitForSomething (app,
-				    ((mask & XtIMXEvent) ? FALSE : TRUE),
-				    ((mask & XtIMTimer) ? FALSE : TRUE),
-				    ((mask & XtIMAlternateInput) ? FALSE : TRUE),
-				    ((mask & XtIMSignal) ? FALSE : TRUE),
-				    TRUE,
-				    TRUE,
-				    (unsigned long *) NULL);
-
-	    if (mask & XtIMXEvent && d != -1) {
-	      GotEvent:
-		XNextEvent(app->list[d], &event);
-		app->last = (short) d;
-		if (event.xany.type == MappingNotify) {
-		    _XtRefreshMapping(&event, False);
-		}
-		XtDispatchEvent(&event);
-		UNLOCK_APP(app);
-		return;
-	    }
-
-	}
+    int i, d;
+    XEvent event;
+    struct timeval cur_time;
+
+    LOCK_APP(app);
+    if (mask == 0) {
+        UNLOCK_APP(app);
+        return;
+    }
+
+    for (;;) {
+
+        if (mask & XtIMSignal && app->signalQueue != NULL) {
+            SignalEventRec *se_ptr = app->signalQueue;
+
+            while (se_ptr != NULL) {
+                if (se_ptr->se_notice) {
+                    se_ptr->se_notice = FALSE;
+                    SeCallProc(se_ptr);
+                    UNLOCK_APP(app);
+                    return;
+                }
+                se_ptr = se_ptr->se_next;
+            }
+        }
+
+        if (mask & XtIMTimer && app->timerQueue != NULL) {
+            X_GETTIMEOFDAY(&cur_time);
+            FIXUP_TIMEVAL(cur_time);
+            if (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) {
+                TimerEventRec *te_ptr = app->timerQueue;
+
+                app->timerQueue = app->timerQueue->te_next;
+                te_ptr->te_next = NULL;
+                if (te_ptr->te_proc != NULL)
+                    TeCallProc(te_ptr);
+                LOCK_PROCESS;
+                te_ptr->te_next = freeTimerRecs;
+                freeTimerRecs = te_ptr;
+                UNLOCK_PROCESS;
+                UNLOCK_APP(app);
+                return;
+            }
+        }
+
+        if (mask & XtIMAlternateInput) {
+            if (app->input_count > 0 && app->outstandingQueue == NULL) {
+                /* Call _XtWaitForSomething to get input queued up */
+                (void) _XtWaitForSomething(app,
+                                           TRUE, TRUE, FALSE, TRUE,
+                                           FALSE, TRUE, (unsigned long *) NULL);
+            }
+            if (app->outstandingQueue != NULL) {
+                InputEvent *ie_ptr = app->outstandingQueue;
+
+                app->outstandingQueue = ie_ptr->ie_oq;
+                ie_ptr->ie_oq = NULL;
+                IeCallProc(ie_ptr);
+                UNLOCK_APP(app);
+                return;
+            }
+        }
+
+        if (mask & XtIMXEvent) {
+            for (i = 1; i <= app->count; i++) {
+                d = (i + app->last) % app->count;
+                if (XEventsQueued(app->list[d], QueuedAfterReading))
+                    goto GotEvent;
+            }
+            for (i = 1; i <= app->count; i++) {
+                d = (i + app->last) % app->count;
+                if (XEventsQueued(app->list[d], QueuedAfterFlush))
+                    goto GotEvent;
+            }
+        }
+
+        /* Nothing to do...wait for something */
+
+        if (CallWorkProc(app))
+            continue;
+
+        d = _XtWaitForSomething(app,
+                                ((mask & XtIMXEvent) ? FALSE : TRUE),
+                                ((mask & XtIMTimer) ? FALSE : TRUE),
+                                ((mask & XtIMAlternateInput) ? FALSE : TRUE),
+                                ((mask & XtIMSignal) ? FALSE : TRUE),
+                                TRUE, TRUE, (unsigned long *) NULL);
+
+        if (mask & XtIMXEvent && d != -1) {
+ GotEvent:
+            XNextEvent(app->list[d], &event);
+            app->last = (short) d;
+            if (event.xany.type == MappingNotify) {
+                _XtRefreshMapping(&event, False);
+            }
+            XtDispatchEvent(&event);
+            UNLOCK_APP(app);
+            return;
+        }
+
+    }
 }
 
-Boolean XtPending(void)
+Boolean
+XtPending(void)
 {
-	return (XtAppPending(_XtDefaultAppContext()) != 0);
+    return (XtAppPending(_XtDefaultAppContext()) != 0);
 }
 
-XtInputMask XtAppPending(
-	XtAppContext app)
+XtInputMask
+XtAppPending(XtAppContext app)
 {
-	struct timeval cur_time;
-	int d;
-	XtInputMask ret = 0;
+    struct timeval cur_time;
+    int d;
+    XtInputMask ret = 0;
 
 /*
  * Check for pending X events
  */
-	LOCK_APP(app);
-	for (d = 0; d < app->count; d++) {
-	    if (XEventsQueued(app->list[d], QueuedAfterReading)) {
-		ret = XtIMXEvent;
-		break;
-	    }
-	}
-	if (ret == 0) {
-	    for (d = 0; d < app->count; d++) {
-		if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
-		    ret = XtIMXEvent;
-		    break;
-		}
-	    }
-	}
-
-	if (app->signalQueue != NULL) {
-	    SignalEventRec *se_ptr = app->signalQueue;
-	    while (se_ptr != NULL) {
-		if (se_ptr->se_notice) {
-		    ret |= XtIMSignal;
-		    break;
-		}
-		se_ptr = se_ptr->se_next;
-	    }
-	}
+    LOCK_APP(app);
+    for (d = 0; d < app->count; d++) {
+        if (XEventsQueued(app->list[d], QueuedAfterReading)) {
+            ret = XtIMXEvent;
+            break;
+        }
+    }
+    if (ret == 0) {
+        for (d = 0; d < app->count; d++) {
+            if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
+                ret = XtIMXEvent;
+                break;
+            }
+        }
+    }
+
+    if (app->signalQueue != NULL) {
+        SignalEventRec *se_ptr = app->signalQueue;
+
+        while (se_ptr != NULL) {
+            if (se_ptr->se_notice) {
+                ret |= XtIMSignal;
+                break;
+            }
+            se_ptr = se_ptr->se_next;
+        }
+    }
 
 /*
  * Check for pending alternate input
  */
-	if (app->timerQueue != NULL) {	/* check timeout queue */
-	    X_GETTIMEOFDAY (&cur_time);
-	    FIXUP_TIMEVAL(cur_time);
-	    if ((IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time))  &&
-                (app->timerQueue->te_proc != NULL)) {
-		ret |= XtIMTimer;
-	    }
-	}
-
-	if (app->outstandingQueue != NULL) ret |= XtIMAlternateInput;
-	else {
-	    /* This won't cause a wait, but will enqueue any input */
-
-	    if(_XtWaitForSomething (app,
-				    FALSE, TRUE, FALSE, TRUE,
-				    FALSE,
-				    TRUE,
-				    (unsigned long *) NULL) != -1)
-		ret |= XtIMXEvent;
-	    if (app->outstandingQueue != NULL) ret |= XtIMAlternateInput;
-	}
-	UNLOCK_APP(app);
-	return ret;
+    if (app->timerQueue != NULL) {      /* check timeout queue */
+        X_GETTIMEOFDAY(&cur_time);
+        FIXUP_TIMEVAL(cur_time);
+        if ((IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) &&
+            (app->timerQueue->te_proc != NULL)) {
+            ret |= XtIMTimer;
+        }
+    }
+
+    if (app->outstandingQueue != NULL)
+        ret |= XtIMAlternateInput;
+    else {
+        /* This won't cause a wait, but will enqueue any input */
+
+        if (_XtWaitForSomething(app,
+                                FALSE, TRUE, FALSE, TRUE,
+                                FALSE, TRUE, (unsigned long *) NULL) != -1)
+            ret |= XtIMXEvent;
+        if (app->outstandingQueue != NULL)
+            ret |= XtIMAlternateInput;
+    }
+    UNLOCK_APP(app);
+    return ret;
 }
 
 /* Peek at alternate input and timer callbacks if there are any */
 
-static Boolean PeekOtherSources(
-	XtAppContext app)
+static Boolean
+PeekOtherSources(XtAppContext app)
 {
-	struct timeval  cur_time;
-
-	if (app->outstandingQueue != NULL) return TRUE;
-
-	if (app->signalQueue != NULL) {
-	    SignalEventRec *se_ptr = app->signalQueue;
-	    while (se_ptr != NULL) {
-		if (se_ptr->se_notice)
-		    return TRUE;
-		se_ptr = se_ptr->se_next;
-	    }
-	}
-
-	if (app->input_count > 0) {
-	    /* Call _XtWaitForSomething to get input queued up */
-	    (void) _XtWaitForSomething (app,
-					TRUE, TRUE, FALSE, TRUE,
-					FALSE,
-					TRUE,
-					(unsigned long *)NULL);
-	    if (app->outstandingQueue != NULL) return TRUE;
-	}
-
-	if (app->timerQueue != NULL) {	/* check timeout queue */
-	    X_GETTIMEOFDAY (&cur_time);
-	    FIXUP_TIMEVAL(cur_time);
-	    if (IS_AT_OR_AFTER (app->timerQueue->te_timer_value, cur_time))
-		return TRUE;
-	}
-
-	return FALSE;
+    struct timeval cur_time;
+
+    if (app->outstandingQueue != NULL)
+        return TRUE;
+
+    if (app->signalQueue != NULL) {
+        SignalEventRec *se_ptr = app->signalQueue;
+
+        while (se_ptr != NULL) {
+            if (se_ptr->se_notice)
+                return TRUE;
+            se_ptr = se_ptr->se_next;
+        }
+    }
+
+    if (app->input_count > 0) {
+        /* Call _XtWaitForSomething to get input queued up */
+        (void) _XtWaitForSomething(app,
+                                   TRUE, TRUE, FALSE, TRUE,
+                                   FALSE, TRUE, (unsigned long *) NULL);
+        if (app->outstandingQueue != NULL)
+            return TRUE;
+    }
+
+    if (app->timerQueue != NULL) {      /* check timeout queue */
+        X_GETTIMEOFDAY(&cur_time);
+        FIXUP_TIMEVAL(cur_time);
+        if (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time))
+            return TRUE;
+    }
+
+    return FALSE;
 }
 
-Boolean XtPeekEvent(
-	XEvent *event)
+Boolean
+XtPeekEvent(XEvent *event)
 {
-	return XtAppPeekEvent(_XtDefaultAppContext(), event);
+    return XtAppPeekEvent(_XtDefaultAppContext(), event);
 }
 
 Boolean XtAppPeekEvent_SkipTimer;
 
-Boolean XtAppPeekEvent(
-	XtAppContext app,
-	XEvent *event)
+Boolean
+XtAppPeekEvent(XtAppContext app, XEvent *event)
 {
-	int i, d;
-	Boolean foundCall = FALSE;
-
-	LOCK_APP(app);
-	for (i = 1; i <= app->count; i++) {
-	    d = (i + app->last) % app->count;
-	    if (d == 0) foundCall = PeekOtherSources(app);
-	    if (XEventsQueued(app->list[d], QueuedAfterReading))
-		goto GotEvent;
-	}
-	for (i = 1; i <= app->count; i++) {
-	    d = (i + app->last) % app->count;
-	    if (XEventsQueued(app->list[d], QueuedAfterFlush))
-		goto GotEvent;
-	}
-
-	if (foundCall) {
-	    event->xany.type = 0;
-	    event->xany.display = NULL;
-	    event->xany.window = 0;
-	    UNLOCK_APP(app);
-	    return FALSE;
-	}
-
-	while (1) {
-		d = _XtWaitForSomething (app,
-			FALSE, FALSE, FALSE, FALSE,
-			TRUE,
-			TRUE,
-			(unsigned long *) NULL);
-
-		if (d != -1) {  /* event */
-			GotEvent:
-			XPeekEvent(app->list[d], event);
-			app->last = (short) ((d == 0 ? app->count : d) - 1);
-			UNLOCK_APP(app);
-			return TRUE;
-		}
-		else {  /* input or timer or signal */
-			/*
-			 * Check to see why a -1 was returned, if a timer expired,
-			 * call it and block some more
-			 */
-			if ((app->timerQueue != NULL) && ! XtAppPeekEvent_SkipTimer) {  /* timer */
-				struct timeval cur_time;
-				Bool did_timer = False;
-
-				X_GETTIMEOFDAY (&cur_time);
-				FIXUP_TIMEVAL(cur_time);
-				while (IS_AT_OR_AFTER(app->timerQueue->te_timer_value, cur_time)) {
-					TimerEventRec *te_ptr = app->timerQueue;
-					app->timerQueue = app->timerQueue->te_next;
-					te_ptr->te_next = NULL;
-					if (te_ptr->te_proc != NULL) {
-					    TeCallProc(te_ptr);
-					    did_timer = True;
-					}
-					LOCK_PROCESS;
-					te_ptr->te_next = freeTimerRecs;
-					freeTimerRecs = te_ptr;
-					UNLOCK_PROCESS;
-					if (app->timerQueue == NULL) break;
-				}
-				if (did_timer)
-				{
-				    for (d = 0; d < app->count; d++)
-				    /* the timer's procedure may have caused an event */
-					    if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
-						    goto GotEvent;
-					    }
-				    continue;  /* keep blocking */
-				}
-			}
-			/*
-			 * spec is vague here; we'll assume signals also return FALSE,
-			 * of course to determine whether a signal is pending requires
-			 * walking the signalQueue looking for se_notice flags which
-			 * this code doesn't do.
-			 */
+    int i, d;
+    Boolean foundCall = FALSE;
+
+    LOCK_APP(app);
+    for (i = 1; i <= app->count; i++) {
+        d = (i + app->last) % app->count;
+        if (d == 0)
+            foundCall = PeekOtherSources(app);
+        if (XEventsQueued(app->list[d], QueuedAfterReading))
+            goto GotEvent;
+    }
+    for (i = 1; i <= app->count; i++) {
+        d = (i + app->last) % app->count;
+        if (XEventsQueued(app->list[d], QueuedAfterFlush))
+            goto GotEvent;
+    }
+
+    if (foundCall) {
+        event->xany.type = 0;
+        event->xany.display = NULL;
+
+        event->xany.window = 0;
+        UNLOCK_APP(app);
+        return FALSE;
+    }
+
+    while (1) {
+        d = _XtWaitForSomething(app,
+                                FALSE, FALSE, FALSE, FALSE,
+                                TRUE, TRUE, (unsigned long *) NULL);
+
+        if (d != -1) {          /* event */
+ GotEvent:
+            XPeekEvent(app->list[d], event);
+            app->last = (short) ((d == 0 ? app->count : d) - 1);
+            UNLOCK_APP(app);
+            return TRUE;
+        }
+        else {                  /* input or timer or signal */
+            /*
+             * Check to see why a -1 was returned, if a timer expired,
+             * call it and block some more
+             */
+            if ((app->timerQueue != NULL) && !XtAppPeekEvent_SkipTimer) {       /* timer */
+                struct timeval cur_time;
+                Bool did_timer = False;
+
+                X_GETTIMEOFDAY(&cur_time);
+                FIXUP_TIMEVAL(cur_time);
+                while (IS_AT_OR_AFTER
+                       (app->timerQueue->te_timer_value, cur_time)) {
+                    TimerEventRec *te_ptr = app->timerQueue;
+
+                    app->timerQueue = app->timerQueue->te_next;
+                    te_ptr->te_next = NULL;
+                    if (te_ptr->te_proc != NULL) {
+                        TeCallProc(te_ptr);
+                        did_timer = True;
+                    }
+                    LOCK_PROCESS;
+                    te_ptr->te_next = freeTimerRecs;
+                    freeTimerRecs = te_ptr;
+                    UNLOCK_PROCESS;
+                    if (app->timerQueue == NULL)
+                        break;
+                }
+                if (did_timer) {
+                    for (d = 0; d < app->count; d++)
+                        /* the timer's procedure may have caused an event */
+                        if (XEventsQueued(app->list[d], QueuedAfterFlush)) {
+                            goto GotEvent;
+                        }
+                    continue;   /* keep blocking */
+                }
+            }
+            /*
+             * spec is vague here; we'll assume signals also return FALSE,
+             * of course to determine whether a signal is pending requires
+             * walking the signalQueue looking for se_notice flags which
+             * this code doesn't do.
+             */
 #if 0
-			if (app->signalQueue != NULL) {  /* signal */
-				event->xany.type = 0;
-				event->xany.display = NULL;
-				event->xany.window = 0;
-				UNLOCK_APP(app);
-				return FALSE;
-			}
-			else
+            if (app->signalQueue != NULL) {     /* signal */
+                event->xany.type = 0;
+                event->xany.display = NULL;
+
+                event->xany.window = 0;
+                UNLOCK_APP(app);
+                return FALSE;
+            }
+            else
 #endif
-			{  /* input */
-				event->xany.type = 0;
-				event->xany.display = NULL;
-				event->xany.window = 0;
-				UNLOCK_APP(app);
-				return FALSE;
-			}
-		}
-	} /* end while */
+            {                   /* input */
+                event->xany.type = 0;
+                event->xany.display = NULL;
+
+                event->xany.window = 0;
+                UNLOCK_APP(app);
+                return FALSE;
+            }
+        }
+    }                           /* end while */
 }
diff --git a/src/Object.c b/src/Object.c
index ee1ea6d..843ff7d 100644
--- a/src/Object.c
+++ b/src/Object.c
@@ -74,63 +74,66 @@ in this Software without prior written authorization from The Open Group.
 #include "IntrinsicI.h"
 #include "StringDefs.h"
 
+/* *INDENT-OFF* */
 static XtResource resources[] = {
-        {XtNdestroyCallback, XtCCallback, XtRCallback,sizeof(XtPointer),
-         XtOffsetOf(ObjectRec,object.destroy_callbacks),
-	 XtRCallback, (XtPointer)NULL}
-    };
+    {XtNdestroyCallback, XtCCallback, XtRCallback,sizeof(XtPointer),
+     XtOffsetOf(ObjectRec,object.destroy_callbacks),
+     XtRCallback, (XtPointer)NULL}
+};
+/* *INDENT-ON* */
 
 static void ObjectClassPartInitialize(WidgetClass);
 static Boolean ObjectSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
 static void ObjectDestroy(Widget);
 
+/* *INDENT-OFF* */
 externaldef(objectclassrec) ObjectClassRec objectClassRec = {
   {
-    /* superclass	  */	NULL,
-    /* class_name	  */	"Object",
-    /* widget_size	  */	sizeof(ObjectRec),
-    /* class_initialize   */    NULL,
-    /* class_part_initialize*/	ObjectClassPartInitialize,
-    /* class_inited       */	FALSE,
-    /* initialize	  */	NULL,
-    /* initialize_hook    */	NULL,
-    /* pad                */    NULL,
-    /* pad		  */	NULL,
-    /* pad       	  */	0,
-    /* resources	  */	resources,
-    /* num_resources	  */    XtNumber(resources),
-    /* xrm_class	  */	NULLQUARK,
-    /* pad                */    FALSE,
-    /* pad                */    FALSE,
-    /* pad                */    FALSE,
-    /* pad                */    FALSE,
-    /* destroy		  */	ObjectDestroy,
-    /* pad		  */	NULL,
-    /* pad		  */	NULL,
-    /* set_values	  */	ObjectSetValues,
-    /* set_values_hook    */	NULL,
-    /* pad                */    NULL,
-    /* get_values_hook    */	NULL,
-    /* pad                */    NULL,
-    /* version		  */	XtVersion,
-    /* callback_offsets   */    NULL,
-    /* pad                */    NULL,
-    /* pad                */    NULL,
-    /* pad                */    NULL,
-    /* extension	    */  NULL
-}
+    /* superclass              */ NULL,
+    /* class_name              */ "Object",
+    /* widget_size             */ sizeof(ObjectRec),
+    /* class_initialize        */ NULL,
+    /* class_part_initialize   */ ObjectClassPartInitialize,
+    /* class_inited            */ FALSE,
+    /* initialize              */ NULL,
+    /* initialize_hook         */ NULL,
+    /* pad                     */ NULL,
+    /* pad                     */ NULL,
+    /* pad                     */ 0,
+    /* resources               */ resources,
+    /* num_resources           */ XtNumber(resources),
+    /* xrm_class               */ NULLQUARK,
+    /* pad                     */ FALSE,
+    /* pad                     */ FALSE,
+    /* pad                     */ FALSE,
+    /* pad                     */ FALSE,
+    /* destroy                 */ ObjectDestroy,
+    /* pad                     */ NULL,
+    /* pad                     */ NULL,
+    /* set_values              */ ObjectSetValues,
+    /* set_values_hook         */ NULL,
+    /* pad                     */ NULL,
+    /* get_values_hook         */ NULL,
+    /* pad                     */ NULL,
+    /* version                 */ XtVersion,
+    /* callback_offsets        */ NULL,
+    /* pad                     */ NULL,
+    /* pad                     */ NULL,
+    /* pad                     */ NULL,
+    /* extension               */ NULL
+  }
 };
+/* *INDENT-ON* */
 
-externaldef(objectClass) WidgetClass objectClass
-                          = (WidgetClass)&objectClassRec;
+externaldef(objectClass)
+WidgetClass objectClass = (WidgetClass) &objectClassRec;
 
 /*
  * Start of object routines.
  */
 
-
-static void ConstructCallbackOffsets(
-    WidgetClass myWidgetClass)
+static void
+ConstructCallbackOffsets(WidgetClass myWidgetClass)
 {
     static XrmQuark QCallback = NULLQUARK;
     register int i;
@@ -138,33 +141,35 @@ static void ConstructCallbackOffsets(
     register CallbackTable newTable;
     register CallbackTable superTable;
     register XrmResourceList resourceList;
-    ObjectClass myObjectClass = (ObjectClass)myWidgetClass;
+    ObjectClass myObjectClass = (ObjectClass) myWidgetClass;
 
     /*
-      This function builds an array of pointers to the resource
-      structures which describe the callbacks for this widget class.
-      This array is special in that the 0th entry is the number of
-      callback pointers.
+       This function builds an array of pointers to the resource
+       structures which describe the callbacks for this widget class.
+       This array is special in that the 0th entry is the number of
+       callback pointers.
      */
 
     if (QCallback == NULLQUARK)
-	QCallback = XrmPermStringToQuark(XtRCallback);
+        QCallback = XrmPermStringToQuark(XtRCallback);
 
     if (myObjectClass->object_class.superclass != NULL) {
-	superTable = (CallbackTable)
-	    ((ObjectClass) myObjectClass->object_class.superclass)->
-		object_class.callback_private;
-	tableSize = (int)(long) superTable[0];
-    } else {
-	superTable = (CallbackTable) NULL;
-	tableSize = 0;
+        superTable = (CallbackTable)
+            ((ObjectClass) myObjectClass->object_class.
+             superclass)->object_class.callback_private;
+        tableSize = (int) (long) superTable[0];
+    }
+    else {
+        superTable = (CallbackTable) NULL;
+        tableSize = 0;
     }
 
     /* Count the number of callbacks */
     resourceList = (XrmResourceList) myObjectClass->object_class.resources;
-    for (i = (int) myObjectClass->object_class.num_resources; --i >= 0; resourceList++)
-	if (resourceList->xrm_type == QCallback)
-	    tableSize++;
+    for (i = (int) myObjectClass->object_class.num_resources; --i >= 0;
+         resourceList++)
+        if (resourceList->xrm_type == QCallback)
+            tableSize++;
 
     /*
      * Allocate and load the table.  Make sure that the new callback
@@ -172,91 +177,92 @@ static void ConstructCallbackOffsets(
      * offsets so that resource overrides work.
      */
     newTable = (CallbackTable)
-	__XtMalloc((Cardinal) (sizeof(XrmResource *) * (size_t) (tableSize + 1)));
+        __XtMalloc((Cardinal)
+                   (sizeof(XrmResource *) * (size_t) (tableSize + 1)));
 
-    newTable[0] = (XrmResource *)(long) tableSize;
+    newTable[0] = (XrmResource *) (long) tableSize;
 
     if (superTable)
-	tableSize -= (int)(long) superTable[0];
+        tableSize -= (int) (long) superTable[0];
     resourceList = (XrmResourceList) myObjectClass->object_class.resources;
-    for (i=1; tableSize > 0; resourceList++)
-	if (resourceList->xrm_type == QCallback) {
-	    newTable[i++] = resourceList;
-	    tableSize--;
-	}
+    for (i = 1; tableSize > 0; resourceList++)
+        if (resourceList->xrm_type == QCallback) {
+            newTable[i++] = resourceList;
+            tableSize--;
+        }
 
     if (superTable)
-	for (tableSize = (int)(long) *superTable++;
-	    --tableSize >= 0; superTable++)
-	    newTable[i++] = *superTable;
+        for (tableSize = (int) (long) *superTable++;
+             --tableSize >= 0; superTable++)
+            newTable[i++] = *superTable;
 
     myObjectClass->object_class.callback_private = (XtPointer) newTable;
 }
 
-static void InheritObjectExtensionMethods(
-    WidgetClass widget_class)
+static void
+InheritObjectExtensionMethods(WidgetClass widget_class)
 {
     ObjectClass oc = (ObjectClass) widget_class;
     ObjectClassExtension ext, super_ext = NULL;
 
     ext = (ObjectClassExtension)
-	XtGetClassExtension(widget_class,
-		    XtOffsetOf(ObjectClassRec, object_class.extension),
-			    NULLQUARK, XtObjectExtensionVersion,
-			    sizeof(ObjectClassExtensionRec));
+        XtGetClassExtension(widget_class,
+                            XtOffsetOf(ObjectClassRec, object_class.extension),
+                            NULLQUARK, XtObjectExtensionVersion,
+                            sizeof(ObjectClassExtensionRec));
 
     if (oc->object_class.superclass)
-	super_ext = (ObjectClassExtension)
-	    XtGetClassExtension(oc->object_class.superclass,
-			XtOffsetOf(ObjectClassRec, object_class.extension),
-				NULLQUARK, XtObjectExtensionVersion,
-				sizeof(ObjectClassExtensionRec));
+        super_ext = (ObjectClassExtension)
+            XtGetClassExtension(oc->object_class.superclass,
+                                XtOffsetOf(ObjectClassRec,
+                                           object_class.extension), NULLQUARK,
+                                XtObjectExtensionVersion,
+                                sizeof(ObjectClassExtensionRec));
     LOCK_PROCESS;
     if (ext) {
-	if (ext->allocate == XtInheritAllocate)
-	    ext->allocate = (super_ext ? super_ext->allocate : NULL);
-	if (ext->deallocate == XtInheritDeallocate)
-	    ext->deallocate = (super_ext ? super_ext->deallocate : NULL);
-    } else if (super_ext) {
-	/* Be careful to inherit only what is appropriate */
-	ext = (ObjectClassExtension)
-	    __XtCalloc(1, sizeof(ObjectClassExtensionRec));
-	ext->next_extension = oc->object_class.extension;
-	ext->record_type = NULLQUARK;
-	ext->version = XtObjectExtensionVersion;
-	ext->record_size = sizeof(ObjectClassExtensionRec);
-	ext->allocate = super_ext->allocate;
-	ext->deallocate = super_ext->deallocate;
-	oc->object_class.extension = (XtPointer) ext;
+        if (ext->allocate == XtInheritAllocate)
+            ext->allocate = (super_ext ? super_ext->allocate : NULL);
+        if (ext->deallocate == XtInheritDeallocate)
+            ext->deallocate = (super_ext ? super_ext->deallocate : NULL);
+    }
+    else if (super_ext) {
+        /* Be careful to inherit only what is appropriate */
+        ext = (ObjectClassExtension)
+            __XtCalloc(1, sizeof(ObjectClassExtensionRec));
+        ext->next_extension = oc->object_class.extension;
+        ext->record_type = NULLQUARK;
+        ext->version = XtObjectExtensionVersion;
+        ext->record_size = sizeof(ObjectClassExtensionRec);
+        ext->allocate = super_ext->allocate;
+        ext->deallocate = super_ext->deallocate;
+        oc->object_class.extension = (XtPointer) ext;
     }
     UNLOCK_PROCESS;
 }
 
-static void ObjectClassPartInitialize(
-    register WidgetClass wc)
+static void
+ObjectClassPartInitialize(register WidgetClass wc)
 {
-   ObjectClass oc = (ObjectClass)wc;
+    ObjectClass oc = (ObjectClass) wc;
 
-   oc->object_class.xrm_class =
-       XrmPermStringToQuark(oc->object_class.class_name);
+    oc->object_class.xrm_class =
+        XrmPermStringToQuark(oc->object_class.class_name);
 
-   if (oc->object_class.resources)
-       _XtCompileResourceList(oc->object_class.resources,
-			      oc->object_class.num_resources);
+    if (oc->object_class.resources)
+        _XtCompileResourceList(oc->object_class.resources,
+                               oc->object_class.num_resources);
 
-   ConstructCallbackOffsets(wc);
-   _XtResourceDependencies(wc);
-   InheritObjectExtensionMethods(wc);
+    ConstructCallbackOffsets(wc);
+    _XtResourceDependencies(wc);
+    InheritObjectExtensionMethods(wc);
 }
 
-
-/*ARGSUSED*/
-static Boolean ObjectSetValues(
-    Widget	old,
-    Widget	request,
-    Widget	widget,
-    ArgList	args,
-    Cardinal *	num_args)
+static Boolean
+ObjectSetValues(Widget old,
+                Widget request _X_UNUSED,
+                Widget widget,
+                ArgList args _X_UNUSED,
+                Cardinal *num_args _X_UNUSED)
 {
     CallbackTable offsets;
     int i;
@@ -265,26 +271,26 @@ static Boolean ObjectSetValues(
     /* Compile any callback lists into internal form */
     offsets = (CallbackTable) XtClass(widget)->core_class.callback_private;
 
-    for (i= (int)(long) *(offsets++); --i >= 0; offsets++) {
-	InternalCallbackList *ol, *nl;
-	ol = (InternalCallbackList *)
-	    ((char *) old - (*offsets)->xrm_offset - 1);
-	nl = (InternalCallbackList *)
-	    ((char *) widget - (*offsets)->xrm_offset - 1);
-	if (*ol != *nl) {
-	    if (*ol != NULL)
-		XtFree((char *) *ol);
-	    if (*nl != NULL)
-		*nl = _XtCompileCallbackList((XtCallbackList) *nl);
-	}
+    for (i = (int) (long) *(offsets++); --i >= 0; offsets++) {
+        InternalCallbackList *ol, *nl;
+
+        ol = (InternalCallbackList *)
+            ((char *) old - (*offsets)->xrm_offset - 1);
+        nl = (InternalCallbackList *)
+            ((char *) widget - (*offsets)->xrm_offset - 1);
+        if (*ol != *nl) {
+            if (*ol != NULL)
+                XtFree((char *) *ol);
+            if (*nl != NULL)
+                *nl = _XtCompileCallbackList((XtCallbackList) *nl);
+        }
     }
     UNLOCK_PROCESS;
     return False;
 }
 
-
-static void ObjectDestroy (
-    register Widget    widget)
+static void
+ObjectDestroy(register Widget widget)
 {
     CallbackTable offsets;
     int i;
@@ -292,12 +298,14 @@ static void ObjectDestroy (
     /* Remove all callbacks associated with widget */
     LOCK_PROCESS;
     offsets = (CallbackTable)
-	widget->core.widget_class->core_class.callback_private;
+        widget->core.widget_class->core_class.callback_private;
+
+    for (i = (int) (long) *(offsets++); --i >= 0; offsets++) {
+        InternalCallbackList cl = *(InternalCallbackList *)
+            ((char *) widget - (*offsets)->xrm_offset - 1);
 
-    for (i = (int)(long) *(offsets++); --i >= 0; offsets++) {
-	InternalCallbackList cl = *(InternalCallbackList *)
-	    ((char *) widget - (*offsets)->xrm_offset - 1);
-	if (cl) XtFree((char *) cl);
+        if (cl)
+            XtFree((char *) cl);
     }
     UNLOCK_PROCESS;
-} /* ObjectDestroy */
+}                               /* ObjectDestroy */
diff --git a/src/PassivGrab.c b/src/PassivGrab.c
index 6457a08..9a2d90b 100644
--- a/src/PassivGrab.c
+++ b/src/PassivGrab.c
@@ -91,7 +91,6 @@ in this Software without prior written authorization from The Open Group.
 #define pDisplay(grabPtr) (((grabPtr)->widget)->core.screen->display)
 #define pWindow(grabPtr) (((grabPtr)->widget)->core.window)
 
-
 /***************************************************************************/
 /*********************** Internal Support Routines *************************/
 /***************************************************************************/
@@ -101,108 +100,106 @@ in this Software without prior written authorization from The Open Group.
  * with the detail.
  */
 
-static void DeleteDetailFromMask(
-    Mask **ppDetailMask,
-    unsigned short detail)
+static void
+DeleteDetailFromMask(Mask **ppDetailMask, unsigned short detail)
 {
     Mask *pDetailMask = *ppDetailMask;
 
     if (!pDetailMask) {
-	int i;
-	pDetailMask = (Mask *)__XtMalloc(sizeof(Mask) * MasksPerDetailMask);
-	for (i = MasksPerDetailMask; --i >= 0; )
-	    pDetailMask[i] = (unsigned long) (~0);
-	*ppDetailMask = pDetailMask;
+        int i;
+
+        pDetailMask = (Mask *) __XtMalloc(sizeof(Mask) * MasksPerDetailMask);
+        for (i = MasksPerDetailMask; --i >= 0;)
+            pDetailMask[i] = (unsigned long) (~0);
+        *ppDetailMask = pDetailMask;
     }
     BITCLEAR((pDetailMask), detail);
 }
 
-
 /*
  * Make an exact copy of the specified detail mask.
  */
 
-static Mask *CopyDetailMask(
-    Mask *pOriginalDetailMask)
+static Mask *
+CopyDetailMask(Mask *pOriginalDetailMask)
 {
     Mask *pTempMask;
     int i;
 
     if (!pOriginalDetailMask)
-	return NULL;
+        return NULL;
 
-    pTempMask = (Mask *)__XtMalloc(sizeof(Mask) * MasksPerDetailMask);
+    pTempMask = (Mask *) __XtMalloc(sizeof(Mask) * MasksPerDetailMask);
 
-    for ( i = 0; i < MasksPerDetailMask; i++)
-      pTempMask[i]= pOriginalDetailMask[i];
+    for (i = 0; i < MasksPerDetailMask; i++)
+        pTempMask[i] = pOriginalDetailMask[i];
 
     return pTempMask;
 }
 
-
 /*
  * Allocate a new grab entry, and fill in all of the fields using the
  * specified parameters.
  */
 
-static XtServerGrabPtr CreateGrab(
-    Widget	widget,
-    Boolean	ownerEvents,
-    Modifiers	modifiers,
-    KeyCode 	keybut,
-    int		pointer_mode,
-    int		keyboard_mode,
-    Mask	event_mask,
-    Window 	confine_to,
-    Cursor 	cursor,
-    Boolean	need_ext)
+static XtServerGrabPtr
+CreateGrab(Widget widget,
+           Boolean ownerEvents,
+           Modifiers modifiers,
+           KeyCode keybut,
+           int pointer_mode,
+           int keyboard_mode,
+           Mask event_mask,
+           Window confine_to,
+           Cursor cursor,
+           Boolean need_ext)
 {
     XtServerGrabPtr grab;
 
     if (confine_to || cursor)
-	need_ext = True;
-    grab = (XtServerGrabPtr)__XtMalloc(sizeof(XtServerGrabRec) +
-				     (need_ext ? sizeof(XtServerGrabExtRec)
-				      : 0));
+        need_ext = True;
+    grab = (XtServerGrabPtr) __XtMalloc(sizeof(XtServerGrabRec) +
+                                        (need_ext ? sizeof(XtServerGrabExtRec)
+                                         : 0));
     grab->next = NULL;
     grab->widget = widget;
     XtSetBit(grab->ownerEvents, ownerEvents);
     XtSetBit(grab->pointerMode, pointer_mode);
     XtSetBit(grab->keyboardMode, keyboard_mode);
-    grab->eventMask = (unsigned short)event_mask;
+    grab->eventMask = (unsigned short) event_mask;
     XtSetBit(grab->hasExt, need_ext);
-    grab->confineToIsWidgetWin = (XtWindow (widget) == confine_to);
+    grab->confineToIsWidgetWin = (XtWindow(widget) == confine_to);
     grab->modifiers = (unsigned short) modifiers;
     grab->keybut = keybut;
     if (need_ext) {
-	XtServerGrabExtPtr ext = GRABEXT(grab);
-	ext->pModifiersMask = NULL;
-	ext->pKeyButMask = NULL;
-	ext->confineTo = confine_to;
-	ext->cursor = cursor;
+        XtServerGrabExtPtr ext = GRABEXT(grab);
+
+        ext->pModifiersMask = NULL;
+        ext->pKeyButMask = NULL;
+        ext->confineTo = confine_to;
+        ext->cursor = cursor;
     }
     return grab;
 }
 
-
 /*
  * Free up the space occupied by a grab entry.
  */
 
-static void FreeGrab(
-    XtServerGrabPtr pGrab)
+static void
+FreeGrab(XtServerGrabPtr pGrab)
 {
     if (pGrab->hasExt) {
 	XtServerGrabExtPtr ext = GRABEXT(pGrab);
 	XtFree((char *)ext->pModifiersMask);
 	XtFree((char *)ext->pKeyButMask);
     }
-    XtFree((char *)pGrab);
+    XtFree((char *) pGrab);
 }
 
 typedef struct _DetailRec {
-    unsigned short 	exact;
-    Mask  		*pMask;
+    unsigned short exact;
+    Mask *pMask;
 } DetailRec, *DetailPtr;
 
 /*
@@ -210,47 +207,45 @@ typedef struct _DetailRec {
  * is contained in the mask of the first, then TRUE is returned.
  */
 
-static Bool IsInGrabMask(
-    register DetailPtr firstDetail,
-    register DetailPtr secondDetail,
-    unsigned short exception)
+static Bool
+IsInGrabMask(register DetailPtr firstDetail,
+             register DetailPtr secondDetail,
+             unsigned short exception)
 {
     if (firstDetail->exact == exception) {
-	if (!firstDetail->pMask)
-	    return TRUE;
+        if (!firstDetail->pMask)
+            return TRUE;
 
-	/* (at present) never called with two non-null pMasks */
-	if (secondDetail->exact == exception)
-	    return FALSE;
+        /* (at present) never called with two non-null pMasks */
+        if (secondDetail->exact == exception)
+            return FALSE;
 
-	if (GETBIT(firstDetail->pMask, secondDetail->exact))
-	    return TRUE;
+        if (GETBIT(firstDetail->pMask, secondDetail->exact))
+            return TRUE;
     }
 
     return FALSE;
 }
 
-
 /*
  * If neither of the details is set to 'exception', and they match
  * exactly, then TRUE is returned.
  */
 
-static Bool IdenticalExactDetails(
-    unsigned short firstExact,
-    unsigned short secondExact,
-    unsigned short exception)
+static Bool
+IdenticalExactDetails(unsigned short firstExact,
+                      unsigned short secondExact,
+                      unsigned short exception)
 {
     if ((firstExact == exception) || (secondExact == exception))
-	return FALSE;
+        return FALSE;
 
     if (firstExact == secondExact)
-	return TRUE;
+        return TRUE;
 
     return FALSE;
 }
 
-
 /*
  * If the first detail is set to 'exception', and its mask has the bit
  * enabled which corresponds to the second detail, OR if neither of the
@@ -258,63 +253,61 @@ static Bool IdenticalExactDetails(
  * TRUE is returned.
  */
 
-static Bool DetailSupersedesSecond(
-    register DetailPtr firstDetail,
-    register DetailPtr secondDetail,
-    unsigned short exception)
+static Bool
+DetailSupersedesSecond(register DetailPtr firstDetail,
+                       register DetailPtr secondDetail,
+                       unsigned short exception)
 {
     if (IsInGrabMask(firstDetail, secondDetail, exception))
-	return TRUE;
+        return TRUE;
 
     if (IdenticalExactDetails(firstDetail->exact, secondDetail->exact,
-			      exception))
-	return TRUE;
+                              exception))
+        return TRUE;
 
     return FALSE;
 }
 
-
 /*
  * If the two grab events match exactly, or if the first grab entry
  * 'encompasses' the second grab entry, then TRUE is returned.
  */
 
-static Bool GrabSupersedesSecond(
-    register XtServerGrabPtr pFirstGrab,
-    register XtServerGrabPtr pSecondGrab)
+static Bool
+GrabSupersedesSecond(register XtServerGrabPtr pFirstGrab,
+                     register XtServerGrabPtr pSecondGrab)
 {
     DetailRec first, second;
 
     first.exact = pFirstGrab->modifiers;
     if (pFirstGrab->hasExt)
-	first.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
+        first.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
     else
-	first.pMask = NULL;
+        first.pMask = NULL;
     second.exact = pSecondGrab->modifiers;
     if (pSecondGrab->hasExt)
-	second.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
+        second.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
     else
-	second.pMask = NULL;
-    if (!DetailSupersedesSecond(&first, &second, (unsigned short)AnyModifier))
-      return FALSE;
+        second.pMask = NULL;
+    if (!DetailSupersedesSecond(&first, &second, (unsigned short) AnyModifier))
+        return FALSE;
 
     first.exact = pFirstGrab->keybut;
     if (pFirstGrab->hasExt)
-	first.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
+        first.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
     else
-	first.pMask = NULL;
+        first.pMask = NULL;
     second.exact = pSecondGrab->keybut;
     if (pSecondGrab->hasExt)
-	second.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
+        second.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
     else
-	second.pMask = NULL;
-    if (DetailSupersedesSecond(&first, &second, (unsigned short)AnyKey))
-      return TRUE;
+        second.pMask = NULL;
+    if (DetailSupersedesSecond(&first, &second, (unsigned short) AnyKey))
+        return TRUE;
 
     return FALSE;
 }
 
-
 /*
  * Two grabs are considered to be matching if either of the following are true:
  *
@@ -327,197 +320,197 @@ static Bool GrabSupersedesSecond(
  *    for the other entry encompasses the first.
  */
 
-static Bool GrabMatchesSecond(
-    register XtServerGrabPtr pFirstGrab,
-    register XtServerGrabPtr pSecondGrab)
+static Bool
+GrabMatchesSecond(register XtServerGrabPtr pFirstGrab,
+                  register XtServerGrabPtr pSecondGrab)
 {
     DetailRec firstD, firstM, secondD, secondM;
 
     if (pDisplay(pFirstGrab) != pDisplay(pSecondGrab))
-	return FALSE;
+        return FALSE;
 
     if (GrabSupersedesSecond(pFirstGrab, pSecondGrab))
-	return TRUE;
+        return TRUE;
 
     if (GrabSupersedesSecond(pSecondGrab, pFirstGrab))
-	return TRUE;
+        return TRUE;
 
     firstD.exact = pFirstGrab->keybut;
     firstM.exact = pFirstGrab->modifiers;
     if (pFirstGrab->hasExt) {
-	firstD.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
-	firstM.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
-    } else {
-	firstD.pMask = NULL;
-	firstM.pMask = NULL;
+        firstD.pMask = GRABEXT(pFirstGrab)->pKeyButMask;
+        firstM.pMask = GRABEXT(pFirstGrab)->pModifiersMask;
+    }
+    else {
+        firstD.pMask = NULL;
+        firstM.pMask = NULL;
     }
     secondD.exact = pSecondGrab->keybut;
     secondM.exact = pSecondGrab->modifiers;
     if (pSecondGrab->hasExt) {
-	secondD.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
-	secondM.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
-    } else {
-	secondD.pMask = NULL;
-	secondM.pMask = NULL;
+        secondD.pMask = GRABEXT(pSecondGrab)->pKeyButMask;
+        secondM.pMask = GRABEXT(pSecondGrab)->pModifiersMask;
+    }
+    else {
+        secondD.pMask = NULL;
+        secondM.pMask = NULL;
     }
 
-    if (DetailSupersedesSecond(&secondD, &firstD, (unsigned short)AnyKey) &&
-	DetailSupersedesSecond(&firstM, &secondM, (unsigned short)AnyModifier))
-	return TRUE;
+    if (DetailSupersedesSecond(&secondD, &firstD, (unsigned short) AnyKey) &&
+        DetailSupersedesSecond(&firstM, &secondM, (unsigned short) AnyModifier))
+        return TRUE;
 
-    if (DetailSupersedesSecond(&firstD, &secondD, (unsigned short)AnyKey) &&
-	DetailSupersedesSecond(&secondM, &firstM, (unsigned short)AnyModifier))
-	return TRUE;
+    if (DetailSupersedesSecond(&firstD, &secondD, (unsigned short) AnyKey) &&
+        DetailSupersedesSecond(&secondM, &firstM, (unsigned short) AnyModifier))
+        return TRUE;
 
     return FALSE;
 }
 
-
 /*
  * Delete a grab combination from the passive grab list.  Each entry will
  * be checked to see if it is affected by the grab being deleted.  This
  * may result in multiple entries being modified/deleted.
  */
 
-static void DeleteServerGrabFromList(
-    XtServerGrabPtr 	*passiveListPtr,
-    XtServerGrabPtr 	pMinuendGrab)
+static void
+DeleteServerGrabFromList(XtServerGrabPtr *passiveListPtr,
+                         XtServerGrabPtr pMinuendGrab)
 {
     register XtServerGrabPtr *next;
     register XtServerGrabPtr grab;
     register XtServerGrabExtPtr ext;
 
-    for (next = passiveListPtr; (grab = *next); )
-    {
-	if (GrabMatchesSecond(grab, pMinuendGrab) &&
-	    (pDisplay(grab) == pDisplay(pMinuendGrab)))
-	{
-	    if (GrabSupersedesSecond(pMinuendGrab, grab))
-	    {
-		/*
-		 * The entry being deleted encompasses the list entry,
-		 * so delete the list entry.
-		 */
-		*next = grab->next;
-		FreeGrab(grab);
-		continue;
-	    }
-
-	    if (!grab->hasExt) {
-		grab = (XtServerGrabPtr)
-		    XtRealloc((char *)grab, (sizeof(XtServerGrabRec) +
-					     sizeof(XtServerGrabExtRec)));
-		*next = grab;
-		grab->hasExt = True;
-		ext = GRABEXT(grab);
-		ext->pKeyButMask = NULL;
-		ext->pModifiersMask = NULL;
-		ext->confineTo = None;
-		ext->cursor = None;
-	    } else
-		ext = GRABEXT(grab);
-	    if ((grab->keybut == AnyKey) && (grab->modifiers != AnyModifier))
-	    {
-		/*
-		 * If the list entry has the key detail of AnyKey, and
-		 * a modifier detail not set to AnyModifier, then we
-		 * simply need to turn off the key detail bit in the
-		 * list entry's key detail mask.
-		 */
-		DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
-	    } else if ((grab->modifiers == AnyModifier) &&
-		       (grab->keybut != AnyKey)) {
-		/*
-		 * The list entry has a specific key detail, but its
-		 * modifier detail is set to AnyModifier; so, we only
-		 * need to turn off the specified modifier combination
-		 * in the list entry's modifier mask.
-		 */
-		DeleteDetailFromMask(&ext->pModifiersMask,
-				     pMinuendGrab->modifiers);
-	    } else if ((pMinuendGrab->keybut != AnyKey) &&
-		       (pMinuendGrab->modifiers != AnyModifier)) {
-		/*
-		 * The list entry has a key detail of AnyKey and a
-		 * modifier detail of AnyModifier; the entry being
-		 * deleted has a specific key and a specific modifier
-		 * combination.  Therefore, we need to mask off the
-		 * keycode from the list entry, and also create a
-		 * new entry for this keycode, which has a modifier
-		 * mask set to AnyModifier & ~(deleted modifiers).
-		 */
-		XtServerGrabPtr pNewGrab;
-
-		DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
-		pNewGrab = CreateGrab(grab->widget,
-				      (Boolean)grab->ownerEvents,
-				      (Modifiers)AnyModifier,
-				      pMinuendGrab->keybut,
-				      (int)grab->pointerMode,
-				      (int)grab->keyboardMode,
-				      (Mask)0, (Window)0, (Cursor)0, True);
-		GRABEXT(pNewGrab)->pModifiersMask =
-		    CopyDetailMask(ext->pModifiersMask);
-
-		DeleteDetailFromMask(&GRABEXT(pNewGrab)->pModifiersMask,
-				     pMinuendGrab->modifiers);
-
-		pNewGrab->next = *passiveListPtr;
-		*passiveListPtr = pNewGrab;
-	    } else if (pMinuendGrab->keybut == AnyKey) {
-		/*
-		 * The list entry has keycode AnyKey and modifier
-		 * AnyModifier; the entry being deleted has
-		 * keycode AnyKey and specific modifiers.  So we
-		 * simply need to mask off the specified modifier
-		 * combination.
-		 */
-		DeleteDetailFromMask(&ext->pModifiersMask,
-				     pMinuendGrab->modifiers);
-	    } else {
-		/*
-		 * The list entry has keycode AnyKey and modifier
-		 * AnyModifier; the entry being deleted has a
-		 * specific keycode and modifier AnyModifier.  So
-		 * we simply need to mask off the specified
-		 * keycode.
-		 */
-		DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
-	    }
-	}
-	next = &(*next)->next;
+    for (next = passiveListPtr; (grab = *next);) {
+        if (GrabMatchesSecond(grab, pMinuendGrab) &&
+            (pDisplay(grab) == pDisplay(pMinuendGrab))) {
+            if (GrabSupersedesSecond(pMinuendGrab, grab)) {
+                /*
+                 * The entry being deleted encompasses the list entry,
+                 * so delete the list entry.
+                 */
+                *next = grab->next;
+                FreeGrab(grab);
+                continue;
+            }
+
+            if (!grab->hasExt) {
+                grab = (XtServerGrabPtr)
+                    XtRealloc((char *) grab, (sizeof(XtServerGrabRec) +
+                                              sizeof(XtServerGrabExtRec)));
+                *next = grab;
+                grab->hasExt = True;
+                ext = GRABEXT(grab);
+                ext->pKeyButMask = NULL;
+                ext->pModifiersMask = NULL;
+                ext->confineTo = None;
+                ext->cursor = None;
+            }
+            else
+                ext = GRABEXT(grab);
+            if ((grab->keybut == AnyKey) && (grab->modifiers != AnyModifier)) {
+                /*
+                 * If the list entry has the key detail of AnyKey, and
+                 * a modifier detail not set to AnyModifier, then we
+                 * simply need to turn off the key detail bit in the
+                 * list entry's key detail mask.
+                 */
+                DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
+            }
+            else if ((grab->modifiers == AnyModifier) &&
+                     (grab->keybut != AnyKey)) {
+                /*
+                 * The list entry has a specific key detail, but its
+                 * modifier detail is set to AnyModifier; so, we only
+                 * need to turn off the specified modifier combination
+                 * in the list entry's modifier mask.
+                 */
+                DeleteDetailFromMask(&ext->pModifiersMask,
+                                     pMinuendGrab->modifiers);
+            }
+            else if ((pMinuendGrab->keybut != AnyKey) &&
+                     (pMinuendGrab->modifiers != AnyModifier)) {
+                /*
+                 * The list entry has a key detail of AnyKey and a
+                 * modifier detail of AnyModifier; the entry being
+                 * deleted has a specific key and a specific modifier
+                 * combination.  Therefore, we need to mask off the
+                 * keycode from the list entry, and also create a
+                 * new entry for this keycode, which has a modifier
+                 * mask set to AnyModifier & ~(deleted modifiers).
+                 */
+                XtServerGrabPtr pNewGrab;
+
+                DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
+                pNewGrab = CreateGrab(grab->widget,
+                                      (Boolean) grab->ownerEvents,
+                                      (Modifiers) AnyModifier,
+                                      pMinuendGrab->keybut,
+                                      (int) grab->pointerMode,
+                                      (int) grab->keyboardMode,
+                                      (Mask) 0, (Window) 0, (Cursor) 0, True);
+                GRABEXT(pNewGrab)->pModifiersMask =
+                    CopyDetailMask(ext->pModifiersMask);
+
+                DeleteDetailFromMask(&GRABEXT(pNewGrab)->pModifiersMask,
+                                     pMinuendGrab->modifiers);
+
+                pNewGrab->next = *passiveListPtr;
+                *passiveListPtr = pNewGrab;
+            }
+            else if (pMinuendGrab->keybut == AnyKey) {
+                /*
+                 * The list entry has keycode AnyKey and modifier
+                 * AnyModifier; the entry being deleted has
+                 * keycode AnyKey and specific modifiers.  So we
+                 * simply need to mask off the specified modifier
+                 * combination.
+                 */
+                DeleteDetailFromMask(&ext->pModifiersMask,
+                                     pMinuendGrab->modifiers);
+            }
+            else {
+                /*
+                 * The list entry has keycode AnyKey and modifier
+                 * AnyModifier; the entry being deleted has a
+                 * specific keycode and modifier AnyModifier.  So
+                 * we simply need to mask off the specified
+                 * keycode.
+                 */
+                DeleteDetailFromMask(&ext->pKeyButMask, pMinuendGrab->keybut);
+            }
+        }
+        next = &(*next)->next;
     }
 }
 
-static void DestroyPassiveList(
-    XtServerGrabPtr	*passiveListPtr)
+static void
+DestroyPassiveList(XtServerGrabPtr *passiveListPtr)
 {
-    XtServerGrabPtr	next, grab;
+    XtServerGrabPtr next, grab;
 
-    for (next = *passiveListPtr; next; ) {
-	grab = next;
-	next = grab->next;
+    for (next = *passiveListPtr; next;) {
+        grab = next;
+        next = grab->next;
 
-	/* not necessary to explicitly ungrab key or button;
-	 * window is being destroyed so server will take care of it.
-	 */
+        /* not necessary to explicitly ungrab key or button;
+         * window is being destroyed so server will take care of it.
+         */
 
-	FreeGrab(grab);
+        FreeGrab(grab);
     }
 }
 
-
 /*
  * This function is called at widget destroy time to clean up
  */
-/*ARGSUSED*/
-void _XtDestroyServerGrabs(
-    Widget		w,
-    XtPointer		closure,
-    XtPointer		call_data) /* unused */
+void
+_XtDestroyServerGrabs(Widget w,
+                      XtPointer closure,
+                      XtPointer call_data _X_UNUSED)
 {
-    XtPerWidgetInput	pwi = (XtPerWidgetInput)closure;
-    XtPerDisplayInput	pdi;
+    XtPerWidgetInput pwi = (XtPerWidgetInput) closure;
+    XtPerDisplayInput pdi;
 
     LOCK_PROCESS;
     pdi = _XtGetPerDisplayInput(XtDisplay(w));
@@ -526,13 +519,13 @@ void _XtDestroyServerGrabs(
 
     /* Remove the active grab, if necessary */
     if ((pdi->keyboard.grabType != XtNoServerGrab) &&
-	(pdi->keyboard.grab.widget == w)) {
-	pdi->keyboard.grabType = XtNoServerGrab;
-	pdi->activatingKey = (KeyCode)0;
+        (pdi->keyboard.grab.widget == w)) {
+        pdi->keyboard.grabType = XtNoServerGrab;
+        pdi->activatingKey = (KeyCode) 0;
     }
     if ((pdi->pointer.grabType != XtNoServerGrab) &&
-	(pdi->pointer.grab.widget == w))
-	pdi->pointer.grabType = XtNoServerGrab;
+        (pdi->pointer.grab.widget == w))
+        pdi->pointer.grabType = XtNoServerGrab;
 
     DestroyPassiveList(&pwi->keyList);
     DestroyPassiveList(&pwi->ptrList);
@@ -545,46 +538,44 @@ void _XtDestroyServerGrabs(
  * the grab.  The grab will remain in effect until the key is released.
  */
 
-XtServerGrabPtr _XtCheckServerGrabsOnWidget (
-    XEvent 		*event,
-    Widget		widget,
-    _XtBoolean		isKeyboard)
+XtServerGrabPtr
+_XtCheckServerGrabsOnWidget(XEvent *event, Widget widget, _XtBoolean isKeyboard)
 {
     register XtServerGrabPtr grab;
-    XtServerGrabRec 	tempGrab;
-    XtServerGrabPtr	*passiveListPtr;
-    XtPerWidgetInput	pwi;
+    XtServerGrabRec tempGrab;
+    XtServerGrabPtr *passiveListPtr;
+    XtPerWidgetInput pwi;
 
     LOCK_PROCESS;
     pwi = _XtGetPerWidgetInput(widget, FALSE);
     UNLOCK_PROCESS;
     if (!pwi)
-	return (XtServerGrabPtr)NULL;
+        return (XtServerGrabPtr) NULL;
     if (isKeyboard)
-	passiveListPtr = &pwi->keyList;
+        passiveListPtr = &pwi->keyList;
     else
-	passiveListPtr = &pwi->ptrList;
+        passiveListPtr = &pwi->ptrList;
 
     /*
      * if either there is no entry in the context manager or the entry
      * is empty, or the keyboard is grabed, then no work to be done
      */
     if (!*passiveListPtr)
-	return (XtServerGrabPtr)NULL;
+        return (XtServerGrabPtr) NULL;
 
     /* Take only the lower thirteen bits as modifier state.  The X Keyboard
      * Extension may be representing keyboard group state in two upper bits.
      */
     tempGrab.widget = widget;
-    tempGrab.keybut = (KeyCode) event->xkey.keycode; /* also xbutton.button */
-    tempGrab.modifiers = event->xkey.state & 0x1FFF; /*also xbutton.state*/
+    tempGrab.keybut = (KeyCode) event->xkey.keycode;    /* also xbutton.button */
+    tempGrab.modifiers = event->xkey.state & 0x1FFF;    /*also xbutton.state */
     tempGrab.hasExt = False;
 
     for (grab = *passiveListPtr; grab; grab = grab->next) {
-	if (GrabMatchesSecond(&tempGrab, grab))
-	    return (grab);
+        if (GrabMatchesSecond(&tempGrab, grab))
+            return (grab);
     }
-    return (XtServerGrabPtr)NULL;
+    return (XtServerGrabPtr) NULL;
 }
 
 /*
@@ -592,54 +583,52 @@ XtServerGrabPtr _XtCheckServerGrabsOnWidget (
  * button grabs for widgets that haven't selected for button release.
  */
 
-/*ARGSUSED*/
-static void  ActiveHandler (
-    Widget 		widget,
-    XtPointer		pdi,
-    XEvent 		*event,
-    Boolean		*cont)
+static void
+ActiveHandler(Widget widget _X_UNUSED,
+              XtPointer pdi _X_UNUSED,
+              XEvent *event _X_UNUSED,
+              Boolean *cont _X_UNUSED)
 {
     /* nothing */
 }
 
-
 /*
- *	MakeGrab
+ *      MakeGrab
  */
-static void  MakeGrab(
-    XtServerGrabPtr	grab,
-    XtServerGrabPtr	*passiveListPtr,
-    Boolean		isKeyboard,
-    XtPerDisplayInput	pdi,
-    XtPerWidgetInput	pwi)
+static void
+MakeGrab(XtServerGrabPtr grab,
+         XtServerGrabPtr *passiveListPtr,
+         Boolean isKeyboard,
+         XtPerDisplayInput pdi,
+         XtPerWidgetInput pwi)
 {
     if (!isKeyboard && !pwi->active_handler_added) {
-	XtAddEventHandler(grab->widget, ButtonReleaseMask, FALSE,
-			  ActiveHandler, (XtPointer)pdi);
-	pwi->active_handler_added = TRUE;
+        XtAddEventHandler(grab->widget, ButtonReleaseMask, FALSE,
+                          ActiveHandler, (XtPointer) pdi);
+        pwi->active_handler_added = TRUE;
     }
 
     if (isKeyboard) {
-	XGrabKey(pDisplay(grab),
-		 grab->keybut, grab->modifiers,
-		 pWindow(grab), grab->ownerEvents,
-		 grab->pointerMode, grab->keyboardMode);
-    } else {
-	Window confineTo = None;
-	Cursor cursor = None;
-
-	if (grab->hasExt) {
-	    if (grab->confineToIsWidgetWin)
-		confineTo = XtWindow (grab->widget);
-	    else
-		confineTo = GRABEXT(grab)->confineTo;
-	    cursor = GRABEXT(grab)->cursor;
-	}
-	XGrabButton(pDisplay(grab),
-		    grab->keybut, grab->modifiers,
-		    pWindow(grab), grab->ownerEvents, grab->eventMask,
-		    grab->pointerMode, grab->keyboardMode,
-		    confineTo, cursor);
+        XGrabKey(pDisplay(grab),
+                 grab->keybut, grab->modifiers,
+                 pWindow(grab), grab->ownerEvents,
+                 grab->pointerMode, grab->keyboardMode);
+    }
+    else {
+        Window confineTo = None;
+        Cursor cursor = None;
+
+        if (grab->hasExt) {
+            if (grab->confineToIsWidgetWin)
+                confineTo = XtWindow(grab->widget);
+            else
+                confineTo = GRABEXT(grab)->confineTo;
+            cursor = GRABEXT(grab)->cursor;
+        }
+        XGrabButton(pDisplay(grab),
+                    grab->keybut, grab->modifiers,
+                    pWindow(grab), grab->ownerEvents, grab->eventMask,
+                    grab->pointerMode, grab->keyboardMode, confineTo, cursor);
     }
 
     /* Add the new grab entry to the passive key grab list */
@@ -647,12 +636,13 @@ static void  MakeGrab(
     *passiveListPtr = grab;
 }
 
-static void MakeGrabs(
-    XtServerGrabPtr	*passiveListPtr,
-    Boolean		isKeyboard,
-    XtPerDisplayInput	pdi)
+static void
+MakeGrabs(XtServerGrabPtr *passiveListPtr,
+          Boolean isKeyboard,
+          XtPerDisplayInput pdi)
 {
-    XtServerGrabPtr	next = *passiveListPtr;
+    XtServerGrabPtr next = *passiveListPtr;
+
     /*
      * make MakeGrab build a new list that has had the merge
      * processing done on it. Start with an empty list
@@ -660,16 +650,15 @@ static void MakeGrabs(
      */
     LOCK_PROCESS;
     *passiveListPtr = NULL;
-    while (next)
-      {
-	  XtServerGrabPtr grab;
-	  XtPerWidgetInput pwi;
-
-	  grab = next;
-	  next = grab->next;
-	  pwi = _XtGetPerWidgetInput(grab->widget, FALSE);
-	  MakeGrab(grab, passiveListPtr, isKeyboard, pdi, pwi);
-      }
+    while (next) {
+        XtServerGrabPtr grab;
+        XtPerWidgetInput pwi;
+
+        grab = next;
+        next = grab->next;
+        pwi = _XtGetPerWidgetInput(grab->widget, FALSE);
+        MakeGrab(grab, passiveListPtr, isKeyboard, pdi, pwi);
+    }
     UNLOCK_PROCESS;
 }
 
@@ -680,15 +669,14 @@ static void MakeGrabs(
  * needed grabs.
  */
 
-/*ARGSUSED*/
-static void  RealizeHandler (
-    Widget 		widget,
-    XtPointer		closure,
-    XEvent 		*event,	/* unused */
-    Boolean		*cont)	/* unused */
+static void
+RealizeHandler(Widget widget,
+               XtPointer closure,
+               XEvent *event _X_UNUSED,
+               Boolean *cont _X_UNUSED)
 {
-    XtPerWidgetInput	pwi = (XtPerWidgetInput)closure;
-    XtPerDisplayInput	pdi;
+    XtPerWidgetInput pwi = (XtPerWidgetInput) closure;
+    XtPerDisplayInput pdi;
 
     LOCK_PROCESS;
     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
@@ -697,7 +685,7 @@ static void  RealizeHandler (
     MakeGrabs(&pwi->ptrList, POINTER, pdi);
 
     XtRemoveEventHandler(widget, XtAllEvents, True,
-			 RealizeHandler, (XtPointer)pwi);
+                         RealizeHandler, (XtPointer) pwi);
     pwi->realize_handler_added = FALSE;
 }
 
@@ -705,43 +693,40 @@ static void  RealizeHandler (
 /**************************** Global Routines ******************************/
 /***************************************************************************/
 
-
 /*
  * Routine used by an application to set up a passive grab for a key/modifier
  * combination.
  */
 
-static
-void GrabKeyOrButton (
-    Widget	widget,
-    KeyCode	keyOrButton,
-    Modifiers	modifiers,
-    Boolean	owner_events,
-    int 	pointer_mode,
-    int 	keyboard_mode,
-    Mask	event_mask,
-    Window 	confine_to,
-    Cursor 	cursor,
-    Boolean	isKeyboard)
+static void
+GrabKeyOrButton(Widget widget,
+                KeyCode keyOrButton,
+                Modifiers modifiers,
+                Boolean owner_events,
+                int pointer_mode,
+                int keyboard_mode,
+                Mask event_mask,
+                Window confine_to,
+                Cursor cursor,
+                Boolean isKeyboard)
 {
-    XtServerGrabPtr	*passiveListPtr;
-    XtServerGrabPtr 	newGrab;
-    XtPerWidgetInput	pwi;
-    XtPerDisplayInput	pdi;
-
+    XtServerGrabPtr *passiveListPtr;
+    XtServerGrabPtr newGrab;
+    XtPerWidgetInput pwi;
+    XtPerDisplayInput pdi;
 
     XtCheckSubclass(widget, coreWidgetClass, "in XtGrabKey or XtGrabButton");
     LOCK_PROCESS;
     pwi = _XtGetPerWidgetInput(widget, TRUE);
     if (isKeyboard)
-      passiveListPtr = &pwi->keyList;
+        passiveListPtr = &pwi->keyList;
     else
-      passiveListPtr = &pwi->ptrList;
+        passiveListPtr = &pwi->ptrList;
     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
     UNLOCK_PROCESS;
     newGrab = CreateGrab(widget, owner_events, modifiers,
-			 keyOrButton, pointer_mode, keyboard_mode,
-			 event_mask, confine_to, cursor, False);
+                         keyOrButton, pointer_mode, keyboard_mode,
+                         event_mask, confine_to, cursor, False);
     /*
      *  if the widget is realized then process the entry into the grab
      * list. else if the list is empty (i.e. first time) then add the
@@ -749,35 +734,31 @@ void GrabKeyOrButton (
      * in the handler at realize time.
      */
     if (XtIsRealized(widget))
-      MakeGrab(newGrab, passiveListPtr, isKeyboard, pdi, pwi);
+        MakeGrab(newGrab, passiveListPtr, isKeyboard, pdi, pwi);
     else {
-	if (!pwi->realize_handler_added)
-	    {
-		XtAddEventHandler(widget, StructureNotifyMask, FALSE,
-				  RealizeHandler,
-				  (XtPointer)pwi);
-		pwi->realize_handler_added = TRUE;
-	    }
-
-	while (*passiveListPtr)
-	    passiveListPtr = &(*passiveListPtr)->next;
-	*passiveListPtr = newGrab;
+        if (!pwi->realize_handler_added) {
+            XtAddEventHandler(widget, StructureNotifyMask, FALSE,
+                              RealizeHandler, (XtPointer) pwi);
+            pwi->realize_handler_added = TRUE;
+        }
+
+        while (*passiveListPtr)
+            passiveListPtr = &(*passiveListPtr)->next;
+        *passiveListPtr = newGrab;
     }
 }
 
-
-static
-void   UngrabKeyOrButton (
-    Widget	widget,
-    int		keyOrButton,
-    Modifiers	modifiers,
-    Boolean	isKeyboard)
+static void
+UngrabKeyOrButton(Widget widget,
+                  int keyOrButton,
+                  Modifiers modifiers,
+                  Boolean isKeyboard)
 {
-    XtServerGrabRec 	tempGrab;
-    XtPerWidgetInput	pwi;
+    XtServerGrabRec tempGrab;
+    XtPerWidgetInput pwi;
 
     XtCheckSubclass(widget, coreWidgetClass,
-		    "in XtUngrabKey or XtUngrabButton");
+                    "in XtUngrabKey or XtUngrabButton");
 
     /* Build a temporary grab list entry */
     tempGrab.widget = widget;
@@ -791,156 +772,147 @@ void   UngrabKeyOrButton (
     /*
      * if there is no entry in the context manager then somethings wrong
      */
-    if (!pwi)
-      {
-	  XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		       "invalidGrab", "ungrabKeyOrButton", XtCXtToolkitError,
-		       "Attempt to remove nonexistent passive grab",
-		       NULL, NULL);
-	  return;
-      }
-
-    if (XtIsRealized(widget))
-      {
-	  if (isKeyboard)
-	    XUngrabKey(widget->core.screen->display,
-		       keyOrButton, (unsigned int)modifiers,
-		       widget->core.window);
-	  else
-	    XUngrabButton(widget->core.screen->display,
-			  (unsigned) keyOrButton, (unsigned int)modifiers,
-			  widget->core.window);
-      }
+    if (!pwi) {
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidGrab", "ungrabKeyOrButton", XtCXtToolkitError,
+                        "Attempt to remove nonexistent passive grab",
+                        NULL, NULL);
+        return;
+    }
 
+    if (XtIsRealized(widget)) {
+        if (isKeyboard)
+            XUngrabKey(widget->core.screen->display,
+                       keyOrButton, (unsigned int) modifiers,
+                       widget->core.window);
+        else
+            XUngrabButton(widget->core.screen->display,
+                          (unsigned) keyOrButton, (unsigned int) modifiers,
+                          widget->core.window);
+    }
 
     /* Delete all entries which are encompassed by the specified grab. */
     DeleteServerGrabFromList(isKeyboard ? &pwi->keyList : &pwi->ptrList,
-			     &tempGrab);
+                             &tempGrab);
 }
 
-void  XtGrabKey (
-    Widget	widget,
-    _XtKeyCode	keycode,
-    Modifiers	modifiers,
-    _XtBoolean	owner_events,
-    int 	pointer_mode,
-    int 	keyboard_mode)
+void
+XtGrabKey(Widget widget,
+          _XtKeyCode keycode,
+          Modifiers modifiers,
+          _XtBoolean owner_events,
+          int pointer_mode,
+          int keyboard_mode)
 {
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    GrabKeyOrButton(widget, (KeyCode)keycode, modifiers, (Boolean) owner_events,
-		    pointer_mode, keyboard_mode,
-		    (Mask)0, (Window)None, (Cursor)None, KEYBOARD);
+    GrabKeyOrButton(widget, (KeyCode) keycode, modifiers,
+                    (Boolean) owner_events, pointer_mode, keyboard_mode,
+                    (Mask) 0, (Window) None, (Cursor) None, KEYBOARD);
     UNLOCK_APP(app);
 }
 
-void  XtGrabButton(
-    Widget	widget,
-    int		button,
-    Modifiers	modifiers,
-    _XtBoolean	owner_events,
-    unsigned int event_mask,
-    int 	pointer_mode,
-    int 	keyboard_mode,
-    Window 	confine_to,
-    Cursor 	cursor)
+void
+XtGrabButton(Widget widget,
+             int button,
+             Modifiers modifiers,
+             _XtBoolean owner_events,
+             unsigned int event_mask,
+             int pointer_mode,
+             int keyboard_mode,
+             Window confine_to,
+             Cursor cursor)
 {
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    GrabKeyOrButton(widget, (KeyCode)button, modifiers, (Boolean) owner_events,
-		    pointer_mode, keyboard_mode,
-		    (Mask)event_mask, confine_to, cursor, POINTER);
+    GrabKeyOrButton(widget, (KeyCode) button, modifiers, (Boolean) owner_events,
+                    pointer_mode, keyboard_mode,
+                    (Mask) event_mask, confine_to, cursor, POINTER);
     UNLOCK_APP(app);
 }
 
-
 /*
  * Routine used by an application to clear a passive grab for a key/modifier
  * combination.
  */
 
-void   XtUngrabKey (
-    Widget	widget,
-    _XtKeyCode	keycode,
-    Modifiers	modifiers)
+void
+XtUngrabKey(Widget widget, _XtKeyCode keycode, Modifiers modifiers)
 {
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    UngrabKeyOrButton(widget, (int)keycode, modifiers, KEYBOARD);
+    UngrabKeyOrButton(widget, (int) keycode, modifiers, KEYBOARD);
     UNLOCK_APP(app);
 }
 
-void   XtUngrabButton (
-    Widget	widget,
-    unsigned int button,
-    Modifiers	modifiers)
+void
+XtUngrabButton(Widget widget, unsigned int button, Modifiers modifiers)
 {
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    UngrabKeyOrButton(widget, (KeyCode)button, modifiers, POINTER);
+    UngrabKeyOrButton(widget, (KeyCode) button, modifiers, POINTER);
     UNLOCK_APP(app);
 }
 
 /*
  * Active grab of Device. clear any client side grabs so we dont lock
  */
-static int GrabDevice (
-    Widget	widget,
-    Boolean	owner_events,
-    int 	pointer_mode,
-    int 	keyboard_mode,
-    Mask	event_mask,
-    Window 	confine_to,
-    Cursor 	cursor,
-    Time	time,
-    Boolean	isKeyboard)
+static int
+GrabDevice(Widget widget,
+           Boolean owner_events,
+           int pointer_mode,
+           int keyboard_mode,
+           Mask event_mask,
+           Window confine_to,
+           Cursor cursor,
+           Time time,
+           Boolean isKeyboard)
 {
-    XtPerDisplayInput	pdi;
-    int			returnVal;
+    XtPerDisplayInput pdi;
+    int returnVal;
 
     XtCheckSubclass(widget, coreWidgetClass,
-		    "in XtGrabKeyboard or XtGrabPointer");
+                    "in XtGrabKeyboard or XtGrabPointer");
     if (!XtIsRealized(widget))
-	return GrabNotViewable;
+        return GrabNotViewable;
     LOCK_PROCESS;
     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
     UNLOCK_PROCESS;
     if (!isKeyboard)
-      returnVal = XGrabPointer(XtDisplay(widget), XtWindow(widget),
-			       owner_events, (unsigned) event_mask,
-			       pointer_mode, keyboard_mode,
-			       confine_to, cursor, time);
+        returnVal = XGrabPointer(XtDisplay(widget), XtWindow(widget),
+                                 owner_events, (unsigned) event_mask,
+                                 pointer_mode, keyboard_mode,
+                                 confine_to, cursor, time);
     else
-      returnVal = XGrabKeyboard(XtDisplay(widget), XtWindow(widget),
-				owner_events, pointer_mode,
-				keyboard_mode, time);
+        returnVal = XGrabKeyboard(XtDisplay(widget), XtWindow(widget),
+                                  owner_events, pointer_mode,
+                                  keyboard_mode, time);
 
     if (returnVal == GrabSuccess) {
-	  XtDevice		device;
-
-	  device = isKeyboard ? &pdi->keyboard : &pdi->pointer;
-	  /* fill in the server grab rec */
-	  device->grab.widget = widget;
-	  device->grab.modifiers = 0;
-	  device->grab.keybut = 0;
-	  XtSetBit(device->grab.ownerEvents, owner_events);
-	  XtSetBit(device->grab.pointerMode, pointer_mode);
-	  XtSetBit(device->grab.keyboardMode, keyboard_mode);
-	  device->grab.hasExt = False;
-	  device->grabType = XtActiveServerGrab;
-	  pdi->activatingKey = (KeyCode)0;
-      }
+        XtDevice device;
+
+        device = isKeyboard ? &pdi->keyboard : &pdi->pointer;
+
+        /* fill in the server grab rec */
+        device->grab.widget = widget;
+        device->grab.modifiers = 0;
+        device->grab.keybut = 0;
+        XtSetBit(device->grab.ownerEvents, owner_events);
+        XtSetBit(device->grab.pointerMode, pointer_mode);
+        XtSetBit(device->grab.keyboardMode, keyboard_mode);
+        device->grab.hasExt = False;
+        device->grabType = XtActiveServerGrab;
+        pdi->activatingKey = (KeyCode) 0;
+    }
     return returnVal;
 }
 
-static void   UngrabDevice(
-    Widget	widget,
-    Time	time,
-    Boolean	isKeyboard)
+static void
+UngrabDevice(Widget widget, Time time, Boolean isKeyboard)
 {
     XtPerDisplayInput pdi;
     XtDevice device;
@@ -949,53 +921,52 @@ static void   UngrabDevice(
     pdi = _XtGetPerDisplayInput(XtDisplay(widget));
     UNLOCK_PROCESS;
     device = isKeyboard ? &pdi->keyboard : &pdi->pointer;
+
     XtCheckSubclass(widget, coreWidgetClass,
-		    "in XtUngrabKeyboard or XtUngrabPointer");
+                    "in XtUngrabKeyboard or XtUngrabPointer");
 
     if (device->grabType != XtNoServerGrab) {
 
-	if (device->grabType != XtPseudoPassiveServerGrab
-	    && XtIsRealized(widget)) {
-	    if (isKeyboard)
-		XUngrabKeyboard(XtDisplay(widget), time);
-	    else
-		XUngrabPointer(XtDisplay(widget), time);
-	}
-	device->grabType = XtNoServerGrab;
-	pdi->activatingKey = (KeyCode)0;
+        if (device->grabType != XtPseudoPassiveServerGrab
+            && XtIsRealized(widget)) {
+            if (isKeyboard)
+                XUngrabKeyboard(XtDisplay(widget), time);
+            else
+                XUngrabPointer(XtDisplay(widget), time);
+        }
+        device->grabType = XtNoServerGrab;
+        pdi->activatingKey = (KeyCode) 0;
     }
 }
 
-
 /*
  * Active grab of keyboard. clear any client side grabs so we dont lock
  */
-int XtGrabKeyboard (
-    Widget	widget,
-    _XtBoolean	owner_events,
-    int 	pointer_mode,
-    int 	keyboard_mode,
-    Time	time)
+int
+XtGrabKeyboard(Widget widget,
+               _XtBoolean owner_events,
+               int pointer_mode,
+               int keyboard_mode,
+               Time time)
 {
     int retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    retval = GrabDevice (widget, (Boolean) owner_events,
-			pointer_mode, keyboard_mode,
-			(Mask)0, (Window)None, (Cursor)None, time, KEYBOARD);
+    retval = GrabDevice(widget, (Boolean) owner_events,
+                        pointer_mode, keyboard_mode,
+                        (Mask) 0, (Window) None, (Cursor) None, time, KEYBOARD);
     UNLOCK_APP(app);
     return retval;
 }
 
-
 /*
  * Ungrab the keyboard
  */
 
-void   XtUngrabKeyboard(
-    Widget	widget,
-    Time	time)
+void
+XtUngrabKeyboard(Widget widget, Time time)
 {
     WIDGET_TO_APPCON(widget);
 
@@ -1004,42 +975,37 @@ void   XtUngrabKeyboard(
     UNLOCK_APP(app);
 }
 
-
-
-
 /*
  * grab the pointer
  */
-int XtGrabPointer (
-    Widget	widget,
-    _XtBoolean	owner_events,
-    unsigned int event_mask,
-    int 	pointer_mode,
-    int 	keyboard_mode,
-    Window 	confine_to,
-    Cursor 	cursor,
-    Time	time)
+int
+XtGrabPointer(Widget widget,
+              _XtBoolean owner_events,
+              unsigned int event_mask,
+              int pointer_mode,
+              int keyboard_mode,
+              Window confine_to,
+              Cursor cursor,
+              Time time)
 {
     int retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    retval = GrabDevice (widget, (Boolean) owner_events,
-			pointer_mode, keyboard_mode,
-			(Mask)event_mask, confine_to,
-			cursor, time, POINTER);
+    retval = GrabDevice(widget, (Boolean) owner_events,
+                        pointer_mode, keyboard_mode,
+                        (Mask) event_mask, confine_to, cursor, time, POINTER);
     UNLOCK_APP(app);
     return retval;
 }
 
-
 /*
  * Ungrab the pointer
  */
 
-void   XtUngrabPointer(
-    Widget	widget,
-    Time	time)
+void
+XtUngrabPointer(Widget widget, Time time)
 {
     WIDGET_TO_APPCON(widget);
 
@@ -1048,16 +1014,14 @@ void   XtUngrabPointer(
     UNLOCK_APP(app);
 }
 
-
-void _XtRegisterPassiveGrabs (
-    Widget	widget)
+void
+_XtRegisterPassiveGrabs(Widget widget)
 {
-    XtPerWidgetInput	pwi = _XtGetPerWidgetInput (widget, FALSE);
+    XtPerWidgetInput pwi = _XtGetPerWidgetInput(widget, FALSE);
 
     if (pwi != NULL && !pwi->realize_handler_added) {
-	XtAddEventHandler(widget, StructureNotifyMask, FALSE,
-			  RealizeHandler,
-			  (XtPointer)pwi);
-	pwi->realize_handler_added = TRUE;
+        XtAddEventHandler(widget, StructureNotifyMask, FALSE,
+                          RealizeHandler, (XtPointer) pwi);
+        pwi->realize_handler_added = TRUE;
     }
 }
diff --git a/src/Pointer.c b/src/Pointer.c
index 70b0ea8..ad322c2 100644
--- a/src/Pointer.c
+++ b/src/Pointer.c
@@ -54,60 +54,54 @@ in this Software without prior written authorization from The Open Group.
 #include "IntrinsicI.h"
 #include "PassivGraI.h"
 
-
 #define AllButtonsMask (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask)
 
-Widget _XtProcessPointerEvent(
-    XButtonEvent  	*event,
-    Widget 		widget,
-    XtPerDisplayInput 	pdi)
+Widget
+_XtProcessPointerEvent(XButtonEvent *event,
+                       Widget widget,
+                       XtPerDisplayInput pdi)
 {
-    XtDevice		device = &pdi->pointer;
-    XtServerGrabPtr	newGrab = NULL, devGrab = &device->grab;
-    Widget		dspWidget = NULL;
-    Boolean		deactivateGrab = FALSE;
-
-    switch (event->type)
-      {
-	case ButtonPress:
-	  {
-	      if (!IsServerGrab(device->grabType))
-		{
-		    Cardinal		i;
-
-		    for (i = (Cardinal) pdi->traceDepth;
-			 i > 0 && !newGrab;
-			 i--)
-		      newGrab = _XtCheckServerGrabsOnWidget((XEvent*)event,
-							    pdi->trace[i-1],
-							    POINTER);
-		}
-	      if (newGrab)
-		{
-		    /* Activate the grab */
-		    device->grab = *newGrab;
-		    device->grabType = XtPassiveServerGrab;
-		}
-	  }
-	  break;
-
-	case ButtonRelease:
-	  {
-	      if ((device->grabType == XtPassiveServerGrab) &&
-		  !(event->state & (unsigned)(~(Button1Mask << (event->button - 1))) &
-		    AllButtonsMask))
-		deactivateGrab = TRUE;
-	  }
-	  break;
-      }
+    XtDevice device = &pdi->pointer;
+    XtServerGrabPtr newGrab = NULL, devGrab = &device->grab;
+    Widget dspWidget = NULL;
+    Boolean deactivateGrab = FALSE;
+
+    switch (event->type) {
+    case ButtonPress:
+    {
+        if (!IsServerGrab(device->grabType)) {
+            Cardinal i;
+
+            for (i = (Cardinal) pdi->traceDepth; i > 0 && !newGrab; i--)
+                newGrab = _XtCheckServerGrabsOnWidget((XEvent *) event,
+                                                      pdi->trace[i - 1],
+                                                      POINTER);
+        }
+        if (newGrab) {
+            /* Activate the grab */
+            device->grab = *newGrab;
+            device->grabType = XtPassiveServerGrab;
+        }
+    }
+        break;
+
+    case ButtonRelease:
+    {
+        if ((device->grabType == XtPassiveServerGrab) &&
+            !(event->state & (unsigned) (~(Button1Mask << (event->button - 1)))
+              & AllButtonsMask))
+            deactivateGrab = TRUE;
+    }
+        break;
+    }
 
     if (IsServerGrab(device->grabType) && !(devGrab)->ownerEvents)
-      dspWidget = (devGrab)->widget;
+        dspWidget = (devGrab)->widget;
     else
-      dspWidget = widget;
+        dspWidget = widget;
 
     if (deactivateGrab)
-      device->grabType = XtNoServerGrab;
+        device->grabType = XtNoServerGrab;
 
     return dspWidget;
 }
diff --git a/src/Popup.c b/src/Popup.c
index 56fa60d..30b6ca6 100644
--- a/src/Popup.c
+++ b/src/Popup.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -51,78 +50,79 @@ SOFTWARE.
 #include "IntrinsicI.h"
 #include "ShellP.h"
 
-void _XtPopup(
-    Widget      widget,
-    XtGrabKind  grab_kind,
-    _XtBoolean  spring_loaded)
+void
+_XtPopup(Widget widget, XtGrabKind grab_kind, _XtBoolean spring_loaded)
 {
     register ShellWidget shell_widget = (ShellWidget) widget;
 
-    if (! XtIsShell(widget)) {
-	XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-		"invalidClass","xtPopup",XtCXtToolkitError,
-                "XtPopup requires a subclass of shellWidgetClass",
-                  NULL, NULL);
+    if (!XtIsShell(widget)) {
+        XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                      "invalidClass", "xtPopup", XtCXtToolkitError,
+                      "XtPopup requires a subclass of shellWidgetClass",
+                      NULL, NULL);
+    }
+
+    if (!shell_widget->shell.popped_up) {
+        XtGrabKind call_data = grab_kind;
+
+        XtCallCallbacks(widget, XtNpopupCallback, (XtPointer) &call_data);
+        shell_widget->shell.popped_up = TRUE;
+        shell_widget->shell.grab_kind = grab_kind;
+        shell_widget->shell.spring_loaded = (Boolean) spring_loaded;
+        if (shell_widget->shell.create_popup_child_proc != NULL) {
+            (*(shell_widget->shell.create_popup_child_proc)) (widget);
+        }
+        if (grab_kind == XtGrabExclusive) {
+            XtAddGrab(widget, TRUE, spring_loaded);
+        }
+        else if (grab_kind == XtGrabNonexclusive) {
+            XtAddGrab(widget, FALSE, spring_loaded);
+        }
+        XtRealizeWidget(widget);
+        XMapRaised(XtDisplay(widget), XtWindow(widget));
     }
+    else
+        XRaiseWindow(XtDisplay(widget), XtWindow(widget));
+
+}                               /* _XtPopup */
 
-    if (! shell_widget->shell.popped_up) {
-	XtGrabKind call_data = grab_kind;
-	XtCallCallbacks(widget, XtNpopupCallback, (XtPointer)&call_data);
-	shell_widget->shell.popped_up = TRUE;
-	shell_widget->shell.grab_kind = grab_kind;
-	shell_widget->shell.spring_loaded = (Boolean) spring_loaded;
-	if (shell_widget->shell.create_popup_child_proc != NULL) {
-	    (*(shell_widget->shell.create_popup_child_proc))(widget);
-	}
-	if (grab_kind == XtGrabExclusive) {
-	    XtAddGrab(widget, TRUE, spring_loaded);
-	} else if (grab_kind == XtGrabNonexclusive) {
-	    XtAddGrab(widget, FALSE, spring_loaded);
-	}
-	XtRealizeWidget(widget);
-	XMapRaised(XtDisplay(widget), XtWindow(widget));
-    } else
-	XRaiseWindow(XtDisplay(widget), XtWindow(widget));
-
-} /* _XtPopup */
-
-void XtPopup (Widget widget, XtGrabKind grab_kind)
+void
+XtPopup(Widget widget, XtGrabKind grab_kind)
 {
     Widget hookobj;
 
     switch (grab_kind) {
 
-      case XtGrabNone:
-      case XtGrabExclusive:
-      case XtGrabNonexclusive:
-	break;
-
-      default:
-	XtAppWarningMsg(
-		XtWidgetToApplicationContext(widget),
-		"invalidGrabKind","xtPopup",XtCXtToolkitError,
-		"grab kind argument has invalid value; XtGrabNone assumed",
-		NULL, NULL);
-	grab_kind = XtGrabNone;
+    case XtGrabNone:
+    case XtGrabExclusive:
+    case XtGrabNonexclusive:
+        break;
+
+    default:
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidGrabKind", "xtPopup", XtCXtToolkitError,
+                        "grab kind argument has invalid value; XtGrabNone assumed",
+                        NULL, NULL);
+        grab_kind = XtGrabNone;
     }
 
     _XtPopup(widget, grab_kind, FALSE);
 
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHpopup;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer)grab_kind;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHpopup;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) grab_kind;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
-} /* XtPopup */
+}                               /* XtPopup */
 
-void XtPopupSpringLoaded (
-    Widget widget)
+void
+XtPopupSpringLoaded(Widget widget)
 {
     Widget hookobj;
 
@@ -130,29 +130,29 @@ void XtPopupSpringLoaded (
 
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHpopupSpringLoaded;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHpopupSpringLoaded;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 }
 
-void XtPopdown(
-    Widget  widget)
+void
+XtPopdown(Widget widget)
 {
     /* Unmap a shell widget if it is mapped, and remove from grab list */
     Widget hookobj;
     ShellWidget shell_widget = (ShellWidget) widget;
     XtGrabKind grab_kind;
 
-    if (! XtIsShell(widget)) {
-	XtAppErrorMsg(XtWidgetToApplicationContext(widget),
-		"invalidClass","xtPopdown",XtCXtToolkitError,
-            "XtPopdown requires a subclass of shellWidgetClass",
-              NULL, NULL);
+    if (!XtIsShell(widget)) {
+        XtAppErrorMsg(XtWidgetToApplicationContext(widget),
+                      "invalidClass", "xtPopdown", XtCXtToolkitError,
+                      "XtPopdown requires a subclass of shellWidgetClass",
+                      NULL, NULL);
     }
 
 #ifndef X_NO_XT_POPDOWN_CONFORMANCE
@@ -162,34 +162,33 @@ void XtPopdown(
 
     grab_kind = shell_widget->shell.grab_kind;
     XWithdrawWindow(XtDisplay(widget), XtWindow(widget),
-		    XScreenNumberOfScreen(XtScreen(widget)));
+                    XScreenNumberOfScreen(XtScreen(widget)));
     if (grab_kind != XtGrabNone)
-	XtRemoveGrab(widget);
+        XtRemoveGrab(widget);
     shell_widget->shell.popped_up = FALSE;
-    XtCallCallbacks(widget, XtNpopdownCallback, (XtPointer)&grab_kind);
+    XtCallCallbacks(widget, XtNpopdownCallback, (XtPointer) &grab_kind);
 
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHpopdown;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHpopdown;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
-} /* XtPopdown */
+}                               /* XtPopdown */
 
-/* ARGSUSED */
-void XtCallbackPopdown(
-    Widget  widget,
-    XtPointer closure,
-    XtPointer call_data)
+void
+XtCallbackPopdown(Widget widget _X_UNUSED,
+                  XtPointer closure,
+                  XtPointer call_data _X_UNUSED)
 {
     register XtPopdownID id = (XtPopdownID) closure;
 
     XtPopdown(id->shell_widget);
     if (id->enable_widget != NULL) {
-	XtSetSensitive(id->enable_widget, TRUE);
+        XtSetSensitive(id->enable_widget, TRUE);
     }
-} /* XtCallbackPopdown */
+}                               /* XtCallbackPopdown */
diff --git a/src/PopupCB.c b/src/PopupCB.c
index 38cba26..7254ae1 100644
--- a/src/PopupCB.c
+++ b/src/PopupCB.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -50,33 +49,28 @@ SOFTWARE.
 #endif
 #include "IntrinsicI.h"
 
-/* ARGSUSED */
-void XtCallbackNone(
-    Widget  widget,
-    XtPointer closure,
-    XtPointer call_data)
+void
+XtCallbackNone(Widget widget, XtPointer closure, XtPointer call_data _X_UNUSED)
 {
     XtSetSensitive(widget, FALSE);
     _XtPopup((Widget) closure, XtGrabNone, FALSE);
-} /* XtCallbackNone */
+}                               /* XtCallbackNone */
 
-/* ARGSUSED */
-void XtCallbackNonexclusive(
-    Widget  widget,
-    XtPointer closure,
-    XtPointer call_data)
+void
+XtCallbackNonexclusive(Widget widget,
+                       XtPointer closure,
+                       XtPointer call_data _X_UNUSED)
 {
 
     XtSetSensitive(widget, FALSE);
     _XtPopup((Widget) closure, XtGrabNonexclusive, FALSE);
-} /* XtCallbackNonexclusive */
+}                               /* XtCallbackNonexclusive */
 
-/* ARGSUSED */
-void XtCallbackExclusive(
-    Widget  widget,
-    XtPointer closure,
-    XtPointer call_data)
+void
+XtCallbackExclusive(Widget widget,
+                    XtPointer closure,
+                    XtPointer call_data _X_UNUSED)
 {
     XtSetSensitive(widget, FALSE);
     _XtPopup((Widget) closure, XtGrabExclusive, FALSE);
-} /* XtCallbackExclusive */
+}                               /* XtCallbackExclusive */
diff --git a/src/RectObj.c b/src/RectObj.c
index 73e9625..7a66402 100644
--- a/src/RectObj.c
+++ b/src/RectObj.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -60,6 +59,7 @@ SOFTWARE.
 
 static void XtCopyAncestorSensitive(Widget, int, XrmValue *);
 
+/* *INDENT-OFF* */
 static XtResource resources[] = {
 
     {XtNancestorSensitive, XtCSensitive, XtRBoolean, sizeof(Boolean),
@@ -75,99 +75,96 @@ static XtResource resources[] = {
          XtOffsetOf(RectObjRec,rectangle.height), XtRImmediate, (XtPointer)0},
     {XtNborderWidth, XtCBorderWidth, XtRDimension, sizeof(Dimension),
          XtOffsetOf(RectObjRec,rectangle.border_width), XtRImmediate,
-	 (XtPointer)1},
+         (XtPointer)1},
     {XtNsensitive, XtCSensitive, XtRBoolean, sizeof(Boolean),
          XtOffsetOf(RectObjRec,rectangle.sensitive), XtRImmediate,
-	 (XtPointer)True}
-    };
+         (XtPointer)True}
+};
+/* *INDENT-ON* */
 
 static void RectClassPartInitialize(WidgetClass);
-static void RectSetValuesAlmost(Widget, Widget, XtWidgetGeometry *, XtWidgetGeometry *);
+static void RectSetValuesAlmost(Widget, Widget, XtWidgetGeometry *,
+                                XtWidgetGeometry *);
 
+/* *INDENT-OFF* */
 externaldef(rectobjclassrec) RectObjClassRec rectObjClassRec = {
   {
-    /* superclass	  */	(WidgetClass)&objectClassRec,
-    /* class_name	  */	"Rect",
-    /* widget_size	  */	sizeof(RectObjRec),
-    /* class_initialize   */    NULL,
-    /* class_part_initialize*/	RectClassPartInitialize,
-    /* class_inited       */	FALSE,
-    /* initialize	  */	NULL,
-    /* initialize_hook    */	NULL,
-    /* realize		  */	NULL,
-    /* actions		  */	NULL,
-    /* num_actions	  */	0,
-    /* resources	  */	resources,
-    /* num_resources	  */	XtNumber(resources),
-    /* xrm_class	  */	NULLQUARK,
-    /* compress_motion	  */	FALSE,
-    /* compress_exposure  */	TRUE,
-    /* compress_enterleave*/ 	FALSE,
-    /* visible_interest	  */	FALSE,
-    /* destroy		  */	NULL,
-    /* resize		  */	NULL,
-    /* expose		  */	NULL,
-    /* set_values	  */	NULL,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */	RectSetValuesAlmost,
-    /* get_values_hook    */	NULL,
-    /* accept_focus	  */	NULL,
-    /* version		  */	XtVersion,
-    /* callback_offsets   */    NULL,
-    /* tm_table           */    NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */	NULL,
-    /* extension	    */  NULL
+    /* superclass            */ (WidgetClass)&objectClassRec,
+    /* class_name            */ "Rect",
+    /* widget_size           */ sizeof(RectObjRec),
+    /* class_initialize      */ NULL,
+    /* class_part_initialize */ RectClassPartInitialize,
+    /* class_inited          */ FALSE,
+    /* initialize            */ NULL,
+    /* initialize_hook       */ NULL,
+    /* realize               */ NULL,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ resources,
+    /* num_resources         */ XtNumber(resources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ NULL,
+    /* resize                */ NULL,
+    /* expose                */ NULL,
+    /* set_values            */ NULL,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ RectSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* version               */ XtVersion,
+    /* callback_offsets      */ NULL,
+    /* tm_table              */ NULL,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
 externaldef(rectObjClass)
-WidgetClass rectObjClass = (WidgetClass)&rectObjClassRec;
+WidgetClass rectObjClass = (WidgetClass) &rectObjClassRec;
 
-/*ARGSUSED*/
-static void XtCopyAncestorSensitive(
-    Widget      widget,
-    int		offset,
-    XrmValue    *value)
+static void
+XtCopyAncestorSensitive(Widget widget, int offset _X_UNUSED, XrmValue *value)
 {
-    static Boolean  sensitive;
+    static Boolean sensitive;
     Widget parent = widget->core.parent;
 
     sensitive = (parent->core.ancestor_sensitive & parent->core.sensitive);
-    value->addr = (XPointer)(&sensitive);
+    value->addr = (XPointer) (&sensitive);
 }
 
-
 /*
  * Start of rectangle object methods
  */
 
-
-static void RectClassPartInitialize(
-    register WidgetClass wc)
+static void
+RectClassPartInitialize(register WidgetClass wc)
 {
-    register RectObjClass roc = (RectObjClass)wc;
-    register RectObjClass super = ((RectObjClass)roc->rect_class.superclass);
+    register RectObjClass roc = (RectObjClass) wc;
+    register RectObjClass super = ((RectObjClass) roc->rect_class.superclass);
 
     /* We don't need to check for null super since we'll get to object
        eventually, and it had better define them!  */
 
-
     if (roc->rect_class.resize == XtInheritResize) {
-	roc->rect_class.resize = super->rect_class.resize;
+        roc->rect_class.resize = super->rect_class.resize;
     }
 
     if (roc->rect_class.expose == XtInheritExpose) {
-	roc->rect_class.expose = super->rect_class.expose;
+        roc->rect_class.expose = super->rect_class.expose;
     }
 
     if (roc->rect_class.set_values_almost == XtInheritSetValuesAlmost) {
-	roc->rect_class.set_values_almost = super->rect_class.set_values_almost;
+        roc->rect_class.set_values_almost = super->rect_class.set_values_almost;
     }
 
-
     if (roc->rect_class.query_geometry == XtInheritQueryGeometry) {
-	roc->rect_class.query_geometry = super->rect_class.query_geometry;
+        roc->rect_class.query_geometry = super->rect_class.query_geometry;
     }
 }
 
@@ -179,12 +176,11 @@ static void RectClassPartInitialize(
  * for use by converters during instance resource resolution.
  */
 
-/*ARGSUSED*/
-static void RectSetValuesAlmost(
-    Widget		old,
-    Widget		new,
-    XtWidgetGeometry    *request,
-    XtWidgetGeometry    *reply)
+static void
+RectSetValuesAlmost(Widget old _X_UNUSED,
+                    Widget new _X_UNUSED,
+                    XtWidgetGeometry *request,
+                    XtWidgetGeometry *reply)
 {
     *request = *reply;
 }
diff --git a/src/ResConfig.c b/src/ResConfig.c
index b668736..a6a27e9 100644
--- a/src/ResConfig.c
+++ b/src/ResConfig.c
@@ -69,433 +69,422 @@ Corporation.
 #define MAX_BUFFER 512
 
 static void _search_child(Widget, char *, char *, char *, char *, char, char *);
-static void _set_and_search(Widget, char *, char *, char *, char *, char , char *);
+static void _set_and_search(Widget, char *, char *, char *, char *, char,
+                            char *);
 static int _locate_children(Widget, Widget **);
 
 /*
  * NAME: _set_resource_values
  *
  * FUNCTION:
- *	This function sets the value on the widget.  It must first determine
- *	if the last part is a valid resource for that widget.  (eg.
- *	labelString is a valid resource for label but not for bulletin board)
- *	It must also add the resource to the application's resource database
- *	and then query it out using specific resource strings that it builds
- *	from the widget information.  This ensures that a customizing tool
- *	on-the-fly paradigm is followed:  an application that is
- *	instantaneously updated should look the same as one that is restarted
- *	and uses the .Xdefaults file.
+ *      This function sets the value on the widget.  It must first determine
+ *      if the last part is a valid resource for that widget.  (eg.
+ *      labelString is a valid resource for label but not for bulletin board)
+ *      It must also add the resource to the application's resource database
+ *      and then query it out using specific resource strings that it builds
+ *      from the widget information.  This ensures that a customizing tool
+ *      on-the-fly paradigm is followed:  an application that is
+ *      instantaneously updated should look the same as one that is restarted
+ *      and uses the .Xdefaults file.
  *
  * PARAMETERS:
- *	w		the widget to match
- *	resource	the resource string to be matched
- *	value		the value to be set
- *	last_part	the last resource part (e.g. *background)
+ *      w               the widget to match
+ *      resource        the resource string to be matched
+ *      value           the value to be set
+ *      last_part       the last resource part (e.g. *background)
  *
  * RETURN VALUES: void
  *
  * ERRORS: none
  */
 static void
-_set_resource_values (
-	Widget w,
-	char *resource,
-	char *value,
-	char *last_part)
+_set_resource_values(Widget w, char *resource, char *value, char *last_part)
 {
-	XrmDatabase 	db = NULL;
-	char		*resource_name = NULL;
-	char		*resource_class = NULL;
-	char		*return_type;
-	XrmValue	return_value;
-	char		*resource_value;
-	Widget		cur = w;
-	char		*temp;
-	XtResourceList	resources_return = NULL;
-	Cardinal 	num_resources_return = 0;
-	Cardinal	res_index;
-	Boolean		found_resource = False;
-	Display		*dpy;
-	XrmDatabase	tmp_db;
-
-	if (last_part == NULL)
-	    return;
-
-	if (!XtIsWidget (w)) {
-	    if (w == 0 || w->core.parent == 0)
-		return;
-	    dpy = XtDisplay (w->core.parent);
-	} else {
-	    dpy = XtDisplay (w);
-	}
-	tmp_db = XtDatabase(dpy);
-
-	/*
-	 * get a list of all the valid resources for this widget
-	 */
-	XtGetResourceList (w->core.widget_class,
-		&resources_return, &num_resources_return);
-
-	/*
-	 * try to match the last_part of the resource string with
-	 * a resource in this resource list
-	 */
-	for (res_index=0; res_index<num_resources_return; res_index++) {
-		if ((strcmp (last_part,
-			resources_return[res_index].resource_name) == 0) ||
-		    (strcmp (last_part,
-			resources_return[res_index].resource_class) == 0)) {
-			found_resource = True;
-			break;
-		}
-	}
-
-	/*
-	 * if resource is not a valid resource for this widget
-	 * or the resource name or class are NULL
-	 * then exit this function
-	 */
-	if (!found_resource
-		|| !resources_return[res_index].resource_name
-		|| !resources_return[res_index].resource_class) {
-		XtFree ((char *) resources_return);
-		return;
-	}
-
-	/*
-	 * build the full resource name and class specifications so
-	 * that you can query the resource database
-	 * 	eg: .app.button1.foreground
-	 * 	    .App.XmPushButton.Foreground
-	 */
-	while (cur != NULL) {
-		/*
-		 * create resource name string
-		 */
-		if (resource_name) {
-			XtAsprintf (&temp, ".%s%s", cur->core.name, resource_name);
-			XtFree (resource_name);
-		} else if (!XtIsWidget (cur) || !cur->core.name) {
-			cur = XtParent(cur);
-			continue;
-		} else {
-			XtAsprintf (&temp, ".%s", cur->core.name);
-		}
-		resource_name = temp;
-
-		/*
-		 * create resource class string
-		 */
-		if ((XtIsTopLevelShell (cur)) && (XtParent (cur) == NULL)) {
-			ApplicationShellWidget	top =
-				(ApplicationShellWidget) (cur);
-
-			if (resource_class) {
-				XtAsprintf (&temp, ".%s%s",
-					top->application.class, resource_class);
-			} else {
-				XtAsprintf (&temp, ".%s",
-					top->application.class);
-			}
-		} else {
-			if (resource_class) {
-				XtAsprintf (&temp, ".%s%s",
-					cur->core.widget_class->core_class.class_name,
-					resource_class);
-			} else {
-				XtAsprintf (&temp, ".%s",
-					cur->core.widget_class->core_class.class_name);
-			}
-		}
-
-		XtFree (resource_class);
-		resource_class = temp;
-
-		cur = XtParent(cur);
-	}
-
-	/*
-	 * add the resource name to the end of the resource name string
-	 */
-	XtAsprintf (&temp, "%s.%s", resource_name,
-		resources_return[res_index].resource_name);
-
-	XtFree (resource_name);
-	resource_name = temp;
-
-	/*
-	 * add the resource class to the end of the resource class string
-	 */
-	XtAsprintf (&temp, "%s.%s", resource_class,
-		resources_return[res_index].resource_class);
-
-	XtFree (resource_class);
-	resource_class = temp;
+    XrmDatabase db = NULL;
+    char *resource_name = NULL;
+    char *resource_class = NULL;
+    char *return_type;
+    XrmValue return_value;
+    char *resource_value;
+    Widget cur = w;
+    char *temp;
+    XtResourceList resources_return = NULL;
+    Cardinal num_resources_return = 0;
+    Cardinal res_index;
+    Boolean found_resource = False;
+    Display *dpy;
+    XrmDatabase tmp_db;
+
+    if (last_part == NULL)
+        return;
+
+    if (!XtIsWidget(w)) {
+        if (w == 0 || w->core.parent == 0)
+            return;
+        dpy = XtDisplay(w->core.parent);
+    }
+    else {
+        dpy = XtDisplay(w);
+    }
+    tmp_db = XtDatabase(dpy);
+
+    /*
+     * get a list of all the valid resources for this widget
+     */
+    XtGetResourceList(w->core.widget_class,
+                      &resources_return, &num_resources_return);
+
+    /*
+     * try to match the last_part of the resource string with
+     * a resource in this resource list
+     */
+    for (res_index = 0; res_index < num_resources_return; res_index++) {
+        if ((strcmp(last_part,
+                    resources_return[res_index].resource_name) == 0) ||
+            (strcmp(last_part,
+                    resources_return[res_index].resource_class) == 0)) {
+            found_resource = True;
+            break;
+        }
+    }
+
+    /*
+     * if resource is not a valid resource for this widget
+     * or the resource name or class are NULL
+     * then exit this function
+     */
+    if (!found_resource
+        || !resources_return[res_index].resource_name
+        || !resources_return[res_index].resource_class) {
+        XtFree((char *) resources_return);
+        return;
+    }
+
+    /*
+     * build the full resource name and class specifications so
+     * that you can query the resource database
+     *      eg: .app.button1.foreground
+     *          .App.XmPushButton.Foreground
+     */
+    while (cur != NULL) {
+        /*
+         * create resource name string
+         */
+        if (resource_name) {
+            XtAsprintf(&temp, ".%s%s", cur->core.name, resource_name);
+            XtFree(resource_name);
+        }
+        else if (!XtIsWidget(cur) || !cur->core.name) {
+            cur = XtParent(cur);
+            continue;
+        }
+        else {
+            XtAsprintf(&temp, ".%s", cur->core.name);
+        }
+        resource_name = temp;
+
+        /*
+         * create resource class string
+         */
+        if ((XtIsTopLevelShell(cur)) && (XtParent(cur) == NULL)) {
+            ApplicationShellWidget top = (ApplicationShellWidget) (cur);
+
+            if (resource_class) {
+                XtAsprintf(&temp, ".%s%s",
+                           top->application.class, resource_class);
+            }
+            else {
+                XtAsprintf(&temp, ".%s", top->application.class);
+            }
+        }
+        else {
+            if (resource_class) {
+                XtAsprintf(&temp, ".%s%s",
+                           cur->core.widget_class->core_class.class_name,
+                           resource_class);
+            }
+            else {
+                XtAsprintf(&temp, ".%s",
+                           cur->core.widget_class->core_class.class_name);
+            }
+        }
+
+        XtFree(resource_class);
+        resource_class = temp;
+
+        cur = XtParent(cur);
+    }
+
+    /*
+     * add the resource name to the end of the resource name string
+     */
+    XtAsprintf(&temp, "%s.%s", resource_name,
+               resources_return[res_index].resource_name);
+
+    XtFree(resource_name);
+    resource_name = temp;
+
+    /*
+     * add the resource class to the end of the resource class string
+     */
+    XtAsprintf(&temp, "%s.%s", resource_class,
+               resources_return[res_index].resource_class);
+
+    XtFree(resource_class);
+    resource_class = temp;
 
 #ifdef DEBUG
-	fprintf (stderr, "resource_name = %s\n", resource_name);
-	fprintf (stderr, "resource_class = %s\n", resource_class);
+    fprintf(stderr, "resource_name = %s\n", resource_name);
+    fprintf(stderr, "resource_class = %s\n", resource_class);
 #endif
 
-	/*
-	 * put the resource and its value in a resource database and
-	 * then query it back out again using the specific name and
-	 * class resource strings that were built above.  This is
-	 * necessary to maintain a precedence similar to the .Xdefaults
-	 * file
-	 */
-	XrmPutStringResource (&db, resource, value);
-	XrmMergeDatabases (db, &tmp_db);
-	XrmGetResource (tmp_db, resource_name, resource_class,
-		&return_type, &return_value);
-	if (return_type)
-		resource_value = XtNewString (return_value.addr);
-	else
-		resource_value = XtNewString (value);
+    /*
+     * put the resource and its value in a resource database and
+     * then query it back out again using the specific name and
+     * class resource strings that were built above.  This is
+     * necessary to maintain a precedence similar to the .Xdefaults
+     * file
+     */
+    XrmPutStringResource(&db, resource, value);
+    XrmMergeDatabases(db, &tmp_db);
+    XrmGetResource(tmp_db, resource_name, resource_class,
+                   &return_type, &return_value);
+    if (return_type)
+        resource_value = XtNewString(return_value.addr);
+    else
+        resource_value = XtNewString(value);
 
 #ifdef DEBUG
-	fprintf (stderr,
-		"Apply:\n\twidget = %s\n\tlast_part = %s\n\tvalue = %s\n",
-		(w->core.name == NULL) ? "NULL" : w->core.name,
-		resources_return[res_index].resource_name,
-		resource_value);
+    fprintf(stderr,
+            "Apply:\n\twidget = %s\n\tlast_part = %s\n\tvalue = %s\n",
+            (w->core.name == NULL) ? "NULL" : w->core.name,
+            resources_return[res_index].resource_name, resource_value);
 #endif
-	/*
-	 * use XtVaSetValues with XtVaTypedArg to convert the value of
-	 * type String the the same type as the resource (last_part).
-	 * Then set the value.
-	 */
-	XtVaSetValues (w,
-		XtVaTypedArg, resources_return[res_index].resource_name,
-		XtRString, resource_value,
-		strlen (resource_value) + 1,
-		NULL);
-
-	XtFree ((char *) resources_return);
-	XtFree (resource_name);
-	XtFree (resource_class);
-	XtFree (resource_value);
+    /*
+     * use XtVaSetValues with XtVaTypedArg to convert the value of
+     * type String the the same type as the resource (last_part).
+     * Then set the value.
+     */
+    XtVaSetValues(w,
+                  XtVaTypedArg, resources_return[res_index].resource_name,
+                  XtRString, resource_value, strlen(resource_value) + 1, NULL);
+
+    XtFree((char *) resources_return);
+    XtFree(resource_name);
+    XtFree(resource_class);
+    XtFree(resource_value);
 }
 
 /*
  * NAME: _apply_values_to_children
  *
  * FUNCTION:
- *	Once the resource string matches the value must be applied to
- *	all children if applicable. (eg. App*Form.background must apply
- *	background to all children of the Form widget)
+ *      Once the resource string matches the value must be applied to
+ *      all children if applicable. (eg. App*Form.background must apply
+ *      background to all children of the Form widget)
  *
  * PARAMETERS:
- *	w		the widget to match
- *	remainder	the part of the resource string left over
- *	resource	the resource string to be matched
- *	value		the value to be set
- *	last_token	the last * or . before the final resoruce part
- *	last_part	the last resource part (e.g. *background)
+ *      w               the widget to match
+ *      remainder       the part of the resource string left over
+ *      resource        the resource string to be matched
+ *      value           the value to be set
+ *      last_token      the last * or . before the final resoruce part
+ *      last_part       the last resource part (e.g. *background)
  *
  * RETURN VALUES: void
  *
  * ERRORS: none
  */
 static void
-_apply_values_to_children (
-	Widget w,
-	char *remainder,
-	char *resource,
-	char *value,
-	char last_token,
-	char *last_part)
+_apply_values_to_children(Widget w,
+                          char *remainder,
+                          char *resource,
+                          char *value,
+                          char last_token,
+                          char *last_part)
 {
-	int 	i;
-	int	num_children;
-	Widget	*children;
+    int i;
+    int num_children;
+    Widget *children;
 
-	/*
-	 * Recursively search through the children
-	 */
-	num_children = _locate_children (w, &children);
+    /*
+     * Recursively search through the children
+     */
+    num_children = _locate_children(w, &children);
 
-	for (i=0; i<num_children; i++) {
+    for (i = 0; i < num_children; i++) {
 
 #ifdef DEBUG
-		if (XtIsWidget (children[i]) && XtIsWidget (w))
-			fprintf (stderr, "searching child %s of parent %s\n",
-				children[i]->core.name, w->core.name);
-		else
-			fprintf (stderr,"searching child (NULL) of parent %s\n",
-				w->core.name);
-		if (!XtIsWidget (children[i]))
-			fprintf (stderr, "children[%d] is NOT a widget\n", i);
-		if (!XtIsWidget (w))
-			fprintf (stderr, "w is NOT a widget\n");
+        if (XtIsWidget(children[i]) && XtIsWidget(w))
+            fprintf(stderr, "searching child %s of parent %s\n",
+                    children[i]->core.name, w->core.name);
+        else
+            fprintf(stderr, "searching child (NULL) of parent %s\n",
+                    w->core.name);
+        if (!XtIsWidget(children[i]))
+            fprintf(stderr, "children[%d] is NOT a widget\n", i);
+        if (!XtIsWidget(w))
+            fprintf(stderr, "w is NOT a widget\n");
 #endif
 
-		_set_resource_values (children[i], resource, value, last_part);
-		_apply_values_to_children (children[i], remainder,
-				resource, value, last_token, last_part);
-	}
+        _set_resource_values(children[i], resource, value, last_part);
+        _apply_values_to_children(children[i], remainder,
+                                  resource, value, last_token, last_part);
+    }
 
-	XtFree ((char *)children);
+    XtFree((char *) children);
 }
 
 /*
  * NAME: _search_child
  *
  * FUNCTION:
- *	descends through each child of the tree
+ *      descends through each child of the tree
  *
  * PARAMETERS:
- *	w		the widget whose children are to be searched
- *	indx		index into the resource string
- *	remainder	the remaining part of the resource string
- *	resource	the resource string to be matched
- *	value		the value to be applied
- *	last_token	the last * or . before the final resoruce part
- *	last_part	the last resource part (e.g. *background)
+ *      w               the widget whose children are to be searched
+ *      indx            index into the resource string
+ *      remainder       the remaining part of the resource string
+ *      resource        the resource string to be matched
+ *      value           the value to be applied
+ *      last_token      the last * or . before the final resoruce part
+ *      last_part       the last resource part (e.g. *background)
  *
  * RETURN VALUES: none
  *
  * ERRORS: none
  */
 static void
-_search_child (
-	Widget w,
-	char *indx,
-	char *remainder,
-	char *resource,
-	char *value,
-	char last_token,
-	char *last_part)
+_search_child(Widget w,
+              char *indx,
+              char *remainder,
+              char *resource,
+              char *value,
+              char last_token,
+              char *last_part)
 {
-	int 	i;
-	int	num_children;
-	Widget	*children;
-
-	/*
-	 * Recursively search through the children
-	 */
-	num_children = _locate_children (w, &children);
-	for (i=0; i<num_children; i++) {
-		_set_and_search (children[i], indx, remainder, resource,
-			value, last_token, last_part);
-	}
-
-	XtFree ((char *)children);
+    int i;
+    int num_children;
+    Widget *children;
+
+    /*
+     * Recursively search through the children
+     */
+    num_children = _locate_children(w, &children);
+    for (i = 0; i < num_children; i++) {
+        _set_and_search(children[i], indx, remainder, resource,
+                        value, last_token, last_part);
+    }
+
+    XtFree((char *) children);
 }
 
 /*
  * NAME: _get_part
  *
  * FUNCTION:
- * 	This routine will return the token and following part of the resource
- * 	when given the current index it will update the index accordingly
+ *      This routine will return the token and following part of the resource
+ *      when given the current index it will update the index accordingly
  *
  * PARAMETERS:
- *	remainder	the part of the resource string left over
- *	indx		the index into the resource string
- *	part		the parsed off part of the resource string
+ *      remainder       the part of the resource string left over
+ *      indx            the index into the resource string
+ *      part            the parsed off part of the resource string
  *
  * RETURN VALUES:
- *	char		the token (* or . or ?) preceding the resource part
- *	indx		the index into the resource string
- *	part		the parsed off part of the resource string
+ *      char            the token (* or . or ?) preceding the resource part
+ *      indx            the index into the resource string
+ *      part            the parsed off part of the resource string
  *
  * ERRORS: none
  */
-/* ARGSUSED */
 static char
-_get_part (
-	char *remainder,
-	char **indx,
-	char **part)
+_get_part(char *remainder _X_UNUSED, char **indx, char **part)
 {
-	char	buffer[MAX_BUFFER];
-	char	*buf_ptr;
-	char	token = **indx;
-	int	i = 0;
-
-	/*
-	 * copy the remainder part into the buffer
-	 */
-	buf_ptr = buffer;
-	(*indx)++;			/* get rid of the token		*/
-	while (**indx && (**indx != '.') && (**indx != '*')) {
-		*buf_ptr++ = *(*indx)++;
-		if (++i >= MAX_BUFFER - 1)
-			break;
-	}
-	*buf_ptr = '\0';
-
-	*part = XtNewString (buffer);	/* return a new string to part	*/
-
-	if (strcmp (*indx, "") == 0)
-		*indx = NULL;
-
-	return (token);			/* return the token		*/
+    char buffer[MAX_BUFFER];
+    char *buf_ptr;
+    char token = **indx;
+    int i = 0;
+
+    /*
+     * copy the remainder part into the buffer
+     */
+    buf_ptr = buffer;
+    (*indx)++;                  /* get rid of the token         */
+    while (**indx && (**indx != '.') && (**indx != '*')) {
+        *buf_ptr++ = *(*indx)++;
+        if (++i >= MAX_BUFFER - 1)
+            break;
+    }
+    *buf_ptr = '\0';
+
+    *part = XtNewString(buffer);        /* return a new string to part  */
+
+    if (strcmp(*indx, "") == 0)
+        *indx = NULL;
+
+    return (token);             /* return the token             */
 }
 
 /*
  * NAME: _match_resource_to_widget
  *
  * FUNCTION:
- *	This function matches the resource part to the widget name or class
+ *      This function matches the resource part to the widget name or class
  *
  * PARAMETERS:
- *	w		the widget to match
- *	part		the parsed off part of the resource string
+ *      w               the widget to match
+ *      part            the parsed off part of the resource string
  *
  * RETURN VALUES:
- *	Boolean		true if a match occurs
+ *      Boolean         true if a match occurs
  *
  * ERRORS: none
  */
 static Boolean
-_match_resource_to_widget (
-	Widget w,
-	char *part)
+_match_resource_to_widget(Widget w, char *part)
 {
-	/*
-	 * Match any widget at this level if the ? is used
-	 */
-	if (strcmp (part, "?") == 0)
-		return (True);
-
-	/*
-	 * if the object is really a widget then its name can be matched
-	 * otherwise only use its class.  Note that if you try to reference
-	 * a widget name when the object is not a widget, you may get a
-	 * core dump from an invalid pointer reference.
-	 */
-	if (XtIsWidget (w)) {
-		if ((strcmp (w->core.name, part) == 0) ||
-		    (strcmp (w->core.widget_class->core_class.class_name,
-							part) == 0))
-			return (True);
-		else
-			return (False);
-	} else {
-		if ((strcmp (w->core.widget_class->core_class.class_name,
-							part) == 0))
-			return (True);
-		else
-			return (False);
-	}
+    /*
+     * Match any widget at this level if the ? is used
+     */
+    if (strcmp(part, "?") == 0)
+        return (True);
+
+    /*
+     * if the object is really a widget then its name can be matched
+     * otherwise only use its class.  Note that if you try to reference
+     * a widget name when the object is not a widget, you may get a
+     * core dump from an invalid pointer reference.
+     */
+    if (XtIsWidget(w)) {
+        if ((strcmp(w->core.name, part) == 0) ||
+            (strcmp(w->core.widget_class->core_class.class_name, part) == 0))
+            return (True);
+        else
+            return (False);
+    }
+    else {
+        if ((strcmp(w->core.widget_class->core_class.class_name, part) == 0))
+            return (True);
+        else
+            return (False);
+    }
 }
 
 /*
  * NAME: _set_and_search
  *
  * FUNCTION:
- * 	The algorithm to search the widget tree and apply a resource string
+ *      The algorithm to search the widget tree and apply a resource string
  *
  * PARAMETERS:
- *	w		the widget to match
- *	indx		the index into the resource string
- *	remainder	the part of the resource string left over
- *	resource	the resource string to be matched
- *	value		the value to be set
- *	last_token	the last * or . before the final resoruce part
- *	last_part	the last resource part (e.g. *background)
+ *      w               the widget to match
+ *      indx            the index into the resource string
+ *      remainder       the part of the resource string left over
+ *      resource        the resource string to be matched
+ *      value           the value to be set
+ *      last_token      the last * or . before the final resoruce part
+ *      last_part       the last resource part (e.g. *background)
  *
  * RETURN VALUES: none
  *
@@ -503,312 +492,309 @@ _match_resource_to_widget (
  *
  * ALGORITHM:
  * loop (look at all children)
- * 	if (resource segment and current widget match)
- *		if '.'
- *			if at end of resource string
- *				set values (	.=over all children
- *						*=this widget only)
- *			else
- *				descend the widget tree
- *				and parse off resource segment
- *			exit the loop
- *		if '*'
- *			if at end of resource string
- *				set values (	.=over all children
- *						*=this widget only)
- *			descend and parse
- *	else
- *		if '.'
- *			continue looping
- *		if '*'
- *			descend but don't parse
- *			continue looping
+ *      if (resource segment and current widget match)
+ *              if '.'
+ *                      if at end of resource string
+ *                              set values (    .=over all children
+ *                                              *=this widget only)
+ *                      else
+ *                              descend the widget tree
+ *                              and parse off resource segment
+ *                      exit the loop
+ *              if '*'
+ *                      if at end of resource string
+ *                              set values (    .=over all children
+ *                                              *=this widget only)
+ *                      descend and parse
+ *      else
+ *              if '.'
+ *                      continue looping
+ *              if '*'
+ *                      descend but don't parse
+ *                      continue looping
  * end loop
  *
  * NOTE:  the _set_resource_values routine will not allow a value to be
- *	set on a resource against the rules of the resource database manager
+ *      set on a resource against the rules of the resource database manager
  */
 static void
-_set_and_search (
-	Widget w,
-	char *indx,
-	char *remainder,
-	char *resource,
-	char *value,
-	char last_token,
-	char *last_part)
+_set_and_search(Widget w,
+                char *indx,
+                char *remainder,
+                char *resource,
+                char *value,
+                char last_token,
+                char *last_part)
 {
-	char	*part;
-	char	*local_index = indx;
-	char	token;
-
-	/*
-	 * parse off one part, return token and the new index
-	 */
-	token = _get_part (remainder, &local_index, &part);
-
-	if (_match_resource_to_widget (w, part)) {
-		if (token == '.') {
-			if (local_index == NULL) {
-				if (last_token == '.') {
-					_set_resource_values (w, resource,
-						value, last_part);
-				} else if (last_token == '*') {
-					_set_resource_values (w, resource,
-						value, last_part);
-					_apply_values_to_children (w,
-						remainder, resource, value,
-						last_token, last_part);
-				}
-			} else
-				_search_child (w, local_index, remainder,
-					resource, value, last_token, last_part);
-			XtFree (part);
-			return;
-		}
-		if (token == '*') {
-			if (local_index == NULL) {
-				if (last_token == '.') {
-					_set_resource_values (w, resource,
-						value, last_part);
-				} else if (last_token == '*') {
-					_set_resource_values (w, resource,
-						value, last_part);
-					_apply_values_to_children ( w,
-						remainder, resource, value,
-						last_token, last_part);
-				}
-			} else
-				_search_child (w, local_index, remainder,
-					resource, value, last_token, last_part);
-		}
-	} else {/* if the widget name and class don't match the part */
-		/* if (token == '.') just continue looping */
-
-		if (token == '*') {
-			_search_child (w, indx, remainder, resource, value,
-				last_token, last_part);
-		}
-	}
-
-	XtFree (part);
+    char *part;
+    char *local_index = indx;
+    char token;
+
+    /*
+     * parse off one part, return token and the new index
+     */
+    token = _get_part(remainder, &local_index, &part);
+
+    if (_match_resource_to_widget(w, part)) {
+        if (token == '.') {
+            if (local_index == NULL) {
+                if (last_token == '.') {
+                    _set_resource_values(w, resource, value, last_part);
+                }
+                else if (last_token == '*') {
+                    _set_resource_values(w, resource, value, last_part);
+                    _apply_values_to_children(w,
+                                              remainder, resource, value,
+                                              last_token, last_part);
+                }
+            }
+            else
+                _search_child(w, local_index, remainder,
+                              resource, value, last_token, last_part);
+            XtFree(part);
+            return;
+        }
+        if (token == '*') {
+            if (local_index == NULL) {
+                if (last_token == '.') {
+                    _set_resource_values(w, resource, value, last_part);
+                }
+                else if (last_token == '*') {
+                    _set_resource_values(w, resource, value, last_part);
+                    _apply_values_to_children(w,
+                                              remainder, resource, value,
+                                              last_token, last_part);
+                }
+            }
+            else
+                _search_child(w, local_index, remainder,
+                              resource, value, last_token, last_part);
+        }
+    }
+    else {                      /* if the widget name and class don't match the part */
+        /* if (token == '.') just continue looping */
+
+        if (token == '*') {
+            _search_child(w, indx, remainder, resource, value,
+                          last_token, last_part);
+        }
+    }
+
+    XtFree(part);
 }
 
 /*
  * NAME: _get_last_part
  *
  * FUNCTION:
- * 	This routine will parse off the last segment of a resource string
- * 	and its token and return them.  the remainder of resource is also
- * 	returned.  strcoll is used to guarantee no problems with
- *	international strings.
+ *      This routine will parse off the last segment of a resource string
+ *      and its token and return them.  the remainder of resource is also
+ *      returned.  strcoll is used to guarantee no problems with
+ *      international strings.
  *
  * PARAMETERS:
- *	remainder	the part of the resource string left over
- *	part		the parsed off part of the resource string
+ *      remainder       the part of the resource string left over
+ *      part            the parsed off part of the resource string
  *
  * RETURN VALUES:
- *	char		the token (* or . or ?) preceding the resource part
- *	remainder	the part of the resource string left over
- *	part		the parsed off part of the resource string
+ *      char            the token (* or . or ?) preceding the resource part
+ *      remainder       the part of the resource string left over
+ *      part            the parsed off part of the resource string
  *
  * ERRORS: none
  */
 static char
-_get_last_part (
-	char *remainder,
-	char **part)
+_get_last_part(char *remainder, char **part)
 {
-	char	*loose, *tight;
-
-	loose = strrchr (remainder, '*');
-	tight = strrchr (remainder, '.');
-
-	if ((loose == NULL) && (tight == NULL)) {
-		*part = XtNewString (remainder);
-		return ('.');
-	}
-	if ((loose == NULL) || (tight && (strcoll (loose, tight) < 0))) {
-		*tight++ = '\0';	/* shorten the remainder string */
-		*part = XtNewString (tight);
-		return ('.');
-	}
-	if ((tight == NULL) || (loose && (strcoll (tight, loose) < 0))) {
-		*loose++ = '\0';
-		*part = XtNewString (loose);
-		return ('*');
-	}
-	*part = NULL;
-
-	return ('0');	/* error - return 0 */
+    char *loose, *tight;
+
+    loose = strrchr(remainder, '*');
+    tight = strrchr(remainder, '.');
+
+    if ((loose == NULL) && (tight == NULL)) {
+        *part = XtNewString(remainder);
+        return ('.');
+    }
+    if ((loose == NULL) || (tight && (strcoll(loose, tight) < 0))) {
+        *tight++ = '\0';        /* shorten the remainder string */
+        *part = XtNewString(tight);
+        return ('.');
+    }
+    if ((tight == NULL) || (loose && (strcoll(tight, loose) < 0))) {
+        *loose++ = '\0';
+        *part = XtNewString(loose);
+        return ('*');
+    }
+    *part = NULL;
+
+    return ('0');               /* error - return 0 */
 }
 
 /*
  * NAME: _search_widget_tree
  *
  * FUNCTION:
- *	This function tries to match a resource string to the widgets
- *	it applies to.  The functions it invokes to do this then set
- *	the value for that resource to each widget.
- *
- *	The resource string has to be parsed into the following format:
- *		resource = App*Form*button1.background
- *		remainder = *Form*button1
- *		last_part = background		last_token = .
- *	As the widget tree is recursively descended, these variables are
- *	passed.  The remainder is parsed at each level in the widget
- *	tree as the _set_and_search function attempts to match
- *	the resource part (eg. part = Form  token = *) to a widget.  When
- *	the entire resource string has been matched, the _set_resource_values
- *	functions is called to apply the value to the widget or widgets.
+ *      This function tries to match a resource string to the widgets
+ *      it applies to.  The functions it invokes to do this then set
+ *      the value for that resource to each widget.
+ *
+ *      The resource string has to be parsed into the following format:
+ *              resource = App*Form*button1.background
+ *              remainder = *Form*button1
+ *              last_part = background          last_token = .
+ *      As the widget tree is recursively descended, these variables are
+ *      passed.  The remainder is parsed at each level in the widget
+ *      tree as the _set_and_search function attempts to match
+ *      the resource part (eg. part = Form  token = *) to a widget.  When
+ *      the entire resource string has been matched, the _set_resource_values
+ *      functions is called to apply the value to the widget or widgets.
  *
  * PARAMETERS:
- *	w		a widget from whose toplevel shell ancestor
- *			the search will start
- *	resource	the resource string to match
- *	value		the value to apply
+ *      w               a widget from whose toplevel shell ancestor
+ *                      the search will start
+ *      resource        the resource string to match
+ *      value           the value to apply
  *
  * RETURN VALUES: none
  *
  * ERRORS: none
  */
 static void
-_search_widget_tree (
-	Widget w,
-	char *resource,
-	char *value)
+_search_widget_tree(Widget w, char *resource, char *value)
 {
-	Widget	parent = w;
-	char	*last_part;
-	char	*remainder = NULL;
-	char	last_token;
-	char	*loose, *tight;
-	int	loose_len, tight_len;
-
-	/*
-	 * Find the root of the tree given any widget
-	 */
-	while (XtParent(parent) != NULL) {
-		parent = XtParent(parent);
-	}
+    Widget parent = w;
+    char *last_part;
+    char *remainder = NULL;
+    char last_token;
+    char *loose, *tight;
+    int loose_len, tight_len;
+
+    /*
+     * Find the root of the tree given any widget
+     */
+    while (XtParent(parent) != NULL) {
+        parent = XtParent(parent);
+    }
 #ifdef DEBUG
-	if (XtIsWidget (w) && XtIsWidget (parent))
-		fprintf (stderr, "widget = %s parent = %s\n",
-			w->core.name, parent->core.name);
-	else
-		fprintf (stderr, "widget = NULL parent = NULL\n");
+    if (XtIsWidget(w) && XtIsWidget(parent))
+        fprintf(stderr, "widget = %s parent = %s\n",
+                w->core.name, parent->core.name);
+    else
+        fprintf(stderr, "widget = NULL parent = NULL\n");
 #endif
 
-	/*
-	 * parse off the Class name that was prepended to this string in
-	 * a customizing tool
-	 */
-	loose = strchr (resource, '*');
-	tight = strchr (resource, '.');
-	if ((loose == NULL) && (tight == NULL))
-		return;
-
-	loose_len = (loose) ? (int) strlen (loose) : 0;
-	tight_len = (tight) ? (int) strlen (tight) : 0;
-
-	if ((loose == NULL) || (tight_len > loose_len))
-		remainder = XtNewString (tight);
-	else if ((tight == NULL) || (loose_len > tight_len))
-		remainder = XtNewString (loose);
-
-	/*
-	 * Parse last segment off of resource string, (eg. background, font,
-	 * etc.)
-	 */
-	if (remainder) {
-	    last_token = _get_last_part (remainder, &last_part);
-	    /*
-	     * this case covers resources of only one level (eg. *background)
-	     */
-	    if (remainder[0] == 0) {
-		    _set_resource_values (w, resource, value, last_part);
-		    if (last_token == '*')
-			    _apply_values_to_children (parent, remainder, resource,
-				    value, last_token, last_part);
-	    /*
-	     * all other resource strings are recursively applied to the widget tree.
-	     * Prepend a '.' to the remainder string if there is no leading token.
-	     */
-	    } else {
-		    char *indx, *copy;
-		    if (remainder[0] != '*' && remainder[0] != '.') {
-			    XtAsprintf (&copy, ".%s", remainder);
-			    XtFree (remainder);
-			    remainder = copy;
-		    }
-		    indx = remainder;
-		    _set_and_search (parent, indx, remainder, resource, value,
-			    last_token, last_part);
-	    }
-
-	    XtFree (remainder);
-	    XtFree (last_part);
-	}
+    /*
+     * parse off the Class name that was prepended to this string in
+     * a customizing tool
+     */
+    loose = strchr(resource, '*');
+    tight = strchr(resource, '.');
+    if ((loose == NULL) && (tight == NULL))
+        return;
+
+    loose_len = (loose) ? (int) strlen(loose) : 0;
+    tight_len = (tight) ? (int) strlen(tight) : 0;
+
+    if ((loose == NULL) || (tight_len > loose_len))
+        remainder = XtNewString(tight);
+    else if ((tight == NULL) || (loose_len > tight_len))
+        remainder = XtNewString(loose);
+
+    /*
+     * Parse last segment off of resource string, (eg. background, font,
+     * etc.)
+     */
+    if (remainder) {
+        last_token = _get_last_part(remainder, &last_part);
+        /*
+         * this case covers resources of only one level (eg. *background)
+         */
+        if (remainder[0] == 0) {
+            _set_resource_values(w, resource, value, last_part);
+            if (last_token == '*')
+                _apply_values_to_children(parent, remainder, resource,
+                                          value, last_token, last_part);
+            /*
+             * all other resource strings are recursively applied to the widget tree.
+             * Prepend a '.' to the remainder string if there is no leading token.
+             */
+        }
+        else {
+            char *indx, *copy;
+
+            if (remainder[0] != '*' && remainder[0] != '.') {
+                XtAsprintf(&copy, ".%s", remainder);
+                XtFree(remainder);
+                remainder = copy;
+            }
+            indx = remainder;
+            _set_and_search(parent, indx, remainder, resource, value,
+                            last_token, last_part);
+        }
+
+        XtFree(remainder);
+        XtFree(last_part);
+    }
 }
 
 /*
  * NAME: _locate_children
  *
  * FUNCTION:
- *	returns a list of all of a widget's children
+ *      returns a list of all of a widget's children
  *
  * PARAMETERS:
- *	w		the parent to search for its children
- *	children	the list of children that is created
- *	normal		flag for normal children
- *	popup		flag for popup children
+ *      w               the parent to search for its children
+ *      children        the list of children that is created
+ *      normal          flag for normal children
+ *      popup           flag for popup children
  *
  * RETURN VALUES:
- *	int		the number of children
- *	children	the list of children found
+ *      int             the number of children
+ *      children        the list of children found
  *
  * ERRORS: none
  */
 static int
-_locate_children (
-	Widget parent,
-	Widget **children)
+_locate_children(Widget parent, Widget **children)
 {
-	CompositeWidget comp = (CompositeWidget) parent;
-	Cardinal	i;
-	int	num_children = 0;
-	int	current = 0;
-
-	/*
-	 * count the number of children
-	 */
-	if (XtIsWidget (parent))
-		num_children = (int) ((Cardinal) num_children + parent->core.num_popups);
-	if (XtIsComposite (parent))
-		num_children = (int) ((Cardinal) num_children + comp->composite.num_children);
-	if (num_children == 0) {
-		*children = NULL;
-		return (0);
-	}
-
-	*children = (Widget *)
-		XtMalloc ((Cardinal) (sizeof(Widget) * (size_t) num_children));
-
-	if (XtIsComposite (parent)) {
-		for (i=0; i<comp->composite.num_children; i++) {
-			(*children)[current] = comp->composite.children[i];
-			current++;
-		}
-	}
-
-	if (XtIsWidget (parent)) {
-		for (i=0; i<parent->core.num_popups; i++) {
-			(*children)[current] = comp->core.popup_list[i];
-			current++;
-		}
-	}
-
-	return (num_children);
+    CompositeWidget comp = (CompositeWidget) parent;
+    Cardinal i;
+    int num_children = 0;
+    int current = 0;
+
+    /*
+     * count the number of children
+     */
+    if (XtIsWidget(parent))
+        num_children =
+            (int) ((Cardinal) num_children + parent->core.num_popups);
+    if (XtIsComposite(parent))
+        num_children =
+            (int) ((Cardinal) num_children + comp->composite.num_children);
+    if (num_children == 0) {
+        *children = NULL;
+        return (0);
+    }
+
+    *children = (Widget *)
+        XtMalloc((Cardinal) (sizeof(Widget) * (size_t) num_children));
+
+    if (XtIsComposite(parent)) {
+        for (i = 0; i < comp->composite.num_children; i++) {
+            (*children)[current] = comp->composite.children[i];
+            current++;
+        }
+    }
+
+    if (XtIsWidget(parent)) {
+        for (i = 0; i < parent->core.num_popups; i++) {
+            (*children)[current] = comp->core.popup_list[i];
+            current++;
+        }
+    }
+
+    return (num_children);
 }
 
 #ifdef DEBUG
@@ -816,48 +802,47 @@ _locate_children (
  * NAME: dump_widget_tree
  *
  * FUNCTION:
- *	recursively printout entire widget tree
+ *      recursively printout entire widget tree
  *
  * PARAMETERS:
- *	w		the widget to match
- *	indent		the amount to indent each line
+ *      w               the widget to match
+ *      indent          the amount to indent each line
  *
  * RETURN VALUES: void
  *
  * ERRORS: none
  */
 static void
-dump_widget_tree (
-	Widget w,
-	int	indent)
+dump_widget_tree(Widget w, int indent)
 {
-	int 	i,j;
-	int	num_children;
-	Widget	*children;
-
-	/*
-	 * Recursively search through the children
-	 */
-	num_children = _locate_children (w, &children);
-	indent += 2;
-	for (i=0; i<num_children; i++) {
-		if (children[i] != NULL) {
-			for (j=0; j<indent; j++)
-				fprintf (stderr, " ");
-			if (XtIsWidget (children[i])) {
-				fprintf (stderr, "(%s)\t",children[i]->core.name);
-				fprintf (stderr, "(%s)\n",
-			children[i]->core.widget_class->core_class.class_name);
-			} else {
-				fprintf (stderr, "(NULL)\t");
-				fprintf (stderr, "(%s)\n",
-			children[i]->core.widget_class->core_class.class_name);
-			}
-		}
-		dump_widget_tree (children[i], indent);
-	}
-
-	XtFree ((char *)children);
+    int i, j;
+    int num_children;
+    Widget *children;
+
+    /*
+     * Recursively search through the children
+     */
+    num_children = _locate_children(w, &children);
+    indent += 2;
+    for (i = 0; i < num_children; i++) {
+        if (children[i] != NULL) {
+            for (j = 0; j < indent; j++)
+                fprintf(stderr, " ");
+            if (XtIsWidget(children[i])) {
+                fprintf(stderr, "(%s)\t", children[i]->core.name);
+                fprintf(stderr, "(%s)\n",
+                        children[i]->core.widget_class->core_class.class_name);
+            }
+            else {
+                fprintf(stderr, "(NULL)\t");
+                fprintf(stderr, "(%s)\n",
+                        children[i]->core.widget_class->core_class.class_name);
+            }
+        }
+        dump_widget_tree(children[i], indent);
+    }
+
+    XtFree((char *) children);
 }
 #endif
 
@@ -865,148 +850,149 @@ dump_widget_tree (
  * NAME: _XtResourceConfiguationEH
  *
  * FUNCTION:
- *	This function is the event handler for the on-the-fly communication
- *	with a resource customization tool.  This event handler must be
+ *      This function is the event handler for the on-the-fly communication
+ *      with a resource customization tool.  This event handler must be
  *      registered for the toplevel shell of each app.  This is best done
  *      in the _XtCreatePopupShell and _XtAppCreateShell functions in Xt's
- *	Create.c source file.
- *
- * 	The property used to communicate with a customizing tool is
- *	placed on the toplevel shell window of the application.  The
- *	customizing tool places a property on this window which causes
- *	this event handler to be invoked via the PropertyNotify event.
- *	This event handler reads the property and then deletes it from
- *	the server.  The contents of the property are a resource string
- *	and value.  The event handler then calls functions to walk the
- *	applications widget tree, determining which widgets are affected
- *	by the resource string, and then applying the value with XtSetValues.
+ *      Create.c source file.
+ *
+ *      The property used to communicate with a customizing tool is
+ *      placed on the toplevel shell window of the application.  The
+ *      customizing tool places a property on this window which causes
+ *      this event handler to be invoked via the PropertyNotify event.
+ *      This event handler reads the property and then deletes it from
+ *      the server.  The contents of the property are a resource string
+ *      and value.  The event handler then calls functions to walk the
+ *      applications widget tree, determining which widgets are affected
+ *      by the resource string, and then applying the value with XtSetValues.
  *
  * PARAMETERS:
- *	w		the widget that invoked this event handler
- *	client_data	not used
- *	event		the event structure
+ *      w               the widget that invoked this event handler
+ *      client_data     not used
+ *      event           the event structure
  *
  * RETURN VALUES: none
  *
  * ERRORS: none
  */
-/* ARGSUSED */
 void
-_XtResourceConfigurationEH (
-	Widget w,
-	XtPointer client_data,
-	XEvent *event)
+_XtResourceConfigurationEH(Widget w,
+                           XtPointer client_data _X_UNUSED,
+                           XEvent *event)
 {
-	Atom		actual_type;
-	int		actual_format;
-	unsigned long	nitems;
-	unsigned long	leftover;
-	char		*data = NULL;
-	char		*data_ptr;
+    Atom actual_type;
+    int actual_format;
+    unsigned long nitems;
+    unsigned long leftover;
+    char *data = NULL;
+    char *data_ptr;
+
 #ifdef DEBUG
-	int		indent = 0;
+    int indent = 0;
 #endif
-	XtPerDisplay	pd;
+    XtPerDisplay pd;
 
 #ifdef DEBUG
-	fprintf (stderr, "in _XtResourceConfiguationEH atom = %u\n",(unsigned) event->xproperty.atom);
-	fprintf (stderr, "    window = %x\n", (unsigned) XtWindow (w));
-	if (XtIsWidget (w))
-		fprintf (stderr, "    widget = %zx   name = %s\n", (size_t)w, w->core.name);
+    fprintf(stderr, "in _XtResourceConfiguationEH atom = %u\n",
+            (unsigned) event->xproperty.atom);
+    fprintf(stderr, "    window = %x\n", (unsigned) XtWindow(w));
+    if (XtIsWidget(w))
+        fprintf(stderr, "    widget = %zx   name = %s\n", (size_t) w,
+                w->core.name);
 #endif
 
-	pd = _XtGetPerDisplay (XtDisplay (w));
+    pd = _XtGetPerDisplay(XtDisplay(w));
 
-	/*
-	 * The window on which a customizing tool places the property
-	 * is determined at this point.  It should be the applications
-	 * toplevel shell window.
-	 *
-	 * A customizing tool sends a "ping" to the application on
-	 * the RCM_INIT property.  The application answers the ping
-	 * by deleting the property.
-	 */
-	if (event->xproperty.atom == pd->rcm_init) {
-		XDeleteProperty (XtDisplay(w), XtWindow (w), pd->rcm_init);
+    /*
+     * The window on which a customizing tool places the property
+     * is determined at this point.  It should be the applications
+     * toplevel shell window.
+     *
+     * A customizing tool sends a "ping" to the application on
+     * the RCM_INIT property.  The application answers the ping
+     * by deleting the property.
+     */
+    if (event->xproperty.atom == pd->rcm_init) {
+        XDeleteProperty(XtDisplay(w), XtWindow(w), pd->rcm_init);
 
 #ifdef DEBUG
-		if (XtIsWidget (w))
-			fprintf (stderr, "%s\n", w->core.name);
-		else
-			fprintf (stderr, "NULL name\n");
-		dump_widget_tree(w, indent);
+        if (XtIsWidget(w))
+            fprintf(stderr, "%s\n", w->core.name);
+        else
+            fprintf(stderr, "NULL name\n");
+        dump_widget_tree(w, indent);
 
-		fprintf (stderr, "answer ping\n");
+        fprintf(stderr, "answer ping\n");
 #endif
-	}
-
-	/*
-	 * This event handler ignores any property notify events that
-	 * are not RCM_INIT or RCM_DATA
-	 */
-	if (event->xproperty.atom != pd->rcm_data)
-		return;
-
-	/*
-	 * Retrieve the data from the property
-	 */
+    }
+
+    /*
+     * This event handler ignores any property notify events that
+     * are not RCM_INIT or RCM_DATA
+     */
+    if (event->xproperty.atom != pd->rcm_data)
+        return;
+
+    /*
+     * Retrieve the data from the property
+     */
 #ifdef DEBUG
-	fprintf (stderr, "receiving RCM_DATA property\n");
+    fprintf(stderr, "receiving RCM_DATA property\n");
 #endif
-	if (XGetWindowProperty (XtDisplay(w),
-		XtWindow (w),
-		pd->rcm_data, 0L, 8192L,
-		TRUE, XA_STRING,
-		&actual_type, &actual_format, &nitems, &leftover,
-		(unsigned char **)&data ) == Success && actual_type == XA_STRING
-			   && actual_format == 8) {
-	/*
-	 *      data format is:
-	 *
-	 *      resource_length, resource, value
-	 *
-	 *      convert the resource_length to a long, skip over it, put a
-	 *      zero byte at the end of the resource, and pick off the
-	 *      resource and value fields.
-	 */
-		if (data) {
-			char *data_end = data + nitems;
-			char *data_value;
-			unsigned long resource_len;
-
-			resource_len = strtoul (data, &data_ptr, 10);
-
-			if (data_ptr != (char *) data) {
-				data_ptr++;
-				data_value = data_ptr + resource_len;
-			} else /* strtoul failed to convert a number */
-				data_ptr = data_value = NULL;
-
-			if (data_value > data_ptr && data_value < data_end) {
-				char *resource;
-				char *value;
-
-				*data_value++ = '\0';
-
-				resource = XtNewString (data_ptr);
-				value = XtNewString (data_value);
+    if (XGetWindowProperty(XtDisplay(w),
+                           XtWindow(w),
+                           pd->rcm_data, 0L, 8192L,
+                           TRUE, XA_STRING,
+                           &actual_type, &actual_format, &nitems, &leftover,
+                           (unsigned char **) &data) == Success &&
+        actual_type == XA_STRING && actual_format == 8) {
+        /*
+         *      data format is:
+         *
+         *      resource_length, resource, value
+         *
+         *      convert the resource_length to a long, skip over it, put a
+         *      zero byte at the end of the resource, and pick off the
+         *      resource and value fields.
+         */
+        if (data) {
+            char *data_end = data + nitems;
+            char *data_value;
+            unsigned long resource_len;
+
+            resource_len = strtoul(data, &data_ptr, 10);
+
+            if (data_ptr != (char *) data) {
+                data_ptr++;
+                data_value = data_ptr + resource_len;
+            }
+            else                /* strtoul failed to convert a number */
+                data_ptr = data_value = NULL;
+
+            if (data_value > data_ptr && data_value < data_end) {
+                char *resource;
+                char *value;
+
+                *data_value++ = '\0';
+
+                resource = XtNewString(data_ptr);
+                value = XtNewString(data_value);
 #ifdef DEBUG
-				fprintf (stderr, "resource_len=%lu\n",
-					 resource_len);
-				fprintf (stderr, "resource = %s\t value = %s\n",
-					 resource, value);
+                fprintf(stderr, "resource_len=%lu\n", resource_len);
+                fprintf(stderr, "resource = %s\t value = %s\n",
+                        resource, value);
 #endif
-				/*
-				 * descend the application widget tree and
-				 * apply the value to the appropriate widgets
-				 */
-				_search_widget_tree (w, resource, value);
-
-				XtFree (resource);
-				XtFree (value);
-			}
-		}
-	}
-
-	XFree ((char *)data);
+                /*
+                 * descend the application widget tree and
+                 * apply the value to the appropriate widgets
+                 */
+                _search_widget_tree(w, resource, value);
+
+                XtFree(resource);
+                XtFree(value);
+            }
+        }
+    }
+
+    XFree((char *) data);
 }
diff --git a/src/Resources.c b/src/Resources.c
index 83ffd4c..4512517 100644
--- a/src/Resources.c
+++ b/src/Resources.c
@@ -68,7 +68,6 @@ in this Software without prior written authorization from The Open Group.
 
 */
 
-/*LINTLIBRARY*/
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -79,165 +78,177 @@ in this Software without prior written authorization from The Open Group.
 #include "StringDefs.h"
 #include <stdio.h>
 
-static XrmClass	QBoolean, QString, QCallProc, QImmediate;
+static XrmClass QBoolean, QString, QCallProc, QImmediate;
 static XrmName QinitialResourcesPersistent, QInitialResourcesPersistent;
 static XrmClass QTranslations, QTranslationTable;
 static XrmName Qtranslations, QbaseTranslations;
 static XrmName Qscreen;
 static XrmClass QScreen;
 
-
-void _XtCopyFromParent(
-    Widget      widget,
-    int		offset,
-    XrmValue    *value)
+void
+_XtCopyFromParent(Widget widget, int offset, XrmValue *value)
 {
     if (widget->core.parent == NULL) {
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidParent","xtCopyFromParent",XtCXtToolkitError,
-                  "CopyFromParent must have non-NULL parent",
-		  NULL, NULL);
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidParent", "xtCopyFromParent", XtCXtToolkitError,
+                        "CopyFromParent must have non-NULL parent", NULL, NULL);
         value->addr = NULL;
         return;
     }
-    value->addr = (XPointer)(((char *)widget->core.parent) + offset);
-} /* _XtCopyFromParent */
-
+    value->addr = (XPointer) (((char *) widget->core.parent) + offset);
+}                               /* _XtCopyFromParent */
 
-void _XtCopyFromArg(
-    XtArgVal src,
-    char* dst,
-    register unsigned int size)
+void
+_XtCopyFromArg(XtArgVal src, char *dst, register unsigned int size)
 {
     if (size > sizeof(XtArgVal))
-	(void) memmove((char *) dst, (char *)  src, (size_t) size);
+        (void) memmove((char *) dst, (char *) src, (size_t) size);
     else {
-	union {
-	    long	longval;
+        union {
+            long longval;
 #ifdef LONG64
-	    int		intval;
+            int intval;
 #endif
-	    short	shortval;
-	    char	charval;
-	    char*	charptr;
-	    XtPointer	ptr;
-	} u;
-	char *p = (char*)&u;
-	if	(size == sizeof(long))	    u.longval = (long)src;
+            short shortval;
+            char charval;
+            char *charptr;
+            XtPointer ptr;
+        } u;
+        char *p = (char *) &u;
+
+        if (size == sizeof(long))
+            u.longval = (long) src;
 #ifdef LONG64
-	else if (size == sizeof(int))	    u.intval = (int)src;
+        else if (size == sizeof(int))
+            u.intval = (int) src;
 #endif
-	else if (size == sizeof(short))	    u.shortval = (short)src;
-	else if (size == sizeof(char))	    u.charval = (char)src;
-	else if (size == sizeof(XtPointer)) u.ptr = (XtPointer)src;
-	else if (size == sizeof(char*))	    u.charptr = (char*)src;
-	else				    p = (char*)&src;
-
-	(void) memmove(dst, p, (size_t) size);
+        else if (size == sizeof(short))
+            u.shortval = (short) src;
+        else if (size == sizeof(char))
+            u.charval = (char) src;
+        else if (size == sizeof(XtPointer))
+            u.ptr = (XtPointer) src;
+        else if (size == sizeof(char *))
+            u.charptr = (char *) src;
+        else
+            p = (char *) &src;
+
+        (void) memmove(dst, p, (size_t) size);
     }
-} /* _XtCopyFromArg */
+}                               /* _XtCopyFromArg */
 
-void _XtCopyToArg(
-    char* src,
-    XtArgVal *dst,
-    register unsigned int size)
+void
+_XtCopyToArg(char *src, XtArgVal *dst, register unsigned int size)
 {
     if (!*dst) {
 #ifdef GETVALUES_BUG
-	/* old GetValues semantics (storing directly into arglists) are bad,
-	 * but preserve for compatibility as long as arglist contains NULL.
-	 */
-	union {
-	    long	longval;
+        /* old GetValues semantics (storing directly into arglists) are bad,
+         * but preserve for compatibility as long as arglist contains NULL.
+         */
+        union {
+            long longval;
 #ifdef LONG64
-	    int		intval;
+            int intval;
 #endif
-	    short	shortval;
-	    char	charval;
-	    char*	charptr;
-	    XtPointer	ptr;
-	} u;
-	if (size <= sizeof(XtArgVal)) {
-	    (void) memmove((char*)&u, (char*)src, (size_t)size );
-	    if	    (size == sizeof(long)) 	*dst = (XtArgVal)u.longval;
+            short shortval;
+            char charval;
+            char *charptr;
+            XtPointer ptr;
+        } u;
+
+        if (size <= sizeof(XtArgVal)) {
+            (void) memmove((char *) &u, (char *) src, (size_t) size);
+            if (size == sizeof(long))
+                *dst = (XtArgVal) u.longval;
 #ifdef LONG64
-	    else if (size == sizeof(int))	*dst = (XtArgVal)u.intval;
+            else if (size == sizeof(int))
+                *dst = (XtArgVal) u.intval;
 #endif
-	    else if (size == sizeof(short))	*dst = (XtArgVal)u.shortval;
-	    else if (size == sizeof(char))	*dst = (XtArgVal)u.charval;
-	    else if (size == sizeof(char*))	*dst = (XtArgVal)u.charptr;
-	    else if (size == sizeof(XtPointer))	*dst = (XtArgVal)u.ptr;
-	    else (void) memmove((char*)dst, (char*)src, (size_t)size );
-	}
-	else
-	    (void) memmove((char*)dst, (char*)src, (size_t)size );
+            else if (size == sizeof(short))
+                *dst = (XtArgVal) u.shortval;
+            else if (size == sizeof(char))
+                *dst = (XtArgVal) u.charval;
+            else if (size == sizeof(char *))
+                *dst = (XtArgVal) u.charptr;
+            else if (size == sizeof(XtPointer))
+                *dst = (XtArgVal) u.ptr;
+            else
+                (void) memmove((char *) dst, (char *) src, (size_t) size);
+        }
+        else
+            (void) memmove((char *) dst, (char *) src, (size_t) size);
 #else
-	XtErrorMsg("invalidGetValues", "xtGetValues", XtCXtToolkitError,
-	    "NULL ArgVal in XtGetValues", NULL, NULL);
+        XtErrorMsg("invalidGetValues", "xtGetValues", XtCXtToolkitError,
+                   "NULL ArgVal in XtGetValues", NULL, NULL);
 #endif
     }
     else {
-	/* proper GetValues semantics: argval is pointer to destination */
-	(void) memmove((char*)*dst, (char*)src, (size_t)size );
+        /* proper GetValues semantics: argval is pointer to destination */
+        (void) memmove((char *) *dst, (char *) src, (size_t) size);
     }
-} /* _XtCopyToArg */
+}                               /* _XtCopyToArg */
 
-static void CopyToArg(
-    char* src,
-    XtArgVal *dst,
-    register unsigned int size)
+static void
+CopyToArg(char *src, XtArgVal *dst, register unsigned int size)
 {
     if (!*dst) {
-	/* old GetValues semantics (storing directly into arglists) are bad,
-	 * but preserve for compatibility as long as arglist contains NULL.
-	 */
-	union {
-	    long	longval;
+        /* old GetValues semantics (storing directly into arglists) are bad,
+         * but preserve for compatibility as long as arglist contains NULL.
+         */
+        union {
+            long longval;
 #ifdef LONG64
-	    int		intval;
+            int intval;
 #endif
-	    short	shortval;
-	    char	charval;
-	    char*	charptr;
-	    XtPointer	ptr;
-	} u;
-	if (size <= sizeof(XtArgVal)) {
-	    (void) memmove((char*)&u, (char*)src, (size_t)size );
-	    if	    (size == sizeof(long)) 	*dst = (XtArgVal)u.longval;
+            short shortval;
+            char charval;
+            char *charptr;
+            XtPointer ptr;
+        } u;
+
+        if (size <= sizeof(XtArgVal)) {
+            (void) memmove((char *) &u, (char *) src, (size_t) size);
+            if (size == sizeof(long))
+                *dst = (XtArgVal) u.longval;
 #ifdef LONG64
-	    else if (size == sizeof(int))	*dst = (XtArgVal)u.intval;
+            else if (size == sizeof(int))
+                *dst = (XtArgVal) u.intval;
 #endif
-	    else if (size == sizeof(short))	*dst = (XtArgVal)u.shortval;
-	    else if (size == sizeof(char))	*dst = (XtArgVal)u.charval;
-	    else if (size == sizeof(char*))	*dst = (XtArgVal)u.charptr;
-	    else if (size == sizeof(XtPointer))	*dst = (XtArgVal)u.ptr;
-	    else (void) memmove((char*)dst, (char*)src, (size_t)size );
-	}
-	else
-	    (void) memmove((char*)dst, (char*)src, (size_t)size );
+            else if (size == sizeof(short))
+                *dst = (XtArgVal) u.shortval;
+            else if (size == sizeof(char))
+                *dst = (XtArgVal) u.charval;
+            else if (size == sizeof(char *))
+                *dst = (XtArgVal) u.charptr;
+            else if (size == sizeof(XtPointer))
+                *dst = (XtArgVal) u.ptr;
+            else
+                (void) memmove((char *) dst, (char *) src, (size_t) size);
+        }
+        else
+            (void) memmove((char *) dst, (char *) src, (size_t) size);
     }
     else {
-	/* proper GetValues semantics: argval is pointer to destination */
-	(void) memmove((char*)*dst, (char*)src, (size_t)size );
+        /* proper GetValues semantics: argval is pointer to destination */
+        (void) memmove((char *) *dst, (char *) src, (size_t) size);
     }
-} /* CopyToArg */
+}                               /* CopyToArg */
 
-
-static Cardinal CountTreeDepth(
-    Widget w)
+static Cardinal
+CountTreeDepth(Widget w)
 {
     Cardinal count;
 
     for (count = 1; w != NULL; w = (Widget) w->core.parent)
-	count++;
+        count++;
 
     return count;
 }
 
-static void GetNamesAndClasses(
-    register Widget	  w,
-    register XrmNameList  names,
-    register XrmClassList classes)
+static void
+GetNamesAndClasses(register Widget w,
+                   register XrmNameList names,
+                   register XrmClassList classes)
 {
     register Cardinal length, j;
     register XrmQuark t;
@@ -248,38 +259,39 @@ static void GetNamesAndClasses(
 
     LOCK_PROCESS;
     for (length = 0; w != NULL; w = (Widget) w->core.parent) {
-	names[length] = w->core.xrm_name;
-	class = XtClass(w);
-	/* KLUDGE KLUDGE KLUDGE KLUDGE */
-	if (w->core.parent == NULL && XtIsApplicationShell(w)) {
-	    classes[length] =
-		((ApplicationShellWidget) w)->application.xrm_class;
-	} else classes[length] = class->core_class.xrm_class;
-	length++;
-     }
+        names[length] = w->core.xrm_name;
+        class = XtClass(w);
+        /* KLUDGE KLUDGE KLUDGE KLUDGE */
+        if (w->core.parent == NULL && XtIsApplicationShell(w)) {
+            classes[length] =
+                ((ApplicationShellWidget) w)->application.xrm_class;
+        }
+        else
+            classes[length] = class->core_class.xrm_class;
+        length++;
+    }
     UNLOCK_PROCESS;
     /* They're in backwards order, flop them around */
-    for (j = 0; j < length/2; j++) {
-	t = names[j];
-	names[j] = names[length-j-1];
-	names[length-j-1] = t;
+    for (j = 0; j < length / 2; j++) {
+        t = names[j];
+        names[j] = names[length - j - 1];
+        names[length - j - 1] = t;
         t = classes[j];
-	classes[j] = classes[length-j-1];
-	classes[length-j-1] = t;
+        classes[j] = classes[length - j - 1];
+        classes[length - j - 1] = t;
     }
     names[length] = NULLQUARK;
     classes[length] = NULLQUARK;
-} /* GetNamesAndClasses */
+}                               /* GetNamesAndClasses */
 
+/* Spiffy fast compiled form of resource list.                          */
+/* XtResourceLists are compiled in-place into XrmResourceLists          */
+/* All atoms are replaced by quarks, and offsets are -offset-1 to       */
+/* indicate that this list has been compiled already                    */
 
-/* Spiffy fast compiled form of resource list.				*/
-/* XtResourceLists are compiled in-place into XrmResourceLists		*/
-/* All atoms are replaced by quarks, and offsets are -offset-1 to	*/
-/* indicate that this list has been compiled already			*/
-
-void _XtCompileResourceList(
-    register XtResourceList resources,
-    	     Cardinal       num_resources)
+void
+_XtCompileResourceList(register XtResourceList resources,
+                       Cardinal num_resources)
 {
     register Cardinal count;
 
@@ -287,50 +299,49 @@ void _XtCompileResourceList(
 #define PSToQ   XrmPermStringToQuark
 
     for (count = 0; count < num_resources; resources++, count++) {
-    	xrmres->xrm_name	 = PSToQ(resources->resource_name);
-    	xrmres->xrm_class	 = PSToQ(resources->resource_class);
-    	xrmres->xrm_type	 = PSToQ(resources->resource_type);
-        xrmres->xrm_offset	 = (int)
-		(-(int)resources->resource_offset - 1);
-    	xrmres->xrm_default_type = PSToQ(resources->default_type);
+        xrmres->xrm_name = PSToQ(resources->resource_name);
+        xrmres->xrm_class = PSToQ(resources->resource_class);
+        xrmres->xrm_type = PSToQ(resources->resource_type);
+        xrmres->xrm_offset = (int)
+            (-(int) resources->resource_offset - 1);
+        xrmres->xrm_default_type = PSToQ(resources->default_type);
     }
 #undef PSToQ
 #undef xrmres
-} /* _XtCompileResourceList */
+}                               /* _XtCompileResourceList */
 
 /* Like _XtCompileResourceList, but strings are not permanent */
-static void  XrmCompileResourceListEphem(
-    register XtResourceList resources,
-    	     Cardinal       num_resources)
+static void
+XrmCompileResourceListEphem(register XtResourceList resources,
+                            Cardinal num_resources)
 {
     register Cardinal count;
 
 #define xrmres  ((XrmResourceList) resources)
 
     for (count = 0; count < num_resources; resources++, count++) {
-    	xrmres->xrm_name	 = StringToName(resources->resource_name);
-    	xrmres->xrm_class	 = StringToClass(resources->resource_class);
-    	xrmres->xrm_type	 = StringToQuark(resources->resource_type);
-        xrmres->xrm_offset	 = (int)
-		(-(int)resources->resource_offset - 1);
-    	xrmres->xrm_default_type = StringToQuark(resources->default_type);
+        xrmres->xrm_name = StringToName(resources->resource_name);
+        xrmres->xrm_class = StringToClass(resources->resource_class);
+        xrmres->xrm_type = StringToQuark(resources->resource_type);
+        xrmres->xrm_offset = (int)
+            (-(int) resources->resource_offset - 1);
+        xrmres->xrm_default_type = StringToQuark(resources->default_type);
     }
 #undef xrmres
-} /* XrmCompileResourceListEphem */
+}                               /* XrmCompileResourceListEphem */
 
-static void BadSize(
-    Cardinal size,
-    XrmQuark name)
+static void
+BadSize(Cardinal size, XrmQuark name)
 {
     String params[2];
     Cardinal num_params = 2;
 
-    params[0] = (String)(long) size;
+    params[0] = (String) (long) size;
     params[1] = XrmQuarkToString(name);
     XtWarningMsg("invalidSizeOverride", "xtDependencies", XtCXtToolkitError,
-	"Representation size %d must match superclass's to override %s",
-	params, &num_params);
-} /* BadType */
+                 "Representation size %d must match superclass's to override %s",
+                 params, &num_params);
+}                               /* BadType */
 
 /*
  * Create a new resource list, with the class resources following the
@@ -340,138 +351,137 @@ static void BadSize(
  * At the same time, add a level of indirection to the XtResourceList to
  * create and XrmResourceList.
  */
-void _XtDependencies(
-    XtResourceList  *class_resp,	/* VAR */
-    Cardinal	    *class_num_resp,    /* VAR */
-    XrmResourceList *super_res,
-    Cardinal	    super_num_res,
-    Cardinal	    super_widget_size)
+void
+_XtDependencies(XtResourceList *class_resp,    /* VAR */
+                Cardinal *class_num_resp,      /* VAR */
+                XrmResourceList *super_res,
+                Cardinal super_num_res,
+                Cardinal super_widget_size)
 {
     register XrmResourceList *new_res;
-	     Cardinal	     new_num_res;
-	     XrmResourceList class_res = (XrmResourceList) *class_resp;
-	     Cardinal        class_num_res = *class_num_resp;
-    register Cardinal	     i, j;
-	     Cardinal        new_next;
+    Cardinal new_num_res;
+    XrmResourceList class_res = (XrmResourceList) *class_resp;
+    Cardinal class_num_res = *class_num_resp;
+    register Cardinal i, j;
+    Cardinal new_next;
 
     if (class_num_res == 0) {
-	/* Just point to superclass resource list */
-	*class_resp = (XtResourceList) super_res;
-	*class_num_resp = super_num_res;
-	return;
+        /* Just point to superclass resource list */
+        *class_resp = (XtResourceList) super_res;
+        *class_num_resp = super_num_res;
+        return;
     }
 
     /* Allocate and initialize new_res with superclass resource pointers */
     new_num_res = super_num_res + class_num_res;
-    new_res = (XrmResourceList *) __XtMalloc((Cardinal)(new_num_res*sizeof(XrmResourceList)));
+    new_res = (XrmResourceList *)
+        __XtMalloc((Cardinal) (new_num_res * sizeof(XrmResourceList)));
     if (super_num_res > 0)
-	XtMemmove(new_res, super_res, super_num_res * sizeof(XrmResourceList));
+        XtMemmove(new_res, super_res, super_num_res * sizeof(XrmResourceList));
 
     /* Put pointers to class resource entries into new_res */
     new_next = super_num_res;
     for (i = 0; i < class_num_res; i++) {
-	if ((Cardinal)(-class_res[i].xrm_offset-1) < super_widget_size) {
-	    /* Probably an override of superclass resources--look for overlap */
-	    for (j = 0; j < super_num_res; j++) {
-		if (class_res[i].xrm_offset == new_res[j]->xrm_offset) {
-		    /* Spec is silent on what fields subclass can override.
-		     * The only two of real concern are type & size.
-		     * Although allowing type to be over-ridden introduces
-		     * the possibility of errors, it's at present the only
-		     * reasonable way to allow a subclass to force a private
-		     * converter to be invoked for a subset of fields.
-		     */
-		    /* We do insist that size be identical to superclass */
-		    if (class_res[i].xrm_size != new_res[j]->xrm_size) {
-			BadSize(class_res[i].xrm_size,
-				(XrmQuark) class_res[i].xrm_name);
-			class_res[i].xrm_size = new_res[j]->xrm_size;
-		    }
-		    new_res[j] = &(class_res[i]);
-		    new_num_res--;
-		    goto NextResource;
-		}
-	    } /* for j */
-	}
-	/* Not an overlap, add an entry to new_res */
-	new_res[new_next++] = &(class_res[i]);
-NextResource:;
-    } /* for i */
+        if ((Cardinal) (-class_res[i].xrm_offset - 1) < super_widget_size) {
+            /* Probably an override of superclass resources--look for overlap */
+            for (j = 0; j < super_num_res; j++) {
+                if (class_res[i].xrm_offset == new_res[j]->xrm_offset) {
+                    /* Spec is silent on what fields subclass can override.
+                     * The only two of real concern are type & size.
+                     * Although allowing type to be over-ridden introduces
+                     * the possibility of errors, it's at present the only
+                     * reasonable way to allow a subclass to force a private
+                     * converter to be invoked for a subset of fields.
+                     */
+                    /* We do insist that size be identical to superclass */
+                    if (class_res[i].xrm_size != new_res[j]->xrm_size) {
+                        BadSize(class_res[i].xrm_size,
+                                (XrmQuark) class_res[i].xrm_name);
+                        class_res[i].xrm_size = new_res[j]->xrm_size;
+                    }
+                    new_res[j] = &(class_res[i]);
+                    new_num_res--;
+                    goto NextResource;
+                }
+            }                   /* for j */
+        }
+        /* Not an overlap, add an entry to new_res */
+        new_res[new_next++] = &(class_res[i]);
+ NextResource:;
+    }                           /* for i */
 
     /* Okay, stuff new resources back into class record */
     *class_resp = (XtResourceList) new_res;
     *class_num_resp = new_num_res;
-} /* _XtDependencies */
-
+}                               /* _XtDependencies */
 
-void _XtResourceDependencies(
-    WidgetClass wc)
+void
+_XtResourceDependencies(WidgetClass wc)
 {
     WidgetClass sc;
 
     sc = wc->core_class.superclass;
     if (sc == NULL) {
-	_XtDependencies(&(wc->core_class.resources),
-			&(wc->core_class.num_resources),
-			(XrmResourceList *) NULL, (unsigned)0, (unsigned)0);
-    } else {
-	_XtDependencies(&(wc->core_class.resources),
-			&(wc->core_class.num_resources),
-			(XrmResourceList *) sc->core_class.resources,
-			sc->core_class.num_resources,
-			sc->core_class.widget_size);
+        _XtDependencies(&(wc->core_class.resources),
+                        &(wc->core_class.num_resources),
+                        (XrmResourceList *) NULL, (unsigned) 0, (unsigned) 0);
+    }
+    else {
+        _XtDependencies(&(wc->core_class.resources),
+                        &(wc->core_class.num_resources),
+                        (XrmResourceList *) sc->core_class.resources,
+                        sc->core_class.num_resources,
+                        sc->core_class.widget_size);
     }
-} /* _XtResourceDependencies */
+}                               /* _XtResourceDependencies */
 
-void _XtConstraintResDependencies(
-    ConstraintWidgetClass wc)
+void
+_XtConstraintResDependencies(ConstraintWidgetClass wc)
 {
     if (wc == (ConstraintWidgetClass) constraintWidgetClass) {
-	_XtDependencies(&(wc->constraint_class.resources),
-			&(wc->constraint_class.num_resources),
-			(XrmResourceList *)NULL, (unsigned)0, (unsigned)0);
-    } else {
-	ConstraintWidgetClass sc;
-
-	sc = (ConstraintWidgetClass) wc->core_class.superclass;
-	_XtDependencies(&(wc->constraint_class.resources),
-			&(wc->constraint_class.num_resources),
-			(XrmResourceList *) sc->constraint_class.resources,
-			sc->constraint_class.num_resources,
-			sc->constraint_class.constraint_size);
+        _XtDependencies(&(wc->constraint_class.resources),
+                        &(wc->constraint_class.num_resources),
+                        (XrmResourceList *) NULL, (unsigned) 0, (unsigned) 0);
     }
-} /* _XtConstraintResDependencies */
-
-
-
+    else {
+        ConstraintWidgetClass sc;
+
+        sc = (ConstraintWidgetClass) wc->core_class.superclass;
+        _XtDependencies(&(wc->constraint_class.resources),
+                        &(wc->constraint_class.num_resources),
+                        (XrmResourceList *) sc->constraint_class.resources,
+                        sc->constraint_class.num_resources,
+                        sc->constraint_class.constraint_size);
+    }
+}                               /* _XtConstraintResDependencies */
 
-XrmResourceList* _XtCreateIndirectionTable (
-    XtResourceList  resources,
-    Cardinal	    num_resources)
+XrmResourceList *
+_XtCreateIndirectionTable(XtResourceList resources, Cardinal num_resources)
 {
     register Cardinal idx;
-    XrmResourceList* table;
+    XrmResourceList *table;
 
-    table = (XrmResourceList*)__XtMalloc((Cardinal)(num_resources * sizeof(XrmResourceList)));
+    table = (XrmResourceList *)
+        __XtMalloc((Cardinal) (num_resources * sizeof(XrmResourceList)));
     for (idx = 0; idx < num_resources; idx++)
-        table[idx] = (XrmResourceList)(&(resources[idx]));
+        table[idx] = (XrmResourceList) (&(resources[idx]));
     return table;
 }
 
-static XtCacheRef *GetResources(
-    Widget	    widget,	    /* Widget resources are associated with */
-    char*	    base,	    /* Base address of memory to write to   */
-    XrmNameList     names,	    /* Full inheritance name of widget      */
-    XrmClassList    classes,	    /* Full inheritance class of widget     */
-    XrmResourceList*  table,	    /* The list of resources required.      */
-    unsigned	    num_resources,  /* number of items in resource list     */
-    XrmQuarkList    quark_args,     /* Arg names quarkified		    */
-    ArgList	    args,	    /* ArgList to override resources	    */
-    unsigned	    num_args,       /* number of items in arg list	    */
-    XtTypedArgList  typed_args,	    /* Typed arg list to override resources */
-    Cardinal*	    pNumTypedArgs,  /* number of items in typed arg list    */
-    Boolean	    tm_hack)	    /* do baseTranslations		    */
-{
+static XtCacheRef *
+GetResources(Widget widget,             /* Widget resources are associated with */
+             char *base,                /* Base address of memory to write to */
+             XrmNameList names,         /* Full inheritance name of widget */
+             XrmClassList classes,      /* Full inheritance class of widget     */
+             XrmResourceList *table,    /* The list of resources required.      */
+             unsigned num_resources,    /* number of items in resource list     */
+             XrmQuarkList quark_args,   /* Arg names quarkified                 */
+             ArgList args,              /* ArgList to override resources */
+             unsigned num_args,         /* number of items in arg list  */
+             XtTypedArgList typed_args, /* Typed arg list to override resources */
+             Cardinal *pNumTypedArgs,   /* number of items in typed arg list    */
+             Boolean tm_hack)           /* do baseTranslations                  */
+{            
 /*
  * assert: *pNumTypedArgs == 0 if num_args > 0
  * assert: num_args == 0 if *pNumTypedArgs > 0
@@ -479,43 +489,43 @@ static XtCacheRef *GetResources(
 #define SEARCHLISTLEN 100
 #define MAXRESOURCES  400
 
-    XrmValue	    value;
-    XrmQuark	    rawType;
-    XrmValue	    convValue;
-    XrmHashTable    stackSearchList[SEARCHLISTLEN];
-    XrmHashTable    *searchList = stackSearchList;
-    unsigned int    searchListSize = SEARCHLISTLEN;
-    Boolean	    found[MAXRESOURCES];
-    int		    typed[MAXRESOURCES];
-    XtCacheRef	    cache_ref[MAXRESOURCES];
-    XtCacheRef      *cache_ptr, *cache_base;
-    Boolean	    persistent_resources = True;
-    Boolean	    found_persistence = False;
-    int		    num_typed_args = (int) *pNumTypedArgs;
-    XrmDatabase     db;
-    Boolean	    do_tm_hack = False;
+    XrmValue value;
+    XrmQuark rawType;
+    XrmValue convValue;
+    XrmHashTable stackSearchList[SEARCHLISTLEN];
+    XrmHashTable *searchList = stackSearchList;
+    unsigned int searchListSize = SEARCHLISTLEN;
+    Boolean found[MAXRESOURCES];
+    int typed[MAXRESOURCES];
+    XtCacheRef cache_ref[MAXRESOURCES];
+    XtCacheRef *cache_ptr, *cache_base;
+    Boolean persistent_resources = True;
+    Boolean found_persistence = False;
+    int num_typed_args = (int) *pNumTypedArgs;
+    XrmDatabase db;
+    Boolean do_tm_hack = False;
 
     if ((args == NULL) && (num_args != 0)) {
-    	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidArgCount","getResources",XtCXtToolkitError,
-                 "argument count > 0 on NULL argument list",
-                   NULL, NULL);
-	num_args = 0;
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidArgCount", "getResources", XtCXtToolkitError,
+                        "argument count > 0 on NULL argument list", NULL, NULL);
+        num_args = 0;
     }
     if (num_resources == 0) {
-	return NULL;
-    } else if (num_resources >= MAXRESOURCES) {
-    	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidResourceCount","getResources",XtCXtToolkitError,
-              "too many resources",
-	      NULL, NULL);
-	return NULL;
-    } else if (table == NULL) {
-    	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"invalidResourceCount","getResources",XtCXtToolkitError,
-              "resource count > 0 on NULL resource list",
-	      NULL, NULL);
-	return NULL;
+        return NULL;
+    }
+    else if (num_resources >= MAXRESOURCES) {
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidResourceCount", "getResources",
+                        XtCXtToolkitError, "too many resources", NULL, NULL);
+        return NULL;
+    }
+    else if (table == NULL) {
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidResourceCount", "getResources",
+                        XtCXtToolkitError,
+                        "resource count > 0 on NULL resource list", NULL, NULL);
+        return NULL;
     }
 
     /* Mark each resource as not found on arg list */
@@ -524,59 +534,58 @@ static XtCacheRef *GetResources(
 
     /* Copy the args into the resources, mark each as found */
     {
-	register ArgList	    arg;
-	register XtTypedArgList	    typed_arg;
-	register XrmName	    argName;
-	register Cardinal	    j;
-	register int	    i;
-	register XrmResourceList rx;
-	register XrmResourceList *res;
-	for (arg = args, i = 0; (Cardinal)i < num_args; i++, arg++) {
-	    argName = quark_args[i];
-	    if (argName == QinitialResourcesPersistent) {
-		persistent_resources = (Boolean)arg->value;
-		found_persistence = True;
-		continue;
-	    }
-	    for (j = 0, res = table; j < num_resources; j++, res++) {
-		rx = *res;
-		if (argName == rx->xrm_name) {
-		    _XtCopyFromArg(
-			arg->value,
-			base - rx->xrm_offset - 1,
-			rx->xrm_size);
-		    found[j] = TRUE;
-		    break;
-		}
-	    }
-	}
-	for (typed_arg = typed_args, i = 0; i < num_typed_args;
-	     i++, typed_arg++) {
-	    register XrmRepresentation argType;
-	    argName = quark_args[i];
-	    argType = (typed_arg->type == NULL) ? NULLQUARK
-		: XrmStringToRepresentation(typed_arg->type);
-	    if (argName == QinitialResourcesPersistent) {
-		persistent_resources = (Boolean)typed_arg->value;
-		found_persistence = True;
-		break;
-	    }
-	    for (j = 0, res = table; j < num_resources; j++, res++) {
-		rx = *res;
-		if (argName == rx->xrm_name) {
-		    if (argType != NULLQUARK && argType != rx->xrm_type) {
-			typed[j] = i + 1;
-		    } else {
-			_XtCopyFromArg(
-				       typed_arg->value,
-				       base - rx->xrm_offset - 1,
-				       rx->xrm_size);
-		    }
-		    found[j] = TRUE;
-		    break;
-		}
-	    }
-	}
+        register ArgList arg;
+        register XtTypedArgList typed_arg;
+        register XrmName argName;
+        register Cardinal j;
+        register int i;
+        register XrmResourceList rx;
+        register XrmResourceList *res;
+
+        for (arg = args, i = 0; (Cardinal) i < num_args; i++, arg++) {
+            argName = quark_args[i];
+            if (argName == QinitialResourcesPersistent) {
+                persistent_resources = (Boolean) arg->value;
+                found_persistence = True;
+                continue;
+            }
+            for (j = 0, res = table; j < num_resources; j++, res++) {
+                rx = *res;
+                if (argName == rx->xrm_name) {
+                    _XtCopyFromArg(arg->value,
+                                   base - rx->xrm_offset - 1, rx->xrm_size);
+                    found[j] = TRUE;
+                    break;
+                }
+            }
+        }
+        for (typed_arg = typed_args, i = 0; i < num_typed_args;
+             i++, typed_arg++) {
+            register XrmRepresentation argType;
+
+            argName = quark_args[i];
+            argType = (typed_arg->type == NULL) ? NULLQUARK
+                : XrmStringToRepresentation(typed_arg->type);
+            if (argName == QinitialResourcesPersistent) {
+                persistent_resources = (Boolean) typed_arg->value;
+                found_persistence = True;
+                break;
+            }
+            for (j = 0, res = table; j < num_resources; j++, res++) {
+                rx = *res;
+                if (argName == rx->xrm_name) {
+                    if (argType != NULLQUARK && argType != rx->xrm_type) {
+                        typed[j] = i + 1;
+                    }
+                    else {
+                        _XtCopyFromArg(typed_arg->value,
+                                       base - rx->xrm_offset - 1, rx->xrm_size);
+                    }
+                    found[j] = TRUE;
+                    break;
+                }
+            }
+        }
     }
 
     /* Ask resource manager for a list of database levels that we can
@@ -584,584 +593,632 @@ static XtCacheRef *GetResources(
 
     db = XtScreenDatabase(XtScreenOfObject(widget));
     while (!XrmQGetSearchList(db, names, classes,
-			      searchList, (int) searchListSize)) {
-	if (searchList == stackSearchList)
-	    searchList = NULL;
-	searchList = (XrmHashTable*)XtRealloc((char*)searchList,
-					      (Cardinal) (sizeof(XrmHashTable) *
-					      (searchListSize *= 2)));
+                              searchList, (int) searchListSize)) {
+        if (searchList == stackSearchList)
+            searchList = NULL;
+        searchList = (XrmHashTable *) XtRealloc((char *) searchList,
+                                                (Cardinal) (sizeof(XrmHashTable)
+                                                            * (searchListSize *=
+                                                               2)));
     }
 
     if (persistent_resources)
-	cache_base = NULL;
+        cache_base = NULL;
     else
-	cache_base = cache_ref;
+        cache_base = cache_ref;
     /* geez, this is an ugly mess */
     if (XtIsShell(widget)) {
-	register XrmResourceList  *res;
-	register Cardinal	  j;
-	Screen *oldscreen = widget->core.screen;
-
-	/* look up screen resource first, since real rdb depends on it */
-	for (res = table, j = 0; j < num_resources; j++, res++) {
-	    if ((*res)->xrm_name != Qscreen)
-		continue;
-	    if (typed[j]) {
-		register XtTypedArg* arg = typed_args + typed[j] - 1;
-		XrmQuark from_type;
-		XrmValue from_val, to_val;
-
-		from_type = StringToQuark(arg->type);
-		from_val.size = (Cardinal) arg->size;
-		if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
-		    from_val.addr = (XPointer)arg->value;
-		else
-		    from_val.addr = (XPointer)&arg->value;
-		to_val.size = sizeof(Screen*);
-		to_val.addr = (XPointer)&widget->core.screen;
-		found[j] = _XtConvert(widget, from_type, &from_val,
-				      QScreen, &to_val, cache_base);
-		if (cache_base && *cache_base)
-		    cache_base++;
-	    }
-	    if (!found[j]) {
-		if (XrmQGetSearchResource(searchList, Qscreen, QScreen,
-				      &rawType, &value)) {
-		    if (rawType != QScreen) {
-			convValue.size = sizeof(Screen*);
-			convValue.addr = (XPointer)&widget->core.screen;
-			(void)_XtConvert(widget, rawType, &value,
-					 QScreen, &convValue, cache_base);
-			if (cache_base && *cache_base)
-			    cache_base++;
-		    } else {
-			widget->core.screen = *((Screen **)value.addr);
-		    }
-		}
-	    }
-	    break;
-	}
-	/* now get the database to use for the rest of the resources */
-	if (widget->core.screen != oldscreen) {
-	    db = XtScreenDatabase(widget->core.screen);
-	    while (!XrmQGetSearchList(db, names, classes,
-				      searchList, (int) searchListSize)) {
-		if (searchList == stackSearchList)
-		    searchList = NULL;
-		searchList = (XrmHashTable*)XtRealloc((char*)searchList,
-						      (Cardinal)(sizeof(XrmHashTable) *
-						      (searchListSize *= 2)));
-	    }
-	}
+        register XrmResourceList *res;
+        register Cardinal j;
+        Screen *oldscreen = widget->core.screen;
+
+        /* look up screen resource first, since real rdb depends on it */
+        for (res = table, j = 0; j < num_resources; j++, res++) {
+            if ((*res)->xrm_name != Qscreen)
+                continue;
+            if (typed[j]) {
+                register XtTypedArg *arg = typed_args + typed[j] - 1;
+                XrmQuark from_type;
+                XrmValue from_val, to_val;
+
+                from_type = StringToQuark(arg->type);
+                from_val.size = (Cardinal) arg->size;
+                if ((from_type == QString) ||
+                    ((unsigned) arg->size > sizeof(XtArgVal)))
+                    from_val.addr = (XPointer) arg->value;
+                else
+                    from_val.addr = (XPointer) &arg->value;
+                to_val.size = sizeof(Screen *);
+                to_val.addr = (XPointer) &widget->core.screen;
+                found[j] = _XtConvert(widget, from_type, &from_val,
+                                      QScreen, &to_val, cache_base);
+                if (cache_base && *cache_base)
+                    cache_base++;
+            }
+            if (!found[j]) {
+                if (XrmQGetSearchResource(searchList, Qscreen, QScreen,
+                                          &rawType, &value)) {
+                    if (rawType != QScreen) {
+                        convValue.size = sizeof(Screen *);
+                        convValue.addr = (XPointer) &widget->core.screen;
+                        (void) _XtConvert(widget, rawType, &value,
+                                          QScreen, &convValue, cache_base);
+                        if (cache_base && *cache_base)
+                            cache_base++;
+                    }
+                    else {
+                        widget->core.screen = *((Screen **) value.addr);
+                    }
+                }
+            }
+            break;
+        }
+        /* now get the database to use for the rest of the resources */
+        if (widget->core.screen != oldscreen) {
+            db = XtScreenDatabase(widget->core.screen);
+            while (!XrmQGetSearchList(db, names, classes,
+                                      searchList, (int) searchListSize)) {
+                if (searchList == stackSearchList)
+                    searchList = NULL;
+                searchList = (XrmHashTable *) XtRealloc((char *) searchList,
+                                                        (Cardinal) (sizeof
+                                                                    (XrmHashTable)
+                                                                    *
+                                                                    (searchListSize
+                                                                     *= 2)));
+            }
+        }
     }
 
     /* go to the resource manager for those resources not found yet */
     /* if it's not in the resource database use the default value   */
 
     {
-	register XrmResourceList  rx;
-	register XrmResourceList  *res;
-	register Cardinal	  j;
-	register XrmRepresentation xrm_type;
-	register XrmRepresentation xrm_default_type;
-	char	char_val;
-	short	short_val;
-	int	int_val;
-	long	long_val;
-	char*	char_ptr;
-
-	if (!found_persistence) {
-	    if (XrmQGetSearchResource(searchList, QinitialResourcesPersistent,
-			QInitialResourcesPersistent, &rawType, &value)) {
-		if (rawType != QBoolean) {
-		    convValue.size = sizeof(Boolean);
-		    convValue.addr = (XPointer)&persistent_resources;
-		    (void)_XtConvert(widget, rawType, &value, QBoolean,
-				     &convValue, NULL);
-		}
-		else
-		    persistent_resources = *(Boolean*)value.addr;
-	    }
-	}
-	if (persistent_resources)
-	    cache_ptr = NULL;
-	else if (cache_base)
-	    cache_ptr = cache_base;
-	else
-	    cache_ptr = cache_ref;
-
-	for (res = table, j = 0; j < num_resources; j++, res++) {
-	    rx = *res;
-	    xrm_type = (XrmRepresentation) rx->xrm_type;
-	    if (typed[j]) {
-		register XtTypedArg* arg = typed_args + typed[j] - 1;
-
-		/*
+        register XrmResourceList rx;
+        register XrmResourceList *res;
+        register Cardinal j;
+        register XrmRepresentation xrm_type;
+        register XrmRepresentation xrm_default_type;
+        char char_val;
+        short short_val;
+        int int_val;
+        long long_val;
+        char *char_ptr;
+
+        if (!found_persistence) {
+            if (XrmQGetSearchResource(searchList, QinitialResourcesPersistent,
+                                      QInitialResourcesPersistent, &rawType,
+                                      &value)) {
+                if (rawType != QBoolean) {
+                    convValue.size = sizeof(Boolean);
+                    convValue.addr = (XPointer) &persistent_resources;
+                    (void) _XtConvert(widget, rawType, &value, QBoolean,
+                                      &convValue, NULL);
+                }
+                else
+                    persistent_resources = *(Boolean *) value.addr;
+            }
+        }
+        if (persistent_resources)
+            cache_ptr = NULL;
+        else if (cache_base)
+            cache_ptr = cache_base;
+        else
+            cache_ptr = cache_ref;
+
+        for (res = table, j = 0; j < num_resources; j++, res++) {
+            rx = *res;
+            xrm_type = (XrmRepresentation) rx->xrm_type;
+            if (typed[j]) {
+                register XtTypedArg *arg = typed_args + typed[j] - 1;
+
+                /*
                  * This resource value has been specified as a typed arg and
-		 * has to be converted. Typed arg conversions are done here
-		 * to correctly interpose them with normal resource conversions.
+                 * has to be converted. Typed arg conversions are done here
+                 * to correctly interpose them with normal resource conversions.
                  */
-		XrmQuark	    from_type;
-		XrmValue            from_val, to_val;
-		Boolean		    converted;
-
-		from_type = StringToQuark(arg->type);
-    		from_val.size = (Cardinal) arg->size;
-		if ((from_type == QString) || ((unsigned) arg->size > sizeof(XtArgVal)))
-        	    from_val.addr = (XPointer)arg->value;
-	        else
-            	    from_val.addr = (XPointer)&arg->value;
-		to_val.size = rx->xrm_size;
-		to_val.addr = base - rx->xrm_offset - 1;
-		converted = _XtConvert(widget, from_type, &from_val,
-				       xrm_type, &to_val, cache_ptr);
-		if (converted) {
-
-		    /* Copy the converted value back into the typed argument.
-		     * normally the data should be <= sizeof(XtArgVal) and
-		     * is stored directly into the 'value' field .... BUT
-		     * if the resource size is greater than sizeof(XtArgVal)
-		     * then we dynamically alloc a block of store to hold the
-		     * data and zap a copy in there !!! .... freeing it later
-		     * the size field in the typed arg is negated to indicate
-		     * that the store pointed to by the value field is
-		     * dynamic .......
-		     * "freeing" happens in the case of _XtCreate after the
-		     * CallInitialize ..... other clients of GetResources
-		     * using typed args should be aware of the need to free
-		     * this store .....
-		     */
-
-		    if(rx->xrm_size > sizeof(XtArgVal)) {
-			arg->value = (XtArgVal) (void *) __XtMalloc(rx->xrm_size);
-			arg->size = -(arg->size);
-		    } else { /* will fit - copy directly into value field */
-			arg->value = (XtArgVal) NULL;
-		    }
-		    CopyToArg((char *)(base - rx->xrm_offset - 1),
-				 &arg->value, rx->xrm_size);
-
-		} else {
-		   /* Conversion failed. Get default value. */
-		   found[j] = False;
-		}
-
-		if (cache_ptr && *cache_ptr)
-		    cache_ptr++;
-	    }
-
-	    if (!found[j]) {
-		Boolean	already_copied = False;
-		Boolean have_value = False;
-
-		if (XrmQGetSearchResource(searchList,
-			(XrmName) rx->xrm_name, (XrmClass) rx->xrm_class, &rawType, &value)) {
-		    if (rawType != xrm_type) {
-			convValue.size = rx->xrm_size;
-			convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
-			already_copied = have_value =
-			    _XtConvert(widget, rawType, &value,
-				       xrm_type, &convValue, cache_ptr);
-			if (cache_ptr && *cache_ptr)
-			    cache_ptr++;
-		    } else have_value = True;
-		    if (have_value && rx->xrm_name == Qtranslations)
-			do_tm_hack = True;
-		}
-		LOCK_PROCESS;
-		if (!have_value
-		    && ((rx->xrm_default_type == QImmediate)
-			|| (rx->xrm_default_type == xrm_type)
-			|| (rx->xrm_default_addr != NULL))) {
-		    /* Convert default value to proper type */
-		    xrm_default_type = (XrmRepresentation) rx->xrm_default_type;
-		    if (xrm_default_type == QCallProc) {
-			(*(XtResourceDefaultProc)(rx->xrm_default_addr))(
-			      widget,-(rx->xrm_offset+1), &value);
-
-		    } else if (xrm_default_type == QImmediate) {
-			/* XtRImmediate == XtRString for type XtRString */
-			if (xrm_type == QString) {
-			    value.addr = rx->xrm_default_addr;
-			} else if (rx->xrm_size == sizeof(int)) {
-			    int_val = (int)(long)rx->xrm_default_addr;
-			    value.addr = (XPointer) &int_val;
-			} else if (rx->xrm_size == sizeof(short)) {
-			    short_val = (short)(long)rx->xrm_default_addr;
-			    value.addr = (XPointer) &short_val;
-			} else if (rx->xrm_size == sizeof(char)) {
-			    char_val = (char)(long)rx->xrm_default_addr;
-			    value.addr = (XPointer) &char_val;
-			} else if (rx->xrm_size == sizeof(long)) {
-			    long_val = (long)rx->xrm_default_addr;
-			    value.addr = (XPointer) &long_val;
-			} else if (rx->xrm_size == sizeof(char*)) {
-			    char_ptr = (char*)rx->xrm_default_addr;
-			    value.addr = (XPointer) &char_ptr;
-			} else {
-			    value.addr = (XPointer) &(rx->xrm_default_addr);
-			}
-		    } else if (xrm_default_type == xrm_type) {
-			value.addr = rx->xrm_default_addr;
-		    } else {
-			value.addr = rx->xrm_default_addr;
-			if (xrm_default_type == QString) {
-			    value.size = (unsigned) strlen((char *)value.addr) + 1;
-			} else {
-			    value.size = sizeof(XtPointer);
-			}
-			convValue.size = rx->xrm_size;
-			convValue.addr = (XPointer)(base - rx->xrm_offset - 1);
-			already_copied =
-			    _XtConvert(widget, xrm_default_type, &value,
-				       xrm_type, &convValue, cache_ptr);
-			if (!already_copied)
-			    value.addr = NULL;
-			if (cache_ptr && *cache_ptr)
-			    cache_ptr++;
-		    }
-		}
-		if (!already_copied) {
-		    if (xrm_type == QString) {
-			*((String*)(base - rx->xrm_offset - 1)) = value.addr;
-		    } else {
-			if (value.addr != NULL) {
-			    XtMemmove(base - rx->xrm_offset - 1,
-				      value.addr, rx->xrm_size);
-			} else {
-			    /* didn't get value, initialize to NULL... */
-			    XtBZero(base - rx->xrm_offset - 1, rx->xrm_size);
-			}
-		    }
-		}
-		UNLOCK_PROCESS;
-	    } 
-	}
-	for (res = table, j = 0; j < num_resources; j++, res++) {
-	    if (!found[j] && typed[j]) {
-		/*
-		 * This resource value was specified as a typed arg.
-		 * However, the default value is being used here since
-		 * type type conversion failed, so we compress the list.
-		 */
-		register XtTypedArg* arg = typed_args + typed[j] - 1;
-		register int i;
-
-		for (i = num_typed_args - typed[j]; i > 0; i--, arg++) {
-		    *arg = *(arg+1);
-		}
-		num_typed_args--;
-	    }
-	}
-	if (tm_hack)
-	    widget->core.tm.current_state = NULL;
-	if (tm_hack &&
-	    (!widget->core.tm.translations ||
-	     (do_tm_hack &&
-	      widget->core.tm.translations->operation != XtTableReplace)) &&
-	    XrmQGetSearchResource(searchList, QbaseTranslations,
-				  QTranslations, &rawType, &value)) {
-	    if (rawType != QTranslationTable) {
-		convValue.size = sizeof(XtTranslations);
-		convValue.addr = (XPointer)&widget->core.tm.current_state;
-		(void)_XtConvert(widget, rawType, &value,
-				 QTranslationTable, &convValue, cache_ptr);
-		if (cache_ptr && *cache_ptr)
-		    cache_ptr++;
-	    } else {
-		/* value.addr can be NULL see: !already_copied */
-		if (value.addr)
-		    *((XtTranslations *)&widget->core.tm.current_state) =
-			*((XtTranslations *)value.addr);
-	    }
-	}
+                XrmQuark from_type;
+                XrmValue from_val, to_val;
+                Boolean converted;
+
+                from_type = StringToQuark(arg->type);
+                from_val.size = (Cardinal) arg->size;
+                if ((from_type == QString) ||
+                    ((unsigned) arg->size > sizeof(XtArgVal)))
+                    from_val.addr = (XPointer) arg->value;
+                else
+                    from_val.addr = (XPointer) &arg->value;
+                to_val.size = rx->xrm_size;
+                to_val.addr = base - rx->xrm_offset - 1;
+                converted = _XtConvert(widget, from_type, &from_val,
+                                       xrm_type, &to_val, cache_ptr);
+                if (converted) {
+
+                    /* Copy the converted value back into the typed argument.
+                     * normally the data should be <= sizeof(XtArgVal) and
+                     * is stored directly into the 'value' field .... BUT
+                     * if the resource size is greater than sizeof(XtArgVal)
+                     * then we dynamically alloc a block of store to hold the
+                     * data and zap a copy in there !!! .... freeing it later
+                     * the size field in the typed arg is negated to indicate
+                     * that the store pointed to by the value field is
+                     * dynamic .......
+                     * "freeing" happens in the case of _XtCreate after the
+                     * CallInitialize ..... other clients of GetResources
+                     * using typed args should be aware of the need to free
+                     * this store .....
+                     */
+
+                    if (rx->xrm_size > sizeof(XtArgVal)) {
+                        arg->value =
+                            (XtArgVal) (void *) __XtMalloc(rx->xrm_size);
+                        arg->size = -(arg->size);
+                    }
+                    else {      /* will fit - copy directly into value field */
+                        arg->value = (XtArgVal) NULL;
+                    }
+                    CopyToArg((char *) (base - rx->xrm_offset - 1),
+                              &arg->value, rx->xrm_size);
+
+                }
+                else {
+                    /* Conversion failed. Get default value. */
+                    found[j] = False;
+                }
+
+                if (cache_ptr && *cache_ptr)
+                    cache_ptr++;
+            }
+
+            if (!found[j]) {
+                Boolean already_copied = False;
+                Boolean have_value = False;
+
+                if (XrmQGetSearchResource(searchList,
+                                          (XrmName) rx->xrm_name,
+                                          (XrmClass) rx->xrm_class, &rawType,
+                                          &value)) {
+                    if (rawType != xrm_type) {
+                        convValue.size = rx->xrm_size;
+                        convValue.addr = (XPointer) (base - rx->xrm_offset - 1);
+                        already_copied = have_value =
+                            _XtConvert(widget, rawType, &value,
+                                       xrm_type, &convValue, cache_ptr);
+                        if (cache_ptr && *cache_ptr)
+                            cache_ptr++;
+                    }
+                    else
+                        have_value = True;
+                    if (have_value && rx->xrm_name == Qtranslations)
+                        do_tm_hack = True;
+                }
+                LOCK_PROCESS;
+                if (!have_value && ((rx->xrm_default_type == QImmediate)
+                                    || (rx->xrm_default_type == xrm_type)
+                                    || (rx->xrm_default_addr != NULL))) {
+                    /* Convert default value to proper type */
+                    xrm_default_type = (XrmRepresentation) rx->xrm_default_type;
+                    if (xrm_default_type == QCallProc) {
+                        (*(XtResourceDefaultProc) (rx->xrm_default_addr))
+                            (widget, -(rx->xrm_offset + 1), &value);
+
+                    }
+                    else if (xrm_default_type == QImmediate) {
+                        /* XtRImmediate == XtRString for type XtRString */
+                        if (xrm_type == QString) {
+                            value.addr = rx->xrm_default_addr;
+                        }
+                        else if (rx->xrm_size == sizeof(int)) {
+                            int_val = (int) (long) rx->xrm_default_addr;
+                            value.addr = (XPointer) &int_val;
+                        }
+                        else if (rx->xrm_size == sizeof(short)) {
+                            short_val = (short) (long) rx->xrm_default_addr;
+                            value.addr = (XPointer) &short_val;
+                        }
+                        else if (rx->xrm_size == sizeof(char)) {
+                            char_val = (char) (long) rx->xrm_default_addr;
+                            value.addr = (XPointer) &char_val;
+                        }
+                        else if (rx->xrm_size == sizeof(long)) {
+                            long_val = (long) rx->xrm_default_addr;
+                            value.addr = (XPointer) &long_val;
+                        }
+                        else if (rx->xrm_size == sizeof(char *)) {
+                            char_ptr = (char *) rx->xrm_default_addr;
+                            value.addr = (XPointer) &char_ptr;
+                        }
+                        else {
+                            value.addr = (XPointer) &(rx->xrm_default_addr);
+                        }
+                    }
+                    else if (xrm_default_type == xrm_type) {
+                        value.addr = rx->xrm_default_addr;
+                    }
+                    else {
+                        value.addr = rx->xrm_default_addr;
+                        if (xrm_default_type == QString) {
+                            value.size =
+                                (unsigned) strlen((char *) value.addr) + 1;
+                        }
+                        else {
+                            value.size = sizeof(XtPointer);
+                        }
+                        convValue.size = rx->xrm_size;
+                        convValue.addr = (XPointer) (base - rx->xrm_offset - 1);
+                        already_copied =
+                            _XtConvert(widget, xrm_default_type, &value,
+                                       xrm_type, &convValue, cache_ptr);
+                        if (!already_copied)
+                            value.addr = NULL;
+                        if (cache_ptr && *cache_ptr)
+                            cache_ptr++;
+                    }
+                }
+                if (!already_copied) {
+                    if (xrm_type == QString) {
+                        *((String *) (base - rx->xrm_offset - 1)) = value.addr;
+                    }
+                    else {
+                        if (value.addr != NULL) {
+                            XtMemmove(base - rx->xrm_offset - 1,
+                                      value.addr, rx->xrm_size);
+                        }
+                        else {
+                            /* didn't get value, initialize to NULL... */
+                            XtBZero(base - rx->xrm_offset - 1, rx->xrm_size);
+                        }
+                    }
+                }
+                UNLOCK_PROCESS;
+            }
+        }
+        for (res = table, j = 0; j < num_resources; j++, res++) {
+            if (!found[j] && typed[j]) {
+                /*
+                 * This resource value was specified as a typed arg.
+                 * However, the default value is being used here since
+                 * type type conversion failed, so we compress the list.
+                 */
+                register XtTypedArg *arg = typed_args + typed[j] - 1;
+                register int i;
+
+                for (i = num_typed_args - typed[j]; i > 0; i--, arg++) {
+                    *arg = *(arg + 1);
+                }
+                num_typed_args--;
+            }
+        }
+        if (tm_hack)
+            widget->core.tm.current_state = NULL;
+        if (tm_hack &&
+            (!widget->core.tm.translations ||
+             (do_tm_hack &&
+              widget->core.tm.translations->operation != XtTableReplace)) &&
+            XrmQGetSearchResource(searchList, QbaseTranslations,
+                                  QTranslations, &rawType, &value)) {
+            if (rawType != QTranslationTable) {
+                convValue.size = sizeof(XtTranslations);
+                convValue.addr = (XPointer) &widget->core.tm.current_state;
+                (void) _XtConvert(widget, rawType, &value,
+                                  QTranslationTable, &convValue, cache_ptr);
+                if (cache_ptr && *cache_ptr)
+                    cache_ptr++;
+            }
+            else {
+                /* value.addr can be NULL see: !already_copied */
+                if (value.addr)
+                    *((XtTranslations *) &widget->core.tm.current_state) =
+                        *((XtTranslations *) value.addr);
+            }
+        }
     }
-    if ((Cardinal)num_typed_args != *pNumTypedArgs) *pNumTypedArgs = (Cardinal) num_typed_args;
-    if (searchList != stackSearchList) XtFree((char*)searchList);
+    if ((Cardinal) num_typed_args != *pNumTypedArgs)
+        *pNumTypedArgs = (Cardinal) num_typed_args;
+    if (searchList != stackSearchList)
+        XtFree((char *) searchList);
     if (!cache_ptr)
-	cache_ptr = cache_base;
+        cache_ptr = cache_base;
     if (cache_ptr && cache_ptr != cache_ref) {
-	int cache_ref_size = (int) (cache_ptr - cache_ref);
-	XtCacheRef *refs = (XtCacheRef*)
-	    __XtMalloc((Cardinal)(sizeof(XtCacheRef) * (size_t)(cache_ref_size + 1)));
-	(void) memmove(refs, cache_ref, sizeof(XtCacheRef)*(size_t)cache_ref_size );
-	refs[cache_ref_size] = NULL;
-	return refs;
+        int cache_ref_size = (int) (cache_ptr - cache_ref);
+        XtCacheRef *refs = (XtCacheRef *)
+            __XtMalloc((Cardinal)
+                       (sizeof(XtCacheRef) * (size_t) (cache_ref_size + 1)));
+
+        (void) memmove(refs, cache_ref,
+                       sizeof(XtCacheRef) * (size_t) cache_ref_size);
+        refs[cache_ref_size] = NULL;
+        return refs;
     }
-    return (XtCacheRef*)NULL;
+    return (XtCacheRef *) NULL;
 }
 
-
-
-static void CacheArgs(
-    ArgList	    args,
-    Cardinal	    num_args,
-    XtTypedArgList  typed_args,
-    Cardinal	    num_typed_args,
-    XrmQuarkList    quark_cache,
-    Cardinal	    num_quarks,
-    XrmQuarkList    *pQuarks)       /* RETURN */
-{
-    register XrmQuarkList   quarks;
-    register Cardinal       i;
-    register Cardinal       count;
+static void
+CacheArgs(ArgList args,
+          Cardinal num_args,
+          XtTypedArgList typed_args,
+          Cardinal num_typed_args,
+          XrmQuarkList quark_cache,
+          Cardinal num_quarks,
+          XrmQuarkList *pQuarks)        /* RETURN */
+{        
+    register XrmQuarkList quarks;
+    register Cardinal i;
+    register Cardinal count;
 
     count = (args != NULL) ? num_args : num_typed_args;
 
     if (num_quarks < count) {
-	quarks = (XrmQuarkList) __XtMalloc((Cardinal)(count * sizeof(XrmQuark)));
-    } else {
-	quarks = quark_cache;
+        quarks =
+            (XrmQuarkList) __XtMalloc((Cardinal) (count * sizeof(XrmQuark)));
+    }
+    else {
+        quarks = quark_cache;
     }
     *pQuarks = quarks;
 
     if (args != NULL) {
-	for (i = count; i; i--)
-	    *quarks++ = StringToQuark((args++)->name);
+        for (i = count; i; i--)
+            *quarks++ = StringToQuark((args++)->name);
     }
     else {
-	for (i = count; i; i--)
-	    *quarks++ = StringToQuark((typed_args++)->name);
+        for (i = count; i; i--)
+            *quarks++ = StringToQuark((typed_args++)->name);
     }
 }
 
 #define FreeCache(cache, pointer) \
-	  if (cache != pointer) XtFree((char *)pointer)
-
-
-XtCacheRef *_XtGetResources(
-    register 	Widget	  	w,
-    		ArgList	  	args,
-    		Cardinal  	num_args,
-		XtTypedArgList	typed_args,
-		Cardinal*	num_typed_args)
+          if (cache != pointer) XtFree((char *)pointer)
+
+XtCacheRef *
+_XtGetResources(register Widget w,
+                ArgList args,
+                Cardinal num_args,
+                XtTypedArgList typed_args,
+                Cardinal *num_typed_args)
 {
-    XrmName	    *names, names_s[50];
-    XrmClass	    *classes, classes_s[50];
-    XrmQuark	    quark_cache[100];
-    XrmQuarkList    quark_args;
-    WidgetClass     wc;
-    XtCacheRef	    *cache_refs = NULL;
-    Cardinal	    count;
+    XrmName *names, names_s[50];
+    XrmClass *classes, classes_s[50];
+    XrmQuark quark_cache[100];
+    XrmQuarkList quark_args;
+    WidgetClass wc;
+    XtCacheRef *cache_refs = NULL;
+    Cardinal count;
 
     wc = XtClass(w);
 
     count = CountTreeDepth(w);
-    names = (XrmName*) XtStackAlloc (count * sizeof(XrmName), names_s);
-    classes = (XrmClass*) XtStackAlloc (count * sizeof(XrmClass), classes_s);
+    names = (XrmName *) XtStackAlloc(count * sizeof(XrmName), names_s);
+    classes = (XrmClass *) XtStackAlloc(count * sizeof(XrmClass), classes_s);
     if (names == NULL || classes == NULL) {
-	_XtAllocError(NULL);
-    } else {
-
-	/* Get names, classes for widget and ancestors */
-	GetNamesAndClasses(w, names, classes);
-
-	/* Compile arg list into quarks */
-	CacheArgs(args, num_args, typed_args, *num_typed_args, quark_cache,
-		  XtNumber(quark_cache), &quark_args);
-
-	/* Get normal resources */
-	LOCK_PROCESS;
-	cache_refs = GetResources(w, (char*)w, names, classes,
-	    (XrmResourceList *) wc->core_class.resources,
-	    wc->core_class.num_resources, quark_args, args, num_args,
-	    typed_args, num_typed_args, XtIsWidget(w));
-
-	if (w->core.constraints != NULL) {
-	    ConstraintWidgetClass cwc;
-	    XtCacheRef *cache_refs_core;
-
-	    cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
-	    cache_refs_core =
-		GetResources(w, (char*)w->core.constraints, names, classes,
-		(XrmResourceList *) cwc->constraint_class.resources,
-		cwc->constraint_class.num_resources,
-		quark_args, args, num_args, typed_args, num_typed_args, False);
-	     XtFree((char *)cache_refs_core);
-	}
-	FreeCache(quark_cache, quark_args);
-	UNLOCK_PROCESS;
-	XtStackFree((XtPointer)names, names_s);
-	XtStackFree((XtPointer)classes, classes_s);
+        _XtAllocError(NULL);
+    }
+    else {
+
+        /* Get names, classes for widget and ancestors */
+        GetNamesAndClasses(w, names, classes);
+
+        /* Compile arg list into quarks */
+        CacheArgs(args, num_args, typed_args, *num_typed_args, quark_cache,
+                  XtNumber(quark_cache), &quark_args);
+
+        /* Get normal resources */
+        LOCK_PROCESS;
+        cache_refs = GetResources(w, (char *) w, names, classes,
+                                  (XrmResourceList *) wc->core_class.resources,
+                                  wc->core_class.num_resources, quark_args,
+                                  args, num_args, typed_args, num_typed_args,
+                                  XtIsWidget(w));
+
+        if (w->core.constraints != NULL) {
+            ConstraintWidgetClass cwc;
+            XtCacheRef *cache_refs_core;
+
+            cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
+            cache_refs_core =
+                GetResources(w, (char *) w->core.constraints, names, classes,
+                             (XrmResourceList *) cwc->constraint_class.
+                             resources, cwc->constraint_class.num_resources,
+                             quark_args, args, num_args, typed_args,
+                             num_typed_args, False);
+            XtFree((char *) cache_refs_core);
+        }
+        FreeCache(quark_cache, quark_args);
+        UNLOCK_PROCESS;
+        XtStackFree((XtPointer) names, names_s);
+        XtStackFree((XtPointer) classes, classes_s);
     }
     return cache_refs;
-} /* _XtGetResources */
-
-
-void _XtGetSubresources (
-    Widget	  w,			/* Widget "parent" of subobject   */
-    XtPointer	  base,			/* Base address to write to       */
-    const char*   name,			/* name of subobject		    */
-    const char*   class,		/* class of subobject		    */
-    XtResourceList resources,		/* resource list for subobject    */
-    Cardinal	  num_resources,
-    ArgList	  args,			/* arg list to override resources */
-    Cardinal	  num_args,
-    XtTypedArgList typed_args,
-    Cardinal      num_typed_args)
+}                               /* _XtGetResources */
+
+void
+_XtGetSubresources(Widget w,                    /* Widget "parent" of subobject */
+                   XtPointer base,              /* Base address to write to */
+                   const char *name,            /* name of subobject        */
+                   const char *class,           /* class of subobject       */
+                   XtResourceList resources,    /* resource list for subobject    */
+                   Cardinal num_resources,
+                   ArgList args,                /* arg list to override resources */
+                   Cardinal num_args,
+                   XtTypedArgList typed_args,
+                   Cardinal num_typed_args)
 {
-    XrmName	  *names, names_s[50];
-    XrmClass	  *classes, classes_s[50];
-    XrmQuark	  quark_cache[100];
-    XrmQuarkList  quark_args;
-    XrmResourceList* table;
-    Cardinal	  count, ntyped_args = num_typed_args;
-    XtCacheRef    *Resrc = NULL;
+    XrmName *names, names_s[50];
+    XrmClass *classes, classes_s[50];
+    XrmQuark quark_cache[100];
+    XrmQuarkList quark_args;
+    XrmResourceList *table;
+    Cardinal count, ntyped_args = num_typed_args;
+    XtCacheRef *Resrc = NULL;
+
     WIDGET_TO_APPCON(w);
 
-    if (num_resources == 0) return;
+    if (num_resources == 0)
+        return;
 
     LOCK_APP(app);
     count = CountTreeDepth(w);
-    count++;	/* make sure there's enough room for name and class */
-    names = (XrmName*) XtStackAlloc(count * sizeof(XrmName), names_s);
-    classes = (XrmClass*) XtStackAlloc(count * sizeof(XrmClass), classes_s);
+    count++;                    /* make sure there's enough room for name and class */
+    names = (XrmName *) XtStackAlloc(count * sizeof(XrmName), names_s);
+    classes = (XrmClass *) XtStackAlloc(count * sizeof(XrmClass), classes_s);
     if (names == NULL || classes == NULL) {
-	_XtAllocError(NULL);
-    } else {
-	/* Get full name, class of subobject */
-	GetNamesAndClasses(w, names, classes);
-	count -= 2;
-	names[count] = StringToName(name);
-	classes[count] = StringToClass(class);
-	count++;
-	names[count] = NULLQUARK;
-	classes[count] = NULLQUARK;
-
-	/* Compile arg list into quarks */
-	CacheArgs(args, num_args, typed_args, num_typed_args,
-		  quark_cache, XtNumber(quark_cache), &quark_args);
-
-	/* Compile resource list if needed */
-	if (((int) resources->resource_offset) >= 0) {
-	    XrmCompileResourceListEphem(resources, num_resources);
-	}
-	table = _XtCreateIndirectionTable(resources, num_resources);
-	Resrc = GetResources(w, (char*)base, names, classes, table, num_resources,
-			    quark_args, args, num_args,
-			    typed_args, &ntyped_args, False);
-	FreeCache(quark_cache, quark_args);
-	XtFree((char *)table);
-	XtFree((char *)Resrc);
-	XtStackFree((XtPointer)names, names_s);
-	XtStackFree((XtPointer)classes, classes_s);
-	UNLOCK_APP(app);
+        _XtAllocError(NULL);
+    }
+    else {
+        /* Get full name, class of subobject */
+        GetNamesAndClasses(w, names, classes);
+        count -= 2;
+        names[count] = StringToName(name);
+        classes[count] = StringToClass(class);
+        count++;
+        names[count] = NULLQUARK;
+        classes[count] = NULLQUARK;
+
+        /* Compile arg list into quarks */
+        CacheArgs(args, num_args, typed_args, num_typed_args,
+                  quark_cache, XtNumber(quark_cache), &quark_args);
+
+        /* Compile resource list if needed */
+        if (((int) resources->resource_offset) >= 0) {
+            XrmCompileResourceListEphem(resources, num_resources);
+        }
+        table = _XtCreateIndirectionTable(resources, num_resources);
+        Resrc =
+            GetResources(w, (char *) base, names, classes, table, num_resources,
+                         quark_args, args, num_args, typed_args, &ntyped_args,
+                         False);
+        FreeCache(quark_cache, quark_args);
+        XtFree((char *) table);
+        XtFree((char *) Resrc);
+        XtStackFree((XtPointer) names, names_s);
+        XtStackFree((XtPointer) classes, classes_s);
+        UNLOCK_APP(app);
     }
 }
 
-void XtGetSubresources (
-    Widget	  w,			/* Widget "parent" of subobject   */
-    XtPointer	  base,			/* Base address to write to       */
-    _Xconst char* name,			/* name of subobject		    */
-    _Xconst char* class,		/* class of subobject		    */
-    XtResourceList resources,		/* resource list for subobject    */
-    Cardinal	  num_resources,
-    ArgList	  args,			/* arg list to override resources */
-    Cardinal	  num_args)
+void
+XtGetSubresources(Widget w,                     /* Widget "parent" of subobject */
+                  XtPointer base,               /* Base address to write to */
+                  _Xconst char *name,           /* name of subobject        */
+                  _Xconst char *class,          /* class of subobject       */
+                  XtResourceList resources,     /* resource list for subobject    */
+                  Cardinal num_resources,
+                  ArgList args,                 /* arg list to override resources */
+                  Cardinal num_args)
 {
-    _XtGetSubresources (w, base, name, class, resources, num_resources, args, num_args, NULL, 0);
+    _XtGetSubresources(w, base, name, class, resources, num_resources, args,
+                       num_args, NULL, 0);
 }
 
-
-void _XtGetApplicationResources (
-    Widget	    w,		  /* Application shell widget       */
-    XtPointer	    base,	  /* Base address to write to       */
-    XtResourceList  resources,	  /* resource list for subobject    */
-    Cardinal	    num_resources,
-    ArgList	    args,	  /* arg list to override resources */
-    Cardinal	    num_args,
-    XtTypedArgList  typed_args,
-    Cardinal	    num_typed_args)
+void
+_XtGetApplicationResources(Widget w,            /* Application shell widget */
+                           XtPointer base,      /* Base address to write to       */
+                           XtResourceList resources,    /* resource list for subobject    */
+                           Cardinal num_resources,
+                           ArgList args,        /* arg list to override resources */
+                           Cardinal num_args,
+                           XtTypedArgList typed_args,
+                           Cardinal num_typed_args)
 {
-    XrmName	    *names, names_s[50];
-    XrmClass	    *classes, classes_s[50];
-    XrmQuark	    quark_cache[100];
-    XrmQuarkList    quark_args;
-    XrmResourceList* table;
-    Cardinal        ntyped_args = num_typed_args;
+    XrmName *names, names_s[50];
+    XrmClass *classes, classes_s[50];
+    XrmQuark quark_cache[100];
+    XrmQuarkList quark_args;
+    XrmResourceList *table;
+    Cardinal ntyped_args = num_typed_args;
+
 #ifdef XTHREADS
-    XtAppContext    app;
+    XtAppContext app;
 #endif
-    XtCacheRef	    *Resrc = NULL;
+    XtCacheRef *Resrc = NULL;
 
-    if (num_resources == 0) return;
+    if (num_resources == 0)
+        return;
 
 #ifdef XTHREADS
-    if (w == NULL) app = _XtDefaultAppContext();
-    else app = XtWidgetToApplicationContext(w);
+    if (w == NULL)
+        app = _XtDefaultAppContext();
+    else
+        app = XtWidgetToApplicationContext(w);
 #endif
 
     LOCK_APP(app);
     /* Get full name, class of application */
     if (w == NULL) {
-	/* hack for R2 compatibility */
-	XtPerDisplay pd = _XtGetPerDisplay(_XtDefaultAppContext()->list[0]);
-	names = (XrmName*) XtStackAlloc (2 * sizeof(XrmName), names_s);
-	classes = (XrmClass*) XtStackAlloc (2 * sizeof(XrmClass), classes_s);
-	if (names == NULL || classes == NULL) {
-	    _XtAllocError(NULL);
-	} else {
-	    names[0] = pd->name;
-	    names[1] = NULLQUARK;
-	    classes[0] = pd->class;
-	    classes[1] = NULLQUARK;
-	}
+        /* hack for R2 compatibility */
+        XtPerDisplay pd = _XtGetPerDisplay(_XtDefaultAppContext()->list[0]);
+
+        names = (XrmName *) XtStackAlloc(2 * sizeof(XrmName), names_s);
+        classes = (XrmClass *) XtStackAlloc(2 * sizeof(XrmClass), classes_s);
+        if (names == NULL || classes == NULL) {
+            _XtAllocError(NULL);
+        }
+        else {
+            names[0] = pd->name;
+            names[1] = NULLQUARK;
+            classes[0] = pd->class;
+            classes[1] = NULLQUARK;
+        }
     }
     else {
-	Cardinal count = CountTreeDepth(w);
-        names = (XrmName*) XtStackAlloc(count * sizeof(XrmName), names_s);
-        classes = (XrmClass*) XtStackAlloc(count * sizeof(XrmClass), classes_s);
-	if (names == NULL || classes == NULL) {
-	    _XtAllocError(NULL);
-	} else {
-	    GetNamesAndClasses(w, names, classes);
-	}
+        Cardinal count = CountTreeDepth(w);
+
+        names = (XrmName *) XtStackAlloc(count * sizeof(XrmName), names_s);
+        classes =
+            (XrmClass *) XtStackAlloc(count * sizeof(XrmClass), classes_s);
+        if (names == NULL || classes == NULL) {
+            _XtAllocError(NULL);
+        }
+        else {
+            GetNamesAndClasses(w, names, classes);
+        }
     }
 
     /* Compile arg list into quarks */
-    CacheArgs(args, num_args, typed_args, num_typed_args,  quark_cache,
-	XtNumber(quark_cache), &quark_args);
+    CacheArgs(args, num_args, typed_args, num_typed_args, quark_cache,
+              XtNumber(quark_cache), &quark_args);
     /* Compile resource list if needed */
     if (((int) resources->resource_offset) >= 0) {
-	XrmCompileResourceListEphem(resources, num_resources);
+        XrmCompileResourceListEphem(resources, num_resources);
     }
-    table = _XtCreateIndirectionTable(resources,num_resources);
+    table = _XtCreateIndirectionTable(resources, num_resources);
 
-    Resrc = GetResources(w, (char*)base, names, classes, table, num_resources,
-			quark_args, args, num_args,
-			typed_args, &ntyped_args, False);
+    Resrc = GetResources(w, (char *) base, names, classes, table, num_resources,
+                         quark_args, args, num_args,
+                         typed_args, &ntyped_args, False);
     FreeCache(quark_cache, quark_args);
-    XtFree((char *)table);
-    XtFree((char *)Resrc);
+    XtFree((char *) table);
+    XtFree((char *) Resrc);
     if (w != NULL) {
-	XtStackFree((XtPointer)names, names_s);
-	XtStackFree((XtPointer)classes, classes_s);
+        XtStackFree((XtPointer) names, names_s);
+        XtStackFree((XtPointer) classes, classes_s);
     }
     UNLOCK_APP(app);
 }
 
-void XtGetApplicationResources (
-    Widget	    w,		  /* Application shell widget       */
-    XtPointer	    base,	  /* Base address to write to       */
-    XtResourceList  resources,	  /* resource list for subobject    */
-    Cardinal	    num_resources,
-    ArgList	    args,	  /* arg list to override resources */
-    Cardinal	    num_args)
+void
+XtGetApplicationResources(Widget w,     /* Application shell widget       */
+                          XtPointer base,       /* Base address to write to       */
+                          XtResourceList resources,     /* resource list for subobject    */
+                          Cardinal num_resources,
+                          ArgList args, /* arg list to override resources */
+                          Cardinal num_args)
 {
-    _XtGetApplicationResources(w, base, resources, num_resources, args, num_args, NULL, 0);
+    _XtGetApplicationResources(w, base, resources, num_resources, args,
+                               num_args, NULL, 0);
 }
 
 static Boolean initialized = FALSE;
 
-void _XtResourceListInitialize(void)
+void
+_XtResourceListInitialize(void)
 {
     LOCK_PROCESS;
     if (initialized) {
-	XtWarningMsg("initializationError","xtInitialize",XtCXtToolkitError,
-                  "Initializing Resource Lists twice",
-		  NULL, NULL);
-	UNLOCK_PROCESS;
-    	return;
+        XtWarningMsg("initializationError", "xtInitialize", XtCXtToolkitError,
+                     "Initializing Resource Lists twice", NULL, NULL);
+        UNLOCK_PROCESS;
+        return;
     }
     initialized = TRUE;
     UNLOCK_PROCESS;
@@ -1170,8 +1227,10 @@ void _XtResourceListInitialize(void)
     QString = XrmPermStringToQuark(XtCString);
     QCallProc = XrmPermStringToQuark(XtRCallProc);
     QImmediate = XrmPermStringToQuark(XtRImmediate);
-    QinitialResourcesPersistent = XrmPermStringToQuark(XtNinitialResourcesPersistent);
-    QInitialResourcesPersistent = XrmPermStringToQuark(XtCInitialResourcesPersistent);
+    QinitialResourcesPersistent =
+        XrmPermStringToQuark(XtNinitialResourcesPersistent);
+    QInitialResourcesPersistent =
+        XrmPermStringToQuark(XtCInitialResourcesPersistent);
     Qtranslations = XrmPermStringToQuark(XtNtranslations);
     QbaseTranslations = XrmPermStringToQuark("baseTranslations");
     QTranslations = XrmPermStringToQuark(XtCTranslations);
diff --git a/src/Selection.c b/src/Selection.c
index 8c48dd7..f5df019 100644
--- a/src/Selection.c
+++ b/src/Selection.c
@@ -77,58 +77,60 @@ in this Software without prior written authorization from The Open Group.
 #include <X11/Xatom.h>
 #include <stdio.h>
 
-void _XtSetDefaultSelectionTimeout(
-	unsigned long *timeout)
+void
+_XtSetDefaultSelectionTimeout(unsigned long *timeout)
 {
-	*timeout = 5000; /* default to 5 seconds */
+    *timeout = 5000;            /* default to 5 seconds */
 }
 
-void XtSetSelectionTimeout(
-	unsigned long timeout)
+void
+XtSetSelectionTimeout(unsigned long timeout)
 {
-	XtAppSetSelectionTimeout(_XtDefaultAppContext(), timeout);
+    XtAppSetSelectionTimeout(_XtDefaultAppContext(), timeout);
 }
 
-void XtAppSetSelectionTimeout(
-	XtAppContext app,
-	unsigned long timeout)
+void
+XtAppSetSelectionTimeout(XtAppContext app, unsigned long timeout)
 {
-	LOCK_APP(app);
-	app->selectionTimeout = timeout;
-	UNLOCK_APP(app);
+    LOCK_APP(app);
+    app->selectionTimeout = timeout;
+    UNLOCK_APP(app);
 }
 
-unsigned long XtGetSelectionTimeout(void)
+unsigned long
+XtGetSelectionTimeout(void)
 {
-	return XtAppGetSelectionTimeout(_XtDefaultAppContext());
+    return XtAppGetSelectionTimeout(_XtDefaultAppContext());
 }
 
-unsigned long XtAppGetSelectionTimeout(
-	XtAppContext app)
+unsigned long
+XtAppGetSelectionTimeout(XtAppContext app)
 {
-	unsigned long retval;
+    unsigned long retval;
 
-	LOCK_APP(app);
-	retval = app->selectionTimeout;
-	UNLOCK_APP(app);
-	return retval;
+    LOCK_APP(app);
+    retval = app->selectionTimeout;
+    UNLOCK_APP(app);
+    return retval;
 }
 
-
 /* General utilities */
 
 static void HandleSelectionReplies(Widget, XtPointer, XEvent *, Boolean *);
 static void ReqTimedOut(XtPointer, XtIntervalId *);
 static void HandlePropertyGone(Widget, XtPointer, XEvent *, Boolean *);
 static void HandleGetIncrement(Widget, XtPointer, XEvent *, Boolean *);
-static void HandleIncremental(Display *, Widget, Atom, CallBackInfo, unsigned long);
+static void HandleIncremental(Display *, Widget, Atom, CallBackInfo,
+                              unsigned long);
 
 static XContext selectPropertyContext = 0;
 static XContext paramPropertyContext = 0;
 static XContext multipleContext = 0;
 
 /* Multiple utilities */
-static void AddSelectionRequests(Widget, Atom, int, Atom *, XtSelectionCallbackProc *, int, XtPointer *, Boolean *, Atom *);
+static void AddSelectionRequests(Widget, Atom, int, Atom *,
+                                 XtSelectionCallbackProc *, int, XtPointer *,
+                                 Boolean *, Atom *);
 static Boolean IsGatheringRequest(Widget, Atom);
 
 #define PREALLOCED 32
@@ -138,7 +140,8 @@ static void AddParamInfo(Widget, Atom, Atom);
 static void RemoveParamInfo(Widget, Atom);
 static Atom GetParamInfo(Widget, Atom);
 
-static int StorageSize[3] = {1, sizeof(short), sizeof(long)};
+static int StorageSize[3] = { 1, sizeof(short), sizeof(long) };
+
 #define BYTELENGTH(length, format) ((length) * (size_t)StorageSize[(format)>>4])
 #define NUMELEM(bytelength, format) ((bytelength) / StorageSize[(format)>>4])
 #define NUMELEM2(bytelength, format) ((unsigned long)(bytelength) / (unsigned long) StorageSize[(format)>>4])
@@ -151,188 +154,192 @@ static int StorageSize[3] = {1, sizeof(short), sizeof(long)};
  * library configuration copying is unnecessary.
  */
 #ifdef XTTRACEMEMORY
-#define XT_COPY_SELECTION	1
+#define XT_COPY_SELECTION       1
 #endif
 
-/*ARGSUSED*/
-static void FreePropList(
- Widget w,			/* unused */
- XtPointer closure,
- XtPointer callData)		/* unused */
+static void
+FreePropList(Widget w _X_UNUSED,
+             XtPointer closure,
+             XtPointer callData _X_UNUSED)
 {
-    PropList sarray = (PropList)closure;
+    PropList sarray = (PropList) closure;
+
     LOCK_PROCESS;
     XDeleteContext(sarray->dpy, DefaultRootWindow(sarray->dpy),
-		   selectPropertyContext);
+                   selectPropertyContext);
     UNLOCK_PROCESS;
-    XtFree((char*)sarray->list);
-    XtFree((char*)closure);
+    XtFree((char *) sarray->list);
+    XtFree((char *) closure);
 }
 
-
-static PropList GetPropList(
-    Display *dpy)
+static PropList
+GetPropList(Display *dpy)
 {
     PropList sarray;
 
     LOCK_PROCESS;
     if (selectPropertyContext == 0)
-	selectPropertyContext = XUniqueContext();
+        selectPropertyContext = XUniqueContext();
     if (XFindContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
-		     (XPointer *)&sarray)) {
-	Atom atoms[4];
-	static char* names[] = {
-	    "INCR",
-	    "MULTIPLE",
-	    "TIMESTAMP",
-	    "_XT_SELECTION_0" };
-
-	XtPerDisplay pd = _XtGetPerDisplay(dpy);
-	sarray = (PropList) __XtMalloc((unsigned) sizeof(PropListRec));
-	sarray->dpy = dpy;
-	XInternAtoms(dpy, names, 4, FALSE, atoms);
-	sarray->incr_atom = atoms[0];
-	sarray->indirect_atom = atoms[1];
-	sarray->timestamp_atom = atoms[2];
-	sarray->propCount = 1;
-	sarray->list =
-	    (SelectionProp)__XtMalloc((unsigned) sizeof(SelectionPropRec));
-	sarray->list[0].prop = atoms[3];
-	sarray->list[0].avail = TRUE;
-	(void) XSaveContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
-			    (char *) sarray);
-	_XtAddCallback( &pd->destroy_callbacks,
-			FreePropList, (XtPointer)sarray );
+                     (XPointer *) &sarray)) {
+        Atom atoms[4];
+
+        static char *names[] = {
+            "INCR",
+            "MULTIPLE",
+            "TIMESTAMP",
+            "_XT_SELECTION_0"
+        };
+
+        XtPerDisplay pd = _XtGetPerDisplay(dpy);
+
+        sarray = (PropList) __XtMalloc((unsigned) sizeof(PropListRec));
+        sarray->dpy = dpy;
+        XInternAtoms(dpy, names, 4, FALSE, atoms);
+        sarray->incr_atom = atoms[0];
+        sarray->indirect_atom = atoms[1];
+        sarray->timestamp_atom = atoms[2];
+        sarray->propCount = 1;
+        sarray->list =
+            (SelectionProp) __XtMalloc((unsigned) sizeof(SelectionPropRec));
+        sarray->list[0].prop = atoms[3];
+        sarray->list[0].avail = TRUE;
+        (void) XSaveContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
+                            (char *) sarray);
+        _XtAddCallback(&pd->destroy_callbacks,
+                       FreePropList, (XtPointer) sarray);
     }
     UNLOCK_PROCESS;
     return sarray;
 }
 
-
-static Atom GetSelectionProperty(
-    Display *dpy)
+static Atom
+GetSelectionProperty(Display *dpy)
 {
- SelectionProp p;
- int propCount;
- char propname[80];
- PropList sarray = GetPropList(dpy);
-
- for (p = sarray->list, propCount=sarray->propCount;
-	propCount;
-	p++, propCount--) {
-   if (p->avail) {
-      p->avail = FALSE;
-      return(p->prop);
-   }
- }
- propCount = sarray->propCount++;
- sarray->list = (SelectionProp) XtRealloc((XtPointer)sarray->list,
-  		(Cardinal)((size_t)sarray->propCount * sizeof(SelectionPropRec)));
- (void) snprintf(propname, sizeof(propname), "_XT_SELECTION_%d", propCount);
- sarray->list[propCount].prop = XInternAtom(dpy, propname, FALSE);
- sarray->list[propCount].avail = FALSE;
- return(sarray->list[propCount].prop);
+    SelectionProp p;
+    int propCount;
+    char propname[80];
+    PropList sarray = GetPropList(dpy);
+
+    for (p = sarray->list, propCount = sarray->propCount;
+         propCount; p++, propCount--) {
+        if (p->avail) {
+            p->avail = FALSE;
+            return (p->prop);
+        }
+    }
+    propCount = sarray->propCount++;
+    sarray->list = (SelectionProp) XtRealloc((XtPointer) sarray->list,
+                                             (Cardinal) ((size_t) sarray->
+                                                         propCount *
+                                                         sizeof
+                                                         (SelectionPropRec)));
+    (void) snprintf(propname, sizeof(propname), "_XT_SELECTION_%d", propCount);
+    sarray->list[propCount].prop = XInternAtom(dpy, propname, FALSE);
+    sarray->list[propCount].avail = FALSE;
+    return (sarray->list[propCount].prop);
 }
 
-static void FreeSelectionProperty(
-    Display *dpy,
-    Atom prop)
+static void
+FreeSelectionProperty(Display *dpy, Atom prop)
 {
- SelectionProp p;
- int propCount;
- PropList sarray;
- if (prop == None) return;
- LOCK_PROCESS;
- if (XFindContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
-		  (XPointer *)&sarray))
-    XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
-	    "noSelectionProperties", "freeSelectionProperty", XtCXtToolkitError,
-		"internal error: no selection property context for display",
-		 NULL,  NULL );
- UNLOCK_PROCESS;
- for (p = sarray->list, propCount=sarray->propCount;
-	propCount;
-	p++, propCount--)
-   if (p->prop == prop) {
-      p->avail = TRUE;
-      return;
-      }
+    SelectionProp p;
+    int propCount;
+    PropList sarray;
+
+    if (prop == None)
+        return;
+    LOCK_PROCESS;
+    if (XFindContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
+                     (XPointer *) &sarray))
+        XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
+                      "noSelectionProperties", "freeSelectionProperty",
+                      XtCXtToolkitError,
+                      "internal error: no selection property context for display",
+                      NULL, NULL);
+    UNLOCK_PROCESS;
+    for (p = sarray->list, propCount = sarray->propCount;
+         propCount; p++, propCount--)
+        if (p->prop == prop) {
+            p->avail = TRUE;
+            return;
+        }
 }
 
-static void FreeInfo(
-    CallBackInfo info)
+static void
+FreeInfo(CallBackInfo info)
 {
-    XtFree((char*)info->incremental);
-    XtFree((char*)info->callbacks);
-    XtFree((char*)info->req_closure);
-    XtFree((char*)info->target);
-    XtFree((char*)info);
+    XtFree((char *) info->incremental);
+    XtFree((char *) info->callbacks);
+    XtFree((char *) info->req_closure);
+    XtFree((char *) info->target);
+    XtFree((char *) info);
 }
 
-static CallBackInfo MakeInfo(
-    Select ctx,
-    XtSelectionCallbackProc *callbacks,
-    XtPointer *closures,
-    int count,
-    Widget widget,
-    Time time,
-    Boolean *incremental,
-    Atom *properties)
+static CallBackInfo
+MakeInfo(Select ctx,
+         XtSelectionCallbackProc *callbacks,
+         XtPointer *closures,
+         int count,
+         Widget widget,
+         Time time,
+         Boolean *incremental,
+         Atom *properties)
 {
-    	CallBackInfo info = XtNew(CallBackInfoRec);
-
-	info->ctx = ctx;
-	info->callbacks = (XtSelectionCallbackProc *)
-	    __XtMalloc((unsigned) ((size_t)count * sizeof(XtSelectionCallbackProc)));
-	(void) memmove((char*)info->callbacks, (char*)callbacks,
-		       (size_t)count * sizeof(XtSelectionCallbackProc));
-	info->req_closure =
-	    (XtPointer*)__XtMalloc((unsigned) ((size_t)count * sizeof(XtPointer)));
-	(void) memmove((char*)info->req_closure, (char*)closures,
-		       (size_t)count * sizeof(XtPointer));
-	if (count == 1 && properties != NULL && properties[0] != None)
-	    info->property = properties[0];
-	else {
-	    info->property = GetSelectionProperty(XtDisplay(widget));
-	    XDeleteProperty(XtDisplay(widget), XtWindow(widget),
-			    info->property);
-	}
-	info->proc = HandleSelectionReplies;
-	info->widget = widget;
-	info->time = time;
-	info->incremental = (Boolean*) __XtMalloc((Cardinal)((size_t)count * sizeof(Boolean)));
-	(void) memmove((char*)info->incremental, (char*) incremental,
-		       (size_t)count * sizeof(Boolean));
-	info->current = 0;
-	info->value = NULL;
-	return (info);
+    CallBackInfo info = XtNew(CallBackInfoRec);
+
+    info->ctx = ctx;
+    info->callbacks = (XtSelectionCallbackProc *)
+        __XtMalloc((unsigned)
+                   ((size_t) count * sizeof(XtSelectionCallbackProc)));
+    (void) memmove((char *) info->callbacks, (char *) callbacks,
+                   (size_t) count * sizeof(XtSelectionCallbackProc));
+    info->req_closure = (XtPointer *)
+        __XtMalloc((unsigned) ((size_t) count * sizeof(XtPointer)));
+    (void) memmove((char *) info->req_closure, (char *) closures,
+                   (size_t) count * sizeof(XtPointer));
+    if (count == 1 && properties != NULL && properties[0] != None)
+        info->property = properties[0];
+    else {
+        info->property = GetSelectionProperty(XtDisplay(widget));
+        XDeleteProperty(XtDisplay(widget), XtWindow(widget), info->property);
+    }
+    info->proc = HandleSelectionReplies;
+    info->widget = widget;
+    info->time = time;
+    info->incremental =
+        (Boolean *) __XtMalloc((Cardinal) ((size_t) count * sizeof(Boolean)));
+    (void) memmove((char *) info->incremental, (char *) incremental,
+                   (size_t) count * sizeof(Boolean));
+    info->current = 0;
+    info->value = NULL;
+    return (info);
 }
 
-static void RequestSelectionValue(
-    CallBackInfo info,
-    Atom selection,
-    Atom target)
+static void
+RequestSelectionValue(CallBackInfo info, Atom selection, Atom target)
 {
 #ifndef DEBUG_WO_TIMERS
     XtAppContext app = XtWidgetToApplicationContext(info->widget);
-	info->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, ReqTimedOut, (XtPointer)info);
+
+    info->timeout = XtAppAddTimeOut(app,
+                                    app->selectionTimeout, ReqTimedOut,
+                                    (XtPointer) info);
 #endif
-	XtAddEventHandler(info->widget, (EventMask)0, TRUE,
-			  HandleSelectionReplies, (XtPointer)info);
-	XConvertSelection(info->ctx->dpy, selection, target,
-			  info->property, XtWindow(info->widget), info->time);
+    XtAddEventHandler(info->widget, (EventMask) 0, TRUE,
+                      HandleSelectionReplies, (XtPointer) info);
+    XConvertSelection(info->ctx->dpy, selection, target,
+                      info->property, XtWindow(info->widget), info->time);
 }
 
-
 static XContext selectContext = 0;
 
-static Select NewContext(
-    Display *dpy,
-    Atom selection)
+static Select
+NewContext(Display *dpy, Atom selection)
 {
     /* assert(selectContext != 0) */
     Select ctx = XtNew(SelectRec);
+
     ctx->dpy = dpy;
     ctx->selection = selection;
     ctx->widget = NULL;
@@ -341,37 +348,35 @@ static Select NewContext(
     ctx->free_when_done = FALSE;
     ctx->was_disowned = FALSE;
     LOCK_PROCESS;
-    (void)XSaveContext(dpy, (Window)selection, selectContext, (char *)ctx);
+    (void) XSaveContext(dpy, (Window) selection, selectContext, (char *) ctx);
     UNLOCK_PROCESS;
     return ctx;
 }
 
-static Select FindCtx(
-    Display *dpy,
-    Atom selection)
+static Select
+FindCtx(Display *dpy, Atom selection)
 {
     Select ctx;
 
     LOCK_PROCESS;
     if (selectContext == 0)
-	selectContext = XUniqueContext();
-    if (XFindContext(dpy, (Window)selection, selectContext, (XPointer *)&ctx))
-	ctx = NewContext(dpy, selection);
+        selectContext = XUniqueContext();
+    if (XFindContext(dpy, (Window) selection, selectContext, (XPointer *) &ctx))
+        ctx = NewContext(dpy, selection);
     UNLOCK_PROCESS;
     return ctx;
 }
 
-/*ARGSUSED*/
-static void WidgetDestroyed(
-    Widget widget,
-    XtPointer closure, XtPointer data)
+static void
+WidgetDestroyed(Widget widget, XtPointer closure, XtPointer data _X_UNUSED)
 {
     Select ctx = (Select) closure;
+
     if (ctx->widget == widget) {
-	if (ctx->free_when_done)
-	    XtFree((char*)ctx);
-	else
-	    ctx->widget = NULL;
+        if (ctx->free_when_done)
+            XtFree((char *) ctx);
+        else
+            ctx->widget = NULL;
     }
 }
 
@@ -379,46 +384,41 @@ static void WidgetDestroyed(
 
 static void HandleSelectionEvents(Widget, XtPointer, XEvent *, Boolean *);
 
-static Boolean LoseSelection(
-    Select ctx,
-    Widget widget,
-    Atom selection,
-    Time time)
+static Boolean
+LoseSelection(Select ctx, Widget widget, Atom selection, Time time)
 {
-    if ((ctx->widget == widget) &&
-	(ctx->selection == selection) && /* paranoia */
-	!ctx->was_disowned &&
-	((time == CurrentTime) || (time >= ctx->time)))
-    {
-	XtRemoveEventHandler(widget, (EventMask)0, TRUE,
-			     HandleSelectionEvents, (XtPointer)ctx);
-	XtRemoveCallback(widget, XtNdestroyCallback,
-			 WidgetDestroyed, (XtPointer)ctx);
-	ctx->was_disowned = TRUE; /* widget officially loses ownership */
-	/* now inform widget */
-	if (ctx->loses) {
-	    if (ctx->incremental)
-	       (*(XtLoseSelectionIncrProc)ctx->loses)
-		   (widget, &ctx->selection, ctx->owner_closure);
-	    else  (*ctx->loses)(widget, &ctx->selection);
-	}
-	return(TRUE);
-    }
-    else return(FALSE);
+    if ((ctx->widget == widget) && (ctx->selection == selection) &&     /* paranoia */
+        !ctx->was_disowned && ((time == CurrentTime) || (time >= ctx->time))) {
+        XtRemoveEventHandler(widget, (EventMask) 0, TRUE,
+                             HandleSelectionEvents, (XtPointer) ctx);
+        XtRemoveCallback(widget, XtNdestroyCallback,
+                         WidgetDestroyed, (XtPointer) ctx);
+        ctx->was_disowned = TRUE;       /* widget officially loses ownership */
+        /* now inform widget */
+        if (ctx->loses) {
+            if (ctx->incremental)
+                (*(XtLoseSelectionIncrProc) ctx->loses)
+                    (widget, &ctx->selection, ctx->owner_closure);
+            else
+                (*ctx->loses) (widget, &ctx->selection);
+        }
+        return (TRUE);
+    }
+    else
+        return (FALSE);
 }
 
 static XContext selectWindowContext = 0;
 
 /* %%% Xlib.h should make this public! */
-typedef int (*xErrorHandler)(Display*, XErrorEvent*);
+typedef int (*xErrorHandler) (Display *, XErrorEvent *);
 
 static xErrorHandler oldErrorHandler = NULL;
 static unsigned long firstProtectRequest;
 static Window errorWindow;
 
-static int LocalErrorHandler (
-    Display *dpy,
-    XErrorEvent *error)
+static int
+LocalErrorHandler(Display *dpy, XErrorEvent *error)
 {
     int retval;
 
@@ -428,24 +428,23 @@ static int LocalErrorHandler (
     LOCK_PROCESS;
 
     if (error->error_code == BadWindow && error->resourceid == errorWindow &&
-	error->serial >= firstProtectRequest) {
-	UNLOCK_PROCESS;
-	return 0;
+        error->serial >= firstProtectRequest) {
+        UNLOCK_PROCESS;
+        return 0;
     }
 
     if (oldErrorHandler == NULL) {
-	UNLOCK_PROCESS;
-	return 0;  /* should never happen */
+        UNLOCK_PROCESS;
+        return 0;               /* should never happen */
     }
 
-    retval = (*oldErrorHandler)(dpy, error);
+    retval = (*oldErrorHandler) (dpy, error);
     UNLOCK_PROCESS;
     return retval;
 }
 
-static void StartProtectedSection(
-    Display *dpy,
-    Window window)
+static void
+StartProtectedSection(Display *dpy, Window window)
 {
     /* protect ourselves against request window being destroyed
      * before completion of transfer */
@@ -457,8 +456,8 @@ static void StartProtectedSection(
     UNLOCK_PROCESS;
 }
 
-static void EndProtectedSection(
-    Display *dpy)
+static void
+EndProtectedSection(Display *dpy)
 {
     /* flush any generated errors on requestor and
      * restore original error handler */
@@ -471,47 +470,47 @@ static void EndProtectedSection(
     UNLOCK_PROCESS;
 }
 
-static void AddHandler(
-    Request req,
-    EventMask mask,
-    XtEventHandler proc,
-    XtPointer closure)
+static void
+AddHandler(Request req, EventMask mask, XtEventHandler proc, XtPointer closure)
 {
     Display *dpy = req->ctx->dpy;
     Window window = req->requestor;
     Widget widget = XtWindowToWidget(dpy, window);
 
-    if (widget != NULL) req->widget = widget;
-    else widget = req->widget;
+    if (widget != NULL)
+        req->widget = widget;
+    else
+        widget = req->widget;
 
     if (XtWindow(widget) == window)
-	XtAddEventHandler(widget, mask, False, proc, closure);
+        XtAddEventHandler(widget, mask, False, proc, closure);
     else {
-	RequestWindowRec *requestWindowRec;
-	LOCK_PROCESS;
-	if (selectWindowContext == 0)
-	    selectWindowContext = XUniqueContext();
-	if (XFindContext(dpy, window, selectWindowContext,
-			 (XPointer *)&requestWindowRec)) {
-	    requestWindowRec = XtNew(RequestWindowRec);
-	    requestWindowRec->active_transfer_count = 0;
-	    (void)XSaveContext(dpy, window, selectWindowContext,
-			       (char *)requestWindowRec);
-	}
-	UNLOCK_PROCESS;
-	if (requestWindowRec->active_transfer_count++ == 0) {
-	    XtRegisterDrawable(dpy, window, widget);
-	    XSelectInput(dpy, window, (long)mask);
-	}
-	XtAddRawEventHandler(widget, mask, FALSE, proc, closure);
+        RequestWindowRec *requestWindowRec;
+
+        LOCK_PROCESS;
+        if (selectWindowContext == 0)
+            selectWindowContext = XUniqueContext();
+        if (XFindContext(dpy, window, selectWindowContext,
+                         (XPointer *) &requestWindowRec)) {
+            requestWindowRec = XtNew(RequestWindowRec);
+            requestWindowRec->active_transfer_count = 0;
+            (void) XSaveContext(dpy, window, selectWindowContext,
+                                (char *) requestWindowRec);
+        }
+        UNLOCK_PROCESS;
+        if (requestWindowRec->active_transfer_count++ == 0) {
+            XtRegisterDrawable(dpy, window, widget);
+            XSelectInput(dpy, window, (long) mask);
+        }
+        XtAddRawEventHandler(widget, mask, FALSE, proc, closure);
     }
 }
 
-static void RemoveHandler(
-    Request req,
-    EventMask mask,
-    XtEventHandler proc,
-    XtPointer closure)
+static void
+RemoveHandler(Request req,
+              EventMask mask,
+              XtEventHandler proc,
+              XtPointer closure)
 {
     Display *dpy = req->ctx->dpy;
     Window window = req->requestor;
@@ -519,200 +518,210 @@ static void RemoveHandler(
 
     if ((XtWindowToWidget(dpy, window) == widget) &&
         (XtWindow(widget) != window)) {
-	/* we had to hang this window onto our widget; take it off */
-	RequestWindowRec* requestWindowRec;
-	XtRemoveRawEventHandler(widget, mask, TRUE, proc, closure);
-	LOCK_PROCESS;
-	(void)XFindContext(dpy, window, selectWindowContext,
-			   (XPointer *)&requestWindowRec);
-	UNLOCK_PROCESS;
-	if (--requestWindowRec->active_transfer_count == 0) {
-	    XtUnregisterDrawable(dpy, window);
-	    StartProtectedSection(dpy, window);
-	    XSelectInput(dpy, window, 0L);
-	    EndProtectedSection(dpy);
-	    LOCK_PROCESS;
-	    (void)XDeleteContext(dpy, window, selectWindowContext);
-	    UNLOCK_PROCESS;
-	    XtFree((char*)requestWindowRec);
-	}
-    } else {
-        XtRemoveEventHandler(widget, mask, TRUE,  proc, closure);
+        /* we had to hang this window onto our widget; take it off */
+        RequestWindowRec *requestWindowRec;
+
+        XtRemoveRawEventHandler(widget, mask, TRUE, proc, closure);
+        LOCK_PROCESS;
+        (void) XFindContext(dpy, window, selectWindowContext,
+                            (XPointer *) &requestWindowRec);
+        UNLOCK_PROCESS;
+        if (--requestWindowRec->active_transfer_count == 0) {
+            XtUnregisterDrawable(dpy, window);
+            StartProtectedSection(dpy, window);
+            XSelectInput(dpy, window, 0L);
+            EndProtectedSection(dpy);
+            LOCK_PROCESS;
+            (void) XDeleteContext(dpy, window, selectWindowContext);
+            UNLOCK_PROCESS;
+            XtFree((char *) requestWindowRec);
+        }
+    }
+    else {
+        XtRemoveEventHandler(widget, mask, TRUE, proc, closure);
     }
 }
 
-/* ARGSUSED */
-static void OwnerTimedOut(
-    XtPointer closure,
-    XtIntervalId   *id)
+static void
+OwnerTimedOut(XtPointer closure, XtIntervalId *id _X_UNUSED)
 {
-    Request req = (Request)closure;
+    Request req = (Request) closure;
     Select ctx = req->ctx;
 
     if (ctx->incremental && (ctx->owner_cancel != NULL)) {
-	(*ctx->owner_cancel)(ctx->widget, &ctx->selection,
-			     &req->target, (XtRequestId*)&req,
-			     ctx->owner_closure);
-    } else {
-	if (ctx->notify == NULL)
-	    XtFree((char*)req->value);
-	else {
-	    /* the requestor hasn't deleted the property, but
-	     * the owner needs to free the value.
-	     */
-	    if (ctx->incremental)
-		(*(XtSelectionDoneIncrProc)ctx->notify)
-			      (ctx->widget, &ctx->selection, &req->target,
-			       (XtRequestId*)&req, ctx->owner_closure);
-	    else
-		(*ctx->notify)(ctx->widget, &ctx->selection, &req->target);
-	}
-    }
-
-    RemoveHandler(req, (EventMask)PropertyChangeMask,
-		  HandlePropertyGone, closure);
-    XtFree((char*)req);
+        (*ctx->owner_cancel) (ctx->widget, &ctx->selection,
+                              &req->target, (XtRequestId *) &req,
+                              ctx->owner_closure);
+    }
+    else {
+        if (ctx->notify == NULL)
+            XtFree((char *) req->value);
+        else {
+            /* the requestor hasn't deleted the property, but
+             * the owner needs to free the value.
+             */
+            if (ctx->incremental)
+                (*(XtSelectionDoneIncrProc) ctx->notify)
+                    (ctx->widget, &ctx->selection, &req->target,
+                     (XtRequestId *) &req, ctx->owner_closure);
+            else
+                (*ctx->notify) (ctx->widget, &ctx->selection, &req->target);
+        }
+    }
+
+    RemoveHandler(req, (EventMask) PropertyChangeMask,
+                  HandlePropertyGone, closure);
+    XtFree((char *) req);
     if (--ctx->ref_count == 0 && ctx->free_when_done)
-	XtFree((char*)ctx);
+        XtFree((char *) ctx);
 }
 
-static void SendIncrement(
-    Request incr)
+static void
+SendIncrement(Request incr)
 {
     Display *dpy = incr->ctx->dpy;
 
     unsigned long incrSize = (unsigned long) MAX_SELECTION_INCR(dpy);
+
     if (incrSize > incr->bytelength - incr->offset)
         incrSize = incr->bytelength - incr->offset;
     StartProtectedSection(dpy, incr->requestor);
     XChangeProperty(dpy, incr->requestor, incr->property,
-    	    incr->type, incr->format, PropModeReplace,
-	    (unsigned char *)incr->value + incr->offset,
-	    NUMELEM((int)incrSize, incr->format));
+                    incr->type, incr->format, PropModeReplace,
+                    (unsigned char *) incr->value + incr->offset,
+                    NUMELEM((int) incrSize, incr->format));
     EndProtectedSection(dpy);
     incr->offset += incrSize;
 }
 
-static void AllSent(
-    Request req)
+static void
+AllSent(Request req)
 {
     Select ctx = req->ctx;
+
     StartProtectedSection(ctx->dpy, req->requestor);
     XChangeProperty(ctx->dpy, req->requestor,
-		    req->property, req->type,  req->format,
-		    PropModeReplace, (unsigned char *) NULL, 0);
+                    req->property, req->type, req->format,
+                    PropModeReplace, (unsigned char *) NULL, 0);
     EndProtectedSection(ctx->dpy);
     req->allSent = TRUE;
 
-    if (ctx->notify == NULL) XtFree((char*)req->value);
+    if (ctx->notify == NULL)
+        XtFree((char *) req->value);
 }
 
-/*ARGSUSED*/
-static void HandlePropertyGone(
-    Widget widget,
-    XtPointer closure,
-    XEvent *ev,
-    Boolean *cont)
+static void
+HandlePropertyGone(Widget widget _X_UNUSED,
+                   XtPointer closure,
+                   XEvent *ev,
+                   Boolean *cont _X_UNUSED)
 {
     XPropertyEvent *event = (XPropertyEvent *) ev;
-    Request req = (Request)closure;
+    Request req = (Request) closure;
     Select ctx = req->ctx;
 
     if ((event->type != PropertyNotify) ||
         (event->state != PropertyDelete) ||
-	(event->atom != req->property) ||
-	(event->window != req->requestor))
-      return;
+        (event->atom != req->property) || (event->window != req->requestor))
+        return;
 #ifndef DEBUG_WO_TIMERS
     XtRemoveTimeOut(req->timeout);
 #endif
     if (req->allSent) {
-	if (ctx->notify) {
-	    if (ctx->incremental) {
-		(*(XtSelectionDoneIncrProc)ctx->notify)
-			      (ctx->widget, &ctx->selection, &req->target,
-			       (XtRequestId*)&req, ctx->owner_closure);
-	    }
-	    else (*ctx->notify)(ctx->widget, &ctx->selection, &req->target);
-	}
-	RemoveHandler(req, (EventMask)PropertyChangeMask,
-		      HandlePropertyGone, closure);
-	XtFree((char*)req);
-	if (--ctx->ref_count == 0 && ctx->free_when_done)
-	    XtFree((char*)ctx);
-    } else  { /* is this part of an incremental transfer? */
-	if (ctx->incremental) {
-	     if (req->bytelength == 0)
-		AllSent(req);
-	     else {
-		unsigned long size = (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
-    		SendIncrement(req);
-		(*(XtConvertSelectionIncrProc)ctx->convert)
-			   (ctx->widget, &ctx->selection, &req->target,
-			    &req->type, &req->value,
-			    &req->bytelength, &req->format,
-			    &size, ctx->owner_closure, (XtPointer*)&req);
-		if (req->bytelength)
-		    req->bytelength = BYTELENGTH(req->bytelength, req->format);
-		req->offset = 0;
-	    }
-	} else {
-	    if (req->offset < req->bytelength)
-		SendIncrement(req);
-	    else AllSent(req);
-	}
+        if (ctx->notify) {
+            if (ctx->incremental) {
+                (*(XtSelectionDoneIncrProc) ctx->notify)
+                    (ctx->widget, &ctx->selection, &req->target,
+                     (XtRequestId *) &req, ctx->owner_closure);
+            }
+            else
+                (*ctx->notify) (ctx->widget, &ctx->selection, &req->target);
+        }
+        RemoveHandler(req, (EventMask) PropertyChangeMask,
+                      HandlePropertyGone, closure);
+        XtFree((char *) req);
+        if (--ctx->ref_count == 0 && ctx->free_when_done)
+            XtFree((char *) ctx);
+    }
+    else {                      /* is this part of an incremental transfer? */
+        if (ctx->incremental) {
+            if (req->bytelength == 0)
+                AllSent(req);
+            else {
+                unsigned long size =
+                    (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
+                SendIncrement(req);
+                (*(XtConvertSelectionIncrProc) ctx->convert)
+                    (ctx->widget, &ctx->selection, &req->target,
+                     &req->type, &req->value,
+                     &req->bytelength, &req->format,
+                     &size, ctx->owner_closure, (XtPointer *) &req);
+                if (req->bytelength)
+                    req->bytelength = BYTELENGTH(req->bytelength, req->format);
+                req->offset = 0;
+            }
+        }
+        else {
+            if (req->offset < req->bytelength)
+                SendIncrement(req);
+            else
+                AllSent(req);
+        }
 #ifndef DEBUG_WO_TIMERS
-	{
-	  XtAppContext app = XtWidgetToApplicationContext(req->widget);
-	  req->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
-	}
+        {
+            XtAppContext app = XtWidgetToApplicationContext(req->widget);
+
+            req->timeout = XtAppAddTimeOut(app,
+                                           app->selectionTimeout, OwnerTimedOut,
+                                           (XtPointer) req);
+        }
 #endif
     }
 }
 
-static void PrepareIncremental(
-    Request req,
-    Widget widget,
-    Window window,
-    Atom property,
-    Atom target,
-    Atom targetType,
-    XtPointer value,
-    unsigned long length,
-    int format)
+static void
+PrepareIncremental(Request req,
+                   Widget widget,
+                   Window window,
+                   Atom property _X_UNUSED,
+                   Atom target,
+                   Atom targetType,
+                   XtPointer value,
+                   unsigned long length,
+                   int format)
 {
-	req->type = targetType;
-	req->value = value;
-	req->bytelength = BYTELENGTH(length,format);
-	req->format = format;
-	req->offset = 0;
-	req->target = target;
-	req->widget = widget;
-	req->allSent = FALSE;
+    req->type = targetType;
+    req->value = value;
+    req->bytelength = BYTELENGTH(length, format);
+    req->format = format;
+    req->offset = 0;
+    req->target = target;
+    req->widget = widget;
+    req->allSent = FALSE;
 #ifndef DEBUG_WO_TIMERS
-	{
-	XtAppContext app = XtWidgetToApplicationContext(widget);
-	req->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
-	}
+    {
+        XtAppContext app = XtWidgetToApplicationContext(widget);
+
+        req->timeout = XtAppAddTimeOut(app,
+                                       app->selectionTimeout, OwnerTimedOut,
+                                       (XtPointer) req);
+    }
 #endif
-	AddHandler(req, (EventMask)PropertyChangeMask,
-		   HandlePropertyGone, (XtPointer)req);
+    AddHandler(req, (EventMask) PropertyChangeMask,
+               HandlePropertyGone, (XtPointer) req);
 /* now send client INCR property */
-	XChangeProperty(req->ctx->dpy, window, req->property,
-			req->ctx->prop_list->incr_atom,
-			32, PropModeReplace,
-			(unsigned char *)&req->bytelength, 1);
+    XChangeProperty(req->ctx->dpy, window, req->property,
+                    req->ctx->prop_list->incr_atom,
+                    32, PropModeReplace, (unsigned char *) &req->bytelength, 1);
 }
 
-static Boolean GetConversion(
-    Select ctx,			/* logical owner */
-    XSelectionRequestEvent* event,
-    Atom target,
-    Atom property,		/* requestor's property */
-    Widget widget)		/* physical owner (receives events) */
-{
+static Boolean
+GetConversion(Select ctx,       /* logical owner */
+              XSelectionRequestEvent *event,
+              Atom target,
+              Atom property,    /* requestor's property */
+              Widget widget)    /* physical owner (receives events) */
+{                  
     XtPointer value = NULL;
     unsigned long length;
     int format;
@@ -726,80 +735,85 @@ static Boolean GetConversion(
     req->requestor = event->requestor;
 
     if (timestamp_target) {
-	value = __XtMalloc(sizeof(long));
-	*(long*)value = (long) ctx->time;
-	targetType = XA_INTEGER;
-	length = 1;
-	format = 32;
+        value = __XtMalloc(sizeof(long));
+        *(long *) value = (long) ctx->time;
+        targetType = XA_INTEGER;
+        length = 1;
+        format = 32;
     }
     else {
-	ctx->ref_count++;
-	if (ctx->incremental == TRUE) {
-	     unsigned long size = (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
-	     if ((*(XtConvertSelectionIncrProc)ctx->convert)
-			       (ctx->widget, &event->selection, &target,
-				&targetType, &value, &length, &format,
-				&size, ctx->owner_closure, (XtRequestId*)&req)
-		     == FALSE) {
-		 XtFree((char*)req);
-		 ctx->ref_count--;
-		 return(FALSE);
-	     }
-	     StartProtectedSection(ctx->dpy, event->requestor);
-	     PrepareIncremental(req, widget, event->requestor, property,
-				target, targetType, value, length, format);
-	     return(TRUE);
-	}
-	ctx->req = req;
-	if ((*ctx->convert)(ctx->widget, &event->selection, &target,
-			    &targetType, &value, &length, &format) == FALSE) {
-	    XtFree((char*)req);
-	    ctx->req = NULL;
-	    ctx->ref_count--;
-	    return(FALSE);
-	}
-	ctx->req = NULL;
+        ctx->ref_count++;
+        if (ctx->incremental == TRUE) {
+            unsigned long size = (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
+
+            if ((*(XtConvertSelectionIncrProc) ctx->convert)
+                (ctx->widget, &event->selection, &target,
+                 &targetType, &value, &length, &format,
+                 &size, ctx->owner_closure, (XtRequestId *) &req)
+                == FALSE) {
+                XtFree((char *) req);
+                ctx->ref_count--;
+                return (FALSE);
+            }
+            StartProtectedSection(ctx->dpy, event->requestor);
+            PrepareIncremental(req, widget, event->requestor, property,
+                               target, targetType, value, length, format);
+            return (TRUE);
+        }
+        ctx->req = req;
+        if ((*ctx->convert) (ctx->widget, &event->selection, &target,
+                             &targetType, &value, &length, &format) == FALSE) {
+            XtFree((char *) req);
+            ctx->req = NULL;
+            ctx->ref_count--;
+            return (FALSE);
+        }
+        ctx->req = NULL;
     }
     StartProtectedSection(ctx->dpy, event->requestor);
-    if (BYTELENGTH(length,format) <= (unsigned long) MAX_SELECTION_INCR(ctx->dpy)) {
-	if (! timestamp_target) {
-	    if (ctx->notify != NULL) {
-		  req->target = target;
-		  req->widget = widget;
-		  req->allSent = TRUE;
+    if (BYTELENGTH(length, format) <=
+        (unsigned long) MAX_SELECTION_INCR(ctx->dpy)) {
+        if (!timestamp_target) {
+            if (ctx->notify != NULL) {
+                req->target = target;
+                req->widget = widget;
+                req->allSent = TRUE;
 #ifndef DEBUG_WO_TIMERS
-		  {
-		  XtAppContext app = XtWidgetToApplicationContext(req->widget);
-		  req->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
-		  }
+                {
+                    XtAppContext app =
+                        XtWidgetToApplicationContext(req->widget);
+                    req->timeout =
+                        XtAppAddTimeOut(app, app->selectionTimeout,
+                                        OwnerTimedOut, (XtPointer) req);
+                }
 #endif
-	          AddHandler(req, (EventMask)PropertyChangeMask,
-			     HandlePropertyGone, (XtPointer)req);
-	      }
-	      else ctx->ref_count--;
+                AddHandler(req, (EventMask) PropertyChangeMask,
+                           HandlePropertyGone, (XtPointer) req);
+            }
+            else
+                ctx->ref_count--;
         }
-	XChangeProperty(ctx->dpy, event->requestor, property,
-			targetType, format, PropModeReplace,
-			(unsigned char *)value, (int)length);
-	/* free storage for client if no notify proc */
-	if (timestamp_target || ctx->notify == NULL) {
-	    XtFree((char*)value);
-	    XtFree((char*)req);
-	}
-    } else {
-	 PrepareIncremental(req, widget, event->requestor, property,
-			    target, targetType, value, length, format);
-    }
-    return(TRUE);
+        XChangeProperty(ctx->dpy, event->requestor, property,
+                        targetType, format, PropModeReplace,
+                        (unsigned char *) value, (int) length);
+        /* free storage for client if no notify proc */
+        if (timestamp_target || ctx->notify == NULL) {
+            XtFree((char *) value);
+            XtFree((char *) req);
+        }
+    }
+    else {
+        PrepareIncremental(req, widget, event->requestor, property,
+                           target, targetType, value, length, format);
+    }
+    return (TRUE);
 }
 
-/*ARGSUSED*/
-static void HandleSelectionEvents(
-    Widget widget,
-    XtPointer closure,
-    XEvent *event,
-    Boolean *cont)
+static void
+HandleSelectionEvents(Widget widget,
+                      XtPointer closure,
+                      XEvent *event,
+                      Boolean *cont _X_UNUSED)
 {
     Select ctx;
     XSelectionEvent ev;
@@ -807,158 +821,167 @@ static void HandleSelectionEvents(
 
     ctx = (Select) closure;
     switch (event->type) {
-      case SelectionClear:
-	/* if this event is not for the selection we registered for,
-	 * don't do anything */
-	if (ctx->selection != event->xselectionclear.selection ||
-	    ctx->serial > event->xselectionclear.serial)
-	    break;
-	(void) LoseSelection(ctx, widget, event->xselectionclear.selection,
-			event->xselectionclear.time);
-	break;
-      case SelectionRequest:
-	/* if this event is not for the selection we registered for,
-	 * don't do anything */
-	if (ctx->selection != event->xselectionrequest.selection)
-	    break;
-	ev.type = SelectionNotify;
-	ev.display = event->xselectionrequest.display;
-	ev.requestor = event->xselectionrequest.requestor;
-	ev.selection = event->xselectionrequest.selection;
-	ev.time = event->xselectionrequest.time;
-	ev.target = event->xselectionrequest.target;
-	if (event->xselectionrequest.property == None) /* obsolete requestor */
-	   event->xselectionrequest.property = event->xselectionrequest.target;
-	if (ctx->widget != widget || ctx->was_disowned
-	   || ((event->xselectionrequest.time != CurrentTime)
-	        && (event->xselectionrequest.time < ctx->time))) {
-	    ev.property = None;
-	    StartProtectedSection(ev.display, ev.requestor);
-	} else {
-	   if (ev.target == ctx->prop_list->indirect_atom) {
-	      IndirectPair *p;
-	      int format;
-	      unsigned long bytesafter, length;
-	      unsigned char *value = NULL;
-	      int count;
-	      Boolean writeback = FALSE;
-
-	      ev.property = event->xselectionrequest.property;
-	      StartProtectedSection(ev.display, ev.requestor);
-	      if (XGetWindowProperty(ev.display, ev.requestor,
-			event->xselectionrequest.property, 0L, 1000000,
-			False,(Atom)AnyPropertyType, &target, &format, &length,
-			&bytesafter, &value) == Success)
-		  count = (int) (BYTELENGTH(length, format) / sizeof(IndirectPair));
-	      else
-		  count = 0;
-	      for (p = (IndirectPair *)value; count; p++, count--) {
-		  EndProtectedSection(ctx->dpy);
-		  if (!GetConversion(ctx, (XSelectionRequestEvent*)event,
-				     p->target, p->property, widget)) {
-
-			p->target = None;
-			writeback = TRUE;
-			StartProtectedSection(ctx->dpy, ev.requestor);
-		  }
-	      }
-	      if (writeback)
-		XChangeProperty(ev.display, ev.requestor,
-			event->xselectionrequest.property, target,
-			format, PropModeReplace, value, (int)length);
-	      XFree((char *)value);
-	  } else /* not multiple */ {
-	       if (GetConversion(ctx, (XSelectionRequestEvent*)event,
-				 event->xselectionrequest.target,
-				 event->xselectionrequest.property,
-				 widget))
-		   ev.property = event->xselectionrequest.property;
-	       else {
-		   ev.property = None;
-		   StartProtectedSection(ctx->dpy, ev.requestor);
-	       }
-	   }
-      }
-      (void) XSendEvent(ctx->dpy, ev.requestor, False, (unsigned long)NULL,
-		   (XEvent *) &ev);
-
-      EndProtectedSection(ctx->dpy);
-
-      break;
+    case SelectionClear:
+        /* if this event is not for the selection we registered for,
+         * don't do anything */
+        if (ctx->selection != event->xselectionclear.selection ||
+            ctx->serial > event->xselectionclear.serial)
+            break;
+        (void) LoseSelection(ctx, widget, event->xselectionclear.selection,
+                             event->xselectionclear.time);
+        break;
+    case SelectionRequest:
+        /* if this event is not for the selection we registered for,
+         * don't do anything */
+        if (ctx->selection != event->xselectionrequest.selection)
+            break;
+        ev.type = SelectionNotify;
+        ev.display = event->xselectionrequest.display;
+
+        ev.requestor = event->xselectionrequest.requestor;
+        ev.selection = event->xselectionrequest.selection;
+        ev.time = event->xselectionrequest.time;
+        ev.target = event->xselectionrequest.target;
+        if (event->xselectionrequest.property == None)  /* obsolete requestor */
+            event->xselectionrequest.property = event->xselectionrequest.target;
+        if (ctx->widget != widget || ctx->was_disowned
+            || ((event->xselectionrequest.time != CurrentTime)
+                && (event->xselectionrequest.time < ctx->time))) {
+            ev.property = None;
+            StartProtectedSection(ev.display, ev.requestor);
+        }
+        else {
+            if (ev.target == ctx->prop_list->indirect_atom) {
+                IndirectPair *p;
+                int format;
+                unsigned long bytesafter, length;
+                unsigned char *value = NULL;
+                int count;
+                Boolean writeback = FALSE;
+
+                ev.property = event->xselectionrequest.property;
+                StartProtectedSection(ev.display, ev.requestor);
+                if (XGetWindowProperty(ev.display, ev.requestor,
+                                       event->xselectionrequest.property, 0L,
+                                       1000000, False, (Atom) AnyPropertyType,
+                                       &target, &format, &length, &bytesafter,
+                                       &value) == Success)
+                    count =
+                        (int) (BYTELENGTH(length, format) /
+                               sizeof(IndirectPair));
+                else
+                    count = 0;
+                for (p = (IndirectPair *) value; count; p++, count--) {
+                    EndProtectedSection(ctx->dpy);
+                    if (!GetConversion(ctx, (XSelectionRequestEvent *) event,
+                                       p->target, p->property, widget)) {
+
+                        p->target = None;
+                        writeback = TRUE;
+                        StartProtectedSection(ctx->dpy, ev.requestor);
+                    }
+                }
+                if (writeback)
+                    XChangeProperty(ev.display, ev.requestor,
+                                    event->xselectionrequest.property, target,
+                                    format, PropModeReplace, value,
+                                    (int) length);
+                XFree((char *) value);
+            }
+            else {              /* not multiple */
+
+                if (GetConversion(ctx, (XSelectionRequestEvent *) event,
+                                  event->xselectionrequest.target,
+                                  event->xselectionrequest.property, widget))
+                    ev.property = event->xselectionrequest.property;
+                else {
+                    ev.property = None;
+                    StartProtectedSection(ctx->dpy, ev.requestor);
+                }
+            }
+        }
+        (void) XSendEvent(ctx->dpy, ev.requestor, False, (unsigned long) NULL,
+                          (XEvent *) &ev);
+
+        EndProtectedSection(ctx->dpy);
+
+        break;
     }
 }
 
-static Boolean OwnSelection(
-    Widget widget,
-    Atom selection,
-    Time time,
-    XtConvertSelectionProc convert,
-    XtLoseSelectionProc lose,
-    XtSelectionDoneProc notify,
-    XtCancelConvertSelectionProc cancel,
-    XtPointer closure,
-    Boolean incremental)
+static Boolean
+OwnSelection(Widget widget,
+             Atom selection,
+             Time time,
+             XtConvertSelectionProc convert,
+             XtLoseSelectionProc lose,
+             XtSelectionDoneProc notify,
+             XtCancelConvertSelectionProc cancel,
+             XtPointer closure,
+             Boolean incremental)
 {
     Select ctx;
     Select oldctx = NULL;
 
-    if (!XtIsRealized(widget)) return False;
+    if (!XtIsRealized(widget))
+        return False;
 
     ctx = FindCtx(XtDisplay(widget), selection);
     if (ctx->widget != widget || ctx->time != time ||
-	ctx->ref_count || ctx->was_disowned)
-    {
-	Boolean replacement = FALSE;
-	Window window = XtWindow(widget);
-	unsigned long serial = XNextRequest(ctx->dpy);
+        ctx->ref_count || ctx->was_disowned) {
+        Boolean replacement = FALSE;
+        Window window = XtWindow(widget);
+        unsigned long serial = XNextRequest(ctx->dpy);
+
         XSetSelectionOwner(ctx->dpy, selection, window, time);
         if (XGetSelectionOwner(ctx->dpy, selection) != window)
-	    return FALSE;
-	if (ctx->ref_count) {	/* exchange is in-progress */
+            return FALSE;
+        if (ctx->ref_count) {   /* exchange is in-progress */
 #ifdef DEBUG_ACTIVE
-	    printf( "Active exchange for widget \"%s\"; selection=0x%lx, ref_count=%d\n",
-		    XtName(widget), (long)selection, ctx->ref_count );
+            printf
+                ("Active exchange for widget \"%s\"; selection=0x%lx, ref_count=%d\n",
+                 XtName(widget), (long) selection, ctx->ref_count);
 #endif
-	    if (ctx->widget != widget ||
-		ctx->convert != convert ||
-		ctx->loses != lose ||
-		ctx->notify != notify ||
-		ctx->owner_cancel != cancel ||
-		ctx->incremental != incremental ||
-		ctx->owner_closure != closure)
-	    {
-		if (ctx->widget == widget) {
-		    XtRemoveEventHandler(widget, (EventMask)0, TRUE,
-					HandleSelectionEvents, (XtPointer)ctx);
-		    XtRemoveCallback(widget, XtNdestroyCallback,
-				     WidgetDestroyed, (XtPointer)ctx);
-		    replacement = TRUE;
-		}
-		else if (!ctx->was_disowned) {
-		    oldctx = ctx;
-		}
-		ctx->free_when_done = TRUE;
-		ctx = NewContext(XtDisplay(widget), selection);
-	    }
-	    else if (!ctx->was_disowned) { /* current owner is new owner */
-		ctx->time = time;
-		return TRUE;
-	    }
-	}
-    	if (ctx->widget != widget || ctx->was_disowned || replacement) {
-	    if (ctx->widget && !ctx->was_disowned && !replacement) {
-		oldctx = ctx;
-		oldctx->free_when_done = TRUE;
-		ctx = NewContext(XtDisplay(widget), selection);
-	    }
-	    XtAddEventHandler(widget, (EventMask)0, TRUE,
-			      HandleSelectionEvents, (XtPointer)ctx);
-	    XtAddCallback(widget, XtNdestroyCallback,
-			  WidgetDestroyed, (XtPointer)ctx);
-	}
-	ctx->widget = widget;	/* Selection offically changes hands. */
-	ctx->time = time;
-	ctx->serial = serial;
+            if (ctx->widget != widget ||
+                ctx->convert != convert ||
+                ctx->loses != lose ||
+                ctx->notify != notify ||
+                ctx->owner_cancel != cancel ||
+                ctx->incremental != incremental ||
+                ctx->owner_closure != closure) {
+                if (ctx->widget == widget) {
+                    XtRemoveEventHandler(widget, (EventMask) 0, TRUE,
+                                         HandleSelectionEvents,
+                                         (XtPointer) ctx);
+                    XtRemoveCallback(widget, XtNdestroyCallback,
+                                     WidgetDestroyed, (XtPointer) ctx);
+                    replacement = TRUE;
+                }
+                else if (!ctx->was_disowned) {
+                    oldctx = ctx;
+                }
+                ctx->free_when_done = TRUE;
+                ctx = NewContext(XtDisplay(widget), selection);
+            }
+            else if (!ctx->was_disowned) {      /* current owner is new owner */
+                ctx->time = time;
+                return TRUE;
+            }
+        }
+        if (ctx->widget != widget || ctx->was_disowned || replacement) {
+            if (ctx->widget && !ctx->was_disowned && !replacement) {
+                oldctx = ctx;
+                oldctx->free_when_done = TRUE;
+                ctx = NewContext(XtDisplay(widget), selection);
+            }
+            XtAddEventHandler(widget, (EventMask) 0, TRUE,
+                              HandleSelectionEvents, (XtPointer) ctx);
+            XtAddCallback(widget, XtNdestroyCallback,
+                          WidgetDestroyed, (XtPointer) ctx);
+        }
+        ctx->widget = widget;   /* Selection offically changes hands. */
+        ctx->time = time;
+        ctx->serial = serial;
     }
     ctx->convert = convert;
     ctx->loses = lose;
@@ -976,79 +999,74 @@ static Boolean OwnSelection(
      * pointer and the record contents must be preserved for LoseSelection.
      */
     if (oldctx) {
-	(void) LoseSelection(oldctx, oldctx->widget, selection, oldctx->time);
-	if (!oldctx->ref_count && oldctx->free_when_done)
-	    XtFree((char*)oldctx);
+        (void) LoseSelection(oldctx, oldctx->widget, selection, oldctx->time);
+        if (!oldctx->ref_count && oldctx->free_when_done)
+            XtFree((char *) oldctx);
     }
     return TRUE;
 }
 
-
-Boolean XtOwnSelection(
-    Widget widget,
-    Atom selection,
-    Time time,
-    XtConvertSelectionProc convert,
-    XtLoseSelectionProc lose,
-    XtSelectionDoneProc notify)
+Boolean
+XtOwnSelection(Widget widget,
+               Atom selection,
+               Time time,
+               XtConvertSelectionProc convert,
+               XtLoseSelectionProc lose,
+               XtSelectionDoneProc notify)
 {
     Boolean retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     retval = OwnSelection(widget, selection, time, convert, lose, notify,
-			(XtCancelConvertSelectionProc)NULL,
-			(XtPointer)NULL, FALSE);
+                          (XtCancelConvertSelectionProc) NULL,
+                          (XtPointer) NULL, FALSE);
     UNLOCK_APP(app);
     return retval;
 }
 
-
-Boolean XtOwnSelectionIncremental(
-    Widget widget,
-    Atom selection,
-    Time time,
-    XtConvertSelectionIncrProc convert,
-    XtLoseSelectionIncrProc lose,
-    XtSelectionDoneIncrProc notify,
-    XtCancelConvertSelectionProc cancel,
-    XtPointer closure)
+Boolean
+XtOwnSelectionIncremental(Widget widget,
+                          Atom selection,
+                          Time time,
+                          XtConvertSelectionIncrProc convert,
+                          XtLoseSelectionIncrProc lose,
+                          XtSelectionDoneIncrProc notify,
+                          XtCancelConvertSelectionProc cancel,
+                          XtPointer closure)
 {
     Boolean retval;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     retval = OwnSelection(widget, selection, time,
-			(XtConvertSelectionProc)convert,
-			(XtLoseSelectionProc)lose,
-			(XtSelectionDoneProc)notify,
-			cancel, closure, TRUE);
+                          (XtConvertSelectionProc) convert,
+                          (XtLoseSelectionProc) lose,
+                          (XtSelectionDoneProc) notify, cancel, closure, TRUE);
     UNLOCK_APP(app);
     return retval;
 }
 
-
-void XtDisownSelection(
-    Widget widget,
-    Atom selection,
-    Time time)
+void
+XtDisownSelection(Widget widget, Atom selection, Time time)
 {
     Select ctx;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     ctx = FindCtx(XtDisplay(widget), selection);
     if (LoseSelection(ctx, widget, selection, time))
-	XSetSelectionOwner(XtDisplay(widget), selection, None, time);
+        XSetSelectionOwner(XtDisplay(widget), selection, None, time);
     UNLOCK_APP(app);
 }
 
 /* Selection Requestor code */
 
-static Boolean IsINCRtype(
-    CallBackInfo info,
-    Window window,
-    Atom prop)
+static Boolean
+IsINCRtype(CallBackInfo info, Window window, Atom prop)
 {
     unsigned long bytesafter;
     unsigned long length;
@@ -1056,122 +1074,127 @@ static Boolean IsINCRtype(
     Atom type;
     unsigned char *value;
 
-    if (prop == None) return False;
+    if (prop == None)
+        return False;
 
     if (XGetWindowProperty(XtDisplay(info->widget), window, prop, 0L, 0L,
-			   False, info->ctx->prop_list->incr_atom, &type,
-			   &format, &length, &bytesafter, &value) != Success)
-	return False;
+                           False, info->ctx->prop_list->incr_atom, &type,
+                           &format, &length, &bytesafter, &value) != Success)
+        return False;
 
     return (type == info->ctx->prop_list->incr_atom);
 }
 
-/*ARGSUSED*/
-static void ReqCleanup(
-    Widget widget,
-    XtPointer closure,
-    XEvent *ev,
-    Boolean *cont)
+static void
+ReqCleanup(Widget widget,
+           XtPointer closure,
+           XEvent *ev,
+           Boolean *cont _X_UNUSED)
 {
-    CallBackInfo info = (CallBackInfo)closure;
+    CallBackInfo info = (CallBackInfo) closure;
     unsigned long bytesafter, length;
     int format;
     Atom target;
 
     if (ev->type == SelectionNotify) {
-	XSelectionEvent *event = (XSelectionEvent *) ev;
-	if (!MATCH_SELECT(event, info)) return; /* not really for us */
-         XtRemoveEventHandler(widget, (EventMask)0, TRUE,
-			   ReqCleanup, (XtPointer) info );
-	if (IsINCRtype(info, XtWindow(widget), event->property)) {
-	    info->proc = HandleGetIncrement;
-	    XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
-			      FALSE, ReqCleanup, (XtPointer) info);
-	} else {
-	   if (event->property != None)
-		XDeleteProperty(event->display, XtWindow(widget),
-				event->property);
-           FreeSelectionProperty(XtDisplay(widget), info->property);
-	   FreeInfo(info);
-	}
-    } else if ((ev->type == PropertyNotify) &&
-		(ev->xproperty.state == PropertyNewValue) &&
-	        (ev->xproperty.atom == info->property)) {
-	XPropertyEvent *event = (XPropertyEvent *) ev;
-	char *value = NULL;
-	if (XGetWindowProperty(event->display, XtWindow(widget),
-			       event->atom, 0L, 1000000, True, AnyPropertyType,
-			       &target, &format, &length, &bytesafter,
-			       (unsigned char **) &value) == Success) {
-	    XFree(value);
-	    if (length == 0) {
-		XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask,
-				     FALSE, ReqCleanup, (XtPointer) info );
-		FreeSelectionProperty(XtDisplay(widget), info->property);
-		XtFree(info->value); /* requestor never got this, so free now */
-		FreeInfo(info);
-	    }
-	}
+        XSelectionEvent *event = (XSelectionEvent *) ev;
+
+        if (!MATCH_SELECT(event, info))
+            return;             /* not really for us */
+        XtRemoveEventHandler(widget, (EventMask) 0, TRUE,
+                             ReqCleanup, (XtPointer) info);
+        if (IsINCRtype(info, XtWindow(widget), event->property)) {
+            info->proc = HandleGetIncrement;
+            XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
+                              FALSE, ReqCleanup, (XtPointer) info);
+        }
+        else {
+            if (event->property != None)
+                XDeleteProperty(event->display, XtWindow(widget),
+                                event->property);
+            FreeSelectionProperty(XtDisplay(widget), info->property);
+            FreeInfo(info);
+        }
+    }
+    else if ((ev->type == PropertyNotify) &&
+             (ev->xproperty.state == PropertyNewValue) &&
+             (ev->xproperty.atom == info->property)) {
+        XPropertyEvent *event = (XPropertyEvent *) ev;
+        char *value = NULL;
+
+        if (XGetWindowProperty(event->display, XtWindow(widget),
+                               event->atom, 0L, 1000000, True, AnyPropertyType,
+                               &target, &format, &length, &bytesafter,
+                               (unsigned char **) &value) == Success) {
+            XFree(value);
+            if (length == 0) {
+                XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask,
+                                     FALSE, ReqCleanup, (XtPointer) info);
+                FreeSelectionProperty(XtDisplay(widget), info->property);
+                XtFree(info->value);    /* requestor never got this, so free now */
+                FreeInfo(info);
+            }
+        }
     }
 }
 
-/* ARGSUSED */
-static void ReqTimedOut(
-    XtPointer closure,
-    XtIntervalId   *id)
+static void
+ReqTimedOut(XtPointer closure, XtIntervalId *id _X_UNUSED)
 {
     XtPointer value = NULL;
     unsigned long length = 0;
     int format = 8;
     Atom resulttype = XT_CONVERT_FAIL;
-    CallBackInfo info = (CallBackInfo)closure;
+    CallBackInfo info = (CallBackInfo) closure;
     unsigned long bytesafter;
     unsigned long proplength;
     Atom type;
 
     if (*info->target == info->ctx->prop_list->indirect_atom) {
-	IndirectPair *pairs = NULL;
-	if (XGetWindowProperty(XtDisplay(info->widget), XtWindow(info->widget),
-			       info->property, 0L, 10000000, True,
-			       AnyPropertyType, &type, &format, &proplength,
-			       &bytesafter, (unsigned char **) &pairs)
-	    == Success) {
-	    XtPointer *c;
-	    int i;
-
-	    XFree(pairs);
-	    for (proplength = proplength / IndirectPairWordSize, i = 0,
-		     c = info->req_closure;
-		 proplength; proplength--, c++, i++)
-		(*info->callbacks[i])(info->widget, *c, &info->ctx->selection,
-				      &resulttype, value, &length, &format);
-	}
-    } else {
-	(*info->callbacks[0])(info->widget, *info->req_closure,
-	    &info->ctx->selection, &resulttype, value, &length, &format);
+        IndirectPair *pairs = NULL;
+
+        if (XGetWindowProperty(XtDisplay(info->widget), XtWindow(info->widget),
+                               info->property, 0L, 10000000, True,
+                               AnyPropertyType, &type, &format, &proplength,
+                               &bytesafter, (unsigned char **) &pairs)
+            == Success) {
+            XtPointer *c;
+            int i;
+
+            XFree(pairs);
+            for (proplength = proplength / IndirectPairWordSize, i = 0,
+                 c = info->req_closure; proplength; proplength--, c++, i++)
+                (*info->callbacks[i]) (info->widget, *c, &info->ctx->selection,
+                                       &resulttype, value, &length, &format);
+        }
+    }
+    else {
+        (*info->callbacks[0]) (info->widget, *info->req_closure,
+                               &info->ctx->selection, &resulttype, value,
+                               &length, &format);
     }
 
     /* change event handlers for straggler events */
-    if (info->proc == (XtEventHandler)HandleSelectionReplies) {
-        XtRemoveEventHandler(info->widget, (EventMask)0,
-			TRUE, info->proc, (XtPointer) info);
-	XtAddEventHandler(info->widget, (EventMask)0, TRUE,
-		ReqCleanup, (XtPointer) info);
-    } else {
-        XtRemoveEventHandler(info->widget,(EventMask) PropertyChangeMask,
-			FALSE, info->proc, (XtPointer) info);
-	XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
-		FALSE, ReqCleanup, (XtPointer) info);
+    if (info->proc == (XtEventHandler) HandleSelectionReplies) {
+        XtRemoveEventHandler(info->widget, (EventMask) 0,
+                             TRUE, info->proc, (XtPointer) info);
+        XtAddEventHandler(info->widget, (EventMask) 0, TRUE,
+                          ReqCleanup, (XtPointer) info);
+    }
+    else {
+        XtRemoveEventHandler(info->widget, (EventMask) PropertyChangeMask,
+                             FALSE, info->proc, (XtPointer) info);
+        XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
+                          FALSE, ReqCleanup, (XtPointer) info);
     }
 
 }
 
-/*ARGSUSED*/
-static void HandleGetIncrement(
-    Widget widget,
-    XtPointer closure,
-    XEvent *ev,
-    Boolean *cont)
+static void
+HandleGetIncrement(Widget widget,
+                   XtPointer closure,
+                   XEvent *ev,
+                   Boolean *cont _X_UNUSED)
 {
     XPropertyEvent *event = (XPropertyEvent *) ev;
     CallBackInfo info = (CallBackInfo) closure;
@@ -1183,109 +1206,115 @@ static void HandleGetIncrement(
     int n = info->current;
 
     if ((event->state != PropertyNewValue) || (event->atom != info->property))
-	 return;
+        return;
 
     bad = XGetWindowProperty(event->display, XtWindow(widget),
-			     event->atom, 0L,
-			     10000000, True, AnyPropertyType, &info->type,
-			     &info->format, &length, &bytesafter,
-			     (unsigned char **) &value);
+                             event->atom, 0L,
+                             10000000, True, AnyPropertyType, &info->type,
+                             &info->format, &length, &bytesafter,
+                             (unsigned char **)&value);
     if (bad)
-      return;
+        return;
 #ifndef DEBUG_WO_TIMERS
     XtRemoveTimeOut(info->timeout);
 #endif
     if (length == 0) {
-       unsigned long u_offset = NUMELEM2(info->offset, info->format);
-       (*info->callbacks[n])(widget, *info->req_closure, &ctx->selection,
-			     &info->type,
-			     (info->offset == 0 ? value : info->value),
-			     &u_offset, &info->format);
-       /* assert ((info->offset != 0) == (info->incremental[n]) */
-       if (info->offset != 0) XFree(value);
-       XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
-		HandleGetIncrement, (XtPointer) info);
-       FreeSelectionProperty(event->display, info->property);
-       FreeInfo(info);
-    } else { /* add increment to collection */
-      if (info->incremental[n]) {
+        unsigned long u_offset = NUMELEM2(info->offset, info->format);
+
+        (*info->callbacks[n]) (widget, *info->req_closure, &ctx->selection,
+                               &info->type,
+                               (info->offset == 0 ? value : info->value),
+                               &u_offset, &info->format);
+        /* assert ((info->offset != 0) == (info->incremental[n]) */
+        if (info->offset != 0)
+            XFree(value);
+        XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
+                             HandleGetIncrement, (XtPointer) info);
+        FreeSelectionProperty(event->display, info->property);
+
+        FreeInfo(info);
+    }
+    else {                      /* add increment to collection */
+        if (info->incremental[n]) {
 #ifdef XT_COPY_SELECTION
-	  int size = (int) BYTELENGTH(length, info->format) + 1;
-	  char *tmp = __XtMalloc((Cardinal) size);
-	  (void) memmove(tmp, value, (size_t) size);
-	  XFree(value);
-	  value = tmp;
+            int size = (int) BYTELENGTH(length, info->format) + 1;
+            char *tmp = __XtMalloc((Cardinal) size);
+
+            (void) memmove(tmp, value, (size_t) size);
+            XFree(value);
+            value = tmp;
 #endif
-        (*info->callbacks[n])(widget, *info->req_closure, &ctx->selection,
-			      &info->type, value, &length, &info->format);
-      } else {
-	  int size = (int) BYTELENGTH(length, info->format);
-	  if (info->offset + size > info->bytelength) {
-	      /* allocate enough for this and the next increment */
-	      info->bytelength = info->offset + size * 2;
-	      info->value = XtRealloc(info->value,
-				      (Cardinal) info->bytelength);
-	  }
-	  (void) memmove(&info->value[info->offset], value, (size_t)size);
-	  info->offset += size;
-	  XFree(value);
-      }
-     /* reset timer */
+            (*info->callbacks[n]) (widget, *info->req_closure, &ctx->selection,
+                                   &info->type, value, &length, &info->format);
+        }
+        else {
+            int size = (int) BYTELENGTH(length, info->format);
+
+            if (info->offset + size > info->bytelength) {
+                /* allocate enough for this and the next increment */
+                info->bytelength = info->offset + size * 2;
+                info->value = XtRealloc(info->value,
+                                        (Cardinal) info->bytelength);
+            }
+            (void) memmove(&info->value[info->offset], value, (size_t) size);
+            info->offset += size;
+            XFree(value);
+        }
+        /* reset timer */
 #ifndef DEBUG_WO_TIMERS
-     {
-     XtAppContext app = XtWidgetToApplicationContext(info->widget);
-     info->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, ReqTimedOut, (XtPointer) info);
-     }
+        {
+            XtAppContext app = XtWidgetToApplicationContext(info->widget);
+
+            info->timeout = XtAppAddTimeOut(app,
+                                            app->selectionTimeout, ReqTimedOut,
+                                            (XtPointer) info);
+        }
 #endif
-   }
+    }
 }
 
-
-static void HandleNone(
-    Widget widget,
-    XtSelectionCallbackProc callback,
-    XtPointer closure,
-    Atom selection)
+static void
+HandleNone(Widget widget,
+           XtSelectionCallbackProc callback,
+           XtPointer closure,
+           Atom selection)
 {
     unsigned long length = 0;
     int format = 8;
     Atom type = None;
 
-    (*callback)(widget, closure, &selection,
-		&type, NULL, &length, &format);
+    (*callback) (widget, closure, &selection, &type, NULL, &length, &format);
 }
 
-
-static unsigned long IncrPropSize(
-     Widget widget,
-     unsigned char* value,
-     int format,
-     unsigned long length)
+static unsigned long
+IncrPropSize(Widget widget,
+             unsigned char *value,
+             int format,
+             unsigned long length)
 {
     if (format == 32) {
-	unsigned long size;
-	size = ((unsigned long*)value)[length-1]; /* %%% what order for longs? */
-	return size;
+        unsigned long size;
+
+        size = ((unsigned long *) value)[length - 1];   /* %%% what order for longs? */
+        return size;
     }
     else {
-	XtAppWarningMsg( XtWidgetToApplicationContext(widget),
-			"badFormat","xtGetSelectionValue",XtCXtToolkitError,
-	"Selection owner returned type INCR property with format != 32",
-			NULL, NULL );
-	return 0;
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "badFormat", "xtGetSelectionValue", XtCXtToolkitError,
+                        "Selection owner returned type INCR property with format != 32",
+                        NULL, NULL);
+        return 0;
     }
 }
 
-
 static
-Boolean HandleNormal(
-    Display *dpy,
-    Widget widget,
-    Atom property,
-    CallBackInfo info,
-    XtPointer closure,
-    Atom selection)
+    Boolean
+HandleNormal(Display *dpy,
+             Widget widget,
+             Atom property,
+             CallBackInfo info,
+             XtPointer closure,
+             Atom selection)
 {
     unsigned long bytesafter;
     unsigned long length;
@@ -1295,88 +1324,92 @@ Boolean HandleNormal(
     int number = info->current;
 
     if (XGetWindowProperty(dpy, XtWindow(widget), property, 0L, 10000000,
-			   False, AnyPropertyType, &type, &format, &length,
-			   &bytesafter, &value) != Success)
-	return FALSE;
+                           False, AnyPropertyType, &type, &format, &length,
+                           &bytesafter, &value) != Success)
+        return FALSE;
 
     if (type == info->ctx->prop_list->incr_atom) {
-	unsigned long size = IncrPropSize(widget, value, format, length);
-	XFree((char *)value);
-	if (info->property != property) {
-	    /* within MULTIPLE */
-	    CallBackInfo ninfo;
-	    ninfo = MakeInfo(info->ctx, &info->callbacks[number],
-			     &info->req_closure[number], 1, widget,
-			     info->time, &info->incremental[number], &property);
-	    ninfo->target = (Atom *) __XtMalloc((unsigned) sizeof(Atom));
-	    *ninfo->target = info->target[number + 1];
-	    info = ninfo;
-	}
-	HandleIncremental(dpy, widget, property, info, size);
-	return FALSE;
+        unsigned long size = IncrPropSize(widget, value, format, length);
+
+        XFree((char *) value);
+        if (info->property != property) {
+            /* within MULTIPLE */
+            CallBackInfo ninfo;
+
+            ninfo = MakeInfo(info->ctx, &info->callbacks[number],
+                             &info->req_closure[number], 1, widget,
+                             info->time, &info->incremental[number], &property);
+            ninfo->target = (Atom *) __XtMalloc((unsigned) sizeof(Atom));
+            *ninfo->target = info->target[number + 1];
+            info = ninfo;
+        }
+        HandleIncremental(dpy, widget, property, info, size);
+        return FALSE;
     }
 
     XDeleteProperty(dpy, XtWindow(widget), property);
 #ifdef XT_COPY_SELECTION
-    if (value) {   /* it could have been deleted after the SelectionNotify */
-	int size = (int) BYTELENGTH(length, info->format) + 1;
-	char *tmp = __XtMalloc((Cardinal) size);
-	(void) memmove(tmp, value, (size_t) size);
-	XFree(value);
-	value = (unsigned char *) tmp;
+    if (value) {                /* it could have been deleted after the SelectionNotify */
+        int size = (int) BYTELENGTH(length, info->format) + 1;
+        char *tmp = __XtMalloc((Cardinal) size);
+
+        (void) memmove(tmp, value, (size_t) size);
+        XFree(value);
+        value = (unsigned char *) tmp;
     }
 #endif
-    (*info->callbacks[number])(widget, closure, &selection,
-			       &type, (XtPointer)value, &length, &format);
+    (*info->callbacks[number]) (widget, closure, &selection,
+                                &type, (XtPointer) value, &length, &format);
 
     if (info->incremental[number]) {
-	/* let requestor know the whole thing has been received */
-	value = (unsigned char*)__XtMalloc((unsigned)1);
-	length = 0;
-	(*info->callbacks[number])(widget, closure, &selection,
-				   &type, (XtPointer)value, &length, &format);
+        /* let requestor know the whole thing has been received */
+        value = (unsigned char *) __XtMalloc((unsigned) 1);
+        length = 0;
+        (*info->callbacks[number]) (widget, closure, &selection,
+                                    &type, (XtPointer) value, &length, &format);
     }
     return TRUE;
 }
 
-static void HandleIncremental(
-    Display *dpy,
-    Widget widget,
-    Atom property,
-    CallBackInfo info,
-    unsigned long size)
+static void
+HandleIncremental(Display *dpy,
+                  Widget widget,
+                  Atom property,
+                  CallBackInfo info,
+                  unsigned long size)
 {
     XtAddEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
-		      HandleGetIncrement, (XtPointer) info);
+                      HandleGetIncrement, (XtPointer) info);
 
     /* now start the transfer */
     XDeleteProperty(dpy, XtWindow(widget), property);
     XFlush(dpy);
 
     info->bytelength = (int) size;
-    if (info->incremental[info->current]) /* requestor wants incremental too */
-	info->value = NULL;	/* so no need for buffer to assemble value */
+    if (info->incremental[info->current])       /* requestor wants incremental too */
+        info->value = NULL;     /* so no need for buffer to assemble value */
     else
-	info->value = (char *) __XtMalloc((unsigned) info->bytelength);
+        info->value = (char *) __XtMalloc((unsigned) info->bytelength);
     info->offset = 0;
 
     /* reset the timer */
     info->proc = HandleGetIncrement;
 #ifndef DEBUG_WO_TIMERS
     {
-    XtAppContext app = XtWidgetToApplicationContext(info->widget);
-    info->timeout = XtAppAddTimeOut(app,
-			 app->selectionTimeout, ReqTimedOut, (XtPointer) info);
+        XtAppContext app = XtWidgetToApplicationContext(info->widget);
+
+        info->timeout = XtAppAddTimeOut(app,
+                                        app->selectionTimeout, ReqTimedOut,
+                                        (XtPointer) info);
     }
 #endif
 }
 
-/*ARGSUSED*/
-static void HandleSelectionReplies(
-    Widget widget,
-    XtPointer closure,
-    XEvent *ev,
-    Boolean *cont)
+static void
+HandleSelectionReplies(Widget widget,
+                       XtPointer closure,
+                       XEvent *ev,
+                       Boolean *cont _X_UNUSED)
 {
     XSelectionEvent *event = (XSelectionEvent *) ev;
     Display *dpy = event->display;
@@ -1387,63 +1420,68 @@ static void HandleSelectionReplies(
     int format;
     Atom type;
 
-    if (event->type != SelectionNotify) return;
-    if (!MATCH_SELECT(event, info)) return; /* not really for us */
+    if (event->type != SelectionNotify)
+        return;
+    if (!MATCH_SELECT(event, info))
+        return;                 /* not really for us */
 #ifndef DEBUG_WO_TIMERS
     XtRemoveTimeOut(info->timeout);
 #endif
-    XtRemoveEventHandler(widget, (EventMask)0, TRUE,
-		HandleSelectionReplies, (XtPointer) info );
+    XtRemoveEventHandler(widget, (EventMask) 0, TRUE,
+                         HandleSelectionReplies, (XtPointer) info);
     if (event->target == ctx->prop_list->indirect_atom) {
-       IndirectPair *pairs = NULL, *p;
-       XtPointer *c;
-
-       if (XGetWindowProperty(dpy, XtWindow(widget), info->property, 0L,
-			      10000000, True, AnyPropertyType, &type, &format,
-			      &length, &bytesafter, (unsigned char **) &pairs)
-	   != Success)
-	   length = 0;
-       for (length = length / IndirectPairWordSize, p = pairs,
-	    c = info->req_closure;
-	    length; length--, p++, c++, info->current++) {
-	    if (event->property == None || format != 32 || p->target == None
-		|| /* bug compatibility */ p->property == None) {
-		HandleNone(widget, info->callbacks[info->current],
-			   *c, event->selection);
-		if (p->property != None)
+        IndirectPair *pairs = NULL, *p;
+        XtPointer *c;
+
+        if (XGetWindowProperty(dpy, XtWindow(widget), info->property, 0L,
+                               10000000, True, AnyPropertyType, &type, &format,
+                               &length, &bytesafter, (unsigned char **) &pairs)
+            != Success)
+            length = 0;
+        for (length = length / IndirectPairWordSize, p = pairs,
+             c = info->req_closure;
+             length; length--, p++, c++, info->current++) {
+            if (event->property == None || format != 32 || p->target == None
+                || /* bug compatibility */ p->property == None) {
+                HandleNone(widget, info->callbacks[info->current],
+                           *c, event->selection);
+                if (p->property != None)
+                    FreeSelectionProperty(XtDisplay(widget), p->property);
+            }
+            else {
+                if (HandleNormal(dpy, widget, p->property, info, *c,
+                                 event->selection)) {
                     FreeSelectionProperty(XtDisplay(widget), p->property);
-	    } else {
-		if (HandleNormal(dpy, widget, p->property, info, *c,
-				 event->selection)) {
-		    FreeSelectionProperty(XtDisplay(widget), p->property);
-		}
-	    }
-       }
-       XFree((char*)pairs);
-       FreeSelectionProperty(dpy, info->property);
-       FreeInfo(info);
-    } else if (event->property == None) {
-	HandleNone(widget, info->callbacks[0], *info->req_closure, event->selection);
+                }
+            }
+        }
+        XFree((char *) pairs);
+        FreeSelectionProperty(dpy, info->property);
+        FreeInfo(info);
+    }
+    else if (event->property == None) {
+        HandleNone(widget, info->callbacks[0], *info->req_closure,
+                   event->selection);
         FreeSelectionProperty(XtDisplay(widget), info->property);
-	FreeInfo(info);
-    } else {
-	if (HandleNormal(dpy, widget, event->property, info,
-			 *info->req_closure, event->selection)) {
-	    FreeSelectionProperty(XtDisplay(widget), info->property);
-	    FreeInfo(info);
-	}
+        FreeInfo(info);
+    }
+    else {
+        if (HandleNormal(dpy, widget, event->property, info,
+                         *info->req_closure, event->selection)) {
+            FreeSelectionProperty(XtDisplay(widget), info->property);
+            FreeInfo(info);
+        }
     }
 }
 
-static void DoLocalTransfer(
-    Request req,
-    Atom selection,
-    Atom target,
-    Widget widget,		/* The widget requesting the value. */
-    XtSelectionCallbackProc callback,
-    XtPointer closure,	/* the closure for the callback, not the conversion */
-    Boolean incremental,
-    Atom property)
+static void
+DoLocalTransfer(Request req,
+                Atom selection,
+                Atom target,
+                Widget widget, /* The widget requesting the value. */
+                XtSelectionCallbackProc callback,
+                XtPointer closure,    /* the closure for the callback, not the conversion */
+                Boolean incremental, Atom property)
 {
     Select ctx = req->ctx;
     XtPointer value = NULL, temp, total = NULL;
@@ -1452,102 +1490,115 @@ static void DoLocalTransfer(
     Atom resulttype;
     unsigned long totallength = 0;
 
-        req->event.type = 0;
-        req->event.target = target;
-        req->event.property = req->property = property;
-        req->event.requestor = req->requestor = XtWindow(widget);
-
-	if (ctx->incremental) {
-	   unsigned long size = (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
-	   if (!(*(XtConvertSelectionIncrProc)ctx->convert)
-			   (ctx->widget, &selection, &target,
-			    &resulttype, &value, &length, &format,
-			    &size, ctx->owner_closure, (XtRequestId*)&req)) {
-	       HandleNone(widget, callback, closure, selection);
-	   }
-	   else {
-		if (incremental) {
-		  Boolean allSent = FALSE;
-	          while (!allSent) {
-	    	      if (ctx->notify && (value != NULL)) {
-              	        int bytelength = (int) BYTELENGTH(length,format);
-	                /* both sides think they own this storage */
-	                temp = __XtMalloc((unsigned)bytelength);
-	                (void) memmove(temp, value, (size_t) bytelength);
-	                value = temp;
-	              }
-		      /* use care; older clients were never warned that
-		       * they must return a value even if length==0
-		       */
-		     if (value == NULL) value = __XtMalloc((unsigned)1);
-		     (*callback)(widget, closure, &selection,
-			&resulttype, value, &length, &format);
-		     if (length) {
-			 /* should owner be notified on end-of-piece?
-			  * Spec is unclear, but non-local transfers don't.
-			  */
-			 (*(XtConvertSelectionIncrProc)ctx->convert)
-					(ctx->widget, &selection, &target,
-					 &resulttype, &value, &length, &format,
-					 &size, ctx->owner_closure,
-					 (XtRequestId*)&req);
-		     }
-		     else allSent = TRUE;
-		  }
-	        } else {
-	          while (length) {
-		    int bytelength = (int) BYTELENGTH(length, format);
-		    total = XtRealloc(total,
-			    (Cardinal) (totallength = totallength + (unsigned long)bytelength));
-		    (void) memmove((char*)total + totallength - bytelength,
-			    value,
-			    (size_t) bytelength);
-		    (*(XtConvertSelectionIncrProc)ctx->convert)
-			   (ctx->widget, &selection, &target,
-			    &resulttype, &value, &length, &format,
-			    &size, ctx->owner_closure, (XtRequestId*)&req);
-		  }
-		  if (total == NULL) total = __XtMalloc(1);
-		  totallength = NUMELEM2(totallength, format);
-		  (*callback)(widget, closure, &selection, &resulttype,
-		    total,  &totallength, &format);
-	      }
-	      if (ctx->notify)
-		  (*(XtSelectionDoneIncrProc)ctx->notify)
-				(ctx->widget, &selection, &target,
-				 (XtRequestId*)&req, ctx->owner_closure);
-	      else XtFree((char*)value);
-	  }
-	} else { /* not incremental owner */
-	  if (!(*ctx->convert)(ctx->widget, &selection, &target,
-			     &resulttype, &value, &length, &format)) {
-	    HandleNone(widget, callback, closure, selection);
-	  } else {
-	      if (ctx->notify && (value != NULL)) {
-                int bytelength = (int) BYTELENGTH(length,format);
-	        /* both sides think they own this storage; better copy */
-	        temp = __XtMalloc((unsigned)bytelength);
-	        (void) memmove(temp, value, (size_t) bytelength);
-	        value = temp;
-	      }
-	      if (value == NULL) value = __XtMalloc((unsigned)1);
-	      (*callback)(widget, closure, &selection, &resulttype,
-			  value, &length, &format);
-	      if (ctx->notify)
-	         (*ctx->notify)(ctx->widget, &selection, &target);
-	  }
-      }
+    req->event.type = 0;
+    req->event.target = target;
+    req->event.property = req->property = property;
+    req->event.requestor = req->requestor = XtWindow(widget);
+
+    if (ctx->incremental) {
+        unsigned long size = (unsigned long) MAX_SELECTION_INCR(ctx->dpy);
+
+        if (!(*(XtConvertSelectionIncrProc) ctx->convert)
+            (ctx->widget, &selection, &target,
+             &resulttype, &value, &length, &format,
+             &size, ctx->owner_closure, (XtRequestId *) &req)) {
+            HandleNone(widget, callback, closure, selection);
+        }
+        else {
+            if (incremental) {
+                Boolean allSent = FALSE;
+
+                while (!allSent) {
+                    if (ctx->notify && (value != NULL)) {
+                        int bytelength = (int) BYTELENGTH(length, format);
+
+                        /* both sides think they own this storage */
+                        temp = __XtMalloc((unsigned) bytelength);
+                        (void) memmove(temp, value, (size_t) bytelength);
+                        value = temp;
+                    }
+                    /* use care; older clients were never warned that
+                     * they must return a value even if length==0
+                     */
+                    if (value == NULL)
+                        value = __XtMalloc((unsigned) 1);
+                    (*callback) (widget, closure, &selection,
+                                 &resulttype, value, &length, &format);
+                    if (length) {
+                        /* should owner be notified on end-of-piece?
+                         * Spec is unclear, but non-local transfers don't.
+                         */
+                        (*(XtConvertSelectionIncrProc) ctx->convert)
+                            (ctx->widget, &selection, &target,
+                             &resulttype, &value, &length, &format,
+                             &size, ctx->owner_closure, (XtRequestId *) &req);
+                    }
+                    else
+                        allSent = TRUE;
+                }
+            }
+            else {
+                while (length) {
+                    int bytelength = (int) BYTELENGTH(length, format);
+
+                    total = XtRealloc(total,
+                                      (Cardinal) (totallength =
+                                                  totallength +
+                                                  (unsigned long) bytelength));
+                    (void) memmove((char *) total + totallength - bytelength,
+                                   value, (size_t) bytelength);
+                    (*(XtConvertSelectionIncrProc) ctx->convert)
+                        (ctx->widget, &selection, &target,
+                         &resulttype, &value, &length, &format,
+                         &size, ctx->owner_closure, (XtRequestId *) &req);
+                }
+                if (total == NULL)
+                    total = __XtMalloc(1);
+                totallength = NUMELEM2(totallength, format);
+                (*callback) (widget, closure, &selection, &resulttype,
+                             total, &totallength, &format);
+            }
+            if (ctx->notify)
+                (*(XtSelectionDoneIncrProc) ctx->notify)
+                    (ctx->widget, &selection, &target,
+                     (XtRequestId *) &req, ctx->owner_closure);
+            else
+                XtFree((char *) value);
+        }
+    }
+    else {                      /* not incremental owner */
+        if (!(*ctx->convert) (ctx->widget, &selection, &target,
+                              &resulttype, &value, &length, &format)) {
+            HandleNone(widget, callback, closure, selection);
+        }
+        else {
+            if (ctx->notify && (value != NULL)) {
+                int bytelength = (int) BYTELENGTH(length, format);
+
+                /* both sides think they own this storage; better copy */
+                temp = __XtMalloc((unsigned) bytelength);
+                (void) memmove(temp, value, (size_t) bytelength);
+                value = temp;
+            }
+            if (value == NULL)
+                value = __XtMalloc((unsigned) 1);
+            (*callback) (widget, closure, &selection, &resulttype,
+                         value, &length, &format);
+            if (ctx->notify)
+                (*ctx->notify) (ctx->widget, &selection, &target);
+        }
+    }
 }
 
-static void GetSelectionValue(
-    Widget widget,
-    Atom selection,
-    Atom target,
-    XtSelectionCallbackProc callback,
-    XtPointer closure,
-    Time time,
-    Boolean incremental,
-    Atom property)
+static void
+GetSelectionValue(Widget widget,
+                  Atom selection,
+                  Atom target,
+                  XtSelectionCallbackProc callback,
+                  XtPointer closure,
+                  Time time,
+                  Boolean incremental,
+                  Atom property)
 {
     Select ctx;
     Atom properties[1];
@@ -1556,39 +1607,41 @@ static void GetSelectionValue(
 
     ctx = FindCtx(XtDisplay(widget), selection);
     if (ctx->widget && !ctx->was_disowned) {
-	RequestRec req;
-	ctx->req = &req;
-	req.ctx = ctx;
-	req.event.time = time;
-	ctx->ref_count++;
-	DoLocalTransfer(&req, selection, target, widget,
-			callback, closure, incremental, property);
-	if (--ctx->ref_count == 0 && ctx->free_when_done)
-	    XtFree((char*)ctx);
-	else
-	    ctx->req = NULL;
+        RequestRec req;
+
+        ctx->req = &req;
+        req.ctx = ctx;
+        req.event.time = time;
+        ctx->ref_count++;
+        DoLocalTransfer(&req, selection, target, widget,
+                        callback, closure, incremental, property);
+        if (--ctx->ref_count == 0 && ctx->free_when_done)
+            XtFree((char *) ctx);
+        else
+            ctx->req = NULL;
     }
     else {
-	CallBackInfo info;
-	info = MakeInfo(ctx, &callback, &closure, 1, widget,
-			time, &incremental, properties);
-	info->target = (Atom *)__XtMalloc((unsigned) sizeof(Atom));
-	 *(info->target) = target;
-	RequestSelectionValue(info, selection, target);
+        CallBackInfo info;
+
+        info = MakeInfo(ctx, &callback, &closure, 1, widget,
+                        time, &incremental, properties);
+        info->target = (Atom *) __XtMalloc((unsigned) sizeof(Atom));
+        *(info->target) = target;
+        RequestSelectionValue(info, selection, target);
     }
 }
 
-
-void XtGetSelectionValue(
-    Widget widget,
-    Atom selection,
-    Atom target,
-    XtSelectionCallbackProc callback,
-    XtPointer closure,
-    Time time)
+void
+XtGetSelectionValue(Widget widget,
+                    Atom selection,
+                    Atom target,
+                    XtSelectionCallbackProc callback,
+                    XtPointer closure,
+                    Time time)
 {
     Atom property;
     Boolean incr = False;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -1596,26 +1649,27 @@ void XtGetSelectionValue(
     RemoveParamInfo(widget, selection);
 
     if (IsGatheringRequest(widget, selection)) {
-      AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
-			   &closure, &incr, &property);
-    } else {
-      GetSelectionValue(widget, selection, target, callback,
-			closure, time, FALSE, property);
+        AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
+                             &closure, &incr, &property);
+    }
+    else {
+        GetSelectionValue(widget, selection, target, callback,
+                          closure, time, FALSE, property);
     }
     UNLOCK_APP(app);
 }
 
-
-void XtGetSelectionValueIncremental(
-    Widget widget,
-    Atom selection,
-    Atom target,
-    XtSelectionCallbackProc callback,
-    XtPointer closure,
-    Time time)
+void
+XtGetSelectionValueIncremental(Widget widget,
+                               Atom selection,
+                               Atom target,
+                               XtSelectionCallbackProc callback,
+                               XtPointer closure,
+                               Time time)
 {
     Atom property;
     Boolean incr = TRUE;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -1623,242 +1677,250 @@ void XtGetSelectionValueIncremental(
     RemoveParamInfo(widget, selection);
 
     if (IsGatheringRequest(widget, selection)) {
-      AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
-			   &closure, &incr, &property);
-    } else {
-      GetSelectionValue(widget, selection, target, callback,
-			closure, time, TRUE, property);
+        AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
+                             &closure, &incr, &property);
+    }
+    else {
+        GetSelectionValue(widget, selection, target, callback,
+                          closure, time, TRUE, property);
     }
 
     UNLOCK_APP(app);
 }
 
-
-static void GetSelectionValues(
-    Widget widget,
-    Atom selection,
-    Atom *targets,
-    int count,
-    XtSelectionCallbackProc *callbacks,
-    int num_callbacks,
-    XtPointer *closures,
-    Time time,
-    Boolean *incremental,
-    Atom *properties)
+static void
+GetSelectionValues(Widget widget,
+                   Atom selection,
+                   Atom *targets,
+                   int count,
+                   XtSelectionCallbackProc *callbacks,
+                   int num_callbacks,
+                   XtPointer *closures,
+                   Time time,
+                   Boolean *incremental,
+                   Atom *properties)
 {
     Select ctx;
     IndirectPair *pairs;
 
-    if (count == 0) return;
+    if (count == 0)
+        return;
     ctx = FindCtx(XtDisplay(widget), selection);
     if (ctx->widget && !ctx->was_disowned) {
         int j, i;
-	RequestRec req;
-	ctx->req = &req;
-	req.ctx = ctx;
-	req.event.time = time;
-	ctx->ref_count++;
-	for (i = 0, j = 0; count; count--, i++, j++ ) {
-	  if (j >= num_callbacks) j = 0;
-
-	  DoLocalTransfer(&req, selection, targets[i], widget,
-			  callbacks[j], closures[i], incremental[i],
-			  properties ? properties[i] : None);
-
-	}
-	if (--ctx->ref_count == 0 && ctx->free_when_done)
-	    XtFree((char*)ctx);
-	else
-	    ctx->req = NULL;
-    } else {
+        RequestRec req;
+
+        ctx->req = &req;
+        req.ctx = ctx;
+        req.event.time = time;
+        ctx->ref_count++;
+        for (i = 0, j = 0; count; count--, i++, j++) {
+            if (j >= num_callbacks)
+                j = 0;
+
+            DoLocalTransfer(&req, selection, targets[i], widget,
+                            callbacks[j], closures[i], incremental[i],
+                            properties ? properties[i] : None);
+
+        }
+        if (--ctx->ref_count == 0 && ctx->free_when_done)
+            XtFree((char *) ctx);
+        else
+            ctx->req = NULL;
+    }
+    else {
         XtSelectionCallbackProc *passed_callbacks;
-	XtSelectionCallbackProc stack_cbs[32];
-	CallBackInfo info;
-	IndirectPair *p;
-	Atom *t;
+        XtSelectionCallbackProc stack_cbs[32];
+        CallBackInfo info;
+        IndirectPair *p;
+        Atom *t;
         int i = 0, j = 0;
 
-	passed_callbacks = (XtSelectionCallbackProc *)
-	  XtStackAlloc(sizeof(XtSelectionCallbackProc) * (size_t)count, stack_cbs);
-
-	/* To deal with the old calls from XtGetSelectionValues* we
-	   will repeat however many callbacks have been passed into
-	   the array */
-	for(i = 0; i < count; i++) {
-	  if (j >= num_callbacks) j = 0;
-	  passed_callbacks[i] = callbacks[j];
-	  j++;
-	}
-	info = MakeInfo(ctx, passed_callbacks, closures, count, widget,
-			time, incremental, properties);
-	XtStackFree((XtPointer) passed_callbacks, stack_cbs);
-
-	info->target = (Atom *)__XtMalloc((unsigned) ((size_t)(count+1) * sizeof(Atom)));
+        passed_callbacks = (XtSelectionCallbackProc *)
+            XtStackAlloc(sizeof(XtSelectionCallbackProc) * (size_t) count,
+                         stack_cbs);
+
+        /* To deal with the old calls from XtGetSelectionValues* we
+           will repeat however many callbacks have been passed into
+           the array */
+        for (i = 0; i < count; i++) {
+            if (j >= num_callbacks)
+                j = 0;
+            passed_callbacks[i] = callbacks[j];
+            j++;
+        }
+        info = MakeInfo(ctx, passed_callbacks, closures, count, widget,
+                        time, incremental, properties);
+        XtStackFree((XtPointer) passed_callbacks, stack_cbs);
+
+        info->target = (Atom *)
+            __XtMalloc((unsigned) ((size_t) (count + 1) * sizeof(Atom)));
         (*info->target) = ctx->prop_list->indirect_atom;
-	(void) memmove((char *) info->target+sizeof(Atom), (char *) targets,
-		       (size_t) count * sizeof(Atom));
-	pairs = (IndirectPair*)__XtMalloc((unsigned)((size_t)count*sizeof(IndirectPair)));
-	for (p = &pairs[count-1], t = &targets[count-1], i = count - 1;
-	     p >= pairs;  p--, t--, i--) {
-	   p->target = *t;
-	   if (properties == NULL || properties[i] == None) {
-	     p->property = GetSelectionProperty(XtDisplay(widget));
-	     XDeleteProperty(XtDisplay(widget), XtWindow(widget),
-			     p->property);
-	   } else {
-	     p->property = properties[i];
-	   }
-	}
-	XChangeProperty(XtDisplay(widget), XtWindow(widget),
-			info->property, info->property,
-			32, PropModeReplace, (unsigned char *) pairs,
-			count * IndirectPairWordSize);
-	XtFree((char*)pairs);
-	RequestSelectionValue(info, selection, ctx->prop_list->indirect_atom);
+        (void) memmove((char *) info->target + sizeof(Atom), (char *) targets,
+                       (size_t) count * sizeof(Atom));
+        pairs = (IndirectPair *)
+            __XtMalloc((unsigned) ((size_t) count * sizeof(IndirectPair)));
+        for (p = &pairs[count - 1], t = &targets[count - 1], i = count - 1;
+             p >= pairs; p--, t--, i--) {
+            p->target = *t;
+            if (properties == NULL || properties[i] == None) {
+                p->property = GetSelectionProperty(XtDisplay(widget));
+                XDeleteProperty(XtDisplay(widget), XtWindow(widget),
+                                p->property);
+            }
+            else {
+                p->property = properties[i];
+            }
+        }
+        XChangeProperty(XtDisplay(widget), XtWindow(widget),
+                        info->property, info->property,
+                        32, PropModeReplace, (unsigned char *) pairs,
+                        count * IndirectPairWordSize);
+        XtFree((char *) pairs);
+        RequestSelectionValue(info, selection, ctx->prop_list->indirect_atom);
     }
 }
 
-
-void XtGetSelectionValues(
-    Widget widget,
-    Atom selection,
-    Atom *targets,
-    int count,
-    XtSelectionCallbackProc callback,
-    XtPointer *closures,
-    Time time)
+void
+XtGetSelectionValues(Widget widget,
+                     Atom selection,
+                     Atom *targets,
+                     int count,
+                     XtSelectionCallbackProc callback,
+                     XtPointer *closures,
+                     Time time)
 {
     Boolean incremental_values[32];
     Boolean *incremental;
     int i;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    incremental = XtStackAlloc((size_t)count * sizeof(Boolean), incremental_values);
-    for(i = 0; i < count; i++) incremental[i] = FALSE;
+    incremental =
+        XtStackAlloc((size_t) count * sizeof(Boolean), incremental_values);
+    for (i = 0; i < count; i++)
+        incremental[i] = FALSE;
     if (IsGatheringRequest(widget, selection)) {
-      AddSelectionRequests(widget, selection, count, targets, &callback,
-			   1, closures, incremental, NULL);
-    } else {
-      GetSelectionValues(widget, selection, targets, count, &callback, 1,
-			 closures, time, incremental, NULL);
+        AddSelectionRequests(widget, selection, count, targets, &callback,
+                             1, closures, incremental, NULL);
+    }
+    else {
+        GetSelectionValues(widget, selection, targets, count, &callback, 1,
+                           closures, time, incremental, NULL);
     }
     XtStackFree((XtPointer) incremental, incremental_values);
     UNLOCK_APP(app);
 }
 
-
-void XtGetSelectionValuesIncremental(
-    Widget widget,
-    Atom selection,
-    Atom *targets,
-    int count,
-    XtSelectionCallbackProc callback,
-    XtPointer *closures,
-    Time time)
+void
+XtGetSelectionValuesIncremental(Widget widget,
+                                Atom selection,
+                                Atom *targets,
+                                int count,
+                                XtSelectionCallbackProc callback,
+                                XtPointer *closures,
+                                Time time)
 {
     Boolean incremental_values[32];
     Boolean *incremental;
     int i;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    incremental = XtStackAlloc((size_t)count * sizeof(Boolean), incremental_values);
-    for(i = 0; i < count; i++) incremental[i] = TRUE;
+    incremental =
+        XtStackAlloc((size_t) count * sizeof(Boolean), incremental_values);
+    for (i = 0; i < count; i++)
+        incremental[i] = TRUE;
     if (IsGatheringRequest(widget, selection)) {
-      AddSelectionRequests(widget, selection, count, targets, &callback,
-			   1, closures, incremental, NULL);
-    } else {
-      GetSelectionValues(widget, selection, targets, count,
-			 &callback, 1, closures, time, incremental, NULL);
+        AddSelectionRequests(widget, selection, count, targets, &callback,
+                             1, closures, incremental, NULL);
+    }
+    else {
+        GetSelectionValues(widget, selection, targets, count,
+                           &callback, 1, closures, time, incremental, NULL);
     }
     XtStackFree((XtPointer) incremental, incremental_values);
     UNLOCK_APP(app);
 }
 
-
-static Request GetRequestRecord(
-    Widget widget,
-    Atom selection,
-    XtRequestId id)
+static Request
+GetRequestRecord(Widget widget, Atom selection, XtRequestId id)
 {
-    Request req = (Request)id;
+    Request req = (Request) id;
     Select ctx = NULL;
 
-    if (   (req == NULL
-	    && ((ctx = FindCtx( XtDisplay(widget), selection )) == NULL
-		|| ctx->req == NULL
-		|| ctx->selection != selection
-		|| ctx->widget == NULL))
-	|| (req != NULL
-	    && (req->ctx == NULL
-		|| req->ctx->selection != selection
-		|| req->ctx->widget != widget)))
-    {
-	String params = XtName(widget);
-	Cardinal num_params = 1;
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-			 "notInConvertSelection", "xtGetSelectionRequest",
-			 XtCXtToolkitError,
-			 "XtGetSelectionRequest or XtGetSelectionParameters called for widget \"%s\" outside of ConvertSelection proc",
-			 &params, &num_params
-		       );
-	return NULL;
+    if ((req == NULL
+         && ((ctx = FindCtx(XtDisplay(widget), selection)) == NULL
+             || ctx->req == NULL
+             || ctx->selection != selection || ctx->widget == NULL))
+        || (req != NULL
+            && (req->ctx == NULL
+                || req->ctx->selection != selection
+                || req->ctx->widget != widget))) {
+        String params = XtName(widget);
+        Cardinal num_params = 1;
+
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "notInConvertSelection", "xtGetSelectionRequest",
+                        XtCXtToolkitError,
+                        "XtGetSelectionRequest or XtGetSelectionParameters called for widget \"%s\" outside of ConvertSelection proc",
+                        &params, &num_params);
+        return NULL;
     }
 
     if (req == NULL) {
-	/* non-incremental owner; only one request can be
-	 * outstanding at a time, so it's safe to keep ptr in ctx */
-	req = ctx->req;
+        /* non-incremental owner; only one request can be
+         * outstanding at a time, so it's safe to keep ptr in ctx */
+        req = ctx->req;
     }
     return req;
 }
 
-XSelectionRequestEvent *XtGetSelectionRequest(
-    Widget widget,
-    Atom selection,
-    XtRequestId id)
+XSelectionRequestEvent *
+XtGetSelectionRequest(Widget widget, Atom selection, XtRequestId id)
 {
-    Request req = (Request)id;
+    Request req = (Request) id;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
 
     req = GetRequestRecord(widget, selection, id);
 
-    if (! req) {
-	UNLOCK_APP(app);
-	return (XSelectionRequestEvent*) NULL;
+    if (!req) {
+        UNLOCK_APP(app);
+        return (XSelectionRequestEvent *) NULL;
     }
 
     if (req->event.type == 0) {
-	/* owner is local; construct the remainder of the event */
-	req->event.type = SelectionRequest;
-	req->event.serial = LastKnownRequestProcessed(XtDisplay(widget));
-	req->event.send_event = True;
-	req->event.display = XtDisplay(widget);
-	req->event.owner = XtWindow(req->ctx->widget);
-	req->event.selection = selection;
+        /* owner is local; construct the remainder of the event */
+        req->event.type = SelectionRequest;
+        req->event.serial = LastKnownRequestProcessed(XtDisplay(widget));
+        req->event.send_event = True;
+        req->event.display = XtDisplay(widget);
+
+        req->event.owner = XtWindow(req->ctx->widget);
+        req->event.selection = selection;
     }
     UNLOCK_APP(app);
     return &req->event;
 }
 
 /* Property atom access */
-Atom XtReservePropertyAtom(
-     Widget w)
+Atom
+XtReservePropertyAtom(Widget w)
 {
-  return(GetSelectionProperty(XtDisplay(w)));
+    return (GetSelectionProperty(XtDisplay(w)));
 }
 
-void XtReleasePropertyAtom(
-     Widget w,
-     Atom atom)
+void
+XtReleasePropertyAtom(Widget w, Atom atom)
 {
-  FreeSelectionProperty(XtDisplay(w), atom);
+    FreeSelectionProperty(XtDisplay(w), atom);
 }
 
-
 /* Multiple utilities */
 
 /* All requests are put in a single list per widget.  It is
@@ -1867,280 +1929,294 @@ void XtReleasePropertyAtom(
    this case is acceptable */
 
 /* Queue one or more requests to the one we're gathering */
-static void AddSelectionRequests(
-     Widget wid,
-     Atom sel,
-     int count,
-     Atom *targets,
-     XtSelectionCallbackProc *callbacks,
-     int num_cb,
-     XtPointer *closures,
-     Boolean *incrementals,
-     Atom *properties)
+static void
+AddSelectionRequests(Widget wid,
+                     Atom sel,
+                     int count,
+                     Atom *targets,
+                     XtSelectionCallbackProc *callbacks,
+                     int num_cb,
+                     XtPointer *closures,
+                     Boolean *incrementals,
+                     Atom *properties)
 {
-  QueuedRequestInfo qi;
-  Window window = XtWindow(wid);
-  Display *dpy = XtDisplay(wid);
-
-  LOCK_PROCESS;
-  if (multipleContext == 0) multipleContext = XUniqueContext();
-
-  qi = NULL;
-  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &qi);
-
-  if (qi != NULL) {
-    QueuedRequest *req = qi->requests;
-    int start = qi->count;
-    int i = 0;
-    int j = 0;
-
-    qi->count += count;
-    req = (QueuedRequest*) XtRealloc((char*) req,
-				     (Cardinal)((size_t)(start + count) *
-				     sizeof(QueuedRequest)));
-    while(i < count) {
-      QueuedRequest newreq = (QueuedRequest)
-	__XtMalloc(sizeof(QueuedRequestRec));
-      newreq->selection = sel;
-      newreq->target = targets[i];
-      if (properties != NULL)
-	newreq->param = properties[i];
-      else {
-	newreq->param = GetSelectionProperty(dpy);
-	XDeleteProperty(dpy, window, newreq->param);
-      }
-      newreq->callback = callbacks[j];
-      newreq->closure = closures[i];
-      newreq->incremental = incrementals[i];
-
-      req[start] = newreq;
-      start++;
-      i++;
-      j++;
-      if (j > num_cb) j = 0;
-    }
-
-    qi->requests = req;
-  } else {
-    /* Impossible */
-  }
-
-  UNLOCK_PROCESS;
-}
+    QueuedRequestInfo qi;
+    Window window = XtWindow(wid);
+    Display *dpy = XtDisplay(wid);
 
-/* Only call IsGatheringRequest when we have a lock already */
+    LOCK_PROCESS;
+    if (multipleContext == 0)
+        multipleContext = XUniqueContext();
+
+    qi = NULL;
+    (void) XFindContext(dpy, window, multipleContext, (XPointer *) &qi);
+
+    if (qi != NULL) {
+        QueuedRequest *req = qi->requests;
+        int start = qi->count;
+        int i = 0;
+        int j = 0;
+
+        qi->count += count;
+        req = (QueuedRequest *) XtRealloc((char *) req,
+                                          (Cardinal) ((size_t) (start + count) *
+                                                      sizeof(QueuedRequest)));
+        while (i < count) {
+            QueuedRequest newreq = (QueuedRequest)
+                __XtMalloc(sizeof(QueuedRequestRec));
+
+            newreq->selection = sel;
+            newreq->target = targets[i];
+            if (properties != NULL)
+                newreq->param = properties[i];
+            else {
+                newreq->param = GetSelectionProperty(dpy);
+                XDeleteProperty(dpy, window, newreq->param);
+            }
+            newreq->callback = callbacks[j];
+            newreq->closure = closures[i];
+            newreq->incremental = incrementals[i];
+
+            req[start] = newreq;
+            start++;
+            i++;
+            j++;
+            if (j > num_cb)
+                j = 0;
+        }
 
-static Boolean IsGatheringRequest(
-     Widget wid,
-     Atom sel)
-{
-  QueuedRequestInfo qi;
-  Window window = XtWindow(wid);
-  Display *dpy = XtDisplay(wid);
-  Boolean found = False;
+        qi->requests = req;
+    }
+    else {
+        /* Impossible */
+    }
 
-  if (multipleContext == 0) multipleContext = XUniqueContext();
+    UNLOCK_PROCESS;
+}
 
-  qi = NULL;
-  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &qi);
+/* Only call IsGatheringRequest when we have a lock already */
 
-  if (qi != NULL) {
-    int i = 0;
-    while(qi->selections[i] != None) {
-      if (qi->selections[i] == sel) {
-	found = True;
-	break;
-      }
-      i++;
+static Boolean
+IsGatheringRequest(Widget wid, Atom sel)
+{
+    QueuedRequestInfo qi;
+    Window window = XtWindow(wid);
+    Display *dpy = XtDisplay(wid);
+    Boolean found = False;
+
+    if (multipleContext == 0)
+        multipleContext = XUniqueContext();
+
+    qi = NULL;
+    (void) XFindContext(dpy, window, multipleContext, (XPointer *) &qi);
+
+    if (qi != NULL) {
+        int i = 0;
+
+        while (qi->selections[i] != None) {
+            if (qi->selections[i] == sel) {
+                found = True;
+                break;
+            }
+            i++;
+        }
     }
-  }
 
-  return(found);
+    return (found);
 }
 
 /* Cleanup request scans the request queue and releases any
    properties queued, and removes any requests queued */
-static void CleanupRequest(
-     Display *dpy,
-     QueuedRequestInfo qi,
-     Atom sel)
+static void
+CleanupRequest(Display *dpy, QueuedRequestInfo qi, Atom sel)
 {
-  int i, j, n;
-
-  i = 0;
-
-  /* Remove this selection from the list */
-  n = 0;
-  while(qi->selections[n] != sel &&
-	qi->selections[n] != None) n++;
-  if (qi->selections[n] == sel) {
-    while(qi->selections[n] != None) {
-      qi->selections[n] = qi->selections[n + 1];
-      n++;
+    int i, j, n;
+
+    i = 0;
+
+    /* Remove this selection from the list */
+    n = 0;
+    while (qi->selections[n] != sel && qi->selections[n] != None)
+        n++;
+    if (qi->selections[n] == sel) {
+        while (qi->selections[n] != None) {
+            qi->selections[n] = qi->selections[n + 1];
+            n++;
+        }
     }
-  }
 
-  while(i < qi->count) {
-    QueuedRequest req = qi->requests[i];
+    while (i < qi->count) {
+        QueuedRequest req = qi->requests[i];
 
-    if (req->selection == sel) {
-      /* Match */
-      if (req->param != None)
-	FreeSelectionProperty(dpy, req->param);
-      qi->count--;
+        if (req->selection == sel) {
+            /* Match */
+            if (req->param != None)
+                FreeSelectionProperty(dpy, req->param);
+            qi->count--;
 
-      for(j = i; j < qi->count; j++)
-	qi->requests[j] = qi->requests[j + 1];
+            for (j = i; j < qi->count; j++)
+                qi->requests[j] = qi->requests[j + 1];
 
-      XtFree((char*) req);
-    } else {
-      i++;
+            XtFree((char *) req);
+        }
+        else {
+            i++;
+        }
     }
-  }
 }
 
-void XtCreateSelectionRequest(
-    Widget widget,
-    Atom selection)
+void
+XtCreateSelectionRequest(Widget widget, Atom selection)
 {
-  QueuedRequestInfo queueInfo;
-  Window window = XtWindow(widget);
-  Display *dpy = XtDisplay(widget);
-  int n;
+    QueuedRequestInfo queueInfo;
+    Window window = XtWindow(widget);
+    Display *dpy = XtDisplay(widget);
+    int n;
 
-  LOCK_PROCESS;
-  if (multipleContext == 0) multipleContext = XUniqueContext();
+    LOCK_PROCESS;
+    if (multipleContext == 0)
+        multipleContext = XUniqueContext();
 
-  queueInfo = NULL;
-  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
+    queueInfo = NULL;
+    (void) XFindContext(dpy, window, multipleContext, (XPointer *) &queueInfo);
 
-  /* If there is one,  then cancel it */
-  if (queueInfo != NULL)
-    CleanupRequest(dpy, queueInfo, selection);
-  else {
-    /* Create it */
-    queueInfo = (QueuedRequestInfo) __XtMalloc(sizeof(QueuedRequestInfoRec));
-    queueInfo->count = 0;
-    queueInfo->selections = (Atom*) __XtMalloc(sizeof(Atom) * 2);
-    queueInfo->selections[0] = None;
-    queueInfo->requests = (QueuedRequest *)
-      __XtMalloc(sizeof(QueuedRequest));
-  }
-
-  /* Append this selection to list */
-  n = 0;
-  while(queueInfo->selections[n] != None) n++;
-  queueInfo->selections =
-    (Atom*) XtRealloc((char*) queueInfo->selections,
-		      (Cardinal)((size_t)(n + 2) * sizeof(Atom)));
-  queueInfo->selections[n] = selection;
-  queueInfo->selections[n + 1] = None;
-
-  (void) XSaveContext(dpy, window, multipleContext, (char*) queueInfo);
-  UNLOCK_PROCESS;
+    /* If there is one,  then cancel it */
+    if (queueInfo != NULL)
+        CleanupRequest(dpy, queueInfo, selection);
+    else {
+        /* Create it */
+        queueInfo =
+            (QueuedRequestInfo) __XtMalloc(sizeof(QueuedRequestInfoRec));
+        queueInfo->count = 0;
+        queueInfo->selections = (Atom *) __XtMalloc(sizeof(Atom) * 2);
+        queueInfo->selections[0] = None;
+        queueInfo->requests = (QueuedRequest *)
+            __XtMalloc(sizeof(QueuedRequest));
+    }
+
+    /* Append this selection to list */
+    n = 0;
+    while (queueInfo->selections[n] != None)
+        n++;
+    queueInfo->selections =
+        (Atom *) XtRealloc((char *) queueInfo->selections,
+                           (Cardinal) ((size_t) (n + 2) * sizeof(Atom)));
+    queueInfo->selections[n] = selection;
+    queueInfo->selections[n + 1] = None;
+
+    (void) XSaveContext(dpy, window, multipleContext, (char *) queueInfo);
+    UNLOCK_PROCESS;
 }
 
-void XtSendSelectionRequest(
-    Widget widget,
-    Atom selection,
-    Time time)
+void
+XtSendSelectionRequest(Widget widget, Atom selection, Time time)
 {
-  QueuedRequestInfo queueInfo;
-  Window window = XtWindow(widget);
-  Display *dpy = XtDisplay(widget);
+    QueuedRequestInfo queueInfo;
+    Window window = XtWindow(widget);
+    Display *dpy = XtDisplay(widget);
 
-  LOCK_PROCESS;
-  if (multipleContext == 0) multipleContext = XUniqueContext();
+    LOCK_PROCESS;
+    if (multipleContext == 0)
+        multipleContext = XUniqueContext();
+
+    queueInfo = NULL;
+    (void) XFindContext(dpy, window, multipleContext, (XPointer *) &queueInfo);
+    if (queueInfo != NULL) {
+        int i;
+        int count = 0;
+        QueuedRequest *req = queueInfo->requests;
+
+        /* Construct the requests and send it using
+           GetSelectionValues */
+        for (i = 0; i < queueInfo->count; i++)
+            if (req[i]->selection == selection)
+                count++;
+
+        if (count > 0) {
+            if (count == 1) {
+                for (i = 0; i < queueInfo->count; i++)
+                    if (req[i]->selection == selection)
+                        break;
+
+                /* special case a multiple which isn't needed */
+                GetSelectionValue(widget, selection, req[i]->target,
+                                  req[i]->callback, req[i]->closure, time,
+                                  req[i]->incremental, req[i]->param);
+            }
+            else {
+                Atom *targets;
+                Atom t[PREALLOCED];
+                XtSelectionCallbackProc *cbs;
+                XtSelectionCallbackProc c[PREALLOCED];
+                XtPointer *closures;
+                XtPointer cs[PREALLOCED];
+                Boolean *incrs;
+                Boolean ins[PREALLOCED];
+                Atom *props;
+                Atom p[PREALLOCED];
+                int j = 0;
+
+                /* Allocate */
+                targets =
+                    (Atom *) XtStackAlloc((size_t) count * sizeof(Atom), t);
+                cbs = (XtSelectionCallbackProc *)
+                    XtStackAlloc((size_t) count *
+                                 sizeof(XtSelectionCallbackProc), c);
+                closures =
+                    (XtPointer *) XtStackAlloc((size_t) count *
+                                               sizeof(XtPointer), cs);
+                incrs =
+                    (Boolean *) XtStackAlloc((size_t) count * sizeof(Boolean),
+                                             ins);
+                props = (Atom *) XtStackAlloc((size_t) count * sizeof(Atom), p);
+
+                /* Copy */
+                for (i = 0; i < queueInfo->count; i++) {
+                    if (req[i]->selection == selection) {
+                        targets[j] = req[i]->target;
+                        cbs[j] = req[i]->callback;
+                        closures[j] = req[i]->closure;
+                        incrs[j] = req[i]->incremental;
+                        props[j] = req[i]->param;
+                        j++;
+                    }
+                }
+
+                /* Make the request */
+                GetSelectionValues(widget, selection, targets, count,
+                                   cbs, count, closures, time, incrs, props);
+
+                /* Free */
+                XtStackFree((XtPointer) targets, t);
+                XtStackFree((XtPointer) cbs, c);
+                XtStackFree((XtPointer) closures, cs);
+                XtStackFree((XtPointer) incrs, ins);
+                XtStackFree((XtPointer) props, p);
+            }
+        }
+    }
 
-  queueInfo = NULL;
-  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
-  if (queueInfo != NULL) {
-    int i;
-    int count = 0;
-    QueuedRequest *req = queueInfo->requests;
-
-    /* Construct the requests and send it using
-       GetSelectionValues */
-    for(i = 0; i < queueInfo->count; i++)
-      if (req[i]->selection == selection) count++;
-
-    if (count > 0) {
-      if (count == 1) {
-	for(i = 0; i < queueInfo->count; i++)
-	  if (req[i]->selection == selection) break;
-
-	/* special case a multiple which isn't needed */
-	GetSelectionValue(widget, selection, req[i]->target,
-			  req[i]->callback, req[i]->closure, time,
-			  req[i]->incremental, req[i]->param);
-      } else {
-	Atom *targets;
-	Atom t[PREALLOCED];
-	XtSelectionCallbackProc *cbs;
-	XtSelectionCallbackProc c[PREALLOCED];
-	XtPointer *closures;
-	XtPointer cs[PREALLOCED];
-	Boolean *incrs;
-	Boolean ins[PREALLOCED];
-	Atom *props;
-	Atom p[PREALLOCED];
-	int j = 0;
-
-	/* Allocate */
-	targets = (Atom *) XtStackAlloc((size_t)count * sizeof(Atom), t);
-	cbs = (XtSelectionCallbackProc *)
-	  XtStackAlloc((size_t)count * sizeof(XtSelectionCallbackProc), c);
-	closures = (XtPointer *) XtStackAlloc((size_t)count * sizeof(XtPointer), cs);
-	incrs = (Boolean *) XtStackAlloc((size_t)count * sizeof(Boolean), ins);
-	props = (Atom *) XtStackAlloc((size_t)count * sizeof(Atom), p);
-
-	/* Copy */
-	for(i = 0; i < queueInfo->count; i++) {
-	  if (req[i]->selection == selection) {
-	    targets[j] = req[i]->target;
-	    cbs[j] = req[i]->callback;
-	    closures[j] = req[i]->closure;
-	    incrs[j] = req[i]->incremental;
-	    props[j] = req[i]->param;
-	    j++;
-	  }
-	}
-
-	/* Make the request */
-	GetSelectionValues(widget, selection, targets, count,
-			   cbs, count, closures, time, incrs, props);
-
-	/* Free */
-	XtStackFree((XtPointer) targets, t);
-	XtStackFree((XtPointer) cbs, c);
-	XtStackFree((XtPointer) closures, cs);
-	XtStackFree((XtPointer) incrs, ins);
-	XtStackFree((XtPointer) props, p);
-      }
-    }
-  }
-
-  CleanupRequest(dpy, queueInfo, selection);
-  UNLOCK_PROCESS;
+    CleanupRequest(dpy, queueInfo, selection);
+    UNLOCK_PROCESS;
 }
 
-void XtCancelSelectionRequest(
-    Widget widget,
-    Atom selection)
+void
+XtCancelSelectionRequest(Widget widget, Atom selection)
 {
-  QueuedRequestInfo queueInfo;
-  Window window = XtWindow(widget);
-  Display *dpy = XtDisplay(widget);
-
-  LOCK_PROCESS;
-  if (multipleContext == 0) multipleContext = XUniqueContext();
+    QueuedRequestInfo queueInfo;
+    Window window = XtWindow(widget);
+    Display *dpy = XtDisplay(widget);
 
-  queueInfo = NULL;
-  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
-  /* If there is one,  then cancel it */
-  if (queueInfo != NULL)
-    CleanupRequest(dpy, queueInfo, selection);
-  UNLOCK_PROCESS;
+    LOCK_PROCESS;
+    if (multipleContext == 0)
+        multipleContext = XUniqueContext();
+
+    queueInfo = NULL;
+    (void) XFindContext(dpy, window, multipleContext, (XPointer *) &queueInfo);
+    /* If there is one,  then cancel it */
+    if (queueInfo != NULL)
+        CleanupRequest(dpy, queueInfo, selection);
+    UNLOCK_PROCESS;
 }
 
 /* Parameter utilities */
@@ -2149,41 +2225,42 @@ void XtCancelSelectionRequest(
 /* Places data on allocated parameter atom,  then records the
    parameter atom data for use in the next call to one of
    the XtGetSelectionValue functions. */
-void XtSetSelectionParameters(
-    Widget requestor,
-    Atom selection,
-    Atom type,
-    XtPointer value,
-    unsigned long length,
-    int format)
+void
+XtSetSelectionParameters(Widget requestor,
+                         Atom selection,
+                         Atom type,
+                         XtPointer value,
+                         unsigned long length,
+                         int format)
 {
-  Display *dpy = XtDisplay(requestor);
-  Window window = XtWindow(requestor);
-  Atom property = GetParamInfo(requestor, selection);
-
-  if (property == None) {
-    property = GetSelectionProperty(dpy);
-    AddParamInfo(requestor, selection, property);
-  }
-
-  XChangeProperty(dpy, window, property,
-		  type, format, PropModeReplace,
-		  (unsigned char *) value, (int) length);
+    Display *dpy = XtDisplay(requestor);
+    Window window = XtWindow(requestor);
+    Atom property = GetParamInfo(requestor, selection);
+
+    if (property == None) {
+        property = GetSelectionProperty(dpy);
+        AddParamInfo(requestor, selection, property);
+    }
+
+    XChangeProperty(dpy, window, property,
+                    type, format, PropModeReplace,
+                    (unsigned char *) value, (int) length);
 }
 
 /* Retrieves data passed in a parameter. Data for this is stored
    on the originator's window */
-void XtGetSelectionParameters(
-    Widget owner,
-    Atom selection,
-    XtRequestId request_id,
-    Atom* type_return,
-    XtPointer* value_return,
-    unsigned long* length_return,
-    int* format_return)
+void
+XtGetSelectionParameters(Widget owner,
+                         Atom selection,
+                         XtRequestId request_id,
+                         Atom *type_return,
+                         XtPointer *value_return,
+                         unsigned long *length_return,
+                         int *format_return)
 {
     Request req;
     Display *dpy = XtDisplay(owner);
+
     WIDGET_TO_APPCON(owner);
 
     *value_return = NULL;
@@ -2195,21 +2272,23 @@ void XtGetSelectionParameters(
     req = GetRequestRecord(owner, selection, request_id);
 
     if (req && req->property) {
-	unsigned long bytes_after;	/* unused */
-	StartProtectedSection(dpy, req->requestor);
-	XGetWindowProperty(dpy, req->requestor, req->property, 0L, 10000000,
-			   False, AnyPropertyType, type_return, format_return,
-			   length_return, &bytes_after,
-			   (unsigned char**) value_return);
-	EndProtectedSection(dpy);
+        unsigned long bytes_after;      /* unused */
+
+        StartProtectedSection(dpy, req->requestor);
+        XGetWindowProperty(dpy, req->requestor, req->property, 0L, 10000000,
+                           False, AnyPropertyType, type_return, format_return,
+                           length_return, &bytes_after,
+                           (unsigned char **) value_return);
+        EndProtectedSection(dpy);
 #ifdef XT_COPY_SELECTION
-	if (*value_return) {
-	    int size = (int) BYTELENGTH(*length_return, *format_return) + 1;
-	    char *tmp = __XtMalloc((Cardinal) size);
-	    (void) memmove(tmp, *value_return, (size_t) size);
-	    XFree(*value_return);
-	    *value_return = tmp;
-	}
+        if (*value_return) {
+            int size = (int) BYTELENGTH(*length_return, *format_return) + 1;
+            char *tmp = __XtMalloc((Cardinal) size);
+
+            (void) memmove(tmp, *value_return, (size_t) size);
+            XFree(*value_return);
+            *value_return = tmp;
+        }
 #endif
     }
     UNLOCK_APP(app);
@@ -2221,100 +2300,97 @@ void XtGetSelectionParameters(
  *  context could be merged with other contexts used during selections.
  */
 
-static void AddParamInfo(
-    Widget w,
-    Atom selection,
-    Atom param_atom)
+static void
+AddParamInfo(Widget w, Atom selection, Atom param_atom)
 {
     Param p;
     ParamInfo pinfo;
 
     LOCK_PROCESS;
     if (paramPropertyContext == 0)
-	paramPropertyContext = XUniqueContext();
+        paramPropertyContext = XUniqueContext();
 
     if (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
-		     (XPointer *) &pinfo)) {
-	pinfo = (ParamInfo) __XtMalloc(sizeof(ParamInfoRec));
-	pinfo->count = 1;
-	pinfo->paramlist = XtNew(ParamRec);
-	p = pinfo->paramlist;
-	(void) XSaveContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
-			    (char *)pinfo);
+                     (XPointer *) &pinfo)) {
+        pinfo = (ParamInfo) __XtMalloc(sizeof(ParamInfoRec));
+        pinfo->count = 1;
+        pinfo->paramlist = XtNew(ParamRec);
+        p = pinfo->paramlist;
+        (void) XSaveContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
+                            (char *) pinfo);
     }
     else {
-	int n;
-	for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++) {
-	    if (p->selection == None || p->selection == selection)
-		break;
-	}
-	if (n == 0) {
-	    pinfo->count++;
-	    pinfo->paramlist = (Param)
-		XtRealloc((char*) pinfo->paramlist,
-			  (Cardinal)(pinfo->count * sizeof(ParamRec)));
-	    p = &pinfo->paramlist[pinfo->count - 1];
-	    (void) XSaveContext(XtDisplay(w), XtWindow(w),
-				paramPropertyContext, (char *)pinfo);
-	}
+        int n;
+
+        for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++) {
+            if (p->selection == None || p->selection == selection)
+                break;
+        }
+        if (n == 0) {
+            pinfo->count++;
+            pinfo->paramlist = (Param)
+                XtRealloc((char *) pinfo->paramlist,
+                          (Cardinal) (pinfo->count * sizeof(ParamRec)));
+            p = &pinfo->paramlist[pinfo->count - 1];
+            (void) XSaveContext(XtDisplay(w), XtWindow(w),
+                                paramPropertyContext, (char *) pinfo);
+        }
     }
     p->selection = selection;
     p->param = param_atom;
     UNLOCK_PROCESS;
 }
 
-static void RemoveParamInfo(
-    Widget w,
-    Atom selection)
+static void
+RemoveParamInfo(Widget w, Atom selection)
 {
     ParamInfo pinfo;
     Boolean retain = False;
 
     LOCK_PROCESS;
     if (paramPropertyContext
-	&& (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
-			 (XPointer *) &pinfo) == 0)) {
-	Param p;
-	int n;
-
-	/* Find and invalidate the parameter data. */
-	for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++) {
-	    if (p->selection != None) {
-		if (p->selection == selection)
-		    p->selection = None;
-		else
-		    retain = True;
-	    }
-	}
-	/* If there's no valid data remaining, release the context entry. */
-	if (! retain) {
-	    XtFree((char*) pinfo->paramlist);
-	    XtFree((char*) pinfo);
-	    XDeleteContext(XtDisplay(w), XtWindow(w), paramPropertyContext);
-	}
+        && (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
+                         (XPointer *) &pinfo) == 0)) {
+        Param p;
+        int n;
+
+        /* Find and invalidate the parameter data. */
+        for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++) {
+            if (p->selection != None) {
+                if (p->selection == selection)
+                    p->selection = None;
+                else
+                    retain = True;
+            }
+        }
+        /* If there's no valid data remaining, release the context entry. */
+        if (!retain) {
+            XtFree((char *) pinfo->paramlist);
+            XtFree((char *) pinfo);
+            XDeleteContext(XtDisplay(w), XtWindow(w), paramPropertyContext);
+        }
     }
     UNLOCK_PROCESS;
 }
 
-static Atom GetParamInfo(
-    Widget w,
-    Atom selection)
+static Atom
+GetParamInfo(Widget w, Atom selection)
 {
     ParamInfo pinfo;
     Atom atom = None;
 
     LOCK_PROCESS;
     if (paramPropertyContext
-	&& (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
-			 (XPointer *) &pinfo) == 0)) {
-	Param p;
-	int n;
-
-	for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++)
-	    if (p->selection == selection) {
-		atom = p->param;
-		break;
-	    }
+        && (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
+                         (XPointer *) &pinfo) == 0)) {
+        Param p;
+        int n;
+
+        for (n = (int) pinfo->count, p = pinfo->paramlist; n; n--, p++)
+            if (p->selection == selection) {
+                atom = p->param;
+                break;
+            }
     }
     UNLOCK_PROCESS;
     return atom;
diff --git a/src/SetSens.c b/src/SetSens.c
index 04d3f3a..2778dba 100644
--- a/src/SetSens.c
+++ b/src/SetSens.c
@@ -75,16 +75,16 @@ in this Software without prior written authorization from The Open Group.
 #include "StringDefs.h"
 
 /*
- *	XtSetSensitive()
+ *      XtSetSensitive()
  */
 
-static void SetAncestorSensitive(
-    register Widget widget,
-    Boolean	    ancestor_sensitive)
+static void
+SetAncestorSensitive(register Widget widget, Boolean ancestor_sensitive)
 {
     Arg args[1];
 
-    if (widget->core.ancestor_sensitive == ancestor_sensitive) return;
+    if (widget->core.ancestor_sensitive == ancestor_sensitive)
+        return;
 
     XtSetArg(args[0], XtNancestorSensitive, ancestor_sensitive);
     XtSetValues(widget, args, XtNumber(args));
@@ -94,28 +94,27 @@ static void SetAncestorSensitive(
        ancestor_sensitive is already FALSE */
 
     if (widget->core.sensitive && XtIsComposite(widget)) {
-	Cardinal i;
-	WidgetList children;
+        Cardinal i;
+        WidgetList children;
 
-	children = ((CompositeWidget) widget)->composite.children;
-	for (i=0; i < ((CompositeWidget)widget)->composite.num_children; i++) {
-	    SetAncestorSensitive (children[i], ancestor_sensitive);
-	}
+        children = ((CompositeWidget) widget)->composite.children;
+        for (i = 0; i < ((CompositeWidget) widget)->composite.num_children; i++) {
+            SetAncestorSensitive(children[i], ancestor_sensitive);
+        }
     }
-} /* SetAncestorSensitive */
+}                               /* SetAncestorSensitive */
 
-
-void XtSetSensitive(
-    register Widget widget,
-    _XtBoolean	    sensitive)
+void
+XtSetSensitive(register Widget widget, _XtBoolean sensitive)
 {
-    Arg			args[1];
+    Arg args[1];
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (widget->core.sensitive == sensitive) {
-	UNLOCK_APP(app);
-	return;
+        UNLOCK_APP(app);
+        return;
     }
 
     XtSetArg(args[0], XtNsensitive, sensitive);
@@ -125,14 +124,14 @@ void XtSetSensitive(
        children's ancestor_sensitive; else do nothing as children's
        ancestor_sensitive is already FALSE */
 
-    if (widget->core.ancestor_sensitive && XtIsComposite (widget)) {
-	Cardinal   i;
-	WidgetList children;
+    if (widget->core.ancestor_sensitive && XtIsComposite(widget)) {
+        Cardinal i;
+        WidgetList children;
 
-	children = ((CompositeWidget) widget)->composite.children;
-	for (i = 0; i < ((CompositeWidget)widget)->composite.num_children; i++){
-	    SetAncestorSensitive (children[i], (Boolean) sensitive);
-	}
+        children = ((CompositeWidget) widget)->composite.children;
+        for (i = 0; i < ((CompositeWidget) widget)->composite.num_children; i++) {
+            SetAncestorSensitive(children[i], (Boolean) sensitive);
+        }
     }
     UNLOCK_APP(app);
-} /* XtSetSensitive */
+}                               /* XtSetSensitive */
diff --git a/src/SetValues.c b/src/SetValues.c
index cbfd680..a50faab 100644
--- a/src/SetValues.c
+++ b/src/SetValues.c
@@ -74,45 +74,44 @@ in this Software without prior written authorization from The Open Group.
 #include "IntrinsicI.h"
 
 /*
- *	XtSetValues(), XtSetSubvalues()
+ *      XtSetValues(), XtSetSubvalues()
  */
 
-
-static void SetValues(
-  char*			base,		/* Base address to write values to   */
-  XrmResourceList*	res,		/* The current resource values.      */
-  register Cardinal	num_resources,	/* number of items in resources      */
-  ArgList 		args,		/* The resource values to set        */
-  Cardinal		num_args)	/* number of items in arg list       */
+static void
+SetValues(char *base,                           /* Base address to write values to */
+          XrmResourceList *res,                 /* The current resource values. */
+          register Cardinal num_resources,      /* number of items in resources      */
+          ArgList args,                         /* The resource values to set */
+          Cardinal num_args)                    /* number of items in arg list       */
 {
-    register ArgList		arg;
-    register Cardinal 	        i;
-    register XrmName		argName;
-    register XrmResourceList*   xrmres;
+    register ArgList arg;
+    register Cardinal i;
+    register XrmName argName;
+    register XrmResourceList *xrmres;
 
     /* Resource lists are assumed to be in compiled form already via the
        initial XtGetResources, XtGetSubresources calls */
 
-    for (arg = args ; num_args != 0; num_args--, arg++) {
-	argName = StringToName(arg->name);
-	for (xrmres = res, i = 0; i < num_resources; i++, xrmres++) {
-	    if (argName == (*xrmres)->xrm_name) {
-		_XtCopyFromArg(arg->value,
-		    base - (*xrmres)->xrm_offset - 1,
-		    (*xrmres)->xrm_size);
-		break;
-	    }
-	}
+    for (arg = args; num_args != 0; num_args--, arg++) {
+        argName = StringToName(arg->name);
+        for (xrmres = res, i = 0; i < num_resources; i++, xrmres++) {
+            if (argName == (*xrmres)->xrm_name) {
+                _XtCopyFromArg(arg->value,
+                               base - (*xrmres)->xrm_offset - 1,
+                               (*xrmres)->xrm_size);
+                break;
+            }
+        }
     }
-} /* SetValues */
-
-static Boolean CallSetValues (
-    WidgetClass class,
-    Widget      current,
-    Widget      request,
-    Widget      new,
-    ArgList     args,
-    Cardinal    num_args)
+}                               /* SetValues */
+
+static Boolean
+CallSetValues(WidgetClass class,
+              Widget current,
+              Widget request,
+              Widget new,
+              ArgList args,
+              Cardinal num_args)
 {
     Boolean redisplay = FALSE;
     WidgetClass superclass;
@@ -124,7 +123,7 @@ static Boolean CallSetValues (
     UNLOCK_PROCESS;
     if (superclass)
         redisplay =
-	    CallSetValues(superclass, current, request, new, args, num_args);
+            CallSetValues(superclass, current, request, new, args, num_args);
 
     LOCK_PROCESS;
     set_values = class->core_class.set_values;
@@ -136,38 +135,39 @@ static Boolean CallSetValues (
     set_values_hook = class->core_class.set_values_hook;
     UNLOCK_PROCESS;
     if (set_values_hook)
-	redisplay |= (*set_values_hook) (new, args, &num_args);
+        redisplay |= (*set_values_hook) (new, args, &num_args);
     return (redisplay);
 }
 
 static Boolean
-CallConstraintSetValues (
-    ConstraintWidgetClass class,
-    Widget      current,
-    Widget      request,
-    Widget      new,
-    ArgList     args,
-    Cardinal    num_args)
+CallConstraintSetValues(ConstraintWidgetClass class,
+                        Widget current,
+                        Widget request,
+                        Widget new,
+                        ArgList args,
+                        Cardinal num_args)
 {
     Boolean redisplay = FALSE;
     XtSetValuesFunc set_values;
 
-    if ((WidgetClass)class != constraintWidgetClass) {
-	ConstraintWidgetClass superclass;
-
-	if (class == NULL) {
-	    XtAppErrorMsg(XtWidgetToApplicationContext(current),
-		    "invalidClass","constraintSetValue",XtCXtToolkitError,
-                 "Subclass of Constraint required in CallConstraintSetValues",
-                  NULL, NULL);
-	} else {
-	    LOCK_PROCESS;
-	    superclass = (ConstraintWidgetClass) class->core_class.superclass;
-	    UNLOCK_PROCESS;
-	    redisplay =
-	       CallConstraintSetValues(superclass,
-				       current, request, new, args, num_args);
-	}
+    if ((WidgetClass) class != constraintWidgetClass) {
+        ConstraintWidgetClass superclass;
+
+        if (class == NULL) {
+            XtAppErrorMsg(XtWidgetToApplicationContext(current),
+                          "invalidClass", "constraintSetValue",
+                          XtCXtToolkitError,
+                          "Subclass of Constraint required in CallConstraintSetValues",
+                          NULL, NULL);
+        }
+        else {
+            LOCK_PROCESS;
+            superclass = (ConstraintWidgetClass) class->core_class.superclass;
+            UNLOCK_PROCESS;
+            redisplay =
+                CallConstraintSetValues(superclass,
+                                        current, request, new, args, num_args);
+        }
     }
     LOCK_PROCESS;
     set_values = class ? class->constraint_class.set_values : NULL;
@@ -177,36 +177,35 @@ CallConstraintSetValues (
     return (redisplay);
 }
 
-void XtSetSubvalues(
-  XtPointer             base,           /* Base address to write values to   */
-  register XtResourceList resources,    /* The current resource values.      */
-  register Cardinal     num_resources,  /* number of items in resources      */
-  ArgList               args,           /* The resource values to set        */
-  Cardinal              num_args)       /* number of items in arg list       */
+void
+XtSetSubvalues(XtPointer base,                  /* Base address to write values to */
+               register XtResourceList resources,       /* The current resource values.      */
+               register Cardinal num_resources, /* number of items in resources      */
+               ArgList args,                    /* The resource values to set */
+               Cardinal num_args)               /* number of items in arg list       */
 {
-      register XrmResourceList*   xrmres;
-      xrmres = _XtCreateIndirectionTable (resources, num_resources);
-      SetValues((char*)base,xrmres,num_resources, args, num_args);
-      XtFree((char *)xrmres);
-}
+    register XrmResourceList *xrmres;
 
+    xrmres = _XtCreateIndirectionTable(resources, num_resources);
+    SetValues((char *) base, xrmres, num_resources, args, num_args);
+    XtFree((char *) xrmres);
+}
 
-void XtSetValues(
-    register Widget   w,
-	     ArgList  args,
-	     Cardinal num_args)
+void
+XtSetValues(register Widget w, ArgList args, Cardinal num_args)
 {
     register Widget oldw, reqw;
+
     /* need to use strictest alignment rules possible in next two decls. */
-    double	    oldwCache[100], reqwCache[100];
-    double	    oldcCache[20], reqcCache[20];
-    Cardinal	    widgetSize, constraintSize;
-    Boolean	    redisplay, cleared_rect_obj = False;
+    double oldwCache[100], reqwCache[100];
+    double oldcCache[20], reqcCache[20];
+    Cardinal widgetSize, constraintSize;
+    Boolean redisplay, cleared_rect_obj = False;
     XtGeometryResult result;
     XtWidgetGeometry geoReq, geoReply;
-    WidgetClass     wc;
+    WidgetClass wc;
     ConstraintWidgetClass cwc = NULL;
-    Boolean	    hasConstraints;
+    Boolean hasConstraints;
     XtAppContext app = XtWidgetToApplicationContext(w);
     Widget hookobj = XtHooksOfDisplay(XtDisplayOfObject(w));
 
@@ -214,9 +213,9 @@ void XtSetValues(
     wc = XtClass(w);
     if ((args == NULL) && (num_args != 0)) {
         XtAppErrorMsg(app,
-		"invalidArgCount","xtSetValues",XtCXtToolkitError,
-                "Argument count > 0 on NULL argument list in XtSetValues",
-                 NULL, NULL);
+                      "invalidArgCount", "xtSetValues", XtCXtToolkitError,
+                      "Argument count > 0 on NULL argument list in XtSetValues",
+                      NULL, NULL);
     }
 
     /* Allocate and copy current widget into old widget */
@@ -225,230 +224,248 @@ void XtSetValues(
     widgetSize = wc->core_class.widget_size;
     UNLOCK_PROCESS;
     oldw = (Widget) XtStackAlloc(widgetSize, oldwCache);
-    reqw = (Widget) XtStackAlloc (widgetSize, reqwCache);
+    reqw = (Widget) XtStackAlloc(widgetSize, reqwCache);
     (void) memmove((char *) oldw, (char *) w, (size_t) widgetSize);
 
     /* Set resource values */
 
     LOCK_PROCESS;
-    SetValues((char*)w, (XrmResourceList *) wc->core_class.resources,
-	wc->core_class.num_resources, args, num_args);
+    SetValues((char *) w, (XrmResourceList *) wc->core_class.resources,
+              wc->core_class.num_resources, args, num_args);
     UNLOCK_PROCESS;
 
-    (void) memmove ((char *) reqw, (char *) w, (size_t) widgetSize);
+    (void) memmove((char *) reqw, (char *) w, (size_t) widgetSize);
 
-    hasConstraints = (XtParent(w) != NULL && !XtIsShell(w) && XtIsConstraint(XtParent(w)));
+    hasConstraints = (XtParent(w) != NULL && !XtIsShell(w) &&
+                      XtIsConstraint(XtParent(w)));
 
     /* Some widget sets apparently do ugly things by freeing the
      * constraints on some children, thus the extra test here */
     if (hasConstraints) {
-	cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
-	if (w->core.constraints) {
-	    LOCK_PROCESS;
-	    constraintSize = cwc->constraint_class.constraint_size;
-	    UNLOCK_PROCESS;
-	} else constraintSize = 0;
-    } else constraintSize = 0;
+        cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
+        if (w->core.constraints) {
+            LOCK_PROCESS;
+            constraintSize = cwc->constraint_class.constraint_size;
+            UNLOCK_PROCESS;
+        }
+        else
+            constraintSize = 0;
+    }
+    else
+        constraintSize = 0;
 
     if (constraintSize) {
-	/* Allocate and copy current constraints into oldw */
-	oldw->core.constraints = XtStackAlloc(constraintSize, oldcCache);
-	reqw->core.constraints = XtStackAlloc(constraintSize, reqcCache);
-	(void) memmove((char *) oldw->core.constraints,
-		       (char *) w->core.constraints, (size_t) constraintSize);
-
-	/* Set constraint values */
-	LOCK_PROCESS;
-	SetValues((char*)w->core.constraints,
-	    (XrmResourceList *)(cwc->constraint_class.resources),
-	    cwc->constraint_class.num_resources, args, num_args);
-	UNLOCK_PROCESS;
-	(void) memmove((char *) reqw->core.constraints,
-		       (char *) w->core.constraints, (size_t) constraintSize);
+        /* Allocate and copy current constraints into oldw */
+        oldw->core.constraints = XtStackAlloc(constraintSize, oldcCache);
+        reqw->core.constraints = XtStackAlloc(constraintSize, reqcCache);
+        (void) memmove((char *) oldw->core.constraints,
+                       (char *) w->core.constraints, (size_t) constraintSize);
+
+        /* Set constraint values */
+        LOCK_PROCESS;
+        SetValues((char *) w->core.constraints,
+                  (XrmResourceList *) (cwc->constraint_class.resources),
+                  cwc->constraint_class.num_resources, args, num_args);
+        UNLOCK_PROCESS;
+        (void) memmove((char *) reqw->core.constraints,
+                       (char *) w->core.constraints, (size_t) constraintSize);
     }
 
     /* Inform widget of changes, then inform parent of changes */
-    redisplay = CallSetValues (wc, oldw, reqw, w, args, num_args);
+    redisplay = CallSetValues(wc, oldw, reqw, w, args, num_args);
     if (hasConstraints) {
-	redisplay |= CallConstraintSetValues(cwc, oldw, reqw, w, args, num_args);
+        redisplay |=
+            CallConstraintSetValues(cwc, oldw, reqw, w, args, num_args);
     }
 
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-	XtChangeHookSetValuesDataRec set_val;
-
-	set_val.old = oldw;
-	set_val.req = reqw;
-	set_val.args = args;
-	set_val.num_args = num_args;
-	call_data.type = XtHsetValues;
-	call_data.widget = w;
-	call_data.event_data = (XtPointer) &set_val;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+        XtChangeHookSetValuesDataRec set_val;
+
+        set_val.old = oldw;
+        set_val.req = reqw;
+        set_val.args = args;
+        set_val.num_args = num_args;
+        call_data.type = XtHsetValues;
+        call_data.widget = w;
+        call_data.event_data = (XtPointer) &set_val;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 
     if (XtIsRectObj(w)) {
-	/* Now perform geometry request if needed */
-	geoReq.request_mode = 0;
-	if (oldw->core.x	!= w->core.x) {
-	    geoReq.x		= w->core.x;
-	    w->core.x		= oldw->core.x;
-	    geoReq.request_mode |= CWX;
-	}
-	if (oldw->core.y	!= w->core.y) {
-	    geoReq.y		= w->core.y;
-	    w->core.y		= oldw->core.y;
-	    geoReq.request_mode |= CWY;
-	}
-	if (oldw->core.width	!= w->core.width) {
-	    geoReq.width	= w->core.width;
-	    w->core.width	= oldw->core.width;
-	    geoReq.request_mode |= CWWidth;
-	}
-	if (oldw->core.height	!= w->core.height) {
-	    geoReq.height	= w->core.height;
-	    w->core.height	= oldw->core.height;
-	    geoReq.request_mode |= CWHeight;
-	}
-	if (oldw->core.border_width != w->core.border_width) {
-	    geoReq.border_width	    = w->core.border_width;
-	    w->core.border_width    = oldw->core.border_width;
-	    geoReq.request_mode	    |= CWBorderWidth;
-	}
-
-	if (geoReq.request_mode != 0) {
-	    /* Pass on any requests for unchanged geometry values */
-	    if (geoReq.request_mode !=
-		(CWX | CWY | CWWidth | CWHeight | CWBorderWidth)) {
-		for ( ; num_args != 0; num_args--, args++) {
-		    if (! (geoReq.request_mode & CWX) &&
-			strcmp(XtNx, args->name) == 0) {
-			geoReq.x = w->core.x;
-			geoReq.request_mode |= CWX;
-		    } else if (! (geoReq.request_mode & CWY) &&
-			       strcmp(XtNy, args->name) == 0) {
-			geoReq.y = w->core.y;
-			geoReq.request_mode |= CWY;
-		    } else if (! (geoReq.request_mode & CWWidth) &&
-			       strcmp(XtNwidth, args->name) == 0) {
-			geoReq.width = w->core.width;
-			geoReq.request_mode |= CWWidth;
-		    } else if (! (geoReq.request_mode & CWHeight) &&
-			       strcmp(XtNheight, args->name) == 0) {
-			geoReq.height = w->core.height;
-			geoReq.request_mode |= CWHeight;
-		    } else if (! (geoReq.request_mode & CWBorderWidth) &&
-			       strcmp(XtNborderWidth, args->name) == 0) {
-			geoReq.border_width = w->core.border_width;
-			geoReq.request_mode |= CWBorderWidth;
-		    }
-		}
-	    }
-	    CALLGEOTAT(_XtGeoTrace(w,
-		     "\nXtSetValues sees some geometry changes for \"%s\".\n",
-			   XtName(w)));
-	    CALLGEOTAT(_XtGeoTab(1));
-	    do {
-		XtGeometryHookDataRec call_data;
-		XtAlmostProc set_values_almost;
-
-		if (XtHasCallbacks(hookobj, XtNgeometryHook) == XtCallbackHasSome) {
-		    call_data.type = XtHpreGeometry;
-		    call_data.widget = w;
-		    call_data.request = &geoReq;
-		    XtCallCallbackList(hookobj,
-			((HookObject)hookobj)->hooks.geometryhook_callbacks,
-			(XtPointer)&call_data);
-		    call_data.result = result =
-			_XtMakeGeometryRequest(w, &geoReq, &geoReply,
-					       &cleared_rect_obj);
-		    call_data.type = XtHpostGeometry;
-		    call_data.reply = &geoReply;
-		    XtCallCallbackList(hookobj,
-			((HookObject)hookobj)->hooks.geometryhook_callbacks,
-			(XtPointer)&call_data);
-		} else {
-		    result = _XtMakeGeometryRequest(w, &geoReq, &geoReply,
-						    &cleared_rect_obj);
-		}
-		if (result == XtGeometryYes || result == XtGeometryDone)
-		    break;
-
-		/* An Almost or No reply.  Call widget and let it munge
-		   request, reply */
-		LOCK_PROCESS;
-		set_values_almost = wc->core_class.set_values_almost;
-		UNLOCK_PROCESS;
-		if (set_values_almost == NULL) {
-		    XtAppWarningMsg(app,
-			    "invalidProcedure","set_values_almost",
-			  XtCXtToolkitError,
-			  "set_values_almost procedure shouldn't be NULL",
-			  NULL, NULL);
-		    break;
-		}
-		if (result == XtGeometryNo) geoReply.request_mode = 0;
-		CALLGEOTAT(_XtGeoTrace(w,"calling SetValuesAlmost.\n"));
-		(*set_values_almost) (oldw, w, &geoReq, &geoReply);
-	    } while (geoReq.request_mode != 0);
-	    /* call resize proc if we changed size and parent
-	     * didn't already invoke resize */
-	    {
-	    XtWidgetProc resize;
-	    LOCK_PROCESS;
-	    resize = wc->core_class.resize;
-	    UNLOCK_PROCESS;
-	    if ((w->core.width != oldw->core.width ||
-		 w->core.height != oldw->core.height)
-		&& result != XtGeometryDone
-		&& resize != (XtWidgetProc) NULL) {
-		CALLGEOTAT(_XtGeoTrace(w,
-				 "XtSetValues calls \"%s\"'s resize proc.\n",
-			       XtName(w)));
-		(*resize)(w);
-	      }
-	    }
-	    CALLGEOTAT(_XtGeoTab(-1));
-	}
-	/* Redisplay if needed.  No point in clearing if the window is
-	 * about to disappear, as the Expose event will just go straight
-	 * to the bit bucket. */
+        /* Now perform geometry request if needed */
+        geoReq.request_mode = 0;
+        if (oldw->core.x != w->core.x) {
+            geoReq.x = w->core.x;
+            w->core.x = oldw->core.x;
+            geoReq.request_mode |= CWX;
+        }
+        if (oldw->core.y != w->core.y) {
+            geoReq.y = w->core.y;
+            w->core.y = oldw->core.y;
+            geoReq.request_mode |= CWY;
+        }
+        if (oldw->core.width != w->core.width) {
+            geoReq.width = w->core.width;
+            w->core.width = oldw->core.width;
+            geoReq.request_mode |= CWWidth;
+        }
+        if (oldw->core.height != w->core.height) {
+            geoReq.height = w->core.height;
+            w->core.height = oldw->core.height;
+            geoReq.request_mode |= CWHeight;
+        }
+        if (oldw->core.border_width != w->core.border_width) {
+            geoReq.border_width = w->core.border_width;
+            w->core.border_width = oldw->core.border_width;
+            geoReq.request_mode |= CWBorderWidth;
+        }
+
+        if (geoReq.request_mode != 0) {
+            /* Pass on any requests for unchanged geometry values */
+            if (geoReq.request_mode !=
+                (CWX | CWY | CWWidth | CWHeight | CWBorderWidth)) {
+                for (; num_args != 0; num_args--, args++) {
+                    if (!(geoReq.request_mode & CWX) &&
+                        strcmp(XtNx, args->name) == 0) {
+                        geoReq.x = w->core.x;
+                        geoReq.request_mode |= CWX;
+                    }
+                    else if (!(geoReq.request_mode & CWY) &&
+                             strcmp(XtNy, args->name) == 0) {
+                        geoReq.y = w->core.y;
+                        geoReq.request_mode |= CWY;
+                    }
+                    else if (!(geoReq.request_mode & CWWidth) &&
+                             strcmp(XtNwidth, args->name) == 0) {
+                        geoReq.width = w->core.width;
+                        geoReq.request_mode |= CWWidth;
+                    }
+                    else if (!(geoReq.request_mode & CWHeight) &&
+                             strcmp(XtNheight, args->name) == 0) {
+                        geoReq.height = w->core.height;
+                        geoReq.request_mode |= CWHeight;
+                    }
+                    else if (!(geoReq.request_mode & CWBorderWidth) &&
+                             strcmp(XtNborderWidth, args->name) == 0) {
+                        geoReq.border_width = w->core.border_width;
+                        geoReq.request_mode |= CWBorderWidth;
+                    }
+                }
+            }
+            CALLGEOTAT(_XtGeoTrace(w,
+                                   "\nXtSetValues sees some geometry changes for \"%s\".\n",
+                                   XtName(w)));
+            CALLGEOTAT(_XtGeoTab(1));
+            do {
+                XtGeometryHookDataRec call_data;
+                XtAlmostProc set_values_almost;
+
+                if (XtHasCallbacks(hookobj, XtNgeometryHook) ==
+                    XtCallbackHasSome) {
+                    call_data.type = XtHpreGeometry;
+                    call_data.widget = w;
+                    call_data.request = &geoReq;
+                    XtCallCallbackList(hookobj,
+                                       ((HookObject) hookobj)->hooks.
+                                       geometryhook_callbacks,
+                                       (XtPointer) &call_data);
+                    call_data.result = result =
+                        _XtMakeGeometryRequest(w, &geoReq, &geoReply,
+                                               &cleared_rect_obj);
+                    call_data.type = XtHpostGeometry;
+                    call_data.reply = &geoReply;
+                    XtCallCallbackList(hookobj,
+                                       ((HookObject) hookobj)->hooks.
+                                       geometryhook_callbacks,
+                                       (XtPointer) &call_data);
+                }
+                else {
+                    result = _XtMakeGeometryRequest(w, &geoReq, &geoReply,
+                                                    &cleared_rect_obj);
+                }
+                if (result == XtGeometryYes || result == XtGeometryDone)
+                    break;
+
+                /* An Almost or No reply.  Call widget and let it munge
+                   request, reply */
+                LOCK_PROCESS;
+                set_values_almost = wc->core_class.set_values_almost;
+                UNLOCK_PROCESS;
+                if (set_values_almost == NULL) {
+                    XtAppWarningMsg(app,
+                                    "invalidProcedure", "set_values_almost",
+                                    XtCXtToolkitError,
+                                    "set_values_almost procedure shouldn't be NULL",
+                                    NULL, NULL);
+                    break;
+                }
+                if (result == XtGeometryNo)
+                    geoReply.request_mode = 0;
+                CALLGEOTAT(_XtGeoTrace(w, "calling SetValuesAlmost.\n"));
+                (*set_values_almost) (oldw, w, &geoReq, &geoReply);
+            } while (geoReq.request_mode != 0);
+            /* call resize proc if we changed size and parent
+             * didn't already invoke resize */
+            {
+                XtWidgetProc resize;
+
+                LOCK_PROCESS;
+                resize = wc->core_class.resize;
+                UNLOCK_PROCESS;
+                if ((w->core.width != oldw->core.width ||
+                     w->core.height != oldw->core.height)
+                    && result != XtGeometryDone
+                    && resize != (XtWidgetProc) NULL) {
+                    CALLGEOTAT(_XtGeoTrace(w,
+                                           "XtSetValues calls \"%s\"'s resize proc.\n",
+                                           XtName(w)));
+                    (*resize) (w);
+                }
+            }
+            CALLGEOTAT(_XtGeoTab(-1));
+        }
+        /* Redisplay if needed.  No point in clearing if the window is
+         * about to disappear, as the Expose event will just go straight
+         * to the bit bucket. */
         if (XtIsWidget(w)) {
             /* widgets can distinguish between redisplay and resize, since
-             the server will cause an expose on resize */
+               the server will cause an expose on resize */
             if (redisplay && XtIsRealized(w) && !w->core.being_destroyed) {
                 CALLGEOTAT(_XtGeoTrace(w,
-				 "XtSetValues calls ClearArea on \"%s\".\n",
-			       XtName(w)));
-		XClearArea (XtDisplay(w), XtWindow(w), 0, 0, 0, 0, TRUE);
-	    }
-        } else { /*non-window object */
-	  if (redisplay && ! cleared_rect_obj ) {
-	      Widget pw = _XtWindowedAncestor(w);
-	      if (XtIsRealized(pw) && !pw->core.being_destroyed) {
-		  RectObj r = (RectObj)w;
-		  int bw2 = r->rectangle.border_width << 1;
-		  CALLGEOTAT(_XtGeoTrace(w,
-		   "XtSetValues calls ClearArea on \"%s\"'s parent \"%s\".\n",
-				 XtName(w),XtName(pw)));
-		  XClearArea (XtDisplay (pw), XtWindow (pw),
-			      r->rectangle.x, r->rectangle.y,
-			      (unsigned) (r->rectangle.width + bw2),
-			      (unsigned) (r->rectangle.height + bw2), TRUE);
-	      }
-	  }
+                                       "XtSetValues calls ClearArea on \"%s\".\n",
+                                       XtName(w)));
+                XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, TRUE);
+            }
+        }
+        else {                  /*non-window object */
+            if (redisplay && !cleared_rect_obj) {
+                Widget pw = _XtWindowedAncestor(w);
+
+                if (XtIsRealized(pw) && !pw->core.being_destroyed) {
+                    RectObj r = (RectObj) w;
+                    int bw2 = r->rectangle.border_width << 1;
+
+                    CALLGEOTAT(_XtGeoTrace(w,
+                                           "XtSetValues calls ClearArea on \"%s\"'s parent \"%s\".\n",
+                                           XtName(w), XtName(pw)));
+                    XClearArea(XtDisplay(pw), XtWindow(pw),
+                               r->rectangle.x, r->rectangle.y,
+                               (unsigned) (r->rectangle.width + bw2),
+                               (unsigned) (r->rectangle.height + bw2), TRUE);
+                }
+            }
         }
     }
 
-
     /* Free dynamic storage */
     if (constraintSize) {
         XtStackFree(oldw->core.constraints, oldcCache);
         XtStackFree(reqw->core.constraints, reqcCache);
     }
-    XtStackFree((XtPointer)oldw, oldwCache);
-    XtStackFree((XtPointer)reqw, reqwCache);
+    XtStackFree((XtPointer) oldw, oldwCache);
+    XtStackFree((XtPointer) reqw, reqwCache);
     UNLOCK_APP(app);
-} /* XtSetValues */
+}                               /* XtSetValues */
diff --git a/src/SetWMCW.c b/src/SetWMCW.c
index 8a065d7..5ea0efc 100644
--- a/src/SetWMCW.c
+++ b/src/SetWMCW.c
@@ -60,42 +60,39 @@ in this Software without prior written authorization from The Open Group.
 #include "IntrinsicI.h"
 #include <X11/Xatom.h>
 
-/*	Function Name: XtSetWMColormapWindows
+/*      Function Name: XtSetWMColormapWindows
  *
- *	Description: Sets the value of the WM_COLORMAP_WINDOWS
+ *      Description: Sets the value of the WM_COLORMAP_WINDOWS
  *                   property on a widget's window.
  *
- *	Arguments:  widget - specifies the widget on whose window the
- *   		           - WM_COLORMAP_WINDOWS property will be stored.
+ *      Arguments:  widget - specifies the widget on whose window the
+ *                         - WM_COLORMAP_WINDOWS property will be stored.
  *
  *                  list - Specifies a list of widgets whose windows are to be
- *		           listed in the WM_COLORMAP_WINDOWS property.
+ *                         listed in the WM_COLORMAP_WINDOWS property.
  *                  count - Specifies the number of widgets in list.
  *
- *	Returns: none.
+ *      Returns: none.
  */
 
 void
-XtSetWMColormapWindows(
-    Widget widget,
-    Widget *list,
-    Cardinal count)
+XtSetWMColormapWindows(Widget widget, Widget *list, Cardinal count)
 {
     Window *data;
     Widget *checked, *top, *temp, hookobj;
     Cardinal i, j, checked_count;
     Boolean match;
     Atom xa_wm_colormap_windows;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    if ( !XtIsRealized(widget) || (count == 0) ) {
-	UNLOCK_APP(app);
-	return;
+    if (!XtIsRealized(widget) || (count == 0)) {
+        UNLOCK_APP(app);
+        return;
     }
 
-    top = checked = (Widget *) __XtMalloc( (Cardinal) sizeof(Widget) * count);
-
+    top = checked = (Widget *) __XtMalloc((Cardinal) sizeof(Widget) * count);
 
 /*
  * The specification calls for only adding the windows that have unique
@@ -106,31 +103,32 @@ XtSetWMColormapWindows(
  */
 
     for (checked_count = 0, i = 0; i < count; i++) {
-	if (!XtIsRealized(list[i])) continue;
+        if (!XtIsRealized(list[i]))
+            continue;
 
-	*checked = list[i];
-	match = FALSE;
+        *checked = list[i];
+        match = FALSE;
 
 /*
  * Don't check first element for matching colormap since there is nothing
  * to check it against.
  */
 
-	if (checked != top)
-	    for (j = 0, temp = top; j < checked_count ; j++, temp++)
-		if ( (*temp)->core.colormap == (*checked)->core.colormap) {
-		    match = TRUE;
-		    break;
-		}
+        if (checked != top)
+            for (j = 0, temp = top; j < checked_count; j++, temp++)
+                if ((*temp)->core.colormap == (*checked)->core.colormap) {
+                    match = TRUE;
+                    break;
+                }
 
 /*
  * If no colormap was found to match then add this widget to the linked list.
  */
 
-	if (!match) {
-	    checked++;
-	    checked_count++;
-	}
+        if (!match) {
+            checked++;
+            checked_count++;
+        }
     }
 
 /*
@@ -138,32 +136,32 @@ XtSetWMColormapWindows(
  * windows and set the property.
  */
 
-    data = (Window *) __XtMalloc( (Cardinal) sizeof(Window) * checked_count);
+    data = (Window *) __XtMalloc((Cardinal) sizeof(Window) * checked_count);
 
-    for ( i = 0 ; i < checked_count ; i++)
-	data[i] = XtWindow(top[i]);
+    for (i = 0; i < checked_count; i++)
+        data[i] = XtWindow(top[i]);
 
     xa_wm_colormap_windows = XInternAtom(XtDisplay(widget),
-					 "WM_COLORMAP_WINDOWS", FALSE);
+                                         "WM_COLORMAP_WINDOWS", FALSE);
 
     XChangeProperty(XtDisplay(widget), XtWindow(widget),
-		    xa_wm_colormap_windows, XA_WINDOW, 32,
-		    PropModeReplace, (unsigned char *) data, (int) i);
+                    xa_wm_colormap_windows, XA_WINDOW, 32,
+                    PropModeReplace, (unsigned char *) data, (int) i);
 
     hookobj = XtHooksOfDisplay(XtDisplay(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
-
-	call_data.type = XtHsetWMColormapWindows;
-	call_data.widget = widget;
-	call_data.event_data = (XtPointer) list;
-	call_data.num_event_data = count;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        XtChangeHookDataRec call_data;
+
+        call_data.type = XtHsetWMColormapWindows;
+        call_data.widget = widget;
+        call_data.event_data = (XtPointer) list;
+        call_data.num_event_data = count;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
 
-    XtFree( (char *) data);
-    XtFree( (char *) top);
+    XtFree((char *) data);
+    XtFree((char *) top);
     UNLOCK_APP(app);
 }
diff --git a/src/Shell.c b/src/Shell.c
index 9527a6e..07713cc 100644
--- a/src/Shell.c
+++ b/src/Shell.c
@@ -120,52 +120,58 @@ static void _XtTitleEncoding(Widget, int, XrmValue *);
  *
  ***************************************************************************/
 
-#define Offset(x)	(XtOffsetOf(ShellRec, x))
+#define Offset(x)       (XtOffsetOf(ShellRec, x))
+/* *INDENT-OFF* */
 static XtResource shellResources[]=
 {
-	{XtNx, XtCPosition, XtRPosition, sizeof(Position),
-	    Offset(core.x), XtRImmediate, (XtPointer)BIGSIZE},
-	{XtNy, XtCPosition, XtRPosition, sizeof(Position),
-	    Offset(core.y), XtRImmediate, (XtPointer)BIGSIZE},
-	{ XtNdepth, XtCDepth, XtRInt, sizeof(int),
-	    Offset(core.depth), XtRCallProc, (XtPointer) _XtShellDepth},
-	{ XtNcolormap, XtCColormap, XtRColormap, sizeof(Colormap),
-	    Offset(core.colormap), XtRCallProc, (XtPointer) _XtShellColormap},
-	{ XtNancestorSensitive, XtCSensitive, XtRBoolean, sizeof(Boolean),
-	    Offset(core.ancestor_sensitive), XtRCallProc,
-	    (XtPointer) _XtShellAncestorSensitive},
-	{ XtNallowShellResize, XtCAllowShellResize, XtRBoolean,
-	    sizeof(Boolean), Offset(shell.allow_shell_resize),
-	    XtRImmediate, (XtPointer)False},
-	{ XtNgeometry, XtCGeometry, XtRString, sizeof(String),
-	    Offset(shell.geometry), XtRString, (XtPointer)NULL},
-	{ XtNcreatePopupChildProc, XtCCreatePopupChildProc, XtRFunction,
-	    sizeof(XtCreatePopupChildProc), Offset(shell.create_popup_child_proc),
-	    XtRFunction, NULL},
-	{ XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
-	    Offset(shell.save_under), XtRImmediate, (XtPointer)False},
-	{ XtNpopupCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
-	    Offset(shell.popup_callback), XtRCallback, (XtPointer) NULL},
-	{ XtNpopdownCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
-	    Offset(shell.popdown_callback), XtRCallback, (XtPointer) NULL},
-	{ XtNoverrideRedirect, XtCOverrideRedirect,
-	    XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
-	    XtRImmediate, (XtPointer)False},
-	{ XtNvisual, XtCVisual, XtRVisual, sizeof(Visual*),
-	    Offset(shell.visual), XtRImmediate, (XtPointer)CopyFromParent}
+    {XtNx, XtCPosition, XtRPosition, sizeof(Position),
+        Offset(core.x), XtRImmediate, (XtPointer)BIGSIZE},
+    {XtNy, XtCPosition, XtRPosition, sizeof(Position),
+        Offset(core.y), XtRImmediate, (XtPointer)BIGSIZE},
+    { XtNdepth, XtCDepth, XtRInt, sizeof(int),
+        Offset(core.depth), XtRCallProc, (XtPointer) _XtShellDepth},
+    { XtNcolormap, XtCColormap, XtRColormap, sizeof(Colormap),
+        Offset(core.colormap), XtRCallProc, (XtPointer) _XtShellColormap},
+    { XtNancestorSensitive, XtCSensitive, XtRBoolean, sizeof(Boolean),
+        Offset(core.ancestor_sensitive), XtRCallProc,
+        (XtPointer) _XtShellAncestorSensitive},
+    { XtNallowShellResize, XtCAllowShellResize, XtRBoolean,
+        sizeof(Boolean), Offset(shell.allow_shell_resize),
+        XtRImmediate, (XtPointer)False},
+    { XtNgeometry, XtCGeometry, XtRString, sizeof(String),
+        Offset(shell.geometry), XtRString, (XtPointer)NULL},
+    { XtNcreatePopupChildProc, XtCCreatePopupChildProc, XtRFunction,
+        sizeof(XtCreatePopupChildProc), Offset(shell.create_popup_child_proc),
+        XtRFunction, NULL},
+    { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
+        Offset(shell.save_under), XtRImmediate, (XtPointer)False},
+    { XtNpopupCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+        Offset(shell.popup_callback), XtRCallback, (XtPointer) NULL},
+    { XtNpopdownCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+        Offset(shell.popdown_callback), XtRCallback, (XtPointer) NULL},
+    { XtNoverrideRedirect, XtCOverrideRedirect,
+        XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
+        XtRImmediate, (XtPointer)False},
+    { XtNvisual, XtCVisual, XtRVisual, sizeof(Visual*),
+        Offset(shell.visual), XtRImmediate, (XtPointer)CopyFromParent}
 };
+/* *INDENT-ON* */
 
 static void ClassPartInitialize(WidgetClass);
 static void Initialize(Widget, Widget, ArgList, Cardinal *);
 static void Realize(Widget, Mask *, XSetWindowAttributes *);
 static void Resize(Widget);
-static Boolean SetValues(Widget, Widget, Widget, ArgList , Cardinal *);
-static void GetValuesHook(Widget, ArgList, Cardinal*);
+static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void GetValuesHook(Widget, ArgList, Cardinal *);
 static void ChangeManaged(Widget);
-static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *, XtWidgetGeometry *);
-static XtGeometryResult RootGeometryManager(Widget gw, XtWidgetGeometry *request, XtWidgetGeometry *reply);
+static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *,
+                                        XtWidgetGeometry *);
+static XtGeometryResult RootGeometryManager(Widget gw,
+                                            XtWidgetGeometry *request,
+                                            XtWidgetGeometry *reply);
 static void Destroy(Widget);
 
+/* *INDENT-OFF* */
 static ShellClassExtensionRec shellClassExtRec = {
     NULL,
     NULLQUARK,
@@ -176,50 +182,52 @@ static ShellClassExtensionRec shellClassExtRec = {
 
 externaldef(shellclassrec) ShellClassRec shellClassRec = {
   {   /* Core */
-    /* superclass	  */	(WidgetClass) &compositeClassRec,
-    /* class_name	  */	"Shell",
-    /* size		  */	sizeof(ShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	ClassPartInitialize,
-    /* Class init'ed ?	  */	FALSE,
-    /* initialize	  */	Initialize,
-    /* initialize_notify  */	NULL,
-    /* realize		  */	Realize,
-    /* actions		  */	NULL,
-    /* num_actions	  */	0,
-    /* resources	  */	shellResources,
-    /* resource_count	  */	XtNumber(shellResources),
-    /* xrm_class	  */	NULLQUARK,
-    /* compress_motion	  */	FALSE,
-    /* compress_exposure  */	TRUE,
-    /* compress_enterleave*/	FALSE,
-    /* visible_interest	  */	FALSE,
-    /* destroy		  */	Destroy,
-    /* resize		  */	Resize,
-    /* expose		  */	NULL,
-    /* set_values	  */	SetValues,
-    /* set_values_hook	  */	NULL,
-    /* set_values_almost  */	XtInheritSetValuesAlmost,
-    /* get_values_hook	  */	GetValuesHook,
-    /* accept_focus	  */	NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets	  */	NULL,
-    /* tm_table		  */	NULL,
-    /* query_geometry	  */	NULL,
-    /* display_accelerator*/	NULL,
-    /* extension	  */	NULL
+    /* superclass            */ (WidgetClass) &compositeClassRec,
+    /* class_name            */ "Shell",
+    /* size                  */ sizeof(ShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ ClassPartInitialize,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ Initialize,
+    /* initialize_notify     */ NULL,
+    /* realize               */ Realize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ shellResources,
+    /* resource_count        */ XtNumber(shellResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ Destroy,
+    /* resize                */ Resize,
+    /* expose                */ NULL,
+    /* set_values            */ SetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ GetValuesHook,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ NULL,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{ /* Composite */
-    /* geometry_manager	  */	GeometryManager,
-    /* change_managed	  */	ChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	  */	NULL
+    /* geometry_manager      */ GeometryManager,
+    /* change_managed        */ ChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ NULL
   },{ /* Shell */
-    /* extension	  */	(XtPointer)&shellClassExtRec
+    /* extension             */ (XtPointer)&shellClassExtRec
   }
 };
+/* *INDENT-ON* */
 
-externaldef(shellwidgetclass) WidgetClass shellWidgetClass = (WidgetClass) (&shellClassRec);
+externaldef(shellwidgetclass)
+WidgetClass shellWidgetClass = (WidgetClass) (&shellClassRec);
 
 /***************************************************************************
  *
@@ -227,64 +235,66 @@ externaldef(shellwidgetclass) WidgetClass shellWidgetClass = (WidgetClass) (&she
  *
  ***************************************************************************/
 
-static XtResource overrideResources[]=
+/* *INDENT-OFF* */
+static XtResource overrideResources[] =
 {
-	{ XtNoverrideRedirect, XtCOverrideRedirect,
-	    XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
-	    XtRImmediate, (XtPointer)True},
-	{ XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
-	    Offset(shell.save_under), XtRImmediate, (XtPointer)True},
+    { XtNoverrideRedirect, XtCOverrideRedirect,
+        XtRBoolean, sizeof(Boolean), Offset(shell.override_redirect),
+        XtRImmediate, (XtPointer)True},
+    { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
+        Offset(shell.save_under), XtRImmediate, (XtPointer)True},
 };
 
 externaldef(overrideshellclassrec) OverrideShellClassRec overrideShellClassRec = {
   {
-    /* superclass         */    (WidgetClass) &shellClassRec,
-    /* class_name         */    "OverrideShell",
-    /* size               */    sizeof(OverrideShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    NULL,
-    /* initialize_notify    */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    overrideResources,
-    /* resource_count     */	XtNumber(overrideResources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/ 	FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    NULL,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    NULL,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		    */  NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension	    */  NULL
+    /* superclass            */ (WidgetClass) &shellClassRec,
+    /* class_name            */ "OverrideShell",
+    /* size                  */ sizeof(OverrideShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ NULL,
+    /* initialize_notify     */ NULL,
+    /* realize               */ XtInheritRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ overrideResources,
+    /* resource_count        */ XtNumber(overrideResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ NULL,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ NULL,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ NULL,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	    */  NULL
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(overrideshellwidgetclass) WidgetClass overrideShellWidgetClass =
-	(WidgetClass) (&overrideShellClassRec);
+externaldef(overrideshellwidgetclass)
+WidgetClass overrideShellWidgetClass = (WidgetClass) (&overrideShellClassRec);
 
 /***************************************************************************
  *
@@ -293,148 +303,157 @@ externaldef(overrideshellwidgetclass) WidgetClass overrideShellWidgetClass =
  ***************************************************************************/
 
 #undef Offset
-#define Offset(x)	(XtOffsetOf(WMShellRec, x))
+#define Offset(x)       (XtOffsetOf(WMShellRec, x))
 
 static int default_unspecified_shell_int = XtUnspecifiedShellInt;
+
 /*
  * Warning, casting XtUnspecifiedShellInt (which is -1) to an (XtPointer)
  * can result is loss of bits on some machines (i.e. crays)
  */
 
-static XtResource wmResources[]=
-{
-	{ XtNtitle, XtCTitle, XtRString, sizeof(String),
-	    Offset(wm.title), XtRString, NULL},
-	{ XtNtitleEncoding, XtCTitleEncoding, XtRAtom, sizeof(Atom),
-	    Offset(wm.title_encoding),
-	    XtRCallProc, (XtPointer) _XtTitleEncoding},
-	{ XtNwmTimeout, XtCWmTimeout, XtRInt, sizeof(int),
-	    Offset(wm.wm_timeout), XtRImmediate,(XtPointer)DEFAULT_WM_TIMEOUT},
-	{ XtNwaitForWm, XtCWaitForWm, XtRBoolean, sizeof(Boolean),
-	    Offset(wm.wait_for_wm), XtRImmediate, (XtPointer)True},
-	{ XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
-	    Offset(wm.transient), XtRImmediate, (XtPointer)False},
+/* *INDENT-OFF* */
+static XtResource wmResources[] =
+{
+    { XtNtitle, XtCTitle, XtRString, sizeof(String),
+        Offset(wm.title), XtRString, NULL},
+    { XtNtitleEncoding, XtCTitleEncoding, XtRAtom, sizeof(Atom),
+        Offset(wm.title_encoding),
+        XtRCallProc, (XtPointer) _XtTitleEncoding},
+    { XtNwmTimeout, XtCWmTimeout, XtRInt, sizeof(int),
+        Offset(wm.wm_timeout), XtRImmediate,(XtPointer)DEFAULT_WM_TIMEOUT},
+    { XtNwaitForWm, XtCWaitForWm, XtRBoolean, sizeof(Boolean),
+        Offset(wm.wait_for_wm), XtRImmediate, (XtPointer)True},
+    { XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
+        Offset(wm.transient), XtRImmediate, (XtPointer)False},
 /* size_hints minus things stored in core */
-	{ XtNbaseWidth, XtCBaseWidth, XtRInt, sizeof(int),
-	    Offset(wm.base_width),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNbaseHeight, XtCBaseHeight, XtRInt, sizeof(int),
-	    Offset(wm.base_height),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNwinGravity, XtCWinGravity, XtRGravity, sizeof(int),
-	    Offset(wm.win_gravity),
-	    XtRGravity, (XtPointer) &default_unspecified_shell_int},
-	{ XtNminWidth, XtCMinWidth, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.min_width),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNminHeight, XtCMinHeight, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.min_height),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNmaxWidth, XtCMaxWidth, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.max_width),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNmaxHeight, XtCMaxHeight, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.max_height),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNwidthInc, XtCWidthInc, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.width_inc),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNheightInc, XtCHeightInc, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.height_inc),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNminAspectX, XtCMinAspectX, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.min_aspect.x),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNminAspectY, XtCMinAspectY, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.min_aspect.y),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNmaxAspectX, XtCMaxAspectX, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.max_aspect.x),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNmaxAspectY, XtCMaxAspectY, XtRInt, sizeof(int),
-	    Offset(wm.size_hints.max_aspect.y),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNbaseWidth, XtCBaseWidth, XtRInt, sizeof(int),
+        Offset(wm.base_width),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNbaseHeight, XtCBaseHeight, XtRInt, sizeof(int),
+        Offset(wm.base_height),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNwinGravity, XtCWinGravity, XtRGravity, sizeof(int),
+        Offset(wm.win_gravity),
+        XtRGravity, (XtPointer) &default_unspecified_shell_int},
+    { XtNminWidth, XtCMinWidth, XtRInt, sizeof(int),
+        Offset(wm.size_hints.min_width),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNminHeight, XtCMinHeight, XtRInt, sizeof(int),
+        Offset(wm.size_hints.min_height),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNmaxWidth, XtCMaxWidth, XtRInt, sizeof(int),
+        Offset(wm.size_hints.max_width),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNmaxHeight, XtCMaxHeight, XtRInt, sizeof(int),
+        Offset(wm.size_hints.max_height),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNwidthInc, XtCWidthInc, XtRInt, sizeof(int),
+        Offset(wm.size_hints.width_inc),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNheightInc, XtCHeightInc, XtRInt, sizeof(int),
+        Offset(wm.size_hints.height_inc),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNminAspectX, XtCMinAspectX, XtRInt, sizeof(int),
+        Offset(wm.size_hints.min_aspect.x),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNminAspectY, XtCMinAspectY, XtRInt, sizeof(int),
+        Offset(wm.size_hints.min_aspect.y),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNmaxAspectX, XtCMaxAspectX, XtRInt, sizeof(int),
+        Offset(wm.size_hints.max_aspect.x),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNmaxAspectY, XtCMaxAspectY, XtRInt, sizeof(int),
+        Offset(wm.size_hints.max_aspect.y),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
 /* wm_hints */
-	{ XtNinput, XtCInput, XtRBool, sizeof(Bool),
-	    Offset(wm.wm_hints.input), XtRImmediate, (XtPointer)False},
-	{ XtNinitialState, XtCInitialState, XtRInitialState, sizeof(int),
-	    Offset(wm.wm_hints.initial_state),
-	    XtRImmediate, (XtPointer)NormalState},
-	{ XtNiconPixmap, XtCIconPixmap, XtRBitmap, sizeof(Pixmap),
-	    Offset(wm.wm_hints.icon_pixmap), XtRPixmap, NULL},
-	{ XtNiconWindow, XtCIconWindow, XtRWindow, sizeof(Window),
-	    Offset(wm.wm_hints.icon_window), XtRWindow,   (XtPointer) NULL},
-	{ XtNiconX, XtCIconX, XtRInt, sizeof(int),
-	    Offset(wm.wm_hints.icon_x),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNiconY, XtCIconY, XtRInt, sizeof(int),
-	    Offset(wm.wm_hints.icon_y),
-	    XtRInt, (XtPointer) &default_unspecified_shell_int},
-	{ XtNiconMask, XtCIconMask, XtRBitmap, sizeof(Pixmap),
-	    Offset(wm.wm_hints.icon_mask), XtRPixmap, NULL},
-	{ XtNwindowGroup, XtCWindowGroup, XtRWindow, sizeof(Window),
-	    Offset(wm.wm_hints.window_group),
-	    XtRImmediate, (XtPointer)XtUnspecifiedWindow},
-	{ XtNclientLeader, XtCClientLeader, XtRWidget, sizeof(Widget),
-	    Offset(wm.client_leader), XtRWidget, NULL},
-	{ XtNwindowRole, XtCWindowRole, XtRString, sizeof(String),
-	    Offset(wm.window_role), XtRString, (XtPointer) NULL},
-	{ XtNurgency, XtCUrgency, XtRBoolean, sizeof(Boolean),
-	    Offset(wm.urgency), XtRImmediate, (XtPointer) False}
+    { XtNinput, XtCInput, XtRBool, sizeof(Bool),
+        Offset(wm.wm_hints.input), XtRImmediate, (XtPointer)False},
+    { XtNinitialState, XtCInitialState, XtRInitialState, sizeof(int),
+        Offset(wm.wm_hints.initial_state),
+        XtRImmediate, (XtPointer)NormalState},
+    { XtNiconPixmap, XtCIconPixmap, XtRBitmap, sizeof(Pixmap),
+        Offset(wm.wm_hints.icon_pixmap), XtRPixmap, NULL},
+    { XtNiconWindow, XtCIconWindow, XtRWindow, sizeof(Window),
+        Offset(wm.wm_hints.icon_window), XtRWindow,   (XtPointer) NULL},
+    { XtNiconX, XtCIconX, XtRInt, sizeof(int),
+        Offset(wm.wm_hints.icon_x),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNiconY, XtCIconY, XtRInt, sizeof(int),
+        Offset(wm.wm_hints.icon_y),
+        XtRInt, (XtPointer) &default_unspecified_shell_int},
+    { XtNiconMask, XtCIconMask, XtRBitmap, sizeof(Pixmap),
+        Offset(wm.wm_hints.icon_mask), XtRPixmap, NULL},
+    { XtNwindowGroup, XtCWindowGroup, XtRWindow, sizeof(Window),
+        Offset(wm.wm_hints.window_group),
+        XtRImmediate, (XtPointer)XtUnspecifiedWindow},
+    { XtNclientLeader, XtCClientLeader, XtRWidget, sizeof(Widget),
+        Offset(wm.client_leader), XtRWidget, NULL},
+    { XtNwindowRole, XtCWindowRole, XtRString, sizeof(String),
+        Offset(wm.window_role), XtRString, (XtPointer) NULL},
+    { XtNurgency, XtCUrgency, XtRBoolean, sizeof(Boolean),
+        Offset(wm.urgency), XtRImmediate, (XtPointer) False}
 };
+/* *INDENT-ON* */
 
-static void WMInitialize(Widget, Widget, ArgList, Cardinal *);
-static Boolean WMSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
-static void WMDestroy(Widget);
+static void
+WMInitialize(Widget, Widget, ArgList, Cardinal *);
+static Boolean
+WMSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void
+WMDestroy(Widget);
 
+/* *INDENT-OFF* */
 externaldef(wmshellclassrec) WMShellClassRec wmShellClassRec = {
   {
-    /* superclass         */    (WidgetClass) &shellClassRec,
-    /* class_name         */    "WMShell",
-    /* size               */    sizeof(WMShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    WMInitialize,
-    /* initialize_notify    */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    wmResources,
-    /* resource_count     */	XtNumber(wmResources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/	FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    WMDestroy,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    WMSetValues,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		    */  NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension	    */  NULL
+    /* superclass            */ (WidgetClass) &shellClassRec,
+    /* class_name            */ "WMShell",
+    /* size                  */ sizeof(WMShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ WMInitialize,
+    /* initialize_notify     */ NULL,
+    /* realize               */ XtInheritRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ wmResources,
+    /* resource_count        */ XtNumber(wmResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ WMDestroy,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ WMSetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ NULL,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	    */  NULL
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(wmshellwidgetclass) WidgetClass wmShellWidgetClass = (WidgetClass) (&wmShellClassRec);
+externaldef(wmshellwidgetclass)
+WidgetClass wmShellWidgetClass = (WidgetClass) (&wmShellClassRec);
 
 /***************************************************************************
  *
@@ -443,74 +462,80 @@ externaldef(wmshellwidgetclass) WidgetClass wmShellWidgetClass = (WidgetClass) (
  ***************************************************************************/
 
 #undef Offset
-#define Offset(x)	(XtOffsetOf(TransientShellRec, x))
+#define Offset(x)       (XtOffsetOf(TransientShellRec, x))
 
+/* *INDENT-OFF* */
 static XtResource transientResources[]=
 {
-	{ XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
-	    Offset(wm.transient), XtRImmediate, (XtPointer)True},
-	{ XtNtransientFor, XtCTransientFor, XtRWidget, sizeof(Widget),
-	    Offset(transient.transient_for), XtRWidget, NULL},
-	{ XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
-	    Offset(shell.save_under), XtRImmediate, (XtPointer)True},
+    { XtNtransient, XtCTransient, XtRBoolean, sizeof(Boolean),
+        Offset(wm.transient), XtRImmediate, (XtPointer)True},
+    { XtNtransientFor, XtCTransientFor, XtRWidget, sizeof(Widget),
+        Offset(transient.transient_for), XtRWidget, NULL},
+    { XtNsaveUnder, XtCSaveUnder, XtRBoolean, sizeof(Boolean),
+        Offset(shell.save_under), XtRImmediate, (XtPointer)True},
 };
+/* *INDENT-ON* */
 
-static void TransientRealize(Widget, Mask *, XSetWindowAttributes *);
-static Boolean TransientSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void
+TransientRealize(Widget, Mask *, XSetWindowAttributes *);
+static Boolean
+TransientSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
 
+/* *INDENT-OFF* */
 externaldef(transientshellclassrec) TransientShellClassRec transientShellClassRec = {
   {
-    /* superclass	  */	(WidgetClass) &vendorShellClassRec,
-    /* class_name	  */	"TransientShell",
-    /* size		  */	sizeof(TransientShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?	  */	FALSE,
-    /* initialize	  */	NULL,
-    /* initialize_notify  */	NULL,
-    /* realize		  */	TransientRealize,
-    /* actions		  */	NULL,
-    /* num_actions	  */	0,
-    /* resources	  */	transientResources,
-    /* resource_count	  */	XtNumber(transientResources),
-    /* xrm_class	  */	NULLQUARK,
-    /* compress_motion	  */	FALSE,
-    /* compress_exposure  */	TRUE,
-    /* compress_enterleave*/	FALSE,
-    /* visible_interest	  */	FALSE,
-    /* destroy		  */	NULL,
-    /* resize		  */	XtInheritResize,
-    /* expose		  */	NULL,
-    /* set_values	  */	TransientSetValues,
-    /* set_values_hook	  */	NULL,
-    /* set_values_almost  */	XtInheritSetValuesAlmost,
-    /* get_values_hook	  */	NULL,
-    /* accept_focus	  */	NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets	  */	NULL,
-    /* tm_table		  */	XtInheritTranslations,
-    /* query_geometry	  */	NULL,
-    /* display_accelerator*/	NULL,
-    /* extension	  */	NULL
+    /* superclass            */ (WidgetClass) &vendorShellClassRec,
+    /* class_name            */ "TransientShell",
+    /* size                  */ sizeof(TransientShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ NULL,
+    /* initialize_notify     */ NULL,
+    /* realize               */ TransientRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ transientResources,
+    /* resource_count        */ XtNumber(transientResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ NULL,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ TransientSetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ XtInheritTranslations,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager	  */	XtInheritGeometryManager,
-    /* change_managed	  */	XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	  */	NULL
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(transientshellwidgetclass) WidgetClass transientShellWidgetClass =
-	(WidgetClass) (&transientShellClassRec);
+externaldef(transientshellwidgetclass)
+WidgetClass transientShellWidgetClass = (WidgetClass) (&transientShellClassRec);
 
 /***************************************************************************
  *
@@ -519,76 +544,83 @@ externaldef(transientshellwidgetclass) WidgetClass transientShellWidgetClass =
  ***************************************************************************/
 
 #undef Offset
-#define Offset(x)	(XtOffsetOf(TopLevelShellRec, x))
+#define Offset(x)       (XtOffsetOf(TopLevelShellRec, x))
 
+/* *INDENT-OFF* */
 static XtResource topLevelResources[]=
 {
-	{ XtNiconName, XtCIconName, XtRString, sizeof(String),
-	    Offset(topLevel.icon_name), XtRString, (XtPointer) NULL},
-	{ XtNiconNameEncoding, XtCIconNameEncoding, XtRAtom, sizeof(Atom),
-	    Offset(topLevel.icon_name_encoding),
-	    XtRCallProc, (XtPointer) _XtTitleEncoding},
-	{ XtNiconic, XtCIconic, XtRBoolean, sizeof(Boolean),
-	    Offset(topLevel.iconic), XtRImmediate, (XtPointer)False}
+    { XtNiconName, XtCIconName, XtRString, sizeof(String),
+        Offset(topLevel.icon_name), XtRString, (XtPointer) NULL},
+    { XtNiconNameEncoding, XtCIconNameEncoding, XtRAtom, sizeof(Atom),
+        Offset(topLevel.icon_name_encoding),
+        XtRCallProc, (XtPointer) _XtTitleEncoding},
+    { XtNiconic, XtCIconic, XtRBoolean, sizeof(Boolean),
+        Offset(topLevel.iconic), XtRImmediate, (XtPointer)False}
 };
+/* *INDENT-ON* */
 
-static void TopLevelInitialize(Widget, Widget, ArgList, Cardinal *);
-static Boolean TopLevelSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
-static void TopLevelDestroy(Widget);
+static void
+TopLevelInitialize(Widget, Widget, ArgList, Cardinal *);
+static Boolean
+TopLevelSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void
+TopLevelDestroy(Widget);
 
+/* *INDENT-OFF* */
 externaldef(toplevelshellclassrec) TopLevelShellClassRec topLevelShellClassRec = {
   {
-    /* superclass         */    (WidgetClass) &vendorShellClassRec,
-    /* class_name         */    "TopLevelShell",
-    /* size               */    sizeof(TopLevelShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    TopLevelInitialize,
-    /* initialize_notify    */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    topLevelResources,
-    /* resource_count     */	XtNumber(topLevelResources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/ 	FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    TopLevelDestroy,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    TopLevelSetValues,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		    */  XtInheritTranslations,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension	    */  NULL
+    /* superclass            */ (WidgetClass) &vendorShellClassRec,
+    /* class_name            */ "TopLevelShell",
+    /* size                  */ sizeof(TopLevelShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ TopLevelInitialize,
+    /* initialize_notify     */ NULL,
+    /* realize               */ XtInheritRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ topLevelResources,
+    /* resource_count        */ XtNumber(topLevelResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ TopLevelDestroy,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ TopLevelSetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ XtInheritTranslations,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	    */  NULL
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   },{
-    /* extension	    */  NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(toplevelshellwidgetclass) WidgetClass topLevelShellWidgetClass =
-	(WidgetClass) (&topLevelShellClassRec);
+externaldef(toplevelshellwidgetclass)
+WidgetClass topLevelShellWidgetClass = (WidgetClass) (&topLevelShellClassRec);
 
 /***************************************************************************
  *
@@ -597,87 +629,95 @@ externaldef(toplevelshellwidgetclass) WidgetClass topLevelShellWidgetClass =
  ***************************************************************************/
 
 #undef Offset
-#define Offset(x)	(XtOffsetOf(ApplicationShellRec, x))
+#define Offset(x)       (XtOffsetOf(ApplicationShellRec, x))
 
+/* *INDENT-OFF* */
 static XtResource applicationResources[]=
 {
     {XtNargc, XtCArgc, XtRInt, sizeof(int),
-	  Offset(application.argc), XtRImmediate, (XtPointer)0},
+          Offset(application.argc), XtRImmediate, (XtPointer)0},
     {XtNargv, XtCArgv, XtRStringArray, sizeof(String*),
-	  Offset(application.argv), XtRPointer, (XtPointer) NULL}
+          Offset(application.argv), XtRPointer, (XtPointer) NULL}
 };
+/* *INDENT-ON* */
 #undef Offset
 
-static void ApplicationInitialize(Widget, Widget, ArgList, Cardinal *);
-static void ApplicationDestroy(Widget);
-static Boolean ApplicationSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
-static void ApplicationShellInsertChild(Widget);
+static void
+ApplicationInitialize(Widget, Widget, ArgList, Cardinal *);
+static void
+ApplicationDestroy(Widget);
+static Boolean
+ApplicationSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void
+ApplicationShellInsertChild(Widget);
 
+/* *INDENT-OFF* */
 static CompositeClassExtensionRec compositeClassExtension = {
-    /* next_extension	*/	NULL,
-    /* record_type	*/	NULLQUARK,
-    /* version		*/	XtCompositeExtensionVersion,
-    /* record_size	*/	sizeof(CompositeClassExtensionRec),
-    /* accepts_objects	*/	TRUE,
+    /* next_extension        */ NULL,
+    /* record_type           */ NULLQUARK,
+    /* version               */ XtCompositeExtensionVersion,
+    /* record_size           */ sizeof(CompositeClassExtensionRec),
+    /* accepts_objects       */ TRUE,
     /* allows_change_managed_set */ FALSE
 };
 
-
 externaldef(applicationshellclassrec) ApplicationShellClassRec applicationShellClassRec = {
   {
-    /* superclass         */    (WidgetClass) &topLevelShellClassRec,
-    /* class_name         */    "ApplicationShell",
-    /* size               */    sizeof(ApplicationShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    ApplicationInitialize,
-    /* initialize_notify  */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    applicationResources,
-    /* resource_count     */	XtNumber(applicationResources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/    FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    ApplicationDestroy,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    ApplicationSetValues,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */	XtInheritSetValuesAlmost,
-    /* get_values_hook    */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		  */	XtInheritTranslations,
-    /* query_geometry	  */	NULL,
-    /* display_accelerator*/	NULL,
-    /* extension	  */	NULL
+    /* superclass            */ (WidgetClass) &topLevelShellClassRec,
+    /* class_name            */ "ApplicationShell",
+    /* size                  */ sizeof(ApplicationShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize*/  NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ ApplicationInitialize,
+    /* initialize_notify     */ NULL,
+    /* realize               */ XtInheritRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ applicationResources,
+    /* resource_count        */ XtNumber(applicationResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ ApplicationDestroy,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ ApplicationSetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ XtInheritTranslations,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	ApplicationShellInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	  */	(XtPointer)&compositeClassExtension
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ ApplicationShellInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ (XtPointer)&compositeClassExtension
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(applicationshellwidgetclass) WidgetClass applicationShellWidgetClass =
-	(WidgetClass) (&applicationShellClassRec);
+externaldef(applicationshellwidgetclass)
+WidgetClass applicationShellWidgetClass =
+    (WidgetClass) (&applicationShellClassRec);
 
 /***************************************************************************
  *
@@ -686,8 +726,9 @@ externaldef(applicationshellwidgetclass) WidgetClass applicationShellWidgetClass
  ***************************************************************************/
 
 #undef Offset
-#define Offset(x)	(XtOffsetOf(SessionShellRec, x))
+#define Offset(x)       (XtOffsetOf(SessionShellRec, x))
 
+/* *INDENT-OFF* */
 static XtResource sessionResources[]=
 {
 #ifndef XT_NO_SM
@@ -730,346 +771,350 @@ static XtResource sessionResources[]=
  {XtNerrorCallback, XtCCallback, XtRCallback, sizeof(XtPointer),
        Offset(session.error_callbacks), XtRCallback, (XtPointer) NULL}
 };
+/* *INDENT-ON* */
 #undef Offset
 
-static void SessionInitialize(Widget, Widget, ArgList, Cardinal *);
-static void SessionDestroy(Widget);
-static Boolean SessionSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
+static void
+SessionInitialize(Widget, Widget, ArgList, Cardinal *);
+static void
+SessionDestroy(Widget);
+static Boolean
+SessionSetValues(Widget, Widget, Widget, ArgList, Cardinal *);
 
+/* *INDENT-OFF* */
 static CompositeClassExtensionRec sessionCompositeClassExtension = {
-    /* next_extension	*/	NULL,
-    /* record_type	*/	NULLQUARK,
-    /* version		*/	XtCompositeExtensionVersion,
-    /* record_size	*/	sizeof(CompositeClassExtensionRec),
-    /* accepts_objects	*/	TRUE,
+    /* next_extension        */ NULL,
+    /* record_type           */ NULLQUARK,
+    /* version               */ XtCompositeExtensionVersion,
+    /* record_size           */ sizeof(CompositeClassExtensionRec),
+    /* accepts_objects       */ TRUE,
     /* allows_change_managed_set */ FALSE
 };
 
-
 externaldef(sessionshellclassrec) SessionShellClassRec sessionShellClassRec = {
   {
-    /* superclass         */    (WidgetClass) &applicationShellClassRec,
-    /* class_name         */    "SessionShell",
-    /* size               */    sizeof(SessionShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    SessionInitialize,
-    /* initialize_notify  */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    sessionResources,
-    /* resource_count     */	XtNumber(sessionResources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/    FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    SessionDestroy,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    SessionSetValues,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */	XtInheritSetValuesAlmost,
-    /* get_values_hook    */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		  */	XtInheritTranslations,
-    /* query_geometry	  */	NULL,
-    /* display_accelerator*/	NULL,
-    /* extension	  */	NULL
+    /* superclass            */ (WidgetClass) &applicationShellClassRec,
+    /* class_name            */ "SessionShell",
+    /* size                  */ sizeof(SessionShellRec),
+    /* Class Initializer     */ NULL,
+    /* class_part_initialize */ NULL,
+    /* Class init'ed ?       */ FALSE,
+    /* initialize            */ SessionInitialize,
+    /* initialize_notify     */ NULL,
+    /* realize               */ XtInheritRealize,
+    /* actions               */ NULL,
+    /* num_actions           */ 0,
+    /* resources             */ sessionResources,
+    /* resource_count        */ XtNumber(sessionResources),
+    /* xrm_class             */ NULLQUARK,
+    /* compress_motion       */ FALSE,
+    /* compress_exposure     */ TRUE,
+    /* compress_enterleave   */ FALSE,
+    /* visible_interest      */ FALSE,
+    /* destroy               */ SessionDestroy,
+    /* resize                */ XtInheritResize,
+    /* expose                */ NULL,
+    /* set_values            */ SessionSetValues,
+    /* set_values_hook       */ NULL,
+    /* set_values_almost     */ XtInheritSetValuesAlmost,
+    /* get_values_hook       */ NULL,
+    /* accept_focus          */ NULL,
+    /* intrinsics version    */ XtVersion,
+    /* callback offsets      */ NULL,
+    /* tm_table              */ XtInheritTranslations,
+    /* query_geometry        */ NULL,
+    /* display_accelerator   */ NULL,
+    /* extension             */ NULL
   },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	  */	(XtPointer)&sessionCompositeClassExtension
+    /* geometry_manager      */ XtInheritGeometryManager,
+    /* change_managed        */ XtInheritChangeManaged,
+    /* insert_child          */ XtInheritInsertChild,
+    /* delete_child          */ XtInheritDeleteChild,
+    /* extension             */ (XtPointer)&sessionCompositeClassExtension
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension	  */	NULL
+    /* extension             */ NULL
   },{
-    /* extension          */    NULL
+    /* extension             */ NULL
   }
 };
+/* *INDENT-ON* */
 
-externaldef(sessionshellwidgetclass) WidgetClass sessionShellWidgetClass =
-	(WidgetClass) (&sessionShellClassRec);
+externaldef(sessionshellwidgetclass)
+WidgetClass sessionShellWidgetClass = (WidgetClass) (&sessionShellClassRec);
 
 /****************************************************************************
  * Whew!
  ****************************************************************************/
 
-static void ComputeWMSizeHints(
-    WMShellWidget w,
-    XSizeHints *hints)
+static void
+ComputeWMSizeHints(WMShellWidget w, XSizeHints *hints)
 {
     register long flags;
+
     hints->flags = flags = w->wm.size_hints.flags;
 #define copy(field) hints->field = w->wm.size_hints.field
     if (flags & (USPosition | PPosition)) {
-	copy(x);
-	copy(y);
+        copy(x);
+        copy(y);
     }
     if (flags & (USSize | PSize)) {
-	copy(width);
-	copy(height);
+        copy(width);
+        copy(height);
     }
     if (flags & PMinSize) {
-	copy(min_width);
-	copy(min_height);
+        copy(min_width);
+        copy(min_height);
     }
     if (flags & PMaxSize) {
-	copy(max_width);
-	copy(max_height);
+        copy(max_width);
+        copy(max_height);
     }
     if (flags & PResizeInc) {
-	copy(width_inc);
-	copy(height_inc);
+        copy(width_inc);
+        copy(height_inc);
     }
     if (flags & PAspect) {
-	copy(min_aspect.x);
-	copy(min_aspect.y);
-	copy(max_aspect.x);
-	copy(max_aspect.y);
+        copy(min_aspect.x);
+        copy(min_aspect.y);
+        copy(max_aspect.x);
+        copy(max_aspect.y);
     }
 #undef copy
 #define copy(field) hints->field = w->wm.field
     if (flags & PBaseSize) {
-	copy(base_width);
-	copy(base_height);
+        copy(base_width);
+        copy(base_height);
     }
     if (flags & PWinGravity)
-	copy(win_gravity);
+        copy(win_gravity);
 #undef copy
 }
 
-static void _SetWMSizeHints(
-    WMShellWidget w)
+static void
+_SetWMSizeHints(WMShellWidget w)
 {
     XSizeHints *size_hints = XAllocSizeHints();
 
-    if (size_hints == NULL) _XtAllocError("XAllocSizeHints");
+    if (size_hints == NULL)
+        _XtAllocError("XAllocSizeHints");
     ComputeWMSizeHints(w, size_hints);
-    XSetWMNormalHints(XtDisplay((Widget)w), XtWindow((Widget)w), size_hints);
-    XFree((char*)size_hints);
+    XSetWMNormalHints(XtDisplay((Widget) w), XtWindow((Widget) w), size_hints);
+    XFree((char *) size_hints);
 }
 
-static ShellClassExtension _FindClassExtension(
-    WidgetClass widget_class)
+static ShellClassExtension
+_FindClassExtension(WidgetClass widget_class)
 {
     ShellClassExtension ext;
-    for (ext = (ShellClassExtension)((ShellWidgetClass)widget_class)
-	       ->shell_class.extension;
-	 ext != NULL && ext->record_type != NULLQUARK;
-	 ext = (ShellClassExtension)ext->next_extension);
+
+    for (ext = (ShellClassExtension) ((ShellWidgetClass) widget_class)
+         ->shell_class.extension;
+         ext != NULL && ext->record_type != NULLQUARK;
+         ext = (ShellClassExtension) ext->next_extension);
 
     if (ext != NULL) {
-	if (  ext->version == XtShellExtensionVersion
-	      && ext->record_size == sizeof(ShellClassExtensionRec)) {
-	    /* continue */
-	} else {
-	    String params[1];
-	    Cardinal num_params = 1;
-	    params[0] = widget_class->core_class.class_name;
-	    XtErrorMsg( "invalidExtension", "shellClassPartInitialize",
-		        XtCXtToolkitError,
-		 "widget class %s has invalid ShellClassExtension record",
-		 params, &num_params);
-	}
+        if (ext->version == XtShellExtensionVersion
+            && ext->record_size == sizeof(ShellClassExtensionRec)) {
+            /* continue */
+        }
+        else {
+            String params[1];
+            Cardinal num_params = 1;
+
+            params[0] = widget_class->core_class.class_name;
+            XtErrorMsg("invalidExtension", "shellClassPartInitialize",
+                       XtCXtToolkitError,
+                       "widget class %s has invalid ShellClassExtension record",
+                       params, &num_params);
+        }
     }
     return ext;
 }
 
-static void ClassPartInitialize(WidgetClass widget_class)
+static void
+ClassPartInitialize(WidgetClass widget_class)
 {
     ShellClassExtension ext = _FindClassExtension(widget_class);
+
     if (ext != NULL) {
-	if (ext->root_geometry_manager == XtInheritRootGeometryManager) {
-	    ext->root_geometry_manager =
-		_FindClassExtension(widget_class->core_class.superclass)
-		    ->root_geometry_manager;
-	}
-    } else {
-	/* if not found, spec requires XtInheritRootGeometryManager */
-	XtPointer *extP
-	    = &((ShellWidgetClass)widget_class)->shell_class.extension;
-	ext = XtNew(ShellClassExtensionRec);
-	(void) memmove((char*)ext,
-		       (char*)_FindClassExtension(widget_class->core_class.superclass),
-		       sizeof(ShellClassExtensionRec));
-	ext->next_extension = *extP;
-	*extP = (XtPointer)ext;
-    }
-}
-
-
-static void EventHandler(Widget wid, XtPointer closure, XEvent *event, Boolean *continue_to_dispatch);
-static void _popup_set_prop(ShellWidget);
+        if (ext->root_geometry_manager == XtInheritRootGeometryManager) {
+            ext->root_geometry_manager =
+                _FindClassExtension(widget_class->core_class.superclass)
+                ->root_geometry_manager;
+        }
+    }
+    else {
+        /* if not found, spec requires XtInheritRootGeometryManager */
+        XtPointer *extP
+            = &((ShellWidgetClass) widget_class)->shell_class.extension;
+        ext = XtNew(ShellClassExtensionRec);
+        (void) memmove((char *) ext,
+                       (char *) _FindClassExtension(widget_class->
+                                                    core_class.superclass),
+                       sizeof(ShellClassExtensionRec));
+        ext->next_extension = *extP;
+        *extP = (XtPointer) ext;
+    }
+}
 
+static void EventHandler(Widget wid, XtPointer closure, XEvent *event,
+                         Boolean *continue_to_dispatch);
+static void _popup_set_prop(ShellWidget);
 
-/*ARGSUSED*/
-static void XtCopyDefaultDepth(
-    Widget      widget,
-    int		offset,
-    XrmValue    *value)
+static void
+XtCopyDefaultDepth(Widget widget, int offset _X_UNUSED, XrmValue *value)
 {
-    value->addr = (XPointer)(&DefaultDepthOfScreen(XtScreenOfObject(widget)));
+    value->addr = (XPointer) (&DefaultDepthOfScreen(XtScreenOfObject(widget)));
 }
 
-static
-void _XtShellDepth(
-    Widget widget,
-    int closure,
-    XrmValue *value)
+static void
+_XtShellDepth(Widget widget, int closure, XrmValue *value)
 {
-   if (widget->core.parent == NULL) XtCopyDefaultDepth(widget,closure,value);
-   else _XtCopyFromParent (widget,closure,value);
+    if (widget->core.parent == NULL)
+        XtCopyDefaultDepth(widget, closure, value);
+    else
+        _XtCopyFromParent(widget, closure, value);
 }
 
-/*ARGSUSED*/
-static void XtCopyDefaultColormap(
-    Widget      widget,
-    int		offset,
-    XrmValue    *value)
+static void
+XtCopyDefaultColormap(Widget widget, int offset _X_UNUSED, XrmValue *value)
 {
-    value->addr = (XPointer)(&DefaultColormapOfScreen(XtScreenOfObject(widget)));
+    value->addr =
+        (XPointer) (&DefaultColormapOfScreen(XtScreenOfObject(widget)));
 }
 
-static
-void _XtShellColormap(
-    Widget widget,
-    int closure,
-    XrmValue *value)
+static void
+_XtShellColormap(Widget widget, int closure, XrmValue *value)
 {
-   if (widget->core.parent == NULL)
-	   XtCopyDefaultColormap(widget,closure,value);
-   else _XtCopyFromParent (widget,closure,value);
+    if (widget->core.parent == NULL)
+        XtCopyDefaultColormap(widget, closure, value);
+    else
+        _XtCopyFromParent(widget, closure, value);
 }
 
-static
-void _XtShellAncestorSensitive(
-    Widget widget,
-    int closure,
-    XrmValue *value)
+static void
+_XtShellAncestorSensitive(Widget widget, int closure, XrmValue *value)
 {
-   static Boolean true = True;
-   if (widget->core.parent == NULL) value->addr = (XPointer)(&true);
-   else _XtCopyFromParent (widget,closure,value);
+    static Boolean true = True;
+
+    if (widget->core.parent == NULL)
+        value->addr = (XPointer) (&true);
+    else
+        _XtCopyFromParent(widget, closure, value);
 }
 
-/*ARGSUSED*/
-static
-void _XtTitleEncoding(
-    Widget widget,
-    int offset,
-    XrmValue *value)
+static void
+_XtTitleEncoding(Widget widget, int offset _X_UNUSED, XrmValue *value)
 {
     static Atom atom;
-    if (XtWidgetToApplicationContext(widget)->langProcRec.proc) atom = None;
-    else atom = XA_STRING;
+
+    if (XtWidgetToApplicationContext(widget)->langProcRec.proc)
+        atom = None;
+    else
+        atom = XA_STRING;
     value->addr = (XPointer) &atom;
 }
 
-
-/* ARGSUSED */
-static void Initialize(
-	Widget req,
-	Widget new,
-	ArgList args,		/* unused */
-	Cardinal *num_args)	/* unused */
+static void
+Initialize(Widget req _X_UNUSED,
+           Widget new,
+           ArgList args _X_UNUSED,
+           Cardinal *num_args _X_UNUSED)
 {
-	ShellWidget w = (ShellWidget) new;
+    ShellWidget w = (ShellWidget) new;
 
-	w->shell.popped_up = FALSE;
-	w->shell.client_specified =
-	    _XtShellNotReparented | _XtShellPositionValid;
+    w->shell.popped_up = FALSE;
+    w->shell.client_specified = _XtShellNotReparented | _XtShellPositionValid;
 
-	if (w->core.x == BIGSIZE) {
-	    w->core.x = 0;
-	    if (w->core.y == BIGSIZE) w->core.y = 0;
-	} else {
-	    if (w->core.y == BIGSIZE) w->core.y = 0;
-	    else w->shell.client_specified |= _XtShellPPositionOK;
-	}
+    if (w->core.x == BIGSIZE) {
+        w->core.x = 0;
+        if (w->core.y == BIGSIZE)
+            w->core.y = 0;
+    }
+    else {
+        if (w->core.y == BIGSIZE)
+            w->core.y = 0;
+        else
+            w->shell.client_specified |= _XtShellPPositionOK;
+    }
 
-	XtAddEventHandler(new, (EventMask) StructureNotifyMask,
-		TRUE, EventHandler, (XtPointer) NULL);
+    XtAddEventHandler(new, (EventMask) StructureNotifyMask,
+                      TRUE, EventHandler, (XtPointer) NULL);
 
 #ifdef EDITRES
-	XtAddEventHandler(new, (EventMask) 0, TRUE,
-			  _XEditResCheckMessages, NULL);
+    XtAddEventHandler(new, (EventMask) 0, TRUE, _XEditResCheckMessages, NULL);
 #endif
 }
 
-/* ARGSUSED */
-static void WMInitialize(
-	Widget req, Widget new,
-	ArgList args,		/* unused */
-	Cardinal *num_args)	/* unused */
+static void
+WMInitialize(Widget req _X_UNUSED,
+             Widget new,
+             ArgList args _X_UNUSED,
+             Cardinal *num_args _X_UNUSED)
 {
-	WMShellWidget w = (WMShellWidget) new;
-	TopLevelShellWidget tls = (TopLevelShellWidget) new;	/* maybe */
+    WMShellWidget w = (WMShellWidget) new;
+    TopLevelShellWidget tls = (TopLevelShellWidget) new;        /* maybe */
 
-	if(w->wm.title == NULL) {
-	    if (XtIsTopLevelShell(new) &&
-		    tls->topLevel.icon_name != NULL &&
-		    strlen(tls->topLevel.icon_name) != 0) {
-		w->wm.title = XtNewString(tls->topLevel.icon_name);
-	    } else {
-		w->wm.title = XtNewString(w->core.name);
-	    }
-	} else {
-	    w->wm.title = XtNewString(w->wm.title);
-	}
-	w->wm.size_hints.flags = 0;
-	w->wm.wm_hints.flags = 0;
-	if (w->wm.window_role)
-	    w->wm.window_role = XtNewString(w->wm.window_role);
+    if (w->wm.title == NULL) {
+        if (XtIsTopLevelShell(new) &&
+            tls->topLevel.icon_name != NULL &&
+            strlen(tls->topLevel.icon_name) != 0) {
+            w->wm.title = XtNewString(tls->topLevel.icon_name);
+        }
+        else {
+            w->wm.title = XtNewString(w->core.name);
+        }
+    }
+    else {
+        w->wm.title = XtNewString(w->wm.title);
+    }
+    w->wm.size_hints.flags = 0;
+    w->wm.wm_hints.flags = 0;
+    if (w->wm.window_role)
+        w->wm.window_role = XtNewString(w->wm.window_role);
 }
 
-
-/* ARGSUSED */
-static void TopLevelInitialize(
-	Widget req, Widget new,
-	ArgList args,		/* unused */
-	Cardinal *num_args)	/* unused */
+static void
+TopLevelInitialize(Widget req _X_UNUSED,
+                   Widget new,
+                   ArgList args _X_UNUSED,
+                   Cardinal *num_args _X_UNUSED)
 {
-	TopLevelShellWidget w = (TopLevelShellWidget) new;
+    TopLevelShellWidget w = (TopLevelShellWidget) new;
 
-	if (w->topLevel.icon_name == NULL) {
-	    w->topLevel.icon_name = XtNewString(w->core.name);
-	} else {
-	    w->topLevel.icon_name = XtNewString(w->topLevel.icon_name);
-	}
+    if (w->topLevel.icon_name == NULL) {
+        w->topLevel.icon_name = XtNewString(w->core.name);
+    }
+    else {
+        w->topLevel.icon_name = XtNewString(w->topLevel.icon_name);
+    }
 
-	if (w->topLevel.iconic)
-	    w->wm.wm_hints.initial_state = IconicState;
+    if (w->topLevel.iconic)
+        w->wm.wm_hints.initial_state = IconicState;
 }
 
 static _XtString *NewArgv(int, _XtString *);
 static _XtString *NewStringArray(_XtString *);
 static void FreeStringArray(_XtString *);
 
-/* ARGSUSED */
-static void ApplicationInitialize(
-    Widget req, Widget new,
-    ArgList args,		/* unused */
-    Cardinal *num_args)		/* unused */
+static void
+ApplicationInitialize(Widget req _X_UNUSED,
+                      Widget new,
+                      ArgList args _X_UNUSED,
+                      Cardinal *num_args _X_UNUSED)
 {
-    ApplicationShellWidget w = (ApplicationShellWidget)new;
+    ApplicationShellWidget w = (ApplicationShellWidget) new;
 
     if (w->application.argc > 0)
-	w->application.argv = NewArgv(w->application.argc,
-				      w->application.argv);
+        w->application.argv = NewArgv(w->application.argc, w->application.argv);
 }
 
 #define XtSaveInactive 0
@@ -1077,628 +1122,634 @@ static void ApplicationInitialize(
 #define XtInteractPending    2
 #define XtInteractActive     3
 
-#define XtCloneCommandMask	(1L<<0)
-#define XtCurrentDirectoryMask	(1L<<1)
-#define XtDiscardCommandMask	(1L<<2)
-#define XtEnvironmentMask	(1L<<3)
-#define XtProgramMask		(1L<<4)
-#define XtResignCommandMask	(1L<<5)
-#define XtRestartCommandMask	(1L<<6)
-#define XtRestartStyleHintMask	(1L<<7)
-#define XtShutdownCommandMask	(1L<<8)
+#define XtCloneCommandMask      (1L<<0)
+#define XtCurrentDirectoryMask  (1L<<1)
+#define XtDiscardCommandMask    (1L<<2)
+#define XtEnvironmentMask       (1L<<3)
+#define XtProgramMask           (1L<<4)
+#define XtResignCommandMask     (1L<<5)
+#define XtRestartCommandMask    (1L<<6)
+#define XtRestartStyleHintMask  (1L<<7)
+#define XtShutdownCommandMask   (1L<<8)
 
 static void JoinSession(SessionShellWidget);
-static void SetSessionProperties(SessionShellWidget, Boolean, unsigned long, unsigned long);
+static void SetSessionProperties(SessionShellWidget, Boolean, unsigned long,
+                                 unsigned long);
 static void StopManagingSession(SessionShellWidget, SmcConn);
 
 typedef struct _XtSaveYourselfRec {
     XtSaveYourself next;
-    int            save_type;
-    int            interact_style;
-    Boolean        shutdown;
-    Boolean        fast;
-    Boolean        cancel_shutdown;
-    int		   phase;
-    int            interact_dialog_type;
-    Boolean	   request_cancel;
-    Boolean	   request_next_phase;
-    Boolean        save_success;
-    int            save_tokens;
-    int            interact_tokens;
+    int save_type;
+    int interact_style;
+    Boolean shutdown;
+    Boolean fast;
+    Boolean cancel_shutdown;
+    int phase;
+    int interact_dialog_type;
+    Boolean request_cancel;
+    Boolean request_next_phase;
+    Boolean save_success;
+    int save_tokens;
+    int interact_tokens;
 } XtSaveYourselfRec;
 
-/* ARGSUSED */
-static void SessionInitialize(
-    Widget req, Widget new,
-    ArgList args,		/* unused */
-    Cardinal *num_args)		/* unused */
+static void
+SessionInitialize(Widget req _X_UNUSED,
+                  Widget new,
+                  ArgList args _X_UNUSED,
+                  Cardinal *num_args _X_UNUSED)
 {
 #ifndef XT_NO_SM
-    SessionShellWidget w = (SessionShellWidget)new;
-
-    if (w->session.session_id) w->session.session_id =
-	XtNewString(w->session.session_id);
-    if (w->session.restart_command) w->session.restart_command =
-	NewStringArray(w->session.restart_command);
-    if (w->session.clone_command) w->session.clone_command =
-	NewStringArray(w->session.clone_command);
-    if (w->session.discard_command) w->session.discard_command =
-	NewStringArray(w->session.discard_command);
-    if (w->session.resign_command) w->session.resign_command =
-	NewStringArray(w->session.resign_command);
-    if (w->session.shutdown_command) w->session.shutdown_command =
-	NewStringArray(w->session.shutdown_command);
-    if (w->session.environment) w->session.environment =
-	NewStringArray(w->session.environment);
-    if (w->session.current_dir) w->session.current_dir =
-	XtNewString(w->session.current_dir);
-    if (w->session.program_path) w->session.program_path =
-	XtNewString(w->session.program_path);
+    SessionShellWidget w = (SessionShellWidget) new;
+
+    if (w->session.session_id)
+        w->session.session_id = XtNewString(w->session.session_id);
+    if (w->session.restart_command)
+        w->session.restart_command = NewStringArray(w->session.restart_command);
+    if (w->session.clone_command)
+        w->session.clone_command = NewStringArray(w->session.clone_command);
+    if (w->session.discard_command)
+        w->session.discard_command = NewStringArray(w->session.discard_command);
+    if (w->session.resign_command)
+        w->session.resign_command = NewStringArray(w->session.resign_command);
+    if (w->session.shutdown_command)
+        w->session.shutdown_command =
+            NewStringArray(w->session.shutdown_command);
+    if (w->session.environment)
+        w->session.environment = NewStringArray(w->session.environment);
+    if (w->session.current_dir)
+        w->session.current_dir = XtNewString(w->session.current_dir);
+    if (w->session.program_path)
+        w->session.program_path = XtNewString(w->session.program_path);
 
     w->session.checkpoint_state = XtSaveInactive;
     w->session.input_id = 0;
     w->session.save = NULL;
 
     if ((w->session.join_session) &&
-	(w->application.argv || w->session.restart_command))
-	JoinSession(w);
+        (w->application.argv || w->session.restart_command))
+        JoinSession(w);
 
     if (w->session.connection)
-	SetSessionProperties(w, True, 0L, 0L);
-#endif /* !XT_NO_SM */
+        SetSessionProperties(w, True, 0L, 0L);
+#endif                          /* !XT_NO_SM */
 }
 
-static void Resize(
-    Widget w)
+static void
+Resize(Widget w)
 {
-    register ShellWidget sw = (ShellWidget)w;
+    register ShellWidget sw = (ShellWidget) w;
     Widget childwid;
     Cardinal i;
-    for(i = 0; i < sw->composite.num_children; i++) {
+
+    for (i = 0; i < sw->composite.num_children; i++) {
         if (XtIsManaged(sw->composite.children[i])) {
-             childwid = sw->composite.children[i];
-             XtResizeWidget(childwid, sw->core.width, sw->core.height,
+            childwid = sw->composite.children[i];
+            XtResizeWidget(childwid, sw->core.width, sw->core.height,
                            childwid->core.border_width);
-	     break;		/* can only be one managed child */
+            break;              /* can only be one managed child */
         }
     }
 }
 
 static void GetGeometry(Widget, Widget);
 
-static void Realize(
-	Widget wid,
-	Mask *vmask,
-	XSetWindowAttributes *attr)
-{
-	ShellWidget w = (ShellWidget) wid;
-        Mask mask = *vmask;
-
-	if (! (w->shell.client_specified & _XtShellGeometryParsed)) {
-	    /* we'll get here only if there was no child the first
-	       time we were realized.  If the shell was Unrealized
-	       and then re-Realized, we probably don't want to
-	       re-evaluate the defaults anyway.
-	     */
-	    GetGeometry(wid, (Widget)NULL);
-	}
-	else if (w->core.background_pixmap == XtUnspecifiedPixmap) {
-	    /* I attempt to inherit my child's background to avoid screen flash
-	     * if there is latency between when I get resized and when my child
-	     * is resized.  Background=None is not satisfactory, as I want the
-	     * user to get immediate feedback on the new dimensions (most
-	     * particularly in the case of a non-reparenting wm).  It is
-	     * especially important to have the server clear any old cruft
-	     * from the display when I am resized larger.
-	     */
-	    register Widget *childP = w->composite.children;
-	    int i;
-	    for (i = (int) w->composite.num_children; i; i--, childP++) {
-		if (XtIsWidget(*childP) && XtIsManaged(*childP)) {
-		    if ((*childP)->core.background_pixmap
-			    != XtUnspecifiedPixmap) {
-			mask &= (unsigned long) (~(CWBackPixel));
-			mask |= CWBackPixmap;
-			attr->background_pixmap =
-			    w->core.background_pixmap =
-				(*childP)->core.background_pixmap;
-		    } else {
-			attr->background_pixel =
-			    w->core.background_pixel =
-				(*childP)->core.background_pixel;
-		    }
-		    break;
-		}
-	    }
-	}
-
-	if(w->shell.save_under) {
-		mask |= CWSaveUnder;
-		attr->save_under = TRUE;
-	}
-	if(w->shell.override_redirect) {
-		mask |= CWOverrideRedirect;
-		attr->override_redirect = TRUE;
-	}
-	if (wid->core.width == 0 || wid->core.height == 0) {
-	    Cardinal count = 1;
-	    XtErrorMsg("invalidDimension", "shellRealize", XtCXtToolkitError,
-		       "Shell widget %s has zero width and/or height",
-		       &wid->core.name, &count);
-	}
-	wid->core.window = XCreateWindow(XtDisplay(wid),
-		wid->core.screen->root, (int)wid->core.x, (int)wid->core.y,
-		(unsigned int)wid->core.width, (unsigned int)wid->core.height,
-		(unsigned int)wid->core.border_width, (int) wid->core.depth,
-		(unsigned int) InputOutput, w->shell.visual,
-		mask, attr);
-
-	_popup_set_prop(w);
-}
-
-
-static void _SetTransientForHint(
-     TransientShellWidget w,
-     Boolean delete)
+static void
+Realize(Widget wid, Mask *vmask, XSetWindowAttributes *attr)
+{
+    ShellWidget w = (ShellWidget) wid;
+    Mask mask = *vmask;
+
+    if (!(w->shell.client_specified & _XtShellGeometryParsed)) {
+        /* we'll get here only if there was no child the first
+           time we were realized.  If the shell was Unrealized
+           and then re-Realized, we probably don't want to
+           re-evaluate the defaults anyway.
+         */
+        GetGeometry(wid, (Widget) NULL);
+    }
+    else if (w->core.background_pixmap == XtUnspecifiedPixmap) {
+        /* I attempt to inherit my child's background to avoid screen flash
+         * if there is latency between when I get resized and when my child
+         * is resized.  Background=None is not satisfactory, as I want the
+         * user to get immediate feedback on the new dimensions (most
+         * particularly in the case of a non-reparenting wm).  It is
+         * especially important to have the server clear any old cruft
+         * from the display when I am resized larger.
+         */
+        register Widget *childP = w->composite.children;
+        int i;
+
+        for (i = (int) w->composite.num_children; i; i--, childP++) {
+            if (XtIsWidget(*childP) && XtIsManaged(*childP)) {
+                if ((*childP)->core.background_pixmap != XtUnspecifiedPixmap) {
+                    mask &= (unsigned long) (~(CWBackPixel));
+                    mask |= CWBackPixmap;
+                    attr->background_pixmap =
+                        w->core.background_pixmap =
+                        (*childP)->core.background_pixmap;
+                }
+                else {
+                    attr->background_pixel =
+                        w->core.background_pixel =
+                        (*childP)->core.background_pixel;
+                }
+                break;
+            }
+        }
+    }
+
+    if (w->shell.save_under) {
+        mask |= CWSaveUnder;
+        attr->save_under = TRUE;
+    }
+    if (w->shell.override_redirect) {
+        mask |= CWOverrideRedirect;
+        attr->override_redirect = TRUE;
+    }
+    if (wid->core.width == 0 || wid->core.height == 0) {
+        Cardinal count = 1;
+
+        XtErrorMsg("invalidDimension", "shellRealize", XtCXtToolkitError,
+                   "Shell widget %s has zero width and/or height",
+                   &wid->core.name, &count);
+    }
+    wid->core.window = XCreateWindow(XtDisplay(wid),
+                                     wid->core.screen->root, (int) wid->core.x,
+                                     (int) wid->core.y,
+                                     (unsigned int) wid->core.width,
+                                     (unsigned int) wid->core.height,
+                                     (unsigned int) wid->core.border_width,
+                                     (int) wid->core.depth,
+                                     (unsigned int) InputOutput,
+                                     w->shell.visual, mask, attr);
+
+    _popup_set_prop(w);
+}
+
+static void
+_SetTransientForHint(TransientShellWidget w, Boolean delete)
 {
     Window window_group;
 
     if (w->wm.transient) {
-	if (w->transient.transient_for != NULL
-	    && XtIsRealized(w->transient.transient_for))
-	    window_group = XtWindow(w->transient.transient_for);
-	else if ((window_group = w->wm.wm_hints.window_group)
-		 == XtUnspecifiedWindowGroup) {
-	    if (delete)
-		XDeleteProperty( XtDisplay((Widget)w),
-				 XtWindow((Widget)w),
-				 XA_WM_TRANSIENT_FOR
-				);
-	    return;
-	}
+        if (w->transient.transient_for != NULL
+            && XtIsRealized(w->transient.transient_for))
+            window_group = XtWindow(w->transient.transient_for);
+        else if ((window_group = w->wm.wm_hints.window_group)
+                 == XtUnspecifiedWindowGroup) {
+            if (delete)
+                XDeleteProperty(XtDisplay((Widget) w),
+                                XtWindow((Widget) w), XA_WM_TRANSIENT_FOR);
+            return;
+        }
 
-	XSetTransientForHint( XtDisplay((Widget)w),
-			      XtWindow((Widget)w),
-			      window_group
-			     );
+        XSetTransientForHint(XtDisplay((Widget) w),
+                             XtWindow((Widget) w), window_group);
     }
 }
 
-
-static void TransientRealize(
-     Widget w,
-     Mask *vmask,
-     XSetWindowAttributes *attr)
+static void
+TransientRealize(Widget w, Mask *vmask, XSetWindowAttributes *attr)
 {
     XtRealizeProc realize;
 
     LOCK_PROCESS;
     realize =
-	transientShellWidgetClass->core_class.superclass->core_class.realize;
+        transientShellWidgetClass->core_class.superclass->core_class.realize;
     UNLOCK_PROCESS;
     (*realize) (w, vmask, attr);
 
-    _SetTransientForHint((TransientShellWidget)w, False);
+    _SetTransientForHint((TransientShellWidget) w, False);
 }
 
-static Widget GetClientLeader(
-    Widget w)
+static Widget
+GetClientLeader(Widget w)
 {
-    while ((! XtIsWMShell(w) || ! ((WMShellWidget)w)->wm.client_leader)
-	   && w->core.parent)
-	w = w->core.parent;
+    while ((!XtIsWMShell(w) || !((WMShellWidget) w)->wm.client_leader)
+           && w->core.parent)
+        w = w->core.parent;
 
     /* ASSERT: w is a WMshell with client_leader set, or w has no parent */
 
-    if (XtIsWMShell(w) && ((WMShellWidget)w)->wm.client_leader)
-	w = ((WMShellWidget)w)->wm.client_leader;
+    if (XtIsWMShell(w) && ((WMShellWidget) w)->wm.client_leader)
+        w = ((WMShellWidget) w)->wm.client_leader;
     return w;
 }
 
-static void EvaluateWMHints(
-    WMShellWidget w)
-{
-	XWMHints *hintp = &w->wm.wm_hints;
-
-	hintp->flags = StateHint | InputHint;
-
-	if (hintp->icon_x == XtUnspecifiedShellInt)
-	    hintp->icon_x = -1;
-	else
-	    hintp->flags |= IconPositionHint;
-
-	if (hintp->icon_y == XtUnspecifiedShellInt)
-	    hintp->icon_y = -1;
-	else
-	    hintp->flags |= IconPositionHint;
-
-	if (hintp->icon_pixmap != None) hintp->flags |= IconPixmapHint;
-	if (hintp->icon_mask != None)   hintp->flags |= IconMaskHint;
-	if (hintp->icon_window != None) hintp->flags |= IconWindowHint;
-
-	if (hintp->window_group == XtUnspecifiedWindow) {
-	    if(w->core.parent) {
-		Widget p;
-		for (p = w->core.parent; p->core.parent; p = p->core.parent);
-		if (XtIsRealized(p)) {
-		    hintp->window_group = XtWindow(p);
-		    hintp->flags |=  WindowGroupHint;
-		}
-	    }
-	} else if (hintp->window_group != XtUnspecifiedWindowGroup)
-	    hintp->flags |=  WindowGroupHint;
-
-	if (w->wm.urgency) hintp->flags |= XUrgencyHint;
-}
-
-
-static void EvaluateSizeHints(
-    WMShellWidget w)
-{
-	struct _OldXSizeHints *sizep = &w->wm.size_hints;
-
-	sizep->x = w->core.x;
-	sizep->y = w->core.y;
-	sizep->width = w->core.width;
-	sizep->height = w->core.height;
-
-	if (sizep->flags & USSize) {
-	    if (sizep->flags & PSize) sizep->flags &= ~PSize;
-	} else
-	    sizep->flags |= PSize;
-
-	if (sizep->flags & USPosition) {
-	    if (sizep->flags & PPosition) sizep->flags &= ~PPosition;
-	} else if (w->shell.client_specified & _XtShellPPositionOK)
-	    sizep->flags |= PPosition;
-
-	if (sizep->min_aspect.x != XtUnspecifiedShellInt
-	    || sizep->min_aspect.y != XtUnspecifiedShellInt
-	    || sizep->max_aspect.x != XtUnspecifiedShellInt
-	    || sizep->max_aspect.y != XtUnspecifiedShellInt) {
-	    sizep->flags |= PAspect;
-	}
-	if (sizep->flags & PBaseSize
-	    || w->wm.base_width != XtUnspecifiedShellInt
-	    || w->wm.base_height != XtUnspecifiedShellInt) {
-	    sizep->flags |= PBaseSize;
-	    if (w->wm.base_width == XtUnspecifiedShellInt)
-		w->wm.base_width = 0;
-	    if (w->wm.base_height == XtUnspecifiedShellInt)
-		w->wm.base_height = 0;
-	}
-	if (sizep->flags & PResizeInc
-	    || sizep->width_inc != XtUnspecifiedShellInt
-	    || sizep->height_inc != XtUnspecifiedShellInt) {
-	    if (sizep->width_inc < 1) sizep->width_inc = 1;
-	    if (sizep->height_inc < 1) sizep->height_inc = 1;
-	    sizep->flags |= PResizeInc;
-	}
-	if (sizep->flags & PMaxSize
-	    || sizep->max_width != XtUnspecifiedShellInt
-	    || sizep->max_height != XtUnspecifiedShellInt) {
-	    sizep->flags |= PMaxSize;
-	    if (sizep->max_width == XtUnspecifiedShellInt)
-		sizep->max_width = BIGSIZE;
-	    if (sizep->max_height == XtUnspecifiedShellInt)
-		sizep->max_height = BIGSIZE;
-	}
-	if (sizep->flags & PMinSize
-	    || sizep->min_width != XtUnspecifiedShellInt
-	    || sizep->min_height != XtUnspecifiedShellInt) {
-	    sizep->flags |= PMinSize;
-	    if (sizep->min_width == XtUnspecifiedShellInt)
-		sizep->min_width = 1;
-	    if (sizep->min_height == XtUnspecifiedShellInt)
-		sizep->min_height = 1;
-	}
-}
-
-static void _popup_set_prop(
-	ShellWidget w)
-{
-	Widget p;
-	WMShellWidget wmshell = (WMShellWidget) w;
-	TopLevelShellWidget tlshell = (TopLevelShellWidget) w;
-	ApplicationShellWidget appshell = (ApplicationShellWidget) w;
-	XTextProperty icon_name;
-	XTextProperty window_name;
-	char **argv;
-	int argc;
-	XSizeHints *size_hints;
-	Window window_group;
-	XClassHint classhint;
-	Boolean copied_iname, copied_wname;
-
-	if (!XtIsWMShell((Widget)w) || w->shell.override_redirect) return;
-
-	if ((size_hints = XAllocSizeHints()) == NULL)
-	    _XtAllocError("XAllocSizeHints");
-
-	copied_iname = copied_wname = False;
-        if (wmshell->wm.title_encoding == None &&
-	    XmbTextListToTextProperty(XtDisplay((Widget)w),
-				      (char**)&wmshell->wm.title,
-				      1, XStdICCTextStyle,
-				      &window_name) >= Success) {
-	    copied_wname = True;
-	} else {
-	    window_name.value = (unsigned char*)wmshell->wm.title;
-	    window_name.encoding = wmshell->wm.title_encoding ?
-		wmshell->wm.title_encoding : XA_STRING;
-	    window_name.format = 8;
-	    window_name.nitems = strlen((char *)window_name.value);
-	}
-
-	if (XtIsTopLevelShell((Widget)w)) {
-            if (tlshell->topLevel.icon_name_encoding == None &&
-		XmbTextListToTextProperty(XtDisplay((Widget)w),
-					  (char**)&tlshell->topLevel.icon_name,
-					  1, XStdICCTextStyle,
-					  &icon_name) >= Success) {
-		copied_iname = True;
-	    } else {
-		icon_name.value = (unsigned char*)tlshell->topLevel.icon_name;
-		icon_name.encoding = tlshell->topLevel.icon_name_encoding ?
-		    tlshell->topLevel.icon_name_encoding : XA_STRING;
-		icon_name.format = 8;
-		icon_name.nitems = strlen((char *)icon_name.value);
-	    }
-	}
-
-	EvaluateWMHints(wmshell);
-	EvaluateSizeHints(wmshell);
-	ComputeWMSizeHints(wmshell, size_hints);
-
-	if (wmshell->wm.transient
-	    && !XtIsTransientShell((Widget)w)
-	    && (window_group = wmshell->wm.wm_hints.window_group)
-	       != XtUnspecifiedWindowGroup) {
-
-	    XSetTransientForHint(XtDisplay((Widget)w),
-				 XtWindow((Widget)w),
-				 window_group
-				 );
-	}
-
-	classhint.res_name = (_XtString) w->core.name;
-	/* For the class, look up to the top of the tree */
-	for (p = (Widget)w; p->core.parent != NULL; p = p->core.parent);
-	if (XtIsApplicationShell(p)) {
-	    classhint.res_class =
-		((ApplicationShellWidget)p)->application.class;
-	} else {
-	    LOCK_PROCESS;
-	    classhint.res_class = (_XtString) XtClass(p)->core_class.class_name;
-	    UNLOCK_PROCESS;
-	}
-
-	if (XtIsApplicationShell((Widget)w)
-	    && (argc = appshell->application.argc) != -1)
-	    argv = (char**)appshell->application.argv;
-	else {
-	    argv = NULL;
-	    argc = 0;
-	}
-
-	XSetWMProperties(XtDisplay((Widget)w), XtWindow((Widget)w),
-			 &window_name,
-			 (XtIsTopLevelShell((Widget)w)) ? &icon_name : NULL,
-			 argv, argc,
-			 size_hints,
-			 &wmshell->wm.wm_hints,
-			 &classhint);
-	XFree((char*)size_hints);
-	if (copied_wname)
-	    XFree((XPointer)window_name.value);
-	if (copied_iname)
-	    XFree((XPointer)icon_name.value);
-
-	LOCK_PROCESS;
-	if (XtWidgetToApplicationContext((Widget)w)->langProcRec.proc) {
-	    char *locale = setlocale(LC_CTYPE, (char *)NULL);
-	    if (locale)
-		XChangeProperty(XtDisplay((Widget)w), XtWindow((Widget)w),
-				XInternAtom(XtDisplay((Widget)w),
-					    "WM_LOCALE_NAME", False),
-				XA_STRING, 8, PropModeReplace,
-				(unsigned char *)locale, (int) strlen(locale));
-	}
-	UNLOCK_PROCESS;
-
-	p = GetClientLeader((Widget)w);
-	if (XtWindow(p))
-	    XChangeProperty(XtDisplay((Widget)w), XtWindow((Widget)w),
-			    XInternAtom(XtDisplay((Widget)w),
-					"WM_CLIENT_LEADER", False),
-			    XA_WINDOW, 32, PropModeReplace,
-			    (unsigned char *)(&(p->core.window)), 1);
+static void
+EvaluateWMHints(WMShellWidget w)
+{
+    XWMHints *hintp = &w->wm.wm_hints;
+
+    hintp->flags = StateHint | InputHint;
+
+    if (hintp->icon_x == XtUnspecifiedShellInt)
+        hintp->icon_x = -1;
+    else
+        hintp->flags |= IconPositionHint;
+
+    if (hintp->icon_y == XtUnspecifiedShellInt)
+        hintp->icon_y = -1;
+    else
+        hintp->flags |= IconPositionHint;
+
+    if (hintp->icon_pixmap != None)
+        hintp->flags |= IconPixmapHint;
+    if (hintp->icon_mask != None)
+        hintp->flags |= IconMaskHint;
+    if (hintp->icon_window != None)
+        hintp->flags |= IconWindowHint;
+
+    if (hintp->window_group == XtUnspecifiedWindow) {
+        if (w->core.parent) {
+            Widget p;
+
+            for (p = w->core.parent; p->core.parent; p = p->core.parent);
+            if (XtIsRealized(p)) {
+                hintp->window_group = XtWindow(p);
+                hintp->flags |= WindowGroupHint;
+            }
+        }
+    }
+    else if (hintp->window_group != XtUnspecifiedWindowGroup)
+        hintp->flags |= WindowGroupHint;
+
+    if (w->wm.urgency)
+        hintp->flags |= XUrgencyHint;
+}
+
+static void
+EvaluateSizeHints(WMShellWidget w)
+{
+    struct _OldXSizeHints *sizep = &w->wm.size_hints;
+
+    sizep->x = w->core.x;
+    sizep->y = w->core.y;
+    sizep->width = w->core.width;
+    sizep->height = w->core.height;
+
+    if (sizep->flags & USSize) {
+        if (sizep->flags & PSize)
+            sizep->flags &= ~PSize;
+    }
+    else
+        sizep->flags |= PSize;
+
+    if (sizep->flags & USPosition) {
+        if (sizep->flags & PPosition)
+            sizep->flags &= ~PPosition;
+    }
+    else if (w->shell.client_specified & _XtShellPPositionOK)
+        sizep->flags |= PPosition;
+
+    if (sizep->min_aspect.x != XtUnspecifiedShellInt
+        || sizep->min_aspect.y != XtUnspecifiedShellInt
+        || sizep->max_aspect.x != XtUnspecifiedShellInt
+        || sizep->max_aspect.y != XtUnspecifiedShellInt) {
+        sizep->flags |= PAspect;
+    }
+    if (sizep->flags & PBaseSize
+        || w->wm.base_width != XtUnspecifiedShellInt
+        || w->wm.base_height != XtUnspecifiedShellInt) {
+        sizep->flags |= PBaseSize;
+        if (w->wm.base_width == XtUnspecifiedShellInt)
+            w->wm.base_width = 0;
+        if (w->wm.base_height == XtUnspecifiedShellInt)
+            w->wm.base_height = 0;
+    }
+    if (sizep->flags & PResizeInc
+        || sizep->width_inc != XtUnspecifiedShellInt
+        || sizep->height_inc != XtUnspecifiedShellInt) {
+        if (sizep->width_inc < 1)
+            sizep->width_inc = 1;
+        if (sizep->height_inc < 1)
+            sizep->height_inc = 1;
+        sizep->flags |= PResizeInc;
+    }
+    if (sizep->flags & PMaxSize
+        || sizep->max_width != XtUnspecifiedShellInt
+        || sizep->max_height != XtUnspecifiedShellInt) {
+        sizep->flags |= PMaxSize;
+        if (sizep->max_width == XtUnspecifiedShellInt)
+            sizep->max_width = BIGSIZE;
+        if (sizep->max_height == XtUnspecifiedShellInt)
+            sizep->max_height = BIGSIZE;
+    }
+    if (sizep->flags & PMinSize
+        || sizep->min_width != XtUnspecifiedShellInt
+        || sizep->min_height != XtUnspecifiedShellInt) {
+        sizep->flags |= PMinSize;
+        if (sizep->min_width == XtUnspecifiedShellInt)
+            sizep->min_width = 1;
+        if (sizep->min_height == XtUnspecifiedShellInt)
+            sizep->min_height = 1;
+    }
+}
+
+static void
+_popup_set_prop(ShellWidget w)
+{
+    Widget p;
+    WMShellWidget wmshell = (WMShellWidget) w;
+    TopLevelShellWidget tlshell = (TopLevelShellWidget) w;
+    ApplicationShellWidget appshell = (ApplicationShellWidget) w;
+    XTextProperty icon_name;
+    XTextProperty window_name;
+    char **argv;
+    int argc;
+    XSizeHints *size_hints;
+    Window window_group;
+    XClassHint classhint;
+    Boolean copied_iname, copied_wname;
+
+    if (!XtIsWMShell((Widget) w) || w->shell.override_redirect)
+        return;
+
+    if ((size_hints = XAllocSizeHints()) == NULL)
+        _XtAllocError("XAllocSizeHints");
+
+    copied_iname = copied_wname = False;
+    if (wmshell->wm.title_encoding == None &&
+        XmbTextListToTextProperty(XtDisplay((Widget) w),
+                                  (char **) &wmshell->wm.title,
+                                  1, XStdICCTextStyle,
+                                  &window_name) >= Success) {
+        copied_wname = True;
+    }
+    else {
+        window_name.value = (unsigned char *) wmshell->wm.title;
+        window_name.encoding = wmshell->wm.title_encoding ?
+            wmshell->wm.title_encoding : XA_STRING;
+        window_name.format = 8;
+        window_name.nitems = strlen((char *) window_name.value);
+    }
+
+    if (XtIsTopLevelShell((Widget) w)) {
+        if (tlshell->topLevel.icon_name_encoding == None &&
+            XmbTextListToTextProperty(XtDisplay((Widget) w),
+                                      (char **) &tlshell->topLevel.icon_name,
+                                      1, XStdICCTextStyle,
+                                      &icon_name) >= Success) {
+            copied_iname = True;
+        }
+        else {
+            icon_name.value = (unsigned char *) tlshell->topLevel.icon_name;
+            icon_name.encoding = tlshell->topLevel.icon_name_encoding ?
+                tlshell->topLevel.icon_name_encoding : XA_STRING;
+            icon_name.format = 8;
+            icon_name.nitems = strlen((char *) icon_name.value);
+        }
+    }
+
+    EvaluateWMHints(wmshell);
+    EvaluateSizeHints(wmshell);
+    ComputeWMSizeHints(wmshell, size_hints);
+
+    if (wmshell->wm.transient && !XtIsTransientShell((Widget) w)
+        && (window_group = wmshell->wm.wm_hints.window_group)
+        != XtUnspecifiedWindowGroup) {
+
+        XSetTransientForHint(XtDisplay((Widget) w),
+                             XtWindow((Widget) w), window_group);
+    }
+
+    classhint.res_name = (_XtString) w->core.name;
+    /* For the class, look up to the top of the tree */
+    for (p = (Widget) w; p->core.parent != NULL; p = p->core.parent);
+    if (XtIsApplicationShell(p)) {
+        classhint.res_class = ((ApplicationShellWidget) p)->application.class;
+    }
+    else {
+        LOCK_PROCESS;
+        classhint.res_class = (_XtString) XtClass(p)->core_class.class_name;
+        UNLOCK_PROCESS;
+    }
+
+    if (XtIsApplicationShell((Widget) w)
+        && (argc = appshell->application.argc) != -1)
+        argv = (char **) appshell->application.argv;
+    else {
+        argv = NULL;
+        argc = 0;
+    }
+
+    XSetWMProperties(XtDisplay((Widget) w), XtWindow((Widget) w),
+                     &window_name,
+                     (XtIsTopLevelShell((Widget) w)) ? &icon_name : NULL,
+                     argv, argc, size_hints, &wmshell->wm.wm_hints, &classhint);
+    XFree((char *) size_hints);
+    if (copied_wname)
+        XFree((XPointer) window_name.value);
+    if (copied_iname)
+        XFree((XPointer) icon_name.value);
+
+    LOCK_PROCESS;
+    if (XtWidgetToApplicationContext((Widget) w)->langProcRec.proc) {
+        char *locale = setlocale(LC_CTYPE, (char *) NULL);
+
+        if (locale)
+            XChangeProperty(XtDisplay((Widget) w), XtWindow((Widget) w),
+                            XInternAtom(XtDisplay((Widget) w),
+                                        "WM_LOCALE_NAME", False),
+                            XA_STRING, 8, PropModeReplace,
+                            (unsigned char *) locale, (int) strlen(locale));
+    }
+    UNLOCK_PROCESS;
+
+    p = GetClientLeader((Widget) w);
+    if (XtWindow(p))
+        XChangeProperty(XtDisplay((Widget) w), XtWindow((Widget) w),
+                        XInternAtom(XtDisplay((Widget) w),
+                                    "WM_CLIENT_LEADER", False),
+                        XA_WINDOW, 32, PropModeReplace,
+                        (unsigned char *) (&(p->core.window)), 1);
 #ifndef XT_NO_SM
-	if (p == (Widget) w) {
-	    for ( ; p->core.parent != NULL; p = p->core.parent);
-	    if (XtIsSubclass(p, sessionShellWidgetClass)) {
-		String sm_client_id =
-		    ((SessionShellWidget)p)->session.session_id;
-		if (sm_client_id != NULL) {
-		    XChangeProperty(XtDisplay((Widget)w), XtWindow((Widget)w),
-				    XInternAtom(XtDisplay((Widget)w),
-						"SM_CLIENT_ID", False),
-				    XA_STRING, 8, PropModeReplace,
-				    (unsigned char *) sm_client_id,
-				    (int) strlen(sm_client_id));
-		}
-	    }
-	}
-#endif /* !XT_NO_SM */
-
-	if (wmshell->wm.window_role)
-	    XChangeProperty(XtDisplay((Widget)w), XtWindow((Widget)w),
-			    XInternAtom(XtDisplay((Widget)w),
-					"WM_WINDOW_ROLE", False),
-			    XA_STRING, 8, PropModeReplace,
-			    (unsigned char *)wmshell->wm.window_role,
-			    (int) strlen(wmshell->wm.window_role));
-}
-
-/* ARGSUSED */
-static void EventHandler(
-	Widget wid,
-	XtPointer closure,	/* unused */
-	XEvent *event,
-        Boolean *continue_to_dispatch) /* unused */
-{
-	register ShellWidget w = (ShellWidget) wid;
-	WMShellWidget wmshell = (WMShellWidget) w;
-	Boolean  sizechanged = FALSE;
-
-	if(w->core.window != event->xany.window) {
-		XtAppErrorMsg(XtWidgetToApplicationContext(wid),
-			"invalidWindow","eventHandler",XtCXtToolkitError,
-                        "Event with wrong window",
-			NULL, NULL);
-		return;
-	}
-
-	switch(event->type) {
-	    case ConfigureNotify:
-	        if (w->core.window != event->xconfigure.window)
-		    return;  /* in case of SubstructureNotify */
-#define NEQ(x)	( w->core.x != event->xconfigure.x )
-		if( NEQ(width) || NEQ(height) || NEQ(border_width) ) {
-			sizechanged = TRUE;
+    if (p == (Widget) w) {
+        for (; p->core.parent != NULL; p = p->core.parent);
+        if (XtIsSubclass(p, sessionShellWidgetClass)) {
+            String sm_client_id = ((SessionShellWidget) p)->session.session_id;
+
+            if (sm_client_id != NULL) {
+                XChangeProperty(XtDisplay((Widget) w), XtWindow((Widget) w),
+                                XInternAtom(XtDisplay((Widget) w),
+                                            "SM_CLIENT_ID", False),
+                                XA_STRING, 8, PropModeReplace,
+                                (unsigned char *) sm_client_id,
+                                (int) strlen(sm_client_id));
+            }
+        }
+    }
+#endif                          /* !XT_NO_SM */
+
+    if (wmshell->wm.window_role)
+        XChangeProperty(XtDisplay((Widget) w), XtWindow((Widget) w),
+                        XInternAtom(XtDisplay((Widget) w),
+                                    "WM_WINDOW_ROLE", False),
+                        XA_STRING, 8, PropModeReplace,
+                        (unsigned char *) wmshell->wm.window_role,
+                        (int) strlen(wmshell->wm.window_role));
+}
+
+static void
+EventHandler(Widget wid,
+             XtPointer closure _X_UNUSED,
+             XEvent *event,
+             Boolean *continue_to_dispatch _X_UNUSED)
+{
+    register ShellWidget w = (ShellWidget) wid;
+    WMShellWidget wmshell = (WMShellWidget) w;
+    Boolean sizechanged = FALSE;
+
+    if (w->core.window != event->xany.window) {
+        XtAppErrorMsg(XtWidgetToApplicationContext(wid),
+                      "invalidWindow", "eventHandler", XtCXtToolkitError,
+                      "Event with wrong window", NULL, NULL);
+        return;
+    }
+
+    switch (event->type) {
+    case ConfigureNotify:
+        if (w->core.window != event->xconfigure.window)
+            return;             /* in case of SubstructureNotify */
+#define NEQ(x)  ( w->core.x != event->xconfigure.x )
+        if (NEQ(width) || NEQ(height) || NEQ(border_width)) {
+            sizechanged = TRUE;
 #undef NEQ
-			w->core.width = (Dimension) event->xconfigure.width;
-			w->core.height = (Dimension) event->xconfigure.height;
-			w->core.border_width = (Dimension) event->xconfigure.border_width;
-		}
-		if (event->xany.send_event /* ICCCM compliant synthetic ev */
-		    /* || w->shell.override_redirect */
-		    || w->shell.client_specified & _XtShellNotReparented)
-	        {
-		    w->core.x = (Position) event->xconfigure.x;
-		    w->core.y = (Position) event->xconfigure.y;
-		    w->shell.client_specified |= _XtShellPositionValid;
-		}
-		else w->shell.client_specified &= ~_XtShellPositionValid;
-		if (XtIsWMShell(wid) && !wmshell->wm.wait_for_wm) {
-		    /* Consider trusting the wm again */
-		    register struct _OldXSizeHints *hintp
-			= &wmshell->wm.size_hints;
+            w->core.width = (Dimension) event->xconfigure.width;
+            w->core.height = (Dimension) event->xconfigure.height;
+            w->core.border_width = (Dimension) event->xconfigure.border_width;
+        }
+        if (event->xany.send_event      /* ICCCM compliant synthetic ev */
+            /* || w->shell.override_redirect */
+            || w->shell.client_specified & _XtShellNotReparented) {
+            w->core.x = (Position) event->xconfigure.x;
+            w->core.y = (Position) event->xconfigure.y;
+            w->shell.client_specified |= _XtShellPositionValid;
+        }
+        else
+            w->shell.client_specified &= ~_XtShellPositionValid;
+        if (XtIsWMShell(wid) && !wmshell->wm.wait_for_wm) {
+            /* Consider trusting the wm again */
+            register struct _OldXSizeHints *hintp = &wmshell->wm.size_hints;
+
 #define EQ(x) (hintp->x == w->core.x)
-		    if (EQ(x) && EQ(y) && EQ(width) && EQ(height)) {
-			wmshell->wm.wait_for_wm = TRUE;
-		    }
+            if (EQ(x) && EQ(y) && EQ(width) && EQ(height)) {
+                wmshell->wm.wait_for_wm = TRUE;
+            }
 #undef EQ
-		}
-		break;
-
-	      case ReparentNotify:
-		if (event->xreparent.window == XtWindow(w)) {
-		   if (event->xreparent.parent !=
-		       RootWindowOfScreen(XtScreen(w)))
-		       w->shell.client_specified &=
-			   ~(_XtShellNotReparented | _XtShellPositionValid);
-		   else {
-		       w->core.x = (Position) event->xreparent.x;
-		       w->core.y = (Position) event->xreparent.y;
-		       w->shell.client_specified |=
-			   (_XtShellNotReparented | _XtShellPositionValid);
-		   }
-	        }
-		return;
-
-              case MapNotify:
-                if (XtIsTopLevelShell(wid)) {
-                    ((TopLevelShellWidget)wid)->topLevel.iconic = FALSE;
-                }
-                return;
+        }
+        break;
+
+    case ReparentNotify:
+        if (event->xreparent.window == XtWindow(w)) {
+            if (event->xreparent.parent != RootWindowOfScreen(XtScreen(w)))
+                w->shell.client_specified &=
+                    ~(_XtShellNotReparented | _XtShellPositionValid);
+            else {
+                w->core.x = (Position) event->xreparent.x;
+                w->core.y = (Position) event->xreparent.y;
+                w->shell.client_specified |=
+                    (_XtShellNotReparented | _XtShellPositionValid);
+            }
+        }
+        return;
 
-	      case UnmapNotify:
-		{
-		    XtPerDisplayInput	pdi;
-		    XtDevice		device;
-		    Widget		p;
+    case MapNotify:
+        if (XtIsTopLevelShell(wid)) {
+            ((TopLevelShellWidget) wid)->topLevel.iconic = FALSE;
+        }
+        return;
 
-                    if (XtIsTopLevelShell(wid))
-                        ((TopLevelShellWidget)wid)->topLevel.iconic = TRUE;
+    case UnmapNotify:
+    {
+        XtPerDisplayInput pdi;
+        XtDevice device;
+        Widget p;
 
-		    pdi = _XtGetPerDisplayInput(event->xunmap.display);
+        if (XtIsTopLevelShell(wid))
+            ((TopLevelShellWidget) wid)->topLevel.iconic = TRUE;
 
-		    device = &pdi->pointer;
-		    if (device->grabType == XtPassiveServerGrab) {
-			p = device->grab.widget;
-			while (p && !(XtIsShell(p)))
-			    p = p->core.parent;
-			if (p == wid)
-			    device->grabType = XtNoServerGrab;
-		    }
+        pdi = _XtGetPerDisplayInput(event->xunmap.display);
 
-		    device = &pdi->keyboard;
-		    if (IsEitherPassiveGrab(device->grabType)) {
-			p = device->grab.widget;
-			while (p && !(XtIsShell(p)))
-			    p = p->core.parent;
-			if (p == wid) {
-			    device->grabType = XtNoServerGrab;
-			    pdi->activatingKey = 0;
-			}
-		    }
+        device = &pdi->pointer;
 
-		    return;
-		}
-	      default:
-		 return;
-	}
-	{
-	XtWidgetProc resize;
+        if (device->grabType == XtPassiveServerGrab) {
+            p = device->grab.widget;
+            while (p && !(XtIsShell(p)))
+                p = p->core.parent;
+            if (p == wid)
+                device->grabType = XtNoServerGrab;
+        }
 
-	LOCK_PROCESS;
-	resize = XtClass(wid)->core_class.resize;
-	UNLOCK_PROCESS;
+        device = &pdi->keyboard;
+        if (IsEitherPassiveGrab(device->grabType)) {
+            p = device->grab.widget;
+            while (p && !(XtIsShell(p)))
+                p = p->core.parent;
+            if (p == wid) {
+                device->grabType = XtNoServerGrab;
+                pdi->activatingKey = 0;
+            }
+        }
 
-	if (sizechanged && resize) {
-	    CALLGEOTAT(_XtGeoTrace((Widget)w,
-			   "Shell \"%s\" is being resized to %d %d.\n",
-			   XtName(wid), wid->core.width, wid->core.height ));
-	    (*resize)(wid);
-	 }
-	}
+        return;
+    }
+    default:
+        return;
+    }
+    {
+        XtWidgetProc resize;
+
+        LOCK_PROCESS;
+        resize = XtClass(wid)->core_class.resize;
+        UNLOCK_PROCESS;
+
+        if (sizechanged && resize) {
+            CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                   "Shell \"%s\" is being resized to %d %d.\n",
+                                   XtName(wid), wid->core.width,
+                                   wid->core.height));
+            (*resize) (wid);
+        }
+    }
 }
 
-static void Destroy(
-	Widget wid)
+static void
+Destroy(Widget wid)
 {
-	if (XtIsRealized(wid))
-	    XDestroyWindow( XtDisplay(wid), XtWindow(wid) );
+    if (XtIsRealized(wid))
+        XDestroyWindow(XtDisplay(wid), XtWindow(wid));
 }
 
-static void WMDestroy(
-	Widget wid)
+static void
+WMDestroy(Widget wid)
 {
-	WMShellWidget w = (WMShellWidget) wid;
+    WMShellWidget w = (WMShellWidget) wid;
 
-	XtFree((char *) w->wm.title);
-	XtFree((char *) w->wm.window_role);
+    XtFree((char *) w->wm.title);
+    XtFree((char *) w->wm.window_role);
 }
 
-static void TopLevelDestroy(
-	Widget wid)
+static void
+TopLevelDestroy(Widget wid)
 {
-	TopLevelShellWidget w = (TopLevelShellWidget) wid;
+    TopLevelShellWidget w = (TopLevelShellWidget) wid;
 
-	XtFree((char *) w->topLevel.icon_name);
+    XtFree((char *) w->topLevel.icon_name);
 }
 
-static void ApplicationDestroy(
-    Widget wid)
+static void
+ApplicationDestroy(Widget wid)
 {
     ApplicationShellWidget w = (ApplicationShellWidget) wid;
+
     if (w->application.argc > 0)
-	FreeStringArray(w->application.argv);
+        FreeStringArray(w->application.argv);
 }
 
-static void SessionDestroy(
-    Widget wid)
+static void
+SessionDestroy(Widget wid)
 {
 #ifndef XT_NO_SM
     SessionShellWidget w = (SessionShellWidget) wid;
@@ -1713,7 +1764,7 @@ static void SessionDestroy(
     FreeStringArray(w->session.environment);
     XtFree(w->session.current_dir);
     XtFree((_XtString) w->session.program_path);
-#endif /* !XT_NO_SM */
+#endif                          /* !XT_NO_SM */
 }
 
 /*
@@ -1722,116 +1773,125 @@ static void SessionDestroy(
  * match the child before parsing the geometry resource.
  *
  */
-static void GetGeometry(
-    Widget W, Widget child)
+static void
+GetGeometry(Widget W, Widget child)
 {
-    register ShellWidget w = (ShellWidget)W;
+    register ShellWidget w = (ShellWidget) W;
     Boolean is_wmshell = XtIsWMShell(W);
     int x, y, width, height, win_gravity = -1, flag;
     XSizeHints hints;
 
     if (child != NULL) {
-	/* we default to our child's size */
-	if (is_wmshell && (w->core.width == 0 || w->core.height == 0))
-	    ((WMShellWidget)W)->wm.size_hints.flags |= PSize;
-	if (w->core.width == 0)	    w->core.width = child->core.width;
-	if (w->core.height == 0)    w->core.height = child->core.height;
-    }
-    if(w->shell.geometry != NULL) {
-	char def_geom[64];
-	x = w->core.x;
-	y = w->core.y;
-	width = w->core.width;
-	height = w->core.height;
-	if (is_wmshell) {
-	    WMShellPart* wm = &((WMShellWidget)w)->wm;
-	    EvaluateSizeHints((WMShellWidget)w);
-	    (void) memmove((char*)&hints, (char*)&wm->size_hints,
-			   sizeof(struct _OldXSizeHints));
-	    hints.win_gravity = wm->win_gravity;
-	    if (wm->size_hints.flags & PBaseSize) {
-		width -= wm->base_width;
-		height -= wm->base_height;
-		hints.base_width = wm->base_width;
-		hints.base_height = wm->base_height;
-	    }
-	    else if (wm->size_hints.flags & PMinSize) {
-		width -= wm->size_hints.min_width;
-		height -= wm->size_hints.min_height;
-	    }
-	    if (wm->size_hints.flags & PResizeInc) {
-		width /= wm->size_hints.width_inc;
-		height /= wm->size_hints.height_inc;
-	    }
-	}
-	else hints.flags = 0;
-
-	snprintf( def_geom, sizeof(def_geom), "%dx%d+%d+%d",
-		  width, height, x, y );
-	flag = XWMGeometry( XtDisplay(W),
-			    XScreenNumberOfScreen(XtScreen(W)),
-			    w->shell.geometry, def_geom,
-			    (unsigned int)w->core.border_width,
-			    &hints, &x, &y, &width, &height,
-			    &win_gravity
-			   );
-	if (flag) {
-	    if (flag & XValue) w->core.x = (Position)x;
-	    if (flag & YValue) w->core.y = (Position)y;
-	    if (flag & WidthValue) w->core.width = (Dimension)width;
-	    if (flag & HeightValue) w->core.height = (Dimension)height;
-	}
-	else {
-	    String params[2];
-	    Cardinal num_params = 2;
-	    params[0] = XtName(W);
-	    params[1] = w->shell.geometry;
-	    XtAppWarningMsg(XtWidgetToApplicationContext(W),
-       "badGeometry", "shellRealize", XtCXtToolkitError,
-       "Shell widget \"%s\" has an invalid geometry specification: \"%s\"",
-			    params, &num_params);
-	}
+        /* we default to our child's size */
+        if (is_wmshell && (w->core.width == 0 || w->core.height == 0))
+            ((WMShellWidget) W)->wm.size_hints.flags |= PSize;
+        if (w->core.width == 0)
+            w->core.width = child->core.width;
+        if (w->core.height == 0)
+            w->core.height = child->core.height;
+    }
+    if (w->shell.geometry != NULL) {
+        char def_geom[64];
+
+        x = w->core.x;
+        y = w->core.y;
+        width = w->core.width;
+        height = w->core.height;
+        if (is_wmshell) {
+            WMShellPart *wm = &((WMShellWidget) w)->wm;
+
+            EvaluateSizeHints((WMShellWidget) w);
+            (void) memmove((char *) &hints, (char *) &wm->size_hints,
+                           sizeof(struct _OldXSizeHints));
+            hints.win_gravity = wm->win_gravity;
+            if (wm->size_hints.flags & PBaseSize) {
+                width -= wm->base_width;
+                height -= wm->base_height;
+                hints.base_width = wm->base_width;
+                hints.base_height = wm->base_height;
+            }
+            else if (wm->size_hints.flags & PMinSize) {
+                width -= wm->size_hints.min_width;
+                height -= wm->size_hints.min_height;
+            }
+            if (wm->size_hints.flags & PResizeInc) {
+                width /= wm->size_hints.width_inc;
+                height /= wm->size_hints.height_inc;
+            }
+        }
+        else
+            hints.flags = 0;
+
+        snprintf(def_geom, sizeof(def_geom), "%dx%d+%d+%d",
+                 width, height, x, y);
+        flag = XWMGeometry(XtDisplay(W),
+                           XScreenNumberOfScreen(XtScreen(W)),
+                           w->shell.geometry, def_geom,
+                           (unsigned int) w->core.border_width,
+                           &hints, &x, &y, &width, &height, &win_gravity);
+        if (flag) {
+            if (flag & XValue)
+                w->core.x = (Position) x;
+            if (flag & YValue)
+                w->core.y = (Position) y;
+            if (flag & WidthValue)
+                w->core.width = (Dimension) width;
+            if (flag & HeightValue)
+                w->core.height = (Dimension) height;
+        }
+        else {
+            String params[2];
+            Cardinal num_params = 2;
+
+            params[0] = XtName(W);
+            params[1] = w->shell.geometry;
+            XtAppWarningMsg(XtWidgetToApplicationContext(W),
+                            "badGeometry", "shellRealize", XtCXtToolkitError,
+                            "Shell widget \"%s\" has an invalid geometry specification: \"%s\"",
+                            params, &num_params);
+        }
     }
     else
-	flag = 0;
+        flag = 0;
 
     if (is_wmshell) {
-	WMShellWidget wmshell = (WMShellWidget) w;
-	if (wmshell->wm.win_gravity == XtUnspecifiedShellInt) {
-	    if (win_gravity != -1)
-		wmshell->wm.win_gravity = win_gravity;
-	    else
-		wmshell->wm.win_gravity = NorthWestGravity;
-	}
-	wmshell->wm.size_hints.flags |= PWinGravity;
-	if ((flag & (XValue|YValue)) == (XValue|YValue))
-	    wmshell->wm.size_hints.flags |= USPosition;
-	if ((flag & (WidthValue|HeightValue)) == (WidthValue|HeightValue))
-	    wmshell->wm.size_hints.flags |= USSize;
+        WMShellWidget wmshell = (WMShellWidget) w;
+
+        if (wmshell->wm.win_gravity == XtUnspecifiedShellInt) {
+            if (win_gravity != -1)
+                wmshell->wm.win_gravity = win_gravity;
+            else
+                wmshell->wm.win_gravity = NorthWestGravity;
+        }
+        wmshell->wm.size_hints.flags |= PWinGravity;
+        if ((flag & (XValue | YValue)) == (XValue | YValue))
+            wmshell->wm.size_hints.flags |= USPosition;
+        if ((flag & (WidthValue | HeightValue)) == (WidthValue | HeightValue))
+            wmshell->wm.size_hints.flags |= USSize;
     }
     w->shell.client_specified |= _XtShellGeometryParsed;
 }
 
-
-static void ChangeManaged(Widget wid)
+static void
+ChangeManaged(Widget wid)
 {
     ShellWidget w = (ShellWidget) wid;
     Widget child = NULL;
     Cardinal i;
 
     for (i = 0; i < w->composite.num_children; i++) {
-	if (XtIsManaged(w->composite.children[i])) {
-	    child = w->composite.children[i];
-	    break;		/* there can only be one of them! */
-	}
+        if (XtIsManaged(w->composite.children[i])) {
+            child = w->composite.children[i];
+            break;              /* there can only be one of them! */
+        }
     }
 
-    if (!XtIsRealized (wid))	/* then we're about to be realized... */
-	GetGeometry(wid, child);
+    if (!XtIsRealized(wid))     /* then we're about to be realized... */
+        GetGeometry(wid, child);
 
     if (child != NULL)
-	XtConfigureWidget (child, (Position)0, (Position)0,
-			   w->core.width, w->core.height, (Dimension)0 );
+        XtConfigureWidget(child, (Position) 0, (Position) 0,
+                          w->core.width, w->core.height, (Dimension) 0);
 }
 
 /*
@@ -1842,143 +1902,140 @@ static void ChangeManaged(Widget wid)
  * asynchronusly denied and the window reverted to it's old size/shape.
  */
 
-/*ARGSUSED*/
-static XtGeometryResult GeometryManager(
-	Widget wid,
-	XtWidgetGeometry *request,
-	XtWidgetGeometry *reply)
-{
-	ShellWidget shell = (ShellWidget)(wid->core.parent);
-	XtWidgetGeometry my_request;
-
-	if(shell->shell.allow_shell_resize == FALSE && XtIsRealized(wid))
-		return(XtGeometryNo);
-
-	if (request->request_mode & (CWX | CWY))
-	    return(XtGeometryNo);
-
-	my_request.request_mode = (request->request_mode & XtCWQueryOnly);
-	if (request->request_mode & CWWidth) {
-	    my_request.width = request->width;
-	    my_request.request_mode |= CWWidth;
-	}
-	if (request->request_mode & CWHeight) {
-	    my_request.height = request->height;
-	    my_request.request_mode |= CWHeight;
-	}
-	if (request->request_mode & CWBorderWidth) {
-	    my_request.border_width = request->border_width;
-	    my_request.request_mode |= CWBorderWidth;
-	}
-	if (XtMakeGeometryRequest((Widget)shell, &my_request, NULL)
-		== XtGeometryYes) {
-	    /* assert: if (request->request_mode & CWWidth) then
-	     * 		  shell->core.width == request->width
-	     * assert: if (request->request_mode & CWHeight) then
-	     * 		  shell->core.height == request->height
-	     *
-	     * so, whatever the WM sized us to (if the Shell requested
-	     * only one of the two) is now the correct child size
-	     */
-
-	    if (!(request->request_mode & XtCWQueryOnly)) {
-		wid->core.width = shell->core.width;
-		wid->core.height = shell->core.height;
-		if (request->request_mode & CWBorderWidth) {
-		    wid->core.x = wid->core.y = (Position) (-request->border_width);
-		}
-	    }
-	    return XtGeometryYes;
-	} else return XtGeometryNo;
+static XtGeometryResult
+GeometryManager(Widget wid,
+                XtWidgetGeometry *request,
+                XtWidgetGeometry *reply _X_UNUSED)
+{
+    ShellWidget shell = (ShellWidget) (wid->core.parent);
+    XtWidgetGeometry my_request;
+
+    if (shell->shell.allow_shell_resize == FALSE && XtIsRealized(wid))
+        return (XtGeometryNo);
+
+    if (request->request_mode & (CWX | CWY))
+        return (XtGeometryNo);
+
+    my_request.request_mode = (request->request_mode & XtCWQueryOnly);
+    if (request->request_mode & CWWidth) {
+        my_request.width = request->width;
+        my_request.request_mode |= CWWidth;
+    }
+    if (request->request_mode & CWHeight) {
+        my_request.height = request->height;
+        my_request.request_mode |= CWHeight;
+    }
+    if (request->request_mode & CWBorderWidth) {
+        my_request.border_width = request->border_width;
+        my_request.request_mode |= CWBorderWidth;
+    }
+    if (XtMakeGeometryRequest((Widget) shell, &my_request, NULL)
+        == XtGeometryYes) {
+        /* assert: if (request->request_mode & CWWidth) then
+         *            shell->core.width == request->width
+         * assert: if (request->request_mode & CWHeight) then
+         *            shell->core.height == request->height
+         *
+         * so, whatever the WM sized us to (if the Shell requested
+         * only one of the two) is now the correct child size
+         */
+
+        if (!(request->request_mode & XtCWQueryOnly)) {
+            wid->core.width = shell->core.width;
+            wid->core.height = shell->core.height;
+            if (request->request_mode & CWBorderWidth) {
+                wid->core.x = wid->core.y = (Position) (-request->border_width);
+            }
+        }
+        return XtGeometryYes;
+    }
+    else
+        return XtGeometryNo;
 }
 
 typedef struct {
-	Widget  w;
-	unsigned long request_num;
-	Boolean done;
+    Widget w;
+    unsigned long request_num;
+    Boolean done;
 } QueryStruct;
 
-static Bool isMine(
-	Display *dpy,
-	register XEvent  *event,
-	char *arg)
-{
-	QueryStruct *q = (QueryStruct *) arg;
-	register Widget w = q->w;
-
-	if ( (dpy != XtDisplay(w)) || (event->xany.window != XtWindow(w)) ) {
-	    return FALSE;
-	}
-	if (event->xany.serial >= q->request_num) {
-	    if (event->type == ConfigureNotify) {
-		q->done = TRUE;
-		return TRUE;
-	    }
-	}
-	else if (event->type == ConfigureNotify)
-	    return TRUE;	/* flush old events */
-	if (event->type == ReparentNotify
-		 && event->xreparent.window == XtWindow(w)) {
-	    /* we might get ahead of this event, so just in case someone
-	     * asks for coordinates before this event is dispatched...
-	     */
-	    register ShellWidget s = (ShellWidget)w;
-	    if (event->xreparent.parent != RootWindowOfScreen(XtScreen(w)))
-		s->shell.client_specified &= ~_XtShellNotReparented;
-	    else
-		s->shell.client_specified |= _XtShellNotReparented;
-	}
-	return FALSE;
-}
-
-static Boolean _wait_for_response(
-	ShellWidget	w,
-	XEvent		*event,
-        unsigned long	request_num)
-{
-	XtAppContext app = XtWidgetToApplicationContext((Widget) w);
-	QueryStruct q;
-	unsigned long timeout;
-
-	if (XtIsWMShell((Widget)w))
-	    timeout = (unsigned long) ((WMShellWidget)w)->wm.wm_timeout;
-	else
-	    timeout = DEFAULT_WM_TIMEOUT;
-
-	XFlush(XtDisplay(w));
-	q.w = (Widget) w;
-	q.request_num = request_num;
-	q.done = FALSE;
-
-	/*
-	 * look for match event and discard all prior configures
-	 */
-	while (XCheckIfEvent(XtDisplay(w),event,isMine,(char*)&q)) {
-	    if (q.done) return TRUE;
-	}
-
-	while (timeout > 0) {
-	    if (_XtWaitForSomething (app,
-				     FALSE, TRUE, TRUE, TRUE,
-				     TRUE,
+static Bool
+isMine(Display *dpy, register XEvent *event, char *arg)
+{
+    QueryStruct *q = (QueryStruct *) arg;
+    register Widget w = q->w;
+
+    if ((dpy != XtDisplay(w)) || (event->xany.window != XtWindow(w))) {
+        return FALSE;
+    }
+    if (event->xany.serial >= q->request_num) {
+        if (event->type == ConfigureNotify) {
+            q->done = TRUE;
+            return TRUE;
+        }
+    }
+    else if (event->type == ConfigureNotify)
+        return TRUE;            /* flush old events */
+    if (event->type == ReparentNotify && event->xreparent.window == XtWindow(w)) {
+        /* we might get ahead of this event, so just in case someone
+         * asks for coordinates before this event is dispatched...
+         */
+        register ShellWidget s = (ShellWidget) w;
+
+        if (event->xreparent.parent != RootWindowOfScreen(XtScreen(w)))
+            s->shell.client_specified &= ~_XtShellNotReparented;
+        else
+            s->shell.client_specified |= _XtShellNotReparented;
+    }
+    return FALSE;
+}
+
+static Boolean
+_wait_for_response(ShellWidget w, XEvent *event, unsigned long request_num)
+{
+    XtAppContext app = XtWidgetToApplicationContext((Widget) w);
+    QueryStruct q;
+    unsigned long timeout;
+
+    if (XtIsWMShell((Widget) w))
+        timeout = (unsigned long) ((WMShellWidget) w)->wm.wm_timeout;
+    else
+        timeout = DEFAULT_WM_TIMEOUT;
+
+    XFlush(XtDisplay(w));
+    q.w = (Widget) w;
+    q.request_num = request_num;
+    q.done = FALSE;
+
+    /*
+     * look for match event and discard all prior configures
+     */
+    while (XCheckIfEvent(XtDisplay(w), event, isMine, (char *) &q)) {
+        if (q.done)
+            return TRUE;
+    }
+
+    while (timeout > 0) {
+        if (_XtWaitForSomething(app, FALSE, TRUE, TRUE, TRUE, TRUE,
 #ifdef XTHREADS
-				     FALSE,
+                                FALSE,
 #endif
-				     &timeout) != -1) {
-		while (XCheckIfEvent(XtDisplay(w),event,isMine,(char*)&q)) {
-		    if (q.done) return TRUE;
-		}
-	    }
-	}
-	return FALSE;
+                                &timeout) != -1) {
+            while (XCheckIfEvent(XtDisplay(w), event, isMine, (char *) &q)) {
+                if (q.done)
+                    return TRUE;
+            }
+        }
+    }
+    return FALSE;
 }
 
-/*ARGSUSED*/
-static XtGeometryResult RootGeometryManager(
-    Widget gw,
-    XtWidgetGeometry *request, XtWidgetGeometry *reply)
+static XtGeometryResult
+RootGeometryManager(Widget gw,
+                    XtWidgetGeometry *request,
+                    XtWidgetGeometry *reply _X_UNUSED)
 {
-    register ShellWidget w = (ShellWidget)gw;
+    register ShellWidget w = (ShellWidget) gw;
     XWindowChanges values;
     unsigned int mask = request->request_mode;
     XEvent event;
@@ -1990,16 +2047,17 @@ static XtGeometryResult RootGeometryManager(
     CALLGEOTAT(_XtGeoTab(1));
 
     if (XtIsWMShell(gw)) {
-	wm = True;
-	hintp = &((WMShellWidget)w)->wm.size_hints;
-	/* for draft-ICCCM wm's, need to make sure hints reflect
-	   (current) reality so client can move and size separately. */
-  	hintp->x = w->core.x;
-  	hintp->y = w->core.y;
-  	hintp->width = w->core.width;
-   	hintp->height = w->core.height;
-    } else
-	wm = False;
+        wm = True;
+        hintp = &((WMShellWidget) w)->wm.size_hints;
+        /* for draft-ICCCM wm's, need to make sure hints reflect
+           (current) reality so client can move and size separately. */
+        hintp->x = w->core.x;
+        hintp->y = w->core.y;
+        hintp->width = w->core.width;
+        hintp->height = w->core.height;
+    }
+    else
+        wm = False;
 
     oldx = w->core.x;
     oldy = w->core.y;
@@ -2008,478 +2066,507 @@ static XtGeometryResult RootGeometryManager(
     oldborder_width = w->core.border_width;
 
 #define PutBackGeometry() \
-	{ w->core.x = (Position) (oldx); \
-	  w->core.y = (Position) (oldy); \
-	  w->core.width = (Dimension) (oldwidth); \
-	  w->core.height = (Dimension) (oldheight); \
-	  w->core.border_width = (Dimension) (oldborder_width); }
+        { w->core.x = (Position) (oldx); \
+          w->core.y = (Position) (oldy); \
+          w->core.width = (Dimension) (oldwidth); \
+          w->core.height = (Dimension) (oldheight); \
+          w->core.border_width = (Dimension) (oldborder_width); }
 
     memset(&values, 0, sizeof(values));
     if (mask & CWX) {
-	    if (w->core.x == request->x) mask &= (unsigned int) (~CWX);
-	    else {
-		w->core.x = (Position) (values.x = request->x);
-		if (wm) {
-		    hintp->flags &= ~USPosition;
-		    hintp->flags |= PPosition;
-		    hintp->x = values.x;
-		}
-	    }
+        if (w->core.x == request->x)
+            mask &= (unsigned int) (~CWX);
+        else {
+            w->core.x = (Position) (values.x = request->x);
+            if (wm) {
+                hintp->flags &= ~USPosition;
+                hintp->flags |= PPosition;
+                hintp->x = values.x;
+            }
+        }
     }
     if (mask & CWY) {
-	    if (w->core.y == request->y) mask &= (unsigned int) (~CWY);
-	    else {
-		w->core.y = (Position) (values.y = request->y);
-		if (wm) {
-		    hintp->flags &= ~USPosition;
-		    hintp->flags |= PPosition;
-		    hintp->y = values.y;
-		}
-	    }
+        if (w->core.y == request->y)
+            mask &= (unsigned int) (~CWY);
+        else {
+            w->core.y = (Position) (values.y = request->y);
+            if (wm) {
+                hintp->flags &= ~USPosition;
+                hintp->flags |= PPosition;
+                hintp->y = values.y;
+            }
+        }
     }
     if (mask & CWBorderWidth) {
-	    if (w->core.border_width == request->border_width) {
-		    mask &= (unsigned int) (~CWBorderWidth);
-	    } else
-		w->core.border_width =
-		    (Dimension) (values.border_width =
-			request->border_width);
+        if (w->core.border_width == request->border_width) {
+            mask &= (unsigned int) (~CWBorderWidth);
+        }
+        else
+            w->core.border_width =
+                (Dimension) (values.border_width = request->border_width);
     }
     if (mask & CWWidth) {
-	    if (w->core.width == request->width) mask &= (unsigned int) (~CWWidth);
-	    else {
-		w->core.width = (Dimension)(values.width = request->width);
-		if (wm) {
-		    hintp->flags &= ~USSize;
-		    hintp->flags |= PSize;
-		    hintp->width = values.width;
-		}
-	    }
+        if (w->core.width == request->width)
+            mask &= (unsigned int) (~CWWidth);
+        else {
+            w->core.width = (Dimension) (values.width = request->width);
+            if (wm) {
+                hintp->flags &= ~USSize;
+                hintp->flags |= PSize;
+                hintp->width = values.width;
+            }
+        }
     }
     if (mask & CWHeight) {
-	    if (w->core.height == request->height) mask &= (unsigned int) (~CWHeight);
-	    else {
-		w->core.height = (Dimension)(values.height = request->height);
-		if (wm) {
-		    hintp->flags &= ~USSize;
-		    hintp->flags |= PSize;
-		    hintp->height = values.height;
-		}
-	    }
+        if (w->core.height == request->height)
+            mask &= (unsigned int) (~CWHeight);
+        else {
+            w->core.height = (Dimension) (values.height = request->height);
+            if (wm) {
+                hintp->flags &= ~USSize;
+                hintp->flags |= PSize;
+                hintp->height = values.height;
+            }
+        }
     }
     if (mask & CWStackMode) {
-	values.stack_mode = request->stack_mode;
-	if (mask & CWSibling)
-	    values.sibling = XtWindow(request->sibling);
+        values.stack_mode = request->stack_mode;
+        if (mask & CWSibling)
+            values.sibling = XtWindow(request->sibling);
     }
 
-    if (!XtIsRealized((Widget)w)) {
-	CALLGEOTAT(_XtGeoTrace((Widget)w,
-		      "Shell \"%s\" is not realized, return XtGeometryYes.\n",
-		       XtName((Widget)w)));
-    	CALLGEOTAT(_XtGeoTab(-1));
-	return XtGeometryYes;
+    if (!XtIsRealized((Widget) w)) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w,
+                               "Shell \"%s\" is not realized, return XtGeometryYes.\n",
+                               XtName((Widget) w)));
+        CALLGEOTAT(_XtGeoTab(-1));
+        return XtGeometryYes;
     }
 
     request_num = NextRequest(XtDisplay(w));
 
-    CALLGEOTAT(_XtGeoTrace((Widget)w,"XConfiguring the Shell X window :\n"));
+    CALLGEOTAT(_XtGeoTrace((Widget) w, "XConfiguring the Shell X window :\n"));
     CALLGEOTAT(_XtGeoTab(1));
 #ifdef XT_GEO_TATTLER
-    if (mask & CWX) { CALLGEOTAT(_XtGeoTrace((Widget)w,"x = %d\n",values.x));}
-    if (mask & CWY) { CALLGEOTAT(_XtGeoTrace((Widget)w,"y = %d\n",values.y));}
-    if (mask & CWWidth) { CALLGEOTAT(_XtGeoTrace((Widget)w,
-					       "width = %d\n",values.width));}
-    if (mask & CWHeight) { CALLGEOTAT(_XtGeoTrace((Widget)w,
-					    "height = %d\n",values.height));}
-    if (mask & CWBorderWidth) { CALLGEOTAT(_XtGeoTrace((Widget)w,
-				  "border_width = %d\n",values.border_width));}
+    if (mask & CWX) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w, "x = %d\n", values.x));
+    }
+    if (mask & CWY) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w, "y = %d\n", values.y));
+    }
+    if (mask & CWWidth) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w, "width = %d\n", values.width));
+    }
+    if (mask & CWHeight) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w, "height = %d\n", values.height));
+    }
+    if (mask & CWBorderWidth) {
+        CALLGEOTAT(_XtGeoTrace((Widget) w,
+                               "border_width = %d\n", values.border_width));
+    }
 #endif
     CALLGEOTAT(_XtGeoTab(-1));
 
-    XConfigureWindow(XtDisplay((Widget)w), XtWindow((Widget)w), mask,&values);
+    XConfigureWindow(XtDisplay((Widget) w), XtWindow((Widget) w), mask,
+                     &values);
 
     if (wm && !w->shell.override_redirect
-	&& mask & (CWX | CWY | CWWidth | CWHeight | CWBorderWidth)) {
-	_SetWMSizeHints((WMShellWidget)w);
+        && mask & (CWX | CWY | CWWidth | CWHeight | CWBorderWidth)) {
+        _SetWMSizeHints((WMShellWidget) w);
     }
 
     if (w->shell.override_redirect) {
-	CALLGEOTAT(_XtGeoTrace((Widget)w,"Shell \"%s\" is override redirect, return XtGeometryYes.\n", XtName((Widget)w)));
-    	CALLGEOTAT(_XtGeoTab(-1));
-	return XtGeometryYes;
+        CALLGEOTAT(_XtGeoTrace
+                   ((Widget) w,
+                    "Shell \"%s\" is override redirect, return XtGeometryYes.\n",
+                    XtName((Widget) w)));
+        CALLGEOTAT(_XtGeoTab(-1));
+        return XtGeometryYes;
     }
 
-
     /* If no non-stacking bits are set, there's no way to tell whether
        or not this worked, so assume it did */
 
-    if (!(mask & (unsigned)(~(CWStackMode | CWSibling)))) return XtGeometryYes;
+    if (!(mask & (unsigned) (~(CWStackMode | CWSibling))))
+        return XtGeometryYes;
 
-    if (wm && ((WMShellWidget)w)->wm.wait_for_wm == FALSE) {
-	    /* the window manager is sick
-	     * so I will do the work and
-	     * say no so if a new WM starts up,
-	     * or the current one recovers
-	     * my size requests will be visible
-	     */
-	CALLGEOTAT(_XtGeoTrace((Widget)w,"Shell \"%s\" has wait_for_wm == FALSE, return XtGeometryNo.\n",
-		       XtName((Widget)w)));
-    	CALLGEOTAT(_XtGeoTab(-1));
+    if (wm && ((WMShellWidget) w)->wm.wait_for_wm == FALSE) {
+        /* the window manager is sick
+         * so I will do the work and
+         * say no so if a new WM starts up,
+         * or the current one recovers
+         * my size requests will be visible
+         */
+        CALLGEOTAT(_XtGeoTrace
+                   ((Widget) w,
+                    "Shell \"%s\" has wait_for_wm == FALSE, return XtGeometryNo.\n",
+                    XtName((Widget) w)));
+        CALLGEOTAT(_XtGeoTab(-1));
 
-	PutBackGeometry();
-	return XtGeometryNo;
+        PutBackGeometry();
+        return XtGeometryNo;
     }
 
     if (_wait_for_response(w, &event, request_num)) {
-	/* got an event */
-	if (event.type == ConfigureNotify) {
+        /* got an event */
+        if (event.type == ConfigureNotify) {
 
 #define NEQ(x, msk) ((mask & msk) && (values.x != event.xconfigure.x))
-	    if (NEQ(x, CWX) ||
-		NEQ(y, CWY) ||
-		NEQ(width, CWWidth) ||
-		NEQ(height, CWHeight) ||
-		NEQ(border_width, CWBorderWidth)) {
+            if (NEQ(x, CWX) ||
+                NEQ(y, CWY) ||
+                NEQ(width, CWWidth) ||
+                NEQ(height, CWHeight) || NEQ(border_width, CWBorderWidth)) {
 #ifdef XT_GEO_TATTLER
-		if (NEQ(x, CWX)) {
-		    CALLGEOTAT(_XtGeoTrace((Widget)w,
-					   "received Configure X %d\n",
-					   event.xconfigure.x));
-		}
-		if (NEQ(y, CWY)) {
-		    CALLGEOTAT(_XtGeoTrace((Widget)w,
-					   "received Configure Y %d\n",
-					   event.xconfigure.y));
-		}
-		if (NEQ(width, CWWidth)) {
-		    CALLGEOTAT(_XtGeoTrace((Widget)w,
-					   "received Configure Width %d\n",
-					   event.xconfigure.width));
-		}
-		if (NEQ(height, CWHeight)) {
-		    CALLGEOTAT(_XtGeoTrace((Widget)w,
-					   "received Configure Height %d\n",
-					   event.xconfigure.height));
-		}
-		if (NEQ(border_width, CWBorderWidth)) {
-		    CALLGEOTAT(_XtGeoTrace((Widget)w,
-				        "received Configure BorderWidth %d\n",
-					event.xconfigure.border_width));
-		}
+                if (NEQ(x, CWX)) {
+                    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                           "received Configure X %d\n",
+                                           event.xconfigure.x));
+                }
+                if (NEQ(y, CWY)) {
+                    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                           "received Configure Y %d\n",
+                                           event.xconfigure.y));
+                }
+                if (NEQ(width, CWWidth)) {
+                    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                           "received Configure Width %d\n",
+                                           event.xconfigure.width));
+                }
+                if (NEQ(height, CWHeight)) {
+                    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                           "received Configure Height %d\n",
+                                           event.xconfigure.height));
+                }
+                if (NEQ(border_width, CWBorderWidth)) {
+                    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                           "received Configure BorderWidth %d\n",
+                                           event.xconfigure.border_width));
+                }
 #endif
 #undef NEQ
-		XPutBackEvent(XtDisplay(w), &event);
-		PutBackGeometry();
-		/*
-		 * We just potentially re-ordered the event queue
-		 * w.r.t. ConfigureNotifies with some trepidation.
-		 * But this is probably a Good Thing because we
-		 * will know the new true state of the world sooner
-		 * this way.
-		 */
-		CALLGEOTAT(_XtGeoTrace((Widget)w,
-			   "ConfigureNotify failed, return XtGeometryNo.\n"));
-		CALLGEOTAT(_XtGeoTab(-1));
-
-		return XtGeometryNo;
-	    }
-	    else {
-		w->core.width = (Dimension) event.xconfigure.width;
-		w->core.height = (Dimension) event.xconfigure.height;
-		w->core.border_width = (Dimension) event.xconfigure.border_width;
-		if (event.xany.send_event || /* ICCCM compliant synth */
-		    w->shell.client_specified & _XtShellNotReparented) {
-
-		    w->core.x = (Position) event.xconfigure.x;
-		    w->core.y = (Position) event.xconfigure.y;
-		    w->shell.client_specified |= _XtShellPositionValid;
-		}
-		else w->shell.client_specified &= ~_XtShellPositionValid;
-		CALLGEOTAT(_XtGeoTrace((Widget)w,
-			 "ConfigureNotify succeed, return XtGeometryYes.\n"));
-		CALLGEOTAT(_XtGeoTab(-1));
-		return XtGeometryYes;
-	    }
-	} else if (!wm) {
-	    PutBackGeometry();
-	    CALLGEOTAT(_XtGeoTrace((Widget)w,
-				   "Not wm, return XtGeometryNo.\n"));
-	    CALLGEOTAT(_XtGeoTab(-1));
-	    return XtGeometryNo;
-	} else XtAppWarningMsg(XtWidgetToApplicationContext((Widget)w),
-			       "internalError", "shell", XtCXtToolkitError,
-			       "Shell's window manager interaction is broken",
-			       NULL, NULL);
-    } else if (wm) { /* no event */
-	((WMShellWidget)w)->wm.wait_for_wm = FALSE; /* timed out; must be broken */
+                XPutBackEvent(XtDisplay(w), &event);
+                PutBackGeometry();
+                /*
+                 * We just potentially re-ordered the event queue
+                 * w.r.t. ConfigureNotifies with some trepidation.
+                 * But this is probably a Good Thing because we
+                 * will know the new true state of the world sooner
+                 * this way.
+                 */
+                CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                       "ConfigureNotify failed, return XtGeometryNo.\n"));
+                CALLGEOTAT(_XtGeoTab(-1));
+
+                return XtGeometryNo;
+            }
+            else {
+                w->core.width = (Dimension) event.xconfigure.width;
+                w->core.height = (Dimension) event.xconfigure.height;
+                w->core.border_width =
+                    (Dimension) event.xconfigure.border_width;
+                if (event.xany.send_event ||    /* ICCCM compliant synth */
+                    w->shell.client_specified & _XtShellNotReparented) {
+
+                    w->core.x = (Position) event.xconfigure.x;
+                    w->core.y = (Position) event.xconfigure.y;
+                    w->shell.client_specified |= _XtShellPositionValid;
+                }
+                else
+                    w->shell.client_specified &= ~_XtShellPositionValid;
+                CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                       "ConfigureNotify succeed, return XtGeometryYes.\n"));
+                CALLGEOTAT(_XtGeoTab(-1));
+                return XtGeometryYes;
+            }
+        }
+        else if (!wm) {
+            PutBackGeometry();
+            CALLGEOTAT(_XtGeoTrace((Widget) w,
+                                   "Not wm, return XtGeometryNo.\n"));
+            CALLGEOTAT(_XtGeoTab(-1));
+            return XtGeometryNo;
+        }
+        else
+            XtAppWarningMsg(XtWidgetToApplicationContext((Widget) w),
+                            "internalError", "shell", XtCXtToolkitError,
+                            "Shell's window manager interaction is broken",
+                            NULL, NULL);
+    }
+    else if (wm) {              /* no event */
+        ((WMShellWidget) w)->wm.wait_for_wm = FALSE;    /* timed out; must be broken */
     }
     PutBackGeometry();
 #undef PutBackGeometry
-    CALLGEOTAT(_XtGeoTrace((Widget)w,
-			   "Timeout passed?, return XtGeometryNo.\n"));
+    CALLGEOTAT(_XtGeoTrace((Widget) w,
+                           "Timeout passed?, return XtGeometryNo.\n"));
     CALLGEOTAT(_XtGeoTab(-1));
     return XtGeometryNo;
-		}
-
-/* ARGSUSED */
-static Boolean SetValues(
-	Widget old, Widget ref, Widget new,
-	ArgList args,
-	Cardinal *num_args)
-{
-	ShellWidget nw = (ShellWidget) new;
-	ShellWidget ow = (ShellWidget) old;
-	Mask mask = 0;
-	XSetWindowAttributes attr;
-
-	if (!XtIsRealized(new))
-	    return False;
-
-	if (ow->shell.save_under != nw->shell.save_under) {
-	    mask = CWSaveUnder;
-	    attr.save_under = nw->shell.save_under;
-	}
-
-	if (ow->shell.override_redirect != nw->shell.override_redirect) {
-	    mask |= CWOverrideRedirect;
-	    attr.override_redirect = nw->shell.override_redirect;
-	}
-
-	if (mask) {
-	    XChangeWindowAttributes(XtDisplay(new),XtWindow(new), mask, &attr);
-	    if ((mask & CWOverrideRedirect) && !nw->shell.override_redirect)
-		_popup_set_prop(nw);
-	}
-
-	if (! (ow->shell.client_specified & _XtShellPositionValid)) {
-	    Cardinal n;
-
-	    for (n = *num_args; n; n--, args++) {
-		if (strcmp(XtNx, args->name) == 0) {
-		    _XtShellGetCoordinates((Widget)ow, &ow->core.x,
-							&ow->core.y);
-		} else if (strcmp(XtNy, args->name) == 0) {
-		    _XtShellGetCoordinates((Widget)ow, &ow->core.x,
-							&ow->core.y);
-		}
-	    }
-	}
-	return FALSE;
-}
-
-/* ARGSUSED */
-static Boolean WMSetValues(
-	Widget old, Widget ref, Widget new,
-	ArgList args,		/* unused */
-	Cardinal *num_args)	/* unused */
-{
-	WMShellWidget nwmshell = (WMShellWidget) new;
-	WMShellWidget owmshell = (WMShellWidget) old;
-	Boolean set_prop
-	    = XtIsRealized(new) && !nwmshell->shell.override_redirect;
-	Boolean title_changed;
-
-	EvaluateSizeHints(nwmshell);
+}
+
+static Boolean
+SetValues(Widget old,
+          Widget ref _X_UNUSED,
+          Widget new,
+          ArgList args,
+          Cardinal *num_args)
+{
+    ShellWidget nw = (ShellWidget) new;
+    ShellWidget ow = (ShellWidget) old;
+    Mask mask = 0;
+    XSetWindowAttributes attr;
+
+    if (!XtIsRealized(new))
+        return False;
+
+    if (ow->shell.save_under != nw->shell.save_under) {
+        mask = CWSaveUnder;
+        attr.save_under = nw->shell.save_under;
+    }
+
+    if (ow->shell.override_redirect != nw->shell.override_redirect) {
+        mask |= CWOverrideRedirect;
+        attr.override_redirect = nw->shell.override_redirect;
+    }
+
+    if (mask) {
+        XChangeWindowAttributes(XtDisplay(new), XtWindow(new), mask, &attr);
+        if ((mask & CWOverrideRedirect) && !nw->shell.override_redirect)
+            _popup_set_prop(nw);
+    }
+
+    if (!(ow->shell.client_specified & _XtShellPositionValid)) {
+        Cardinal n;
+
+        for (n = *num_args; n; n--, args++) {
+            if (strcmp(XtNx, args->name) == 0) {
+                _XtShellGetCoordinates((Widget) ow, &ow->core.x, &ow->core.y);
+            }
+            else if (strcmp(XtNy, args->name) == 0) {
+                _XtShellGetCoordinates((Widget) ow, &ow->core.x, &ow->core.y);
+            }
+        }
+    }
+    return FALSE;
+}
+
+static Boolean
+WMSetValues(Widget old,
+            Widget ref _X_UNUSED,
+            Widget new,
+            ArgList args _X_UNUSED,
+            Cardinal *num_args _X_UNUSED)
+{
+    WMShellWidget nwmshell = (WMShellWidget) new;
+    WMShellWidget owmshell = (WMShellWidget) old;
+    Boolean set_prop = XtIsRealized(new) && !nwmshell->shell.override_redirect;
+    Boolean title_changed;
+
+    EvaluateSizeHints(nwmshell);
 
 #define NEQ(f) (nwmshell->wm.size_hints.f != owmshell->wm.size_hints.f)
 
-	if (set_prop
-	    && (NEQ(flags) || NEQ(min_width) || NEQ(min_height)
-		|| NEQ(max_width) || NEQ(max_height)
-		|| NEQ(width_inc) || NEQ(height_inc)
-		|| NEQ(min_aspect.x) || NEQ(min_aspect.y)
-		|| NEQ(max_aspect.x) || NEQ(max_aspect.y)
+    if (set_prop && (NEQ(flags) || NEQ(min_width) || NEQ(min_height)
+                     || NEQ(max_width) || NEQ(max_height)
+                     || NEQ(width_inc) || NEQ(height_inc)
+                     || NEQ(min_aspect.x) || NEQ(min_aspect.y)
+                     || NEQ(max_aspect.x) || NEQ(max_aspect.y)
 #undef NEQ
 #define NEQ(f) (nwmshell->wm.f != owmshell->wm.f)
-
-		|| NEQ(base_width) || NEQ(base_height) || NEQ(win_gravity))) {
-	    _SetWMSizeHints(nwmshell);
-	}
+                     || NEQ(base_width) || NEQ(base_height) ||
+                     NEQ(win_gravity))) {
+        _SetWMSizeHints(nwmshell);
+    }
 #undef NEQ
 
-	if (nwmshell->wm.title != owmshell->wm.title) {
-	    XtFree(owmshell->wm.title);
-	    if (! nwmshell->wm.title) nwmshell->wm.title = (_XtString) "";
-	    nwmshell->wm.title = XtNewString(nwmshell->wm.title);
-	    title_changed = True;
-	} else
-	    title_changed = False;
-
-	if (set_prop
-	    && (title_changed ||
-		nwmshell->wm.title_encoding != owmshell->wm.title_encoding)) {
-
-	    XTextProperty title;
-	    Boolean copied = False;
-
-            if (nwmshell->wm.title_encoding == None &&
-		XmbTextListToTextProperty(XtDisplay(new),
-					  (char**)&nwmshell->wm.title,
-					  1, XStdICCTextStyle,
-					  &title) >= Success) {
-		copied = True;
-	    } else {
-		title.value = (unsigned char*)nwmshell->wm.title;
-		title.encoding = nwmshell->wm.title_encoding ?
-		    nwmshell->wm.title_encoding : XA_STRING;
-		title.format = 8;
-		title.nitems = strlen(nwmshell->wm.title);
-	    }
-	    XSetWMName(XtDisplay(new), XtWindow(new), &title);
-	    if (copied)
-		XFree((XPointer)title.value);
-	}
-
-	EvaluateWMHints(nwmshell);
-
-#define NEQ(f)	(nwmshell->wm.wm_hints.f != owmshell->wm.wm_hints.f)
-
-	if (set_prop
-	    && (NEQ(flags) || NEQ(input) || NEQ(initial_state)
-		|| NEQ(icon_x) || NEQ(icon_y)
-		|| NEQ(icon_pixmap) || NEQ(icon_mask) || NEQ(icon_window)
-		|| NEQ(window_group))) {
-
-	    XSetWMHints(XtDisplay(new), XtWindow(new), &nwmshell->wm.wm_hints);
-	}
+    if (nwmshell->wm.title != owmshell->wm.title) {
+        XtFree(owmshell->wm.title);
+        if (!nwmshell->wm.title)
+            nwmshell->wm.title = (_XtString) "";
+        nwmshell->wm.title = XtNewString(nwmshell->wm.title);
+        title_changed = True;
+    }
+    else
+        title_changed = False;
+
+    if (set_prop
+        && (title_changed ||
+            nwmshell->wm.title_encoding != owmshell->wm.title_encoding)) {
+
+        XTextProperty title;
+        Boolean copied = False;
+
+        if (nwmshell->wm.title_encoding == None &&
+            XmbTextListToTextProperty(XtDisplay(new),
+                                      (char **) &nwmshell->wm.title,
+                                      1, XStdICCTextStyle, &title) >= Success) {
+            copied = True;
+        }
+        else {
+            title.value = (unsigned char *) nwmshell->wm.title;
+            title.encoding = nwmshell->wm.title_encoding ?
+                nwmshell->wm.title_encoding : XA_STRING;
+            title.format = 8;
+            title.nitems = strlen(nwmshell->wm.title);
+        }
+        XSetWMName(XtDisplay(new), XtWindow(new), &title);
+        if (copied)
+            XFree((XPointer) title.value);
+    }
+
+    EvaluateWMHints(nwmshell);
+
+#define NEQ(f)  (nwmshell->wm.wm_hints.f != owmshell->wm.wm_hints.f)
+
+    if (set_prop && (NEQ(flags) || NEQ(input) || NEQ(initial_state)
+                     || NEQ(icon_x) || NEQ(icon_y)
+                     || NEQ(icon_pixmap) || NEQ(icon_mask) || NEQ(icon_window)
+                     || NEQ(window_group))) {
+
+        XSetWMHints(XtDisplay(new), XtWindow(new), &nwmshell->wm.wm_hints);
+    }
 #undef NEQ
 
- 	if (XtIsRealized(new) &&
-	    nwmshell->wm.transient != owmshell->wm.transient) {
- 	    if (nwmshell->wm.transient) {
-		if (!XtIsTransientShell(new) &&
-		    !nwmshell->shell.override_redirect &&
-		    nwmshell->wm.wm_hints.window_group !=
-		       XtUnspecifiedWindowGroup)
-		    XSetTransientForHint(XtDisplay(new), XtWindow(new),
-					 nwmshell->wm.wm_hints.window_group);
-	    }
- 	    else XDeleteProperty(XtDisplay(new), XtWindow(new),
- 				 XA_WM_TRANSIENT_FOR);
- 	}
-
-	if (nwmshell->wm.client_leader != owmshell->wm.client_leader
-	    && XtWindow(new) && !nwmshell->shell.override_redirect) {
-	    Widget leader = GetClientLeader(new);
-	    if (XtWindow(leader))
-		XChangeProperty(XtDisplay(new), XtWindow(new),
-				XInternAtom(XtDisplay(new),
-					    "WM_CLIENT_LEADER", False),
-				XA_WINDOW, 32, PropModeReplace,
-				(unsigned char *) &(leader->core.window), 1);
-	}
-
-	if (nwmshell->wm.window_role != owmshell->wm.window_role) {
-	    XtFree((_XtString) owmshell->wm.window_role);
-	    if (set_prop && nwmshell->wm.window_role) {
-		XChangeProperty(XtDisplay(new), XtWindow(new),
-				XInternAtom(XtDisplay(new), "WM_WINDOW_ROLE",
-					    False),
-				XA_STRING, 8, PropModeReplace,
-				(unsigned char *)nwmshell->wm.window_role,
-				(int) strlen(nwmshell->wm.window_role));
-	    } else if (XtIsRealized(new) && ! nwmshell->wm.window_role) {
-		XDeleteProperty(XtDisplay(new), XtWindow(new),
-				XInternAtom(XtDisplay(new), "WM_WINDOW_ROLE",
-					    False));
-	    }
-	}
-
-	return FALSE;
-}
-
-/*ARGSUSED*/
-static Boolean TransientSetValues(
-     Widget oldW, Widget refW, Widget newW,
-     ArgList args,		/* unused */
-     Cardinal *num_args)	/* unused */
-{
-    TransientShellWidget old = (TransientShellWidget)oldW;
-    TransientShellWidget new = (TransientShellWidget)newW;
+    if (XtIsRealized(new) && nwmshell->wm.transient != owmshell->wm.transient) {
+        if (nwmshell->wm.transient) {
+            if (!XtIsTransientShell(new) &&
+                !nwmshell->shell.override_redirect &&
+                nwmshell->wm.wm_hints.window_group != XtUnspecifiedWindowGroup)
+                XSetTransientForHint(XtDisplay(new), XtWindow(new),
+                                     nwmshell->wm.wm_hints.window_group);
+        }
+        else
+            XDeleteProperty(XtDisplay(new), XtWindow(new), XA_WM_TRANSIENT_FOR);
+    }
+
+    if (nwmshell->wm.client_leader != owmshell->wm.client_leader
+        && XtWindow(new) && !nwmshell->shell.override_redirect) {
+        Widget leader = GetClientLeader(new);
+
+        if (XtWindow(leader))
+            XChangeProperty(XtDisplay(new), XtWindow(new),
+                            XInternAtom(XtDisplay(new),
+                                        "WM_CLIENT_LEADER", False),
+                            XA_WINDOW, 32, PropModeReplace,
+                            (unsigned char *) &(leader->core.window), 1);
+    }
+
+    if (nwmshell->wm.window_role != owmshell->wm.window_role) {
+        XtFree((_XtString) owmshell->wm.window_role);
+        if (set_prop && nwmshell->wm.window_role) {
+            XChangeProperty(XtDisplay(new), XtWindow(new),
+                            XInternAtom(XtDisplay(new), "WM_WINDOW_ROLE",
+                                        False),
+                            XA_STRING, 8, PropModeReplace,
+                            (unsigned char *) nwmshell->wm.window_role,
+                            (int) strlen(nwmshell->wm.window_role));
+        }
+        else if (XtIsRealized(new) && !nwmshell->wm.window_role) {
+            XDeleteProperty(XtDisplay(new), XtWindow(new),
+                            XInternAtom(XtDisplay(new), "WM_WINDOW_ROLE",
+                                        False));
+        }
+    }
+
+    return FALSE;
+}
+
+static Boolean
+TransientSetValues(Widget oldW,
+                   Widget refW _X_UNUSED,
+                   Widget newW,
+                   ArgList args _X_UNUSED,
+                   Cardinal *num_args _X_UNUSED)
+{
+    TransientShellWidget old = (TransientShellWidget) oldW;
+    TransientShellWidget new = (TransientShellWidget) newW;
 
     if (XtIsRealized(newW)
-	&& ((new->wm.transient && !old->wm.transient)
-	    || ((new->transient.transient_for != old->transient.transient_for)
-		|| (new->transient.transient_for == NULL
-		    && (new->wm.wm_hints.window_group
-			!= old->wm.wm_hints.window_group))))) {
+        && ((new->wm.transient && !old->wm.transient)
+            || ((new->transient.transient_for != old->transient.transient_for)
+                || (new->transient.transient_for == NULL
+                    && (new->wm.wm_hints.window_group
+                        != old->wm.wm_hints.window_group))))) {
 
-	_SetTransientForHint(new, True);
+        _SetTransientForHint(new, True);
     }
     return False;
 }
 
-
-/* ARGSUSED */
-static Boolean TopLevelSetValues(
-     Widget oldW, Widget refW, Widget newW,
-     ArgList args,		/* unused */
-     Cardinal *num_args)	/* unused */
+static Boolean
+TopLevelSetValues(Widget oldW,
+                  Widget refW _X_UNUSED,
+                  Widget newW,
+                  ArgList args _X_UNUSED,
+                  Cardinal *num_args _X_UNUSED)
 {
-    TopLevelShellWidget old = (TopLevelShellWidget)oldW;
-    TopLevelShellWidget new = (TopLevelShellWidget)newW;
+    TopLevelShellWidget old = (TopLevelShellWidget) oldW;
+    TopLevelShellWidget new = (TopLevelShellWidget) newW;
     Boolean name_changed;
 
     if (old->topLevel.icon_name != new->topLevel.icon_name) {
-	XtFree((XtPointer)old->topLevel.icon_name);
-	if (! new->topLevel.icon_name) new->topLevel.icon_name = (_XtString) "";
-	new->topLevel.icon_name = XtNewString(new->topLevel.icon_name);
-	name_changed = True;
-    } else
-	name_changed = False;
+        XtFree((XtPointer) old->topLevel.icon_name);
+        if (!new->topLevel.icon_name)
+            new->topLevel.icon_name = (_XtString) "";
+        new->topLevel.icon_name = XtNewString(new->topLevel.icon_name);
+        name_changed = True;
+    }
+    else
+        name_changed = False;
 
     if (XtIsRealized(newW)) {
-	if (new->topLevel.iconic != old->topLevel.iconic) {
-	    if (new->topLevel.iconic)
-		XIconifyWindow(XtDisplay(newW),
-			       XtWindow(newW),
-			       XScreenNumberOfScreen(XtScreen(newW))
-			       );
-	    else {
-		Boolean map = new->shell.popped_up;
-		XtPopup(newW, XtGrabNone);
-		if (map) XMapWindow(XtDisplay(newW), XtWindow(newW));
-	    }
-	}
-
-	if (!new->shell.override_redirect &&
-	    (name_changed ||
-	     (old->topLevel.icon_name_encoding
-	      != new->topLevel.icon_name_encoding))) {
-
-	    XTextProperty icon_name;
-	    Boolean copied = False;
+        if (new->topLevel.iconic != old->topLevel.iconic) {
+            if (new->topLevel.iconic)
+                XIconifyWindow(XtDisplay(newW),
+                               XtWindow(newW),
+                               XScreenNumberOfScreen(XtScreen(newW))
+                    );
+            else {
+                Boolean map = new->shell.popped_up;
+
+                XtPopup(newW, XtGrabNone);
+                if (map)
+                    XMapWindow(XtDisplay(newW), XtWindow(newW));
+            }
+        }
+
+        if (!new->shell.override_redirect &&
+            (name_changed ||
+             (old->topLevel.icon_name_encoding
+              != new->topLevel.icon_name_encoding))) {
+
+            XTextProperty icon_name;
+            Boolean copied = False;
 
             if (new->topLevel.icon_name_encoding == None &&
-		XmbTextListToTextProperty(XtDisplay(newW),
-					  (char**) &new->topLevel.icon_name,
-					  1, XStdICCTextStyle,
-					  &icon_name) >= Success) {
-		copied = True;
-	    } else {
-		icon_name.value = (unsigned char *)new->topLevel.icon_name;
-		icon_name.encoding = new->topLevel.icon_name_encoding ?
-		    new->topLevel.icon_name_encoding : XA_STRING;
-		icon_name.format = 8;
-		icon_name.nitems = strlen((char *)icon_name.value);
-	    }
-	    XSetWMIconName(XtDisplay(newW), XtWindow(newW), &icon_name);
-	    if (copied)
-		XFree((XPointer)icon_name.value);
-	}
+                XmbTextListToTextProperty(XtDisplay(newW),
+                                          (char **) &new->topLevel.icon_name,
+                                          1, XStdICCTextStyle,
+                                          &icon_name) >= Success) {
+                copied = True;
+            }
+            else {
+                icon_name.value = (unsigned char *) new->topLevel.icon_name;
+                icon_name.encoding = new->topLevel.icon_name_encoding ?
+                    new->topLevel.icon_name_encoding : XA_STRING;
+                icon_name.format = 8;
+                icon_name.nitems = strlen((char *) icon_name.value);
+            }
+            XSetWMIconName(XtDisplay(newW), XtWindow(newW), &icon_name);
+            if (copied)
+                XFree((XPointer) icon_name.value);
+        }
     }
     else if (new->topLevel.iconic != old->topLevel.iconic) {
-	if (new->topLevel.iconic)
-	    new->wm.wm_hints.initial_state = IconicState;
+        if (new->topLevel.iconic)
+            new->wm.wm_hints.initial_state = IconicState;
     }
     return False;
 }
 
-static _XtString * NewArgv(
-    int count,
-    _XtString *str)  /* do not assume it's terminated by a NULL element */
-{
+/* do not assume it's terminated by a NULL element */
+static _XtString *
+NewArgv(int count, _XtString *str)
+{                 
     Cardinal nbytes = 0;
     Cardinal num = 0;
     _XtString *newarray;
@@ -2487,62 +2574,64 @@ static _XtString * NewArgv(
     _XtString *strarray = str;
     _XtString sptr;
 
-    if (count <= 0 || !str) return NULL;
+    if (count <= 0 || !str)
+        return NULL;
 
     for (num = (Cardinal) count; num--; str++) {
-	nbytes = (nbytes + (Cardinal) strlen(*str));
-	nbytes++;
+        nbytes = (nbytes + (Cardinal) strlen(*str));
+        nbytes++;
     }
-    num = (Cardinal) ((size_t)(count+1) * sizeof(_XtString));
+    num = (Cardinal) ((size_t) (count + 1) * sizeof(_XtString));
     new = newarray = (_XtString *) __XtMalloc(num + nbytes);
     sptr = ((char *) new) + num;
 
     for (str = strarray; count--; str++) {
-	*new = sptr;
-	strcpy(*new, *str);
-	new++;
-	sptr = strchr(sptr, '\0');
-	sptr++;
+        *new = sptr;
+        strcpy(*new, *str);
+        new++;
+        sptr = strchr(sptr, '\0');
+        sptr++;
     }
     *new = NULL;
     return newarray;
 }
 
-
-/*ARGSUSED*/
-static Boolean ApplicationSetValues(
-    Widget current, Widget request, Widget new,
-    ArgList args,
-    Cardinal *num_args)
+static Boolean
+ApplicationSetValues(Widget current,
+                     Widget request _X_UNUSED,
+                     Widget new,
+                     ArgList args _X_UNUSED,
+                     Cardinal *num_args _X_UNUSED)
 {
     ApplicationShellWidget nw = (ApplicationShellWidget) new;
     ApplicationShellWidget cw = (ApplicationShellWidget) current;
 
     if (cw->application.argc != nw->application.argc ||
-	cw->application.argv != nw->application.argv) {
-
-	if (nw->application.argc > 0)
-	    nw->application.argv = NewArgv(nw->application.argc,
-					   nw->application.argv);
-	if (cw->application.argc > 0)
-	    FreeStringArray(cw->application.argv);
-
-	if (XtIsRealized(new) && !nw->shell.override_redirect) {
-	    if (nw->application.argc >= 0 && nw->application.argv)
-		XSetCommand(XtDisplay(new), XtWindow(new),
-			    nw->application.argv, nw->application.argc);
-	    else
-		XDeleteProperty(XtDisplay(new), XtWindow(new), XA_WM_COMMAND);
-	}
+        cw->application.argv != nw->application.argv) {
+
+        if (nw->application.argc > 0)
+            nw->application.argv = NewArgv(nw->application.argc,
+                                           nw->application.argv);
+        if (cw->application.argc > 0)
+            FreeStringArray(cw->application.argv);
+
+        if (XtIsRealized(new) && !nw->shell.override_redirect) {
+            if (nw->application.argc >= 0 && nw->application.argv)
+                XSetCommand(XtDisplay(new), XtWindow(new),
+                            nw->application.argv, nw->application.argc);
+            else
+                XDeleteProperty(XtDisplay(new), XtWindow(new), XA_WM_COMMAND);
+        }
     }
     return False;
 }
 
-/*ARGSUSED*/
-static Boolean SessionSetValues(
-    Widget current, Widget request, Widget new,
-    ArgList args,
-    Cardinal *num_args)
+static Boolean
+SessionSetValues(Widget current,
+                 Widget request _X_UNUSED,
+                 Widget new,
+                 ArgList args _X_UNUSED,
+                 Cardinal *num_args _X_UNUSED)
 {
 #ifndef XT_NO_SM
     SessionShellWidget nw = (SessionShellWidget) new;
@@ -2552,189 +2641,204 @@ static Boolean SessionSetValues(
     Boolean initialize = False;
 
     if (cw->session.session_id != nw->session.session_id) {
-	nw->session.session_id = XtNewString(nw->session.session_id);
-	XtFree(cw->session.session_id);
+        nw->session.session_id = XtNewString(nw->session.session_id);
+        XtFree(cw->session.session_id);
     }
 
     if (cw->session.clone_command != nw->session.clone_command) {
-	if (nw->session.clone_command) {
-	    nw->session.clone_command =
-		NewStringArray(nw->session.clone_command);
-	    set_mask |= XtCloneCommandMask;
-	} else unset_mask |= XtCloneCommandMask;
-	FreeStringArray(cw->session.clone_command);
+        if (nw->session.clone_command) {
+            nw->session.clone_command =
+                NewStringArray(nw->session.clone_command);
+            set_mask |= XtCloneCommandMask;
+        }
+        else
+            unset_mask |= XtCloneCommandMask;
+        FreeStringArray(cw->session.clone_command);
     }
 
     if (cw->session.current_dir != nw->session.current_dir) {
-	if (nw->session.current_dir) {
-	    nw->session.current_dir =
-		XtNewString(nw->session.current_dir);
-	    set_mask |= XtCurrentDirectoryMask;
-	} else unset_mask |= XtCurrentDirectoryMask;
-	XtFree((char *) cw->session.current_dir);
+        if (nw->session.current_dir) {
+            nw->session.current_dir = XtNewString(nw->session.current_dir);
+            set_mask |= XtCurrentDirectoryMask;
+        }
+        else
+            unset_mask |= XtCurrentDirectoryMask;
+        XtFree((char *) cw->session.current_dir);
     }
 
     if (cw->session.discard_command != nw->session.discard_command) {
-	if (nw->session.discard_command) {
-	    nw->session.discard_command =
-		NewStringArray(nw->session.discard_command);
-	    set_mask |=  XtDiscardCommandMask;
-	} else unset_mask |= XtDiscardCommandMask;
-	FreeStringArray(cw->session.discard_command);
+        if (nw->session.discard_command) {
+            nw->session.discard_command =
+                NewStringArray(nw->session.discard_command);
+            set_mask |= XtDiscardCommandMask;
+        }
+        else
+            unset_mask |= XtDiscardCommandMask;
+        FreeStringArray(cw->session.discard_command);
     }
 
     if (cw->session.environment != nw->session.environment) {
-	if (nw->session.environment) {
-	    nw->session.environment =
-		NewStringArray(nw->session.environment);
-	    set_mask |= XtEnvironmentMask;
-	} else unset_mask |= XtEnvironmentMask;
-	FreeStringArray(cw->session.environment);
+        if (nw->session.environment) {
+            nw->session.environment = NewStringArray(nw->session.environment);
+            set_mask |= XtEnvironmentMask;
+        }
+        else
+            unset_mask |= XtEnvironmentMask;
+        FreeStringArray(cw->session.environment);
     }
 
     if (cw->session.program_path != nw->session.program_path) {
-	if (nw->session.program_path) {
-	    nw->session.program_path =
-		XtNewString(nw->session.program_path);
-	    set_mask |= XtProgramMask;
-	} else unset_mask |= XtProgramMask;
-	XtFree((char *) cw->session.program_path);
+        if (nw->session.program_path) {
+            nw->session.program_path = XtNewString(nw->session.program_path);
+            set_mask |= XtProgramMask;
+        }
+        else
+            unset_mask |= XtProgramMask;
+        XtFree((char *) cw->session.program_path);
     }
 
     if (cw->session.resign_command != nw->session.resign_command) {
-	if (nw->session.resign_command) {
-	    nw->session.resign_command =
-		NewStringArray(nw->session.resign_command);
-	    set_mask |= XtResignCommandMask;
-	} else set_mask |= XtResignCommandMask;
-	FreeStringArray(cw->session.resign_command);
+        if (nw->session.resign_command) {
+            nw->session.resign_command =
+                NewStringArray(nw->session.resign_command);
+            set_mask |= XtResignCommandMask;
+        }
+        else
+            set_mask |= XtResignCommandMask;
+        FreeStringArray(cw->session.resign_command);
     }
 
     if (cw->session.restart_command != nw->session.restart_command) {
-	if (nw->session.restart_command) {
-	    nw->session.restart_command =
-		NewStringArray(nw->session.restart_command);
-	    set_mask |= XtRestartCommandMask;
-	} else unset_mask |= XtRestartCommandMask;
-	FreeStringArray(cw->session.restart_command);
+        if (nw->session.restart_command) {
+            nw->session.restart_command =
+                NewStringArray(nw->session.restart_command);
+            set_mask |= XtRestartCommandMask;
+        }
+        else
+            unset_mask |= XtRestartCommandMask;
+        FreeStringArray(cw->session.restart_command);
     }
 
     if (cw->session.restart_style != nw->session.restart_style)
-	set_mask |= XtRestartStyleHintMask;
+        set_mask |= XtRestartStyleHintMask;
 
     if (cw->session.shutdown_command != nw->session.shutdown_command) {
-	if (nw->session.shutdown_command) {
-	    nw->session.shutdown_command =
-		NewStringArray(nw->session.shutdown_command);
-	    set_mask |= XtShutdownCommandMask;
-	} else unset_mask |= XtShutdownCommandMask;
-	FreeStringArray(cw->session.shutdown_command);
+        if (nw->session.shutdown_command) {
+            nw->session.shutdown_command =
+                NewStringArray(nw->session.shutdown_command);
+            set_mask |= XtShutdownCommandMask;
+        }
+        else
+            unset_mask |= XtShutdownCommandMask;
+        FreeStringArray(cw->session.shutdown_command);
     }
 
     if ((!cw->session.join_session && nw->session.join_session) ||
-	(!cw->session.connection && nw->session.connection)) {
-	JoinSession(nw);
-	initialize = True;
+        (!cw->session.connection && nw->session.connection)) {
+        JoinSession(nw);
+        initialize = True;
     }
 
     if (nw->session.connection && (set_mask || unset_mask || initialize))
-	SetSessionProperties((SessionShellWidget) new, initialize, set_mask, unset_mask);
+        SetSessionProperties((SessionShellWidget) new, initialize, set_mask,
+                             unset_mask);
 
     if ((cw->session.join_session && !nw->session.join_session) ||
-	(cw->session.connection && !nw->session.connection))
-	StopManagingSession(nw, nw->session.connection);
-#endif /* !XT_NO_SM */
+        (cw->session.connection && !nw->session.connection))
+        StopManagingSession(nw, nw->session.connection);
+#endif                          /* !XT_NO_SM */
 
     if (cw->wm.client_leader != nw->wm.client_leader ||
-	cw->session.session_id != nw->session.session_id) {
-	Widget leader;
-	if (cw->session.session_id) {
-	    leader = GetClientLeader(current);
-	    if (XtWindow(leader))
-		XDeleteProperty(XtDisplay(leader), XtWindow(leader),
-				XInternAtom(XtDisplay(leader), "SM_CLIENT_ID",
-					    False));
-	}
-	if (nw->session.session_id) {
-	    leader = GetClientLeader(new);
-	    if (XtWindow(leader))
-		XChangeProperty(XtDisplay(leader), XtWindow(leader),
-				XInternAtom(XtDisplay(leader), "SM_CLIENT_ID",
-					    False),
-				XA_STRING, 8, PropModeReplace,
-				(unsigned char *) nw->session.session_id,
-				(int) strlen(nw->session.session_id));
-	}
+        cw->session.session_id != nw->session.session_id) {
+        Widget leader;
+
+        if (cw->session.session_id) {
+            leader = GetClientLeader(current);
+            if (XtWindow(leader))
+                XDeleteProperty(XtDisplay(leader), XtWindow(leader),
+                                XInternAtom(XtDisplay(leader), "SM_CLIENT_ID",
+                                            False));
+        }
+        if (nw->session.session_id) {
+            leader = GetClientLeader(new);
+            if (XtWindow(leader))
+                XChangeProperty(XtDisplay(leader), XtWindow(leader),
+                                XInternAtom(XtDisplay(leader), "SM_CLIENT_ID",
+                                            False),
+                                XA_STRING, 8, PropModeReplace,
+                                (unsigned char *) nw->session.session_id,
+                                (int) strlen(nw->session.session_id));
+        }
     }
     return False;
 }
 
-void _XtShellGetCoordinates(
-    Widget widget,
-    Position* x,
-    Position* y)
+void
+_XtShellGetCoordinates(Widget widget, Position *x, Position *y)
 {
-    ShellWidget w = (ShellWidget)widget;
+    ShellWidget w = (ShellWidget) widget;
+
     if (XtIsRealized(widget) &&
-	!(w->shell.client_specified & _XtShellPositionValid)) {
-	int tmpx, tmpy;
-	Window tmpchild;
-	(void) XTranslateCoordinates(XtDisplay(w), XtWindow(w),
-				     RootWindowOfScreen(XtScreen(w)),
-				     (int) -w->core.border_width,
-				     (int) -w->core.border_width,
-				     &tmpx, &tmpy, &tmpchild);
-	w->core.x = (Position) tmpx;
-	w->core.y = (Position) tmpy;
-	w->shell.client_specified |= _XtShellPositionValid;
+        !(w->shell.client_specified & _XtShellPositionValid)) {
+        int tmpx, tmpy;
+        Window tmpchild;
+
+        (void) XTranslateCoordinates(XtDisplay(w), XtWindow(w),
+                                     RootWindowOfScreen(XtScreen(w)),
+                                     (int) -w->core.border_width,
+                                     (int) -w->core.border_width,
+                                     &tmpx, &tmpy, &tmpchild);
+        w->core.x = (Position) tmpx;
+        w->core.y = (Position) tmpy;
+        w->shell.client_specified |= _XtShellPositionValid;
     }
     *x = w->core.x;
     *y = w->core.y;
 }
 
-static void GetValuesHook(
-    Widget	widget,
-    ArgList	args,
-    Cardinal*	num_args)
+static void
+GetValuesHook(Widget widget, ArgList args, Cardinal *num_args)
 {
     ShellWidget w = (ShellWidget) widget;
 
     /* x and y resource values may be invalid after a shell resize */
     if (XtIsRealized(widget) &&
-	!(w->shell.client_specified & _XtShellPositionValid)) {
-	Cardinal	n;
-	Position	x, y;
-
-	for (n = *num_args; n; n--, args++) {
-	    if (strcmp(XtNx, args->name) == 0) {
-		_XtShellGetCoordinates(widget, &x, &y);
-		_XtCopyToArg((char *) &x, &args->value, sizeof(Position));
-	    } else if (strcmp(XtNy, args->name) == 0) {
-		_XtShellGetCoordinates(widget, &x, &y);
-		_XtCopyToArg((char *) &y, &args->value, sizeof(Position));
-	    }
-	}
+        !(w->shell.client_specified & _XtShellPositionValid)) {
+        Cardinal n;
+        Position x, y;
+
+        for (n = *num_args; n; n--, args++) {
+            if (strcmp(XtNx, args->name) == 0) {
+                _XtShellGetCoordinates(widget, &x, &y);
+                _XtCopyToArg((char *) &x, &args->value, sizeof(Position));
+            }
+            else if (strcmp(XtNy, args->name) == 0) {
+                _XtShellGetCoordinates(widget, &x, &y);
+                _XtCopyToArg((char *) &y, &args->value, sizeof(Position));
+            }
+        }
     }
 }
 
-static void ApplicationShellInsertChild(
-    Widget widget)
+static void
+ApplicationShellInsertChild(Widget widget)
 {
-    if (! XtIsWidget(widget) && XtIsRectObj(widget)) {
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-	       "invalidClass", "applicationShellInsertChild", XtCXtToolkitError,
-	       "ApplicationShell does not accept RectObj children; ignored",
-	       NULL, NULL);
+    if (!XtIsWidget(widget) && XtIsRectObj(widget)) {
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidClass", "applicationShellInsertChild",
+                        XtCXtToolkitError,
+                        "ApplicationShell does not accept RectObj children; ignored",
+                        NULL, NULL);
     }
     else {
-	XtWidgetProc insert_child;
+        XtWidgetProc insert_child;
 
-	LOCK_PROCESS;
-	insert_child =
-	    ((CompositeWidgetClass)applicationShellClassRec.core_class.
-	   superclass)->composite_class.insert_child;
-	UNLOCK_PROCESS;
-	(*insert_child) (widget);
+        LOCK_PROCESS;
+        insert_child =
+            ((CompositeWidgetClass) applicationShellClassRec.core_class.
+             superclass)->composite_class.insert_child;
+        UNLOCK_PROCESS;
+        (*insert_child) (widget);
     }
 }
 
@@ -2744,10 +2848,10 @@ static void ApplicationShellInsertChild(
 
  *************************************************************************/
 
-#define XtSessionCheckpoint	0
-#define XtSessionInteract	1
+#define XtSessionCheckpoint     0
+#define XtSessionInteract       1
 
-static void CallSaveCallbacks(SessionShellWidget );
+static void CallSaveCallbacks(SessionShellWidget);
 static _XtString *EditCommand(_XtString, _XtString *, _XtString *);
 static Boolean ExamineToken(XtPointer);
 static void GetIceEvent(XtPointer, int *, XtInputId *);
@@ -2758,93 +2862,98 @@ static void XtCallSaveCallbacks(SmcConn, SmPointer, int, Bool, int, Bool);
 static void XtCallSaveCompleteCallbacks(SmcConn, SmPointer);
 
 #ifndef XT_NO_SM
-static void StopManagingSession(
-    SessionShellWidget w,
-    SmcConn connection) /* connection to close, if any */
-{
+static void
+StopManagingSession(SessionShellWidget w, SmcConn connection)
+{                               /* connection to close, if any */
     if (connection)
-	SmcCloseConnection(connection, 0, NULL);
+        SmcCloseConnection(connection, 0, NULL);
 
     if (w->session.input_id) {
-	XtRemoveInput(w->session.input_id);
-	w->session.input_id = 0;
+        XtRemoveInput(w->session.input_id);
+        w->session.input_id = 0;
     }
     w->session.connection = NULL;
 }
 
 #define XT_MSG_LENGTH 256
-static void JoinSession(
-    SessionShellWidget w)
+static void
+JoinSession(SessionShellWidget w)
 {
     IceConn ice_conn;
     SmcCallbacks smcb;
-    char * sm_client_id;
+    char *sm_client_id;
     unsigned long mask;
-    static char context;  /* used to guarantee the connection isn't shared */
+    static char context;        /* used to guarantee the connection isn't shared */
 
     smcb.save_yourself.callback = XtCallSaveCallbacks;
     smcb.die.callback = XtCallDieCallbacks;
     smcb.save_complete.callback = XtCallSaveCompleteCallbacks;
     smcb.shutdown_cancelled.callback = XtCallCancelCallbacks;
     smcb.save_yourself.client_data = smcb.die.client_data =
-	smcb.save_complete.client_data =
-	    smcb.shutdown_cancelled.client_data = (SmPointer) w;
+        smcb.save_complete.client_data =
+        smcb.shutdown_cancelled.client_data = (SmPointer) w;
     mask = SmcSaveYourselfProcMask | SmcDieProcMask |
-	SmcSaveCompleteProcMask | SmcShutdownCancelledProcMask;
+        SmcSaveCompleteProcMask | SmcShutdownCancelledProcMask;
 
     if (w->session.connection) {
-	SmcModifyCallbacks(w->session.connection, mask, &smcb);
-	sm_client_id = SmcClientID(w->session.connection);
-    } else if (getenv("SESSION_MANAGER")) {
-	char error_msg[XT_MSG_LENGTH];
-	error_msg[0] = '\0';
-	w->session.connection =
-	    SmcOpenConnection(NULL, &context, SmProtoMajor, SmProtoMinor,
-			      mask, &smcb, w->session.session_id,
-			      &sm_client_id, XT_MSG_LENGTH, error_msg);
-	if (error_msg[0]) {
-	    String params[1];
-	    Cardinal num_params = 1;
-	    params[0] = error_msg;
-	    XtAppWarningMsg(XtWidgetToApplicationContext((Widget) w),
-			    "sessionManagement", "SmcOpenConnection",
-			    XtCXtToolkitError,
-			    "Tried to connect to session manager, %s",
-			    params, &num_params);
-	}
+        SmcModifyCallbacks(w->session.connection, mask, &smcb);
+        sm_client_id = SmcClientID(w->session.connection);
+    }
+    else if (getenv("SESSION_MANAGER")) {
+        char error_msg[XT_MSG_LENGTH];
+
+        error_msg[0] = '\0';
+        w->session.connection =
+            SmcOpenConnection(NULL, &context, SmProtoMajor, SmProtoMinor,
+                              mask, &smcb, w->session.session_id,
+                              &sm_client_id, XT_MSG_LENGTH, error_msg);
+        if (error_msg[0]) {
+            String params[1];
+            Cardinal num_params = 1;
+
+            params[0] = error_msg;
+            XtAppWarningMsg(XtWidgetToApplicationContext((Widget) w),
+                            "sessionManagement", "SmcOpenConnection",
+                            XtCXtToolkitError,
+                            "Tried to connect to session manager, %s",
+                            params, &num_params);
+        }
     }
 
     if (w->session.connection) {
-	if (w->session.session_id == NULL
-	    || (strcmp(w->session.session_id, sm_client_id) != 0)) {
-	    XtFree(w->session.session_id);
-	    w->session.session_id = XtNewString(sm_client_id);
-	}
-	free(sm_client_id);
-	ice_conn = SmcGetIceConnection(w->session.connection);
-	w->session.input_id =
-	    XtAppAddInput(XtWidgetToApplicationContext((Widget)w),
-			  IceConnectionNumber(ice_conn),
-			  (XtPointer) XtInputReadMask,
-			  GetIceEvent, (XtPointer) w);
-
-	w->session.restart_command =
-	    EditCommand(w->session.session_id, w->session.restart_command,
-			w->application.argv);
-
-	if (! w->session.clone_command) w->session.clone_command =
-	    EditCommand(NULL, NULL, w->session.restart_command);
-
-	if (! w->session.program_path)
-	    w->session.program_path = w->session.restart_command
-		? XtNewString(w->session.restart_command[0]) : NULL;
+        if (w->session.session_id == NULL
+            || (strcmp(w->session.session_id, sm_client_id) != 0)) {
+            XtFree(w->session.session_id);
+            w->session.session_id = XtNewString(sm_client_id);
+        }
+        free(sm_client_id);
+        ice_conn = SmcGetIceConnection(w->session.connection);
+        w->session.input_id =
+            XtAppAddInput(XtWidgetToApplicationContext((Widget) w),
+                          IceConnectionNumber(ice_conn),
+                          (XtPointer) XtInputReadMask,
+                          GetIceEvent, (XtPointer) w);
+
+        w->session.restart_command =
+            EditCommand(w->session.session_id, w->session.restart_command,
+                        w->application.argv);
+
+        if (!w->session.clone_command)
+            w->session.clone_command =
+                EditCommand(NULL, NULL, w->session.restart_command);
+
+        if (!w->session.program_path)
+            w->session.program_path = w->session.restart_command
+                ? XtNewString(w->session.restart_command[0]) : NULL;
     }
 }
+
 #undef XT_MSG_LENGTH
 
-#endif /* !XT_NO_SM */
+#endif                          /* !XT_NO_SM */
 
-static _XtString * NewStringArray(_XtString *str)
+static _XtString *
+NewStringArray(_XtString *str)
 {
     Cardinal nbytes = 0;
     Cardinal num = 0;
@@ -2853,38 +2962,38 @@ static _XtString * NewStringArray(_XtString *str)
     _XtString *strarray = str;
     _XtString sptr;
 
-    if (!str) return NULL;
+    if (!str)
+        return NULL;
 
     for (num = 0; *str; num++, str++) {
-	nbytes = nbytes + (Cardinal)strlen(*str);
-	nbytes++;
+        nbytes = nbytes + (Cardinal) strlen(*str);
+        nbytes++;
     }
-    num = (Cardinal)((size_t)(num + 1) * sizeof(_XtString));
+    num = (Cardinal) ((size_t) (num + 1) * sizeof(_XtString));
     new = newarray = (_XtString *) __XtMalloc(num + nbytes);
     sptr = ((char *) new) + num;
 
     for (str = strarray; *str; str++) {
-	*new = sptr;
-	strcpy(*new, *str);
-	new++;
-	sptr = strchr(sptr, '\0');
-	sptr++;
+        *new = sptr;
+        strcpy(*new, *str);
+        new++;
+        sptr = strchr(sptr, '\0');
+        sptr++;
     }
     *new = NULL;
     return newarray;
 }
 
-static void FreeStringArray(_XtString *str)
+static void
+FreeStringArray(_XtString *str)
 {
     if (str)
-	XtFree((_XtString) str);
+        XtFree((_XtString) str);
 }
 
-
 #ifndef XT_NO_SM
-static SmProp * CardPack(
-    _Xconst _XtString name,
-    XtPointer closure)
+static SmProp *
+CardPack(_Xconst _XtString name, XtPointer closure)
 {
     unsigned char *prop = (unsigned char *) closure;
     SmProp *p;
@@ -2892,14 +3001,15 @@ static SmProp * CardPack(
     p = (SmProp *) __XtMalloc(sizeof(SmProp) + sizeof(SmPropValue));
     p->vals = (SmPropValue *) (((char *) p) + sizeof(SmProp));
     p->num_vals = 1;
-    p->type = (char *)SmCARD8;
-    p->name = (char *)name;
+    p->type = (char *) SmCARD8;
+    p->name = (char *) name;
     p->vals->length = 1;
     p->vals->value = (SmPointer) prop;
     return p;
 }
 
-static SmProp * ArrayPack(_Xconst _XtString name, XtPointer closure)
+static SmProp *
+ArrayPack(_Xconst _XtString name, XtPointer closure)
 {
     _XtString prop = *(_XtString *) closure;
     SmProp *p;
@@ -2907,16 +3017,15 @@ static SmProp * ArrayPack(_Xconst _XtString name, XtPointer closure)
     p = (SmProp *) __XtMalloc(sizeof(SmProp) + sizeof(SmPropValue));
     p->vals = (SmPropValue *) (((char *) p) + sizeof(SmProp));
     p->num_vals = 1;
-    p->type = (char *)SmARRAY8;
+    p->type = (char *) SmARRAY8;
     p->name = (char *) name;
     p->vals->length = (int) strlen(prop) + 1;
     p->vals->value = prop;
     return p;
 }
 
-static SmProp * ListPack(
-    _Xconst _XtString name,
-    XtPointer closure)
+static SmProp *
+ListPack(_Xconst _XtString name, XtPointer closure)
 {
     _XtString *prop = *(_XtString **) closure;
     SmProp *p;
@@ -2925,36 +3034,38 @@ static SmProp * ListPack(
     int n = 0;
 
     for (ptr = prop; *ptr; ptr++)
-	n++;
-    p = (SmProp*) __XtMalloc((Cardinal)(sizeof(SmProp) + (size_t)n * sizeof(SmPropValue)));
+        n++;
+    p = (SmProp *)
+        __XtMalloc((Cardinal)
+                   (sizeof(SmProp) + (size_t) n * sizeof(SmPropValue)));
     p->vals = (SmPropValue *) (((char *) p) + sizeof(SmProp));
     p->num_vals = n;
-    p->type = (char *)SmLISTofARRAY8;
-    p->name = (char *)name;
+    p->type = (char *) SmLISTofARRAY8;
+    p->name = (char *) name;
     for (ptr = prop, vals = p->vals; *ptr; ptr++, vals++) {
-	vals->length = (int) strlen(*ptr) + 1;
-	vals->value = *ptr;
+        vals->length = (int) strlen(*ptr) + 1;
+        vals->value = *ptr;
     }
     return p;
 }
 
-static void FreePacks(
-    SmProp **props,
-    int num_props)
+static void
+FreePacks(SmProp ** props, int num_props)
 {
     while (--num_props >= 0)
-	XtFree((char *) props[num_props]);
+        XtFree((char *) props[num_props]);
 }
 
-typedef SmProp* (*PackProc)(_Xconst _XtString, XtPointer);
+typedef SmProp *(*PackProc) (_Xconst _XtString, XtPointer);
 
 typedef struct PropertyRec {
-    String	name;
-    int		offset;
-    PackProc	proc;
+    String name;
+    int offset;
+    PackProc proc;
 } PropertyRec, *PropertyTable;
 
 #define Offset(x) (XtOffsetOf(SessionShellRec, x))
+/* *INDENT-OFF* */
 static PropertyRec propertyTable[] = {
   {SmCloneCommand,     Offset(session.clone_command),    ListPack},
   {SmCurrentDirectory, Offset(session.current_dir),      ArrayPack},
@@ -2966,15 +3077,16 @@ static PropertyRec propertyTable[] = {
   {SmRestartStyleHint, Offset(session.restart_style),    CardPack},
   {SmShutdownCommand,  Offset(session.shutdown_command), ListPack}
 };
+/* *INDENT-ON* */
 #undef Offset
 
 #define XT_NUM_SM_PROPS 11
 
-static void SetSessionProperties(
-    SessionShellWidget w,
-    Boolean initialize,
-    unsigned long set_mask,
-    unsigned long unset_mask)
+static void
+SetSessionProperties(SessionShellWidget w,
+                     Boolean initialize,
+                     unsigned long set_mask,
+                     unsigned long unset_mask)
 {
     PropertyTable p = propertyTable;
     int n;
@@ -2984,116 +3096,117 @@ static void SetSessionProperties(
     SmProp *props[XT_NUM_SM_PROPS];
 
     if (w->session.connection == NULL)
-	return;
+        return;
 
     if (initialize) {
-	char nam_buf[32];
-	char pid[12];
-	String user_name;
-	String pidp = pid;
-
-	/* set all non-NULL session properties, the UserID and the ProcessID */
-	for (n = XtNumber(propertyTable); n; n--, p++) {
-	    addr = (XtPointer *) ((char *) w + p->offset);
-	    if (p->proc == CardPack) {
-		if (*(unsigned char *)addr)
-		    props[num_props++] =(*(p->proc))(p->name, (XtPointer)addr);
-	    }
-	    else if (* addr)
-		props[num_props++] = (*(p->proc))(p->name, (XtPointer)addr);
-
-	}
-	user_name = _XtGetUserName(nam_buf, sizeof nam_buf);
-	if (user_name)
-	    props[num_props++] = ArrayPack(SmUserID, &user_name);
-	snprintf(pid, sizeof(pid), "%ld", (long)getpid());
-	props[num_props++] = ArrayPack(SmProcessID, &pidp);
-
-	if (num_props) {
-	    SmcSetProperties(w->session.connection, num_props, props);
-	    FreePacks(props, num_props);
-	}
-	return;
+        char nam_buf[32];
+        char pid[12];
+        String user_name;
+        String pidp = pid;
+
+        /* set all non-NULL session properties, the UserID and the ProcessID */
+        for (n = XtNumber(propertyTable); n; n--, p++) {
+            addr = (XtPointer *) ((char *) w + p->offset);
+            if (p->proc == CardPack) {
+                if (*(unsigned char *) addr)
+                    props[num_props++] =
+                        (*(p->proc)) (p->name, (XtPointer) addr);
+            }
+            else if (*addr)
+                props[num_props++] = (*(p->proc)) (p->name, (XtPointer) addr);
+
+        }
+        user_name = _XtGetUserName(nam_buf, sizeof nam_buf);
+        if (user_name)
+            props[num_props++] = ArrayPack(SmUserID, &user_name);
+        snprintf(pid, sizeof(pid), "%ld", (long) getpid());
+        props[num_props++] = ArrayPack(SmProcessID, &pidp);
+
+        if (num_props) {
+            SmcSetProperties(w->session.connection, num_props, props);
+            FreePacks(props, num_props);
+        }
+        return;
     }
 
     if (set_mask) {
-	mask = 1L;
-	for (n = XtNumber(propertyTable); n; n--, p++, mask <<= 1)
-	    if (mask & set_mask) {
-		addr = (XtPointer *) ((char *) w + p->offset);
-		props[num_props++] = (*(p->proc))(p->name, (XtPointer)addr);
-	    }
-	SmcSetProperties(w->session.connection, num_props, props);
-	FreePacks(props, num_props);
+        mask = 1L;
+        for (n = XtNumber(propertyTable); n; n--, p++, mask <<= 1)
+            if (mask & set_mask) {
+                addr = (XtPointer *) ((char *) w + p->offset);
+                props[num_props++] = (*(p->proc)) (p->name, (XtPointer) addr);
+            }
+        SmcSetProperties(w->session.connection, num_props, props);
+        FreePacks(props, num_props);
     }
 
     if (unset_mask) {
-	char *pnames[XT_NUM_SM_PROPS];
+        char *pnames[XT_NUM_SM_PROPS];
 
-	mask = 1L;
-	num_props = 0;
-	for (n = XtNumber(propertyTable); n; n--, p++, mask <<= 1)
-	    if (mask & unset_mask)
-		pnames[num_props++] = (char *)p->name;
-	SmcDeleteProperties(w->session.connection, num_props, pnames);
+        mask = 1L;
+        num_props = 0;
+        for (n = XtNumber(propertyTable); n; n--, p++, mask <<= 1)
+            if (mask & unset_mask)
+                pnames[num_props++] = (char *) p->name;
+        SmcDeleteProperties(w->session.connection, num_props, pnames);
     }
 }
 
-/*ARGSUSED*/
-static void GetIceEvent(
-    XtPointer	client_data,
-    int *	source,
-    XtInputId *	id)
+static void
+GetIceEvent(XtPointer client_data,
+            int *source _X_UNUSED,
+            XtInputId *id _X_UNUSED)
 {
     SessionShellWidget w = (SessionShellWidget) client_data;
     IceProcessMessagesStatus status;
 
     status = IceProcessMessages(SmcGetIceConnection(w->session.connection),
-				NULL, NULL);
+                                NULL, NULL);
 
     if (status == IceProcessMessagesIOError) {
-	StopManagingSession(w, w->session.connection);
-	XtCallCallbackList((Widget)w, w->session.error_callbacks,
-			   (XtPointer) NULL);
+        StopManagingSession(w, w->session.connection);
+        XtCallCallbackList((Widget) w, w->session.error_callbacks,
+                           (XtPointer) NULL);
     }
 }
 
-static void CleanUpSave(
-    SessionShellWidget w)
+static void
+CleanUpSave(SessionShellWidget w)
 {
     XtSaveYourself next = w->session.save->next;
-    XtFree((char *)w->session.save);
+
+    XtFree((char *) w->session.save);
     w->session.save = next;
     if (w->session.save)
-	CallSaveCallbacks(w);
+        CallSaveCallbacks(w);
 }
 
-static void CallSaveCallbacks(
-    SessionShellWidget w)
+static void
+CallSaveCallbacks(SessionShellWidget w)
 {
     if (XtHasCallbacks((Widget) w, XtNsaveCallback) != XtCallbackHasSome) {
-	/* if the application makes no attempt to save state, report failure */
-	SmcSaveYourselfDone(w->session.connection, False);
-	CleanUpSave(w);
-    } else {
-	XtCheckpointToken token;
+        /* if the application makes no attempt to save state, report failure */
+        SmcSaveYourselfDone(w->session.connection, False);
+        CleanUpSave(w);
+    }
+    else {
+        XtCheckpointToken token;
 
-	w->session.checkpoint_state = XtSaveActive;
-	token = GetToken((Widget) w, XtSessionCheckpoint);
-	_XtCallConditionalCallbackList((Widget)w, w->session.save_callbacks,
-				       (XtPointer)token, ExamineToken);
-	XtSessionReturnToken(token);
+        w->session.checkpoint_state = XtSaveActive;
+        token = GetToken((Widget) w, XtSessionCheckpoint);
+        _XtCallConditionalCallbackList((Widget) w, w->session.save_callbacks,
+                                       (XtPointer) token, ExamineToken);
+        XtSessionReturnToken(token);
     }
 }
 
-/*ARGSUSED*/
-static void XtCallSaveCallbacks(
-    SmcConn	connection,	/* unused */
-    SmPointer	client_data,
-    int		save_type,
-    Bool	shutdown,
-    int		interact,
-    Bool	fast)
+static void
+XtCallSaveCallbacks(SmcConn connection _X_UNUSED,
+                    SmPointer client_data,
+                    int save_type,
+                    Bool shutdown,
+                    int interact,
+                    Bool fast)
 {
     SessionShellWidget w = (SessionShellWidget) client_data;
     XtSaveYourself save;
@@ -3114,117 +3227,106 @@ static void XtCallSaveCallbacks(
 
     prev = (XtSaveYourself) &w->session.save;
     while (prev->next)
-	prev = prev->next;
+        prev = prev->next;
     prev->next = save;
 
     if (w->session.checkpoint_state == XtSaveInactive)
-	CallSaveCallbacks(w);
+        CallSaveCallbacks(w);
 }
 
-static void XtInteractPermission(
-    SmcConn	connection,
-    SmPointer	data)
+static void
+XtInteractPermission(SmcConn connection, SmPointer data)
 {
     Widget w = (Widget) data;
     SessionShellWidget sw = (SessionShellWidget) data;
     XtCallbackProc callback;
     XtPointer client_data;
 
-
-    _XtPeekCallback(w, sw->session.interact_callbacks, &callback,
-		    &client_data);
+    _XtPeekCallback(w, sw->session.interact_callbacks, &callback, &client_data);
     if (callback) {
-	XtCheckpointToken token;
+        XtCheckpointToken token;
 
-	sw->session.checkpoint_state = XtInteractActive;
-	token = GetToken(w, XtSessionInteract);
-    	XtRemoveCallback(w, XtNinteractCallback, callback, client_data);
-	(*callback)(w, client_data, (XtPointer) token);
-    } else if (! sw->session.save->cancel_shutdown) {
-	SmcInteractDone(connection, False);
+        sw->session.checkpoint_state = XtInteractActive;
+        token = GetToken(w, XtSessionInteract);
+        XtRemoveCallback(w, XtNinteractCallback, callback, client_data);
+        (*callback) (w, client_data, (XtPointer) token);
+    }
+    else if (!sw->session.save->cancel_shutdown) {
+        SmcInteractDone(connection, False);
     }
 }
 
-/*ARGSUSED*/
-static void XtCallSaveCompleteCallbacks(
-    SmcConn	connection,
-    SmPointer	client_data)
+static void
+XtCallSaveCompleteCallbacks(SmcConn connection _X_UNUSED, SmPointer client_data)
 {
-    SessionShellWidget w =  (SessionShellWidget) client_data;
+    SessionShellWidget w = (SessionShellWidget) client_data;
 
-    XtCallCallbackList((Widget)w, w->session.save_complete_callbacks,
-		       (XtPointer) NULL);
+    XtCallCallbackList((Widget) w, w->session.save_complete_callbacks,
+                       (XtPointer) NULL);
 }
 
-/*ARGSUSED*/
-static void XtCallNextPhaseCallbacks(
-    SmcConn	connection,	/* unused */
-    SmPointer	client_data)
+static void
+XtCallNextPhaseCallbacks(SmcConn connection _X_UNUSED, SmPointer client_data)
 {
-    SessionShellWidget w =  (SessionShellWidget) client_data;
+    SessionShellWidget w = (SessionShellWidget) client_data;
+
     w->session.save->phase = 2;
     CallSaveCallbacks(w);
 }
 
-/*ARGSUSED*/
-static void XtCallDieCallbacks(
-    SmcConn	connection,	/* unused */
-    SmPointer	client_data)
+static void
+XtCallDieCallbacks(SmcConn connection _X_UNUSED, SmPointer client_data)
 {
-    SessionShellWidget w =  (SessionShellWidget) client_data;
+    SessionShellWidget w = (SessionShellWidget) client_data;
 
     StopManagingSession(w, w->session.connection);
-    XtCallCallbackList((Widget)w, w->session.die_callbacks,
-		       (XtPointer) NULL);
+    XtCallCallbackList((Widget) w, w->session.die_callbacks, (XtPointer) NULL);
 }
 
-/*ARGSUSED*/
-static void XtCallCancelCallbacks(
-    SmcConn	connection,	/* unused */
-    SmPointer	client_data)
+static void
+XtCallCancelCallbacks(SmcConn connection _X_UNUSED, SmPointer client_data)
 {
     SessionShellWidget w = (SessionShellWidget) client_data;
     Boolean call_interacts = False;
 
     if (w->session.checkpoint_state != XtSaveInactive) {
-	w->session.save->cancel_shutdown = True;
-	call_interacts = (w->session.save->interact_style !=
-			  SmInteractStyleNone);
+        w->session.save->cancel_shutdown = True;
+        call_interacts = (w->session.save->interact_style !=
+                          SmInteractStyleNone);
     }
 
-    XtCallCallbackList((Widget)w, w->session.cancel_callbacks,
-		       (XtPointer) NULL);
+    XtCallCallbackList((Widget) w, w->session.cancel_callbacks,
+                       (XtPointer) NULL);
 
     if (call_interacts) {
-	w->session.save->interact_style = SmInteractStyleNone;
-	XtInteractPermission(w->session.connection, (SmPointer) w);
+        w->session.save->interact_style = SmInteractStyleNone;
+        XtInteractPermission(w->session.connection, (SmPointer) w);
     }
 
     if (w->session.checkpoint_state != XtSaveInactive) {
-	if (w->session.save->save_tokens == 0 &&
-	    w->session.checkpoint_state == XtSaveActive) {
-	    w->session.checkpoint_state = XtSaveInactive;
-	    SmcSaveYourselfDone(w->session.connection,
-				w->session.save->save_success);
-	    CleanUpSave(w);
-	}
+        if (w->session.save->save_tokens == 0 &&
+            w->session.checkpoint_state == XtSaveActive) {
+            w->session.checkpoint_state = XtSaveInactive;
+            SmcSaveYourselfDone(w->session.connection,
+                                w->session.save->save_success);
+            CleanUpSave(w);
+        }
     }
 }
 
-static XtCheckpointToken GetToken(
-    Widget	widget,
-    int		type)
+static XtCheckpointToken
+GetToken(Widget widget, int type)
 {
     SessionShellWidget w = (SessionShellWidget) widget;
     XtCheckpointToken token;
     XtSaveYourself save = w->session.save;
 
     if (type == XtSessionCheckpoint)
-	w->session.save->save_tokens++;
+        w->session.save->save_tokens++;
     else if (type == XtSessionInteract)
-	w->session.save->interact_tokens++;
+        w->session.save->interact_tokens++;
     else
-	return (XtCheckpointToken) NULL;
+        return (XtCheckpointToken) NULL;
 
     token = (XtCheckpointToken) __XtMalloc(sizeof(XtCheckpointTokenRec));
     token->save_type = save->save_type;
@@ -3242,32 +3344,34 @@ static XtCheckpointToken GetToken(
     return token;
 }
 
-XtCheckpointToken XtSessionGetToken(Widget widget)
+XtCheckpointToken
+XtSessionGetToken(Widget widget)
 {
     SessionShellWidget w = (SessionShellWidget) widget;
     XtCheckpointToken token = NULL;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     if (w->session.checkpoint_state)
-	token = GetToken(widget, XtSessionCheckpoint);
+        token = GetToken(widget, XtSessionCheckpoint);
 
     UNLOCK_APP(app);
     return token;
 }
 
-static Boolean ExamineToken(
-    XtPointer	call_data)
+static Boolean
+ExamineToken(XtPointer call_data)
 {
     XtCheckpointToken token = (XtCheckpointToken) call_data;
     SessionShellWidget w = (SessionShellWidget) token->widget;
 
     if (token->interact_dialog_type == SmDialogError)
-	w->session.save->interact_dialog_type = SmDialogError;
+        w->session.save->interact_dialog_type = SmDialogError;
     if (token->request_next_phase)
-	w->session.save->request_next_phase = True;
-    if (! token->save_success)
-	w->session.save->save_success = False;
+        w->session.save->request_next_phase = True;
+    if (!token->save_success)
+        w->session.save->save_success = False;
 
     token->interact_dialog_type = w->session.save->interact_dialog_type;
     token->request_next_phase = w->session.save->request_next_phase;
@@ -3277,91 +3381,94 @@ static Boolean ExamineToken(
     return True;
 }
 
-void XtSessionReturnToken(XtCheckpointToken token)
+void
+XtSessionReturnToken(XtCheckpointToken token)
 {
     SessionShellWidget w = (SessionShellWidget) token->widget;
     Boolean has_some;
     Boolean phase_done;
     XtCallbackProc callback;
     XtPointer client_data;
-    WIDGET_TO_APPCON((Widget)w);
+
+    WIDGET_TO_APPCON((Widget) w);
 
     LOCK_APP(app);
 
     has_some = (XtHasCallbacks(token->widget, XtNinteractCallback)
-		== XtCallbackHasSome);
+                == XtCallbackHasSome);
 
     (void) ExamineToken((XtPointer) token);
 
     if (token->type == XtSessionCheckpoint) {
-	w->session.save->save_tokens--;
-	if (has_some && w->session.checkpoint_state == XtSaveActive) {
-	    w->session.checkpoint_state = XtInteractPending;
-	    SmcInteractRequest(w->session.connection,
-			       w->session.save->interact_dialog_type,
-			       XtInteractPermission, (SmPointer) w);
-	}
-	XtFree((char*) token);
-    } else {
-	if (token->request_cancel)
-	    w->session.save->request_cancel = True;
-	token->request_cancel = w->session.save->request_cancel;
-	if (has_some) {
-	    _XtPeekCallback((Widget)w, w->session.interact_callbacks,
-			    &callback, &client_data);
-	    XtRemoveCallback((Widget)w, XtNinteractCallback,
-			     callback, client_data);
-	    (*callback)((Widget)w, client_data, (XtPointer)token);
-	} else {
-	    w->session.save->interact_tokens--;
-	    if (w->session.save->interact_tokens == 0) {
-		w->session.checkpoint_state = XtSaveActive;
-		if (! w->session.save->cancel_shutdown)
-		    SmcInteractDone(w->session.connection,
-				    w->session.save->request_cancel);
-	    }
-	    XtFree((char *) token);
-	}
+        w->session.save->save_tokens--;
+        if (has_some && w->session.checkpoint_state == XtSaveActive) {
+            w->session.checkpoint_state = XtInteractPending;
+            SmcInteractRequest(w->session.connection,
+                               w->session.save->interact_dialog_type,
+                               XtInteractPermission, (SmPointer) w);
+        }
+        XtFree((char *) token);
+    }
+    else {
+        if (token->request_cancel)
+            w->session.save->request_cancel = True;
+        token->request_cancel = w->session.save->request_cancel;
+        if (has_some) {
+            _XtPeekCallback((Widget) w, w->session.interact_callbacks,
+                            &callback, &client_data);
+            XtRemoveCallback((Widget) w, XtNinteractCallback,
+                             callback, client_data);
+            (*callback) ((Widget) w, client_data, (XtPointer) token);
+        }
+        else {
+            w->session.save->interact_tokens--;
+            if (w->session.save->interact_tokens == 0) {
+                w->session.checkpoint_state = XtSaveActive;
+                if (!w->session.save->cancel_shutdown)
+                    SmcInteractDone(w->session.connection,
+                                    w->session.save->request_cancel);
+            }
+            XtFree((char *) token);
+        }
     }
 
     phase_done = (w->session.save->save_tokens == 0 &&
-		  w->session.checkpoint_state == XtSaveActive);
+                  w->session.checkpoint_state == XtSaveActive);
 
     if (phase_done) {
-	if (w->session.save->request_next_phase &&
-	    w->session.save->phase == 1) {
-	    SmcRequestSaveYourselfPhase2(w->session.connection,
-					 XtCallNextPhaseCallbacks,
-					 (SmPointer)w);
-	} else {
-	    w->session.checkpoint_state = XtSaveInactive;
-	    SmcSaveYourselfDone(w->session.connection,
-				w->session.save->save_success);
-	    CleanUpSave(w);
-	}
+        if (w->session.save->request_next_phase && w->session.save->phase == 1) {
+            SmcRequestSaveYourselfPhase2(w->session.connection,
+                                         XtCallNextPhaseCallbacks,
+                                         (SmPointer) w);
+        }
+        else {
+            w->session.checkpoint_state = XtSaveInactive;
+            SmcSaveYourselfDone(w->session.connection,
+                                w->session.save->save_success);
+            CleanUpSave(w);
+        }
     }
 
     UNLOCK_APP(app);
 }
 
-static Boolean IsInArray(
-    String str,
-    _XtString *sarray)
+static Boolean
+IsInArray(String str, _XtString *sarray)
 {
     if (str == NULL || sarray == NULL)
-	return False;
+        return False;
     for (; *sarray; sarray++) {
-	if (strcmp(*sarray, str) == 0)
-	    return True;
+        if (strcmp(*sarray, str) == 0)
+            return True;
     }
     return False;
 }
 
-static _XtString* EditCommand(
-    _XtString str,		/* if not NULL, the sm_client_id */
-    _XtString *src1,	/* first choice */
-    _XtString *src2)	/* alternate */
-{
+static _XtString *
+EditCommand(_XtString str,      /* if not NULL, the sm_client_id */
+            _XtString *src1,   /* first choice */
+            _XtString *src2)   /* alternate */
+{   
     Boolean have;
     Boolean want;
     int count;
@@ -3371,46 +3478,55 @@ static _XtString* EditCommand(
 
     want = (str != NULL);
     sarray = (src1 ? src1 : src2);
-    if (! sarray) return NULL;
+    if (!sarray)
+        return NULL;
     have = IsInArray("-xtsessionID", sarray);
     if ((want && have) || (!want && !have)) {
-	if (sarray == src1)
-	    return src1;
-	else
-	    return NewStringArray(sarray);
+        if (sarray == src1)
+            return src1;
+        else
+            return NewStringArray(sarray);
     }
 
     count = 0;
     for (s = sarray; *s; s++)
-	count++;
+        count++;
 
     if (want) {
-	s = new = (_XtString *) __XtMalloc((Cardinal)((size_t) (count+3) * sizeof(_XtString*)));
-	*s = *sarray;				s++; sarray++;
-	*s = (_XtString) "-xtsessionID";	s++;
-	*s = str;				s++;
-	for (; --count > 0; s++, sarray++)
-	    *s = *sarray;
-	*s = NULL;
-    } else {
-	if (count < 3)
-	    return NewStringArray(sarray);
-	s = new = (_XtString *) __XtMalloc((Cardinal)((size_t)(count-1) * sizeof(_XtString*)));
-	for (; --count >= 0; sarray++) {
-	    if (strcmp(*sarray, "-xtsessionID") == 0) {
-		sarray++;
-		count--;
-	    } else {
-		*s = *sarray;
-		s++;
-	    }
-	}
-	*s = NULL;
+        s = new = (_XtString *)
+            __XtMalloc((Cardinal) ((size_t) (count + 3) * sizeof(_XtString *)));
+        *s = *sarray;
+        s++;
+        sarray++;
+        *s = (_XtString) "-xtsessionID";
+        s++;
+        *s = str;
+        s++;
+        for (; --count > 0; s++, sarray++)
+            *s = *sarray;
+        *s = NULL;
+    }
+    else {
+        if (count < 3)
+            return NewStringArray(sarray);
+        s = new = (_XtString *)
+            __XtMalloc((Cardinal) ((size_t) (count - 1) * sizeof(_XtString *)));
+        for (; --count >= 0; sarray++) {
+            if (strcmp(*sarray, "-xtsessionID") == 0) {
+                sarray++;
+                count--;
+            }
+            else {
+                *s = *sarray;
+                s++;
+            }
+        }
+        *s = NULL;
     }
     s = new;
     new = NewStringArray(new);
-    XtFree((char *)s);
+    XtFree((char *) s);
     return new;
 }
 
-#endif /* !XT_NO_SM */
+#endif                          /* !XT_NO_SM */
diff --git a/src/TMaction.c b/src/TMaction.c
index 84ba2a0..21e4c35 100644
--- a/src/TMaction.c
+++ b/src/TMaction.c
@@ -1,5 +1,3 @@
-/*LINTLIBRARY*/
-
 /***********************************************************
 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
 
@@ -85,220 +83,220 @@ in this Software without prior written authorization from The Open Group.
 #else
 #define RConst /**/
 #endif
-
 static _Xconst _XtString XtNtranslationError = "translationError";
 
-typedef struct _CompiledAction{
-    XrmQuark		signature;
-    XtActionProc	proc;
-}CompiledAction, *CompiledActionTable;
-
+typedef struct _CompiledAction {
+    XrmQuark signature;
+    XtActionProc proc;
+} CompiledAction, *CompiledActionTable;
 
 #define GetClassActions(wc) \
-  ((wc->core_class.actions) \
-? (((TMClassCache)wc->core_class.actions)->actions) \
-: NULL)
-
-static CompiledActionTable CompileActionTable(
-    register RConst struct _XtActionsRec *actions,
-    register Cardinal count,	/* may be 0 */
-    Boolean stat,	/* if False, copy before compiling in place */
-    Boolean perm)	/* if False, use XrmStringToQuark */
+      ((wc->core_class.actions) \
+       ? (((TMClassCache)wc->core_class.actions)->actions) \
+       : NULL)
+
+static CompiledActionTable
+CompileActionTable(register RConst struct _XtActionsRec *actions, register Cardinal count,      /* may be 0 */
+                   Boolean stat,        /* if False, copy before compiling in place */
+                   Boolean perm)        /* if False, use XrmStringToQuark */
 {
     register CompiledActionTable cActions;
     register int i;
     CompiledAction hold;
     CompiledActionTable cTableHold;
-    XrmQuark (*func)(_Xconst char*);
+    XrmQuark (*func) (_Xconst char *);
 
     if (!count)
-	return (CompiledActionTable) NULL;
+        return (CompiledActionTable) NULL;
     func = (perm ? XrmPermStringToQuark : XrmStringToQuark);
 
-    if (! stat) {
-	cTableHold = cActions = (CompiledActionTable)
-	    __XtMalloc((Cardinal)((size_t)count * sizeof(CompiledAction)));
+    if (!stat) {
+        cTableHold = cActions = (CompiledActionTable)
+            __XtMalloc((Cardinal) ((size_t) count * sizeof(CompiledAction)));
 
-	for (i= (int)count; --i >= 0; cActions++, actions++) {
-	    cActions->proc = actions->proc;
-	    cActions->signature = (*func)(actions->string);
-	}
-    } else {
-	cTableHold = (CompiledActionTable) actions;
+        for (i = (int) count; --i >= 0; cActions++, actions++) {
+            cActions->proc = actions->proc;
+            cActions->signature = (*func) (actions->string);
+        }
+    }
+    else {
+        cTableHold = (CompiledActionTable) actions;
 
-	for (i= (int)count; --i >= 0; actions++)
-	    ((CompiledActionTable) actions)->signature =
-		(*func)(actions->string);
+        for (i = (int) count; --i >= 0; actions++)
+            ((CompiledActionTable) actions)->signature =
+                (*func) (actions->string);
     }
     cActions = cTableHold;
 
     /* Insertion sort.  Whatever sort is used, it must be stable. */
-    for (i=1; (Cardinal) i <= count - 1; i++) {
-	register Cardinal j;
-	hold = cActions[i];
-	j = (Cardinal)i;
-	while (j && cActions[j-1].signature > hold.signature) {
-	    cActions[j] = cActions[j-1];
-	    j--;
-	}
-	cActions[j] = hold;
+    for (i = 1; (Cardinal) i <= count - 1; i++) {
+        register Cardinal j;
+
+        hold = cActions[i];
+        j = (Cardinal) i;
+        while (j && cActions[j - 1].signature > hold.signature) {
+            cActions[j] = cActions[j - 1];
+            j--;
+        }
+        cActions[j] = hold;
     }
 
     return cActions;
 }
 
-
 typedef struct _ActionListRec *ActionList;
 typedef struct _ActionListRec {
-    ActionList		next;
+    ActionList next;
     CompiledActionTable table;
-    TMShortCard		count;
+    TMShortCard count;
 } ActionListRec;
 
-static void ReportUnboundActions(
-    XtTranslations	xlations,
-    TMBindData		bindData)
+static void
+ReportUnboundActions(XtTranslations xlations, TMBindData bindData)
 {
-    TMSimpleStateTree	stateTree;
+    TMSimpleStateTree stateTree;
     Cardinal num_unbound = 0;
     Cardinal num_params = 1;
-    char* message;
+    char *message;
     char messagebuf[1000];
     register Cardinal num_chars = 0;
     register Cardinal i, j;
     XtActionProc *procs;
 
-    for (i=0; i < xlations->numStateTrees; i++) {
-	if (bindData->simple.isComplex)
-	  procs = TMGetComplexBindEntry(bindData, i)->procs;
-	else
-	  procs = TMGetSimpleBindEntry(bindData, i)->procs;
-
-	stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i];
-	for (j=0; j < stateTree->numQuarks; j++) {
-	    if (procs[j] == NULL) {
-		String s = XrmQuarkToString(stateTree->quarkTbl[j]);
-		if (num_unbound != 0)
-		    num_chars += 2;
-		num_chars += (Cardinal)strlen(s);
-		num_unbound++;
-	    }
-	}
+    for (i = 0; i < xlations->numStateTrees; i++) {
+        if (bindData->simple.isComplex)
+            procs = TMGetComplexBindEntry(bindData, i)->procs;
+        else
+            procs = TMGetSimpleBindEntry(bindData, i)->procs;
+
+        stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i];
+        for (j = 0; j < stateTree->numQuarks; j++) {
+            if (procs[j] == NULL) {
+                String s = XrmQuarkToString(stateTree->quarkTbl[j]);
+
+                if (num_unbound != 0)
+                    num_chars += 2;
+                num_chars += (Cardinal) strlen(s);
+                num_unbound++;
+            }
+        }
     }
     if (num_unbound == 0)
-	return;
-    message = XtStackAlloc (num_chars + 1, messagebuf);
+        return;
+    message = XtStackAlloc(num_chars + 1, messagebuf);
     if (message != NULL) {
-	String params[1];
-
-	*message = '\0';
-	num_unbound = 0;
-	for (i=0; i < xlations->numStateTrees; i++) {
-	    if (bindData->simple.isComplex)
-		procs = TMGetComplexBindEntry(bindData, i)->procs;
-	    else
-		procs = TMGetSimpleBindEntry(bindData, i)->procs;
-
-	    stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i];
-	    for (j=0; j < stateTree->numQuarks; j++) {
-		if (procs[j] == NULL) {
-		    String s = XrmQuarkToString(stateTree->quarkTbl[j]);
-		    if (num_unbound != 0)
-			(void) strcat(message, ", ");
-		    (void) strcat(message, s);
-		    num_unbound++;
-		}
-	    }
-	}
-	message[num_chars] = '\0';
-	params[0] = message;
-	XtWarningMsg(XtNtranslationError,"unboundActions",XtCXtToolkitError,
-		     "Actions not found: %s",
-		     params, &num_params);
-	XtStackFree (message, messagebuf);
+        String params[1];
+
+        *message = '\0';
+        num_unbound = 0;
+        for (i = 0; i < xlations->numStateTrees; i++) {
+            if (bindData->simple.isComplex)
+                procs = TMGetComplexBindEntry(bindData, i)->procs;
+            else
+                procs = TMGetSimpleBindEntry(bindData, i)->procs;
+
+            stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i];
+            for (j = 0; j < stateTree->numQuarks; j++) {
+                if (procs[j] == NULL) {
+                    String s = XrmQuarkToString(stateTree->quarkTbl[j]);
+
+                    if (num_unbound != 0)
+                        (void) strcat(message, ", ");
+                    (void) strcat(message, s);
+                    num_unbound++;
+                }
+            }
+        }
+        message[num_chars] = '\0';
+        params[0] = message;
+        XtWarningMsg(XtNtranslationError, "unboundActions", XtCXtToolkitError,
+                     "Actions not found: %s", params, &num_params);
+        XtStackFree(message, messagebuf);
     }
 }
 
-
-static CompiledAction *SearchActionTable(
-    XrmQuark		signature,
-    CompiledActionTable	actionTable,
-    Cardinal		numActions)
+static CompiledAction *
+SearchActionTable(XrmQuark signature,
+                  CompiledActionTable actionTable,
+                  Cardinal numActions)
 {
     int left, right;
 
     left = 0;
-    right = (int)numActions - 1;
+    right = (int) numActions - 1;
     while (left <= right) {
-	int i = (left + right) >> 1;
-	if (signature < actionTable[i].signature)
-	    right = i - 1;
-	else if (signature > actionTable[i].signature)
-	    left = i + 1;
-	else {
-	    while (i && actionTable[i - 1].signature == signature)
-		i--;
-	    return &actionTable[i];
-	}
+        int i = (left + right) >> 1;
+
+        if (signature < actionTable[i].signature)
+            right = i - 1;
+        else if (signature > actionTable[i].signature)
+            left = i + 1;
+        else {
+            while (i && actionTable[i - 1].signature == signature)
+                i--;
+            return &actionTable[i];
+        }
     }
     return (CompiledAction *) NULL;
 }
 
-static int BindActions(
-    TMSimpleStateTree	stateTree,
-    XtActionProc	*procs,
-    CompiledActionTable compiledActionTable,
-    TMShortCard		numActions,
-    Cardinal 		*ndxP)
+static int
+BindActions(TMSimpleStateTree stateTree,
+            XtActionProc *procs,
+            CompiledActionTable compiledActionTable,
+            TMShortCard numActions,
+            Cardinal *ndxP)
 {
-    register int unbound = (int)(stateTree->numQuarks - *ndxP);
-    CompiledAction* action;
+    register int unbound = (int) (stateTree->numQuarks - *ndxP);
+    CompiledAction *action;
     register Cardinal ndx;
     register Boolean savedNdx = False;
 
     for (ndx = *ndxP; ndx < stateTree->numQuarks; ndx++) {
-	if (procs[ndx] == NULL) {
-	    /* attempt to bind it */
-	    XrmQuark q = stateTree->quarkTbl[ndx];
-
-	    action = SearchActionTable(q, compiledActionTable, numActions);
-	    if (action) {
-		procs[ndx] = action->proc;
-		unbound--;
-	    } else if (!savedNdx) {
-		*ndxP= ndx;
-		savedNdx = True;
-	    }
-	} else {
-	    /* already bound, leave it alone */
-	    unbound--;
-	}
+        if (procs[ndx] == NULL) {
+            /* attempt to bind it */
+            XrmQuark q = stateTree->quarkTbl[ndx];
+
+            action = SearchActionTable(q, compiledActionTable, numActions);
+            if (action) {
+                procs[ndx] = action->proc;
+                unbound--;
+            }
+            else if (!savedNdx) {
+                *ndxP = ndx;
+                savedNdx = True;
+            }
+        }
+        else {
+            /* already bound, leave it alone */
+            unbound--;
+        }
     }
     return unbound;
 }
 
-typedef struct _TMBindCacheStatusRec{
-    unsigned int	boundInClass:1;
-    unsigned int	boundInHierarchy:1;
-    unsigned int	boundInContext:1;
-    unsigned int	notFullyBound:1;
-    unsigned int	refCount:28;
-}TMBindCacheStatusRec, *TMBindCacheStatus;
+typedef struct _TMBindCacheStatusRec {
+    unsigned int boundInClass:1;
+    unsigned int boundInHierarchy:1;
+    unsigned int boundInContext:1;
+    unsigned int notFullyBound:1;
+    unsigned int refCount:28;
+} TMBindCacheStatusRec, *TMBindCacheStatus;
 
-typedef struct _TMBindCacheRec{
+typedef struct _TMBindCacheRec {
     struct _TMBindCacheRec *next;
     TMBindCacheStatusRec status;
-    TMStateTree		stateTree;
+    TMStateTree stateTree;
 #ifdef TRACE_TM
-    WidgetClass		widgetClass;
-#endif /* TRACE_TM */
-    XtActionProc	procs[1];	/* variable length */
-}TMBindCacheRec, *TMBindCache;
+    WidgetClass widgetClass;
+#endif                          /* TRACE_TM */
+    XtActionProc procs[1];      /* variable length */
+} TMBindCacheRec, *TMBindCache;
 
 typedef struct _TMClassCacheRec {
-    CompiledActionTable	actions;
-    TMBindCacheRec	*bindCache;
-}TMClassCacheRec, *TMClassCache;
+    CompiledActionTable actions;
+    TMBindCacheRec *bindCache;
+} TMClassCacheRec, *TMClassCache;
 
 #define IsPureClassBind(bc) \
   (bc->status.boundInClass && \
@@ -309,464 +307,427 @@ typedef struct _TMClassCacheRec {
 #define GetClassCache(w) \
   ((TMClassCache)w->core.widget_class->core_class.actions)
 
-
-static int  BindProcs(
-    Widget 		widget,
-    TMSimpleStateTree	stateTree,
-    XtActionProc	*procs,
-    TMBindCacheStatus 	bindStatus)
+static int
+BindProcs(Widget widget,
+          TMSimpleStateTree stateTree,
+          XtActionProc *procs,
+          TMBindCacheStatus bindStatus)
 {
-    register WidgetClass    	class;
-    register ActionList     	actionList;
-    int 			unbound = -1, newUnbound = -1;
-    Cardinal 			ndx = 0;
-    Widget			w = widget;
+    register WidgetClass class;
+    register ActionList actionList;
+    int unbound = -1, newUnbound = -1;
+    Cardinal ndx = 0;
+    Widget w = widget;
 
     LOCK_PROCESS;
     do {
         class = w->core.widget_class;
         do {
             if (class->core_class.actions != NULL)
-	      unbound =
-		BindActions(stateTree,
-			    procs,
-			    GetClassActions(class),
-			    (TMShortCard) class->core_class.num_actions,
-			    &ndx);
-	    class = class->core_class.superclass;
+                unbound =
+                    BindActions(stateTree,
+                                procs,
+                                GetClassActions(class),
+                                (TMShortCard) class->core_class.num_actions,
+                                &ndx);
+            class = class->core_class.superclass;
         } while (unbound != 0 && class != NULL);
-	if (unbound < (int)stateTree->numQuarks)
-	  bindStatus->boundInClass = True;
-	else
-	  bindStatus->boundInClass = False;
-	if (newUnbound == -1)
-	  newUnbound = unbound;
-	w = XtParent(w);
+        if (unbound < (int) stateTree->numQuarks)
+            bindStatus->boundInClass = True;
+        else
+            bindStatus->boundInClass = False;
+        if (newUnbound == -1)
+            newUnbound = unbound;
+        w = XtParent(w);
     } while (unbound != 0 && w != NULL);
 
     if (newUnbound > unbound)
-      bindStatus->boundInHierarchy = True;
+        bindStatus->boundInHierarchy = True;
     else
-      bindStatus->boundInHierarchy = False;
+        bindStatus->boundInHierarchy = False;
 
     if (unbound) {
-	XtAppContext app = XtWidgetToApplicationContext(widget);
-	newUnbound = unbound;
-	for (actionList = app->action_table;
-	     unbound != 0 && actionList != NULL;
-	     actionList = actionList->next) {
-	    unbound = BindActions(stateTree,
-				  procs,
-				  actionList->table,
-				  actionList->count,
-				  &ndx);
-	}
-	if (newUnbound > unbound)
-	  bindStatus->boundInContext = True;
-	else
-	  bindStatus->boundInContext = False;
-
-    } else {
-	bindStatus->boundInContext = False;
+        XtAppContext app = XtWidgetToApplicationContext(widget);
+
+        newUnbound = unbound;
+        for (actionList = app->action_table;
+             unbound != 0 && actionList != NULL;
+             actionList = actionList->next) {
+            unbound = BindActions(stateTree,
+                                  procs,
+                                  actionList->table, actionList->count, &ndx);
+        }
+        if (newUnbound > unbound)
+            bindStatus->boundInContext = True;
+        else
+            bindStatus->boundInContext = False;
+
+    }
+    else {
+        bindStatus->boundInContext = False;
     }
     UNLOCK_PROCESS;
     return unbound;
 }
 
-static XtActionProc  *TryBindCache(
-    Widget	widget,
-    TMStateTree	stateTree)
+static XtActionProc *
+TryBindCache(Widget widget, TMStateTree stateTree)
 {
-    TMClassCache	classCache;
+    TMClassCache classCache;
 
     LOCK_PROCESS;
     classCache = GetClassCache(widget);
 
-    if (classCache == NULL)
-      {
-	  WidgetClass	wc = XtClass(widget);
+    if (classCache == NULL) {
+        WidgetClass wc = XtClass(widget);
 
-	  wc->core_class.actions = (XtActionList)
-	    _XtInitializeActionData(NULL, 0, True);
-      }
-    else
-      {
-	  TMBindCache bindCache =
-	    (TMBindCache)(classCache->bindCache);
-	  for (; bindCache; bindCache = bindCache->next)
-	    {
-		if (IsPureClassBind(bindCache) &&
-		    (stateTree == bindCache->stateTree))
-		  {
-		      bindCache->status.refCount++;
-		      UNLOCK_PROCESS;
-		      return &bindCache->procs[0];
-		  }
-	    }
-      }
+        wc->core_class.actions = (XtActionList)
+            _XtInitializeActionData(NULL, 0, True);
+    }
+    else {
+        TMBindCache bindCache = (TMBindCache) (classCache->bindCache);
+
+        for (; bindCache; bindCache = bindCache->next) {
+            if (IsPureClassBind(bindCache) &&
+                (stateTree == bindCache->stateTree)) {
+                bindCache->status.refCount++;
+                UNLOCK_PROCESS;
+                return &bindCache->procs[0];
+            }
+        }
+    }
     UNLOCK_PROCESS;
     return NULL;
 }
 
-
-
 /*
  * The class record actions field will point to the bind cache header
  * after this call is made out of coreClassPartInit.
  */
-XtPointer _XtInitializeActionData(
-    register struct _XtActionsRec	*actions,
-    register Cardinal			count,
-    _XtBoolean				inPlace)
+XtPointer
+_XtInitializeActionData(register struct _XtActionsRec *actions,
+                        register Cardinal count,
+                        _XtBoolean inPlace)
 {
-    TMClassCache	classCache;
+    TMClassCache classCache;
 
     classCache = XtNew(TMClassCacheRec);
-    classCache->actions = CompileActionTable(actions, count, (Boolean) inPlace, True);
+    classCache->actions =
+        CompileActionTable(actions, count, (Boolean) inPlace, True);
     classCache->bindCache = NULL;
-    return (XtPointer)classCache;
+    return (XtPointer) classCache;
 }
 
+#define TM_BIND_CACHE_REALLOC   2
 
-#define TM_BIND_CACHE_REALLOC	2
-
-static XtActionProc *EnterBindCache(
-    Widget		w,
-    TMSimpleStateTree	stateTree,
-    XtActionProc 	*procs,
-    TMBindCacheStatus 	bindStatus)
+static XtActionProc *
+EnterBindCache(Widget w,
+               TMSimpleStateTree stateTree,
+               XtActionProc *procs,
+               TMBindCacheStatus bindStatus)
 {
-    TMClassCache	classCache;
-    TMBindCache*	bindCachePtr;
-    TMShortCard		procsSize;
-    TMBindCache		bindCache;
+    TMClassCache classCache;
+    TMBindCache *bindCachePtr;
+    TMShortCard procsSize;
+    TMBindCache bindCache;
 
     LOCK_PROCESS;
     classCache = GetClassCache(w);
     bindCachePtr = &classCache->bindCache;
-    procsSize = (TMShortCard)(stateTree->numQuarks * sizeof(XtActionProc));
+    procsSize = (TMShortCard) (stateTree->numQuarks * sizeof(XtActionProc));
 
     for (bindCache = *bindCachePtr;
-	 (*bindCachePtr);
-	bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr)
-      {
-	  TMBindCacheStatus	cacheStatus = &bindCache->status;
-
-	  if ((bindStatus->boundInClass == cacheStatus->boundInClass) &&
-	      (bindStatus->boundInHierarchy == cacheStatus->boundInHierarchy) &&
-	      (bindStatus->boundInContext == cacheStatus->boundInContext) &&
-	      (bindCache->stateTree == (TMStateTree)stateTree) &&
-	      !XtMemcmp(&bindCache->procs[0], procs, procsSize))
-	    {
-		bindCache->status.refCount++;
-		break;
-	    }
-      }
-    if (*bindCachePtr == NULL)
-      {
-	  *bindCachePtr =
-	    bindCache = (TMBindCache)
-	      __XtMalloc((Cardinal)(sizeof(TMBindCacheRec) +
-		       (size_t)(procsSize - sizeof(XtActionProc))));
-	  bindCache->next = NULL;
-	  bindCache->status = *bindStatus;
-	  bindCache->status.refCount = 1;
-	  bindCache->stateTree = (TMStateTree)stateTree;
+         (*bindCachePtr);
+         bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) {
+        TMBindCacheStatus cacheStatus = &bindCache->status;
+
+        if ((bindStatus->boundInClass == cacheStatus->boundInClass) &&
+            (bindStatus->boundInHierarchy == cacheStatus->boundInHierarchy) &&
+            (bindStatus->boundInContext == cacheStatus->boundInContext) &&
+            (bindCache->stateTree == (TMStateTree) stateTree) &&
+            !XtMemcmp(&bindCache->procs[0], procs, procsSize)) {
+            bindCache->status.refCount++;
+            break;
+        }
+    }
+    if (*bindCachePtr == NULL) {
+        *bindCachePtr = bindCache = (TMBindCache)
+            __XtMalloc((Cardinal) (sizeof(TMBindCacheRec) +
+                                   (size_t) (procsSize -
+                                             sizeof(XtActionProc))));
+        bindCache->next = NULL;
+        bindCache->status = *bindStatus;
+        bindCache->status.refCount = 1;
+        bindCache->stateTree = (TMStateTree) stateTree;
 #ifdef TRACE_TM
-	  bindCache->widgetClass = XtClass(w);
-	  if (_XtGlobalTM.numBindCache == _XtGlobalTM.bindCacheTblSize)
-	    {
-		_XtGlobalTM.bindCacheTblSize =
-			    (TMShortCard)(_XtGlobalTM.bindCacheTblSize + 16);
-		_XtGlobalTM.bindCacheTbl = (TMBindCache *)
-		  XtRealloc((char *)_XtGlobalTM.bindCacheTbl,
-			    (Cardinal)((_XtGlobalTM.bindCacheTblSize) *
-				       sizeof(TMBindCache)));
-	    }
-	  _XtGlobalTM.bindCacheTbl[_XtGlobalTM.numBindCache++] = bindCache;
-#endif /* TRACE_TM */
-	  XtMemmove((XtPointer)&bindCache->procs[0],
-		    (XtPointer)procs, procsSize);
-      }
+        bindCache->widgetClass = XtClass(w);
+        if (_XtGlobalTM.numBindCache == _XtGlobalTM.bindCacheTblSize) {
+            _XtGlobalTM.bindCacheTblSize =
+                (TMShortCard) (_XtGlobalTM.bindCacheTblSize + 16);
+            _XtGlobalTM.bindCacheTbl = (TMBindCache *)
+                XtRealloc((char *) _XtGlobalTM.bindCacheTbl,
+                          (Cardinal) ((_XtGlobalTM.bindCacheTblSize) *
+                                      sizeof(TMBindCache)));
+        }
+        _XtGlobalTM.bindCacheTbl[_XtGlobalTM.numBindCache++] = bindCache;
+#endif                          /* TRACE_TM */
+        XtMemmove((XtPointer) &bindCache->procs[0],
+                  (XtPointer) procs, procsSize);
+    }
     UNLOCK_PROCESS;
     return &bindCache->procs[0];
 }
 
-static void RemoveFromBindCache(
-    Widget		w,
-    XtActionProc 	*procs)
+static void
+RemoveFromBindCache(Widget w, XtActionProc *procs)
 {
-    TMClassCache	classCache;
-    TMBindCache*	bindCachePtr;
-    TMBindCache		bindCache;
-    XtAppContext	app = XtWidgetToApplicationContext (w);
+    TMClassCache classCache;
+    TMBindCache *bindCachePtr;
+    TMBindCache bindCache;
+    XtAppContext app = XtWidgetToApplicationContext(w);
 
     LOCK_PROCESS;
     classCache = GetClassCache(w);
-    bindCachePtr = (TMBindCache *)&classCache->bindCache;
+    bindCachePtr = (TMBindCache *) &classCache->bindCache;
 
     for (bindCache = *bindCachePtr;
-	 *bindCachePtr;
-	 bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr)
-      {
-	  if (&bindCache->procs[0] == procs)
-	    {
-		if (--bindCache->status.refCount == 0)
-		  {
+         *bindCachePtr;
+         bindCachePtr = &(*bindCachePtr)->next, bindCache = *bindCachePtr) {
+        if (&bindCache->procs[0] == procs) {
+            if (--bindCache->status.refCount == 0) {
 #ifdef TRACE_TM
-		      TMShortCard	j;
-		      Boolean		found = False;
-		      TMBindCache	*tbl = _XtGlobalTM.bindCacheTbl;
-
-		      for (j = 0; j < _XtGlobalTM.numBindCache; j++) {
-			  if (found)
-			    tbl[j-1] = tbl[j];
-			  if (tbl[j] == bindCache)
-			    found = True;
-		      }
-		      if (!found)
-			XtWarning("where's the action ??? ");
-		      else
-			_XtGlobalTM.numBindCache--;
-#endif /* TRACE_TM */
-		      *bindCachePtr = bindCache->next;
-		      bindCache->next = app->free_bindings;
-		      app->free_bindings = bindCache;
-		  }
-		break;
-	    }
-      }
-      UNLOCK_PROCESS;
+                TMShortCard j;
+                Boolean found = False;
+                TMBindCache *tbl = _XtGlobalTM.bindCacheTbl;
+
+                for (j = 0; j < _XtGlobalTM.numBindCache; j++) {
+                    if (found)
+                        tbl[j - 1] = tbl[j];
+                    if (tbl[j] == bindCache)
+                        found = True;
+                }
+                if (!found)
+                    XtWarning("where's the action ??? ");
+                else
+                    _XtGlobalTM.numBindCache--;
+#endif                          /* TRACE_TM */
+                *bindCachePtr = bindCache->next;
+                bindCache->next = app->free_bindings;
+                app->free_bindings = bindCache;
+            }
+            break;
+        }
+    }
+    UNLOCK_PROCESS;
 }
 
-/* ARGSUSED */
-static void RemoveAccelerators(
-    Widget widget,
-    XtPointer closure, XtPointer data)
+static void
+RemoveAccelerators(Widget widget, XtPointer closure, XtPointer data _X_UNUSED)
 {
-    Widget 		destination = (Widget)closure;
-    TMComplexBindProcs	bindProcs;
-    XtTranslations	stackXlations[16];
-    XtTranslations	*xlationsList, destXlations;
-    TMShortCard		i, numXlations = 0;
+    Widget destination = (Widget) closure;
+    TMComplexBindProcs bindProcs;
+    XtTranslations stackXlations[16];
+    XtTranslations *xlationsList, destXlations;
+    TMShortCard i, numXlations = 0;
 
     if ((destXlations = destination->core.tm.translations) == NULL) {
         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-            XtNtranslationError,"nullTable",XtCXtToolkitError,
-            "Can't remove accelerators from NULL table",
-            NULL, NULL);
+                        XtNtranslationError, "nullTable", XtCXtToolkitError,
+                        "Can't remove accelerators from NULL table",
+                        NULL, NULL);
         return;
     }
 
     xlationsList = (XtTranslations *)
-      XtStackAlloc((destXlations->numStateTrees * sizeof(XtTranslations)),
-		   stackXlations);
-
-    for (i = 0, bindProcs = TMGetComplexBindEntry(destination->core.tm.proc_table, i);
-	 i < destXlations->numStateTrees;
-	 i++, bindProcs++) {
-	if (bindProcs->widget == widget) {
-	    /*
-	     * if it's being destroyed don't do all the work
-	     */
-	    if (destination->core.being_destroyed) {
-		bindProcs->procs = NULL;
-	    }
-	    else
-	      xlationsList[numXlations] = bindProcs->aXlations;
-	    numXlations++;
-	}
+        XtStackAlloc((destXlations->numStateTrees * sizeof(XtTranslations)),
+                     stackXlations);
+
+    for (i = 0, bindProcs =
+         TMGetComplexBindEntry(destination->core.tm.proc_table, i);
+         i < destXlations->numStateTrees; i++, bindProcs++) {
+        if (bindProcs->widget == widget) {
+            /*
+             * if it's being destroyed don't do all the work
+             */
+            if (destination->core.being_destroyed) {
+                bindProcs->procs = NULL;
+            }
+            else
+                xlationsList[numXlations] = bindProcs->aXlations;
+            numXlations++;
+        }
     }
 
     if (numXlations == 0)
-      XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		      XtNtranslationError,"nullTable",XtCXtToolkitError,
-		      "Tried to remove nonexistent accelerators",
-		      NULL, NULL);
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        XtNtranslationError, "nullTable", XtCXtToolkitError,
+                        "Tried to remove nonexistent accelerators", NULL, NULL);
     else {
-	if (!destination->core.being_destroyed)
-	  for (i = 0; i < numXlations; i++)
-	    _XtUnmergeTranslations(destination, xlationsList[i]);
+        if (!destination->core.being_destroyed)
+            for (i = 0; i < numXlations; i++)
+                _XtUnmergeTranslations(destination, xlationsList[i]);
     }
-    XtStackFree((char *)xlationsList, stackXlations);
+    XtStackFree((char *) xlationsList, stackXlations);
 }
 
-void _XtBindActions(
-    Widget widget,
-    XtTM tm)
+void
+_XtBindActions(Widget widget, XtTM tm)
 {
-    XtTranslations  		xlations = tm->translations;
-    TMSimpleStateTree		stateTree;
-    int				globalUnbound = 0;
-    Cardinal 			i;
-    TMBindData			bindData = (TMBindData)tm->proc_table;
-    TMSimpleBindProcs		simpleBindProcs = NULL;
-    TMComplexBindProcs 		complexBindProcs = NULL;
-    XtActionProc		*newProcs;
-    Widget			bindWidget;
+    XtTranslations xlations = tm->translations;
+    TMSimpleStateTree stateTree;
+    int globalUnbound = 0;
+    Cardinal i;
+    TMBindData bindData = (TMBindData) tm->proc_table;
+    TMSimpleBindProcs simpleBindProcs = NULL;
+    TMComplexBindProcs complexBindProcs = NULL;
+    XtActionProc *newProcs;
+    Widget bindWidget;
 
     if ((xlations == NULL) || widget->core.being_destroyed)
-      return;
-
-    for (i = 0; i < xlations->numStateTrees; i++)
-      {
-	  stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i];
-	  if (bindData->simple.isComplex) {
-	      complexBindProcs = TMGetComplexBindEntry(bindData, i);
-	      if (complexBindProcs->widget) {
-		  bindWidget = complexBindProcs->widget;
-
-		  if (bindWidget->core.destroy_callbacks != NULL)
-		      _XtAddCallbackOnce((InternalCallbackList *)
-					 &bindWidget->core.destroy_callbacks,
-					 RemoveAccelerators,
-					 (XtPointer)widget);
-		  else
-		      _XtAddCallback((InternalCallbackList *)
-				     &bindWidget->core.destroy_callbacks,
-				     RemoveAccelerators,
-				     (XtPointer)widget);
-	      }
-	      else
-		bindWidget = widget;
-	  }
-	  else {
-	      simpleBindProcs = TMGetSimpleBindEntry(bindData, i);
-	      bindWidget = widget;
-	  }
-	  if ((newProcs =
-	       TryBindCache(bindWidget,(TMStateTree)stateTree)) == NULL)
-	    {
-		XtActionProc		*procs, stackProcs[256];
-		int			localUnbound;
-		TMBindCacheStatusRec	bcStatusRec;
-
-		procs = (XtActionProc *)
-		  XtStackAlloc(stateTree->numQuarks * sizeof(XtActionProc),
-			       stackProcs);
-		XtBZero((XtPointer)procs,
-			stateTree->numQuarks * sizeof(XtActionProc));
-
-		localUnbound = BindProcs(bindWidget,
-					 stateTree,
-					 procs,
-					 &bcStatusRec);
-
-		if (localUnbound)
-		  bcStatusRec.notFullyBound = True;
-		else
-		  bcStatusRec.notFullyBound = False;
-
-		newProcs =
-		  EnterBindCache(bindWidget,
-				 stateTree,
-				 procs,
-				 &bcStatusRec);
-		XtStackFree((XtPointer)procs, (XtPointer)stackProcs);
-		globalUnbound += localUnbound;
-	    }
-	  if (bindData->simple.isComplex)
-	    complexBindProcs->procs = newProcs;
-	  else
-	    simpleBindProcs->procs = newProcs;
-      }
+        return;
+
+    for (i = 0; i < xlations->numStateTrees; i++) {
+        stateTree = (TMSimpleStateTree) xlations->stateTreeTbl[i];
+        if (bindData->simple.isComplex) {
+            complexBindProcs = TMGetComplexBindEntry(bindData, i);
+            if (complexBindProcs->widget) {
+                bindWidget = complexBindProcs->widget;
+
+                if (bindWidget->core.destroy_callbacks != NULL)
+                    _XtAddCallbackOnce((InternalCallbackList *)
+                                       &bindWidget->core.destroy_callbacks,
+                                       RemoveAccelerators, (XtPointer) widget);
+                else
+                    _XtAddCallback((InternalCallbackList *)
+                                   &bindWidget->core.destroy_callbacks,
+                                   RemoveAccelerators, (XtPointer) widget);
+            }
+            else
+                bindWidget = widget;
+        }
+        else {
+            simpleBindProcs = TMGetSimpleBindEntry(bindData, i);
+            bindWidget = widget;
+        }
+        if ((newProcs =
+             TryBindCache(bindWidget, (TMStateTree) stateTree)) == NULL) {
+            XtActionProc *procs, stackProcs[256];
+            int localUnbound;
+            TMBindCacheStatusRec bcStatusRec;
+
+            procs = (XtActionProc *)
+                XtStackAlloc(stateTree->numQuarks * sizeof(XtActionProc),
+                             stackProcs);
+            XtBZero((XtPointer) procs,
+                    stateTree->numQuarks * sizeof(XtActionProc));
+
+            localUnbound = BindProcs(bindWidget,
+                                     stateTree, procs, &bcStatusRec);
+
+            if (localUnbound)
+                bcStatusRec.notFullyBound = True;
+            else
+                bcStatusRec.notFullyBound = False;
+
+            newProcs =
+                EnterBindCache(bindWidget, stateTree, procs, &bcStatusRec);
+            XtStackFree((XtPointer) procs, (XtPointer) stackProcs);
+            globalUnbound += localUnbound;
+        }
+        if (bindData->simple.isComplex)
+            complexBindProcs->procs = newProcs;
+        else
+            simpleBindProcs->procs = newProcs;
+    }
     if (globalUnbound)
-      ReportUnboundActions(xlations,
-			   (TMBindData)tm->proc_table);
+        ReportUnboundActions(xlations, (TMBindData) tm->proc_table);
 }
 
-
-void _XtUnbindActions(
-    Widget 	widget,
-    XtTranslations xlations,
-    TMBindData	bindData)
+void
+_XtUnbindActions(Widget widget, XtTranslations xlations, TMBindData bindData)
 {
-    Cardinal			i;
-    Widget			bindWidget;
-    XtActionProc		*procs;
+    Cardinal i;
+    Widget bindWidget;
+    XtActionProc *procs;
 
-    if ((xlations == NULL) || !XtIsRealized(widget)) return;
+    if ((xlations == NULL) || !XtIsRealized(widget))
+        return;
 
     for (i = 0; i < xlations->numStateTrees; i++) {
-	if (bindData->simple.isComplex) {
-	    TMComplexBindProcs	complexBindProcs;
-
-	    complexBindProcs = TMGetComplexBindEntry(bindData, i);
-
-	    if (complexBindProcs->widget) {
-		/*
-		 * check for this being an accelerator binding whose
-		 * source is gone ( set by RemoveAccelerators)
-		 */
-		if (complexBindProcs->procs == NULL)
-		  continue;
-
-		XtRemoveCallback(complexBindProcs->widget,
-				 XtNdestroyCallback,
-				 RemoveAccelerators,
-				 (XtPointer)widget);
-		bindWidget = complexBindProcs->widget;
-	    }
-	    else
-	      bindWidget = widget;
-	    procs = complexBindProcs->procs;
-	    complexBindProcs->procs = NULL;
-	}
-	else {
-	    TMSimpleBindProcs simpleBindProcs;
-	    simpleBindProcs = TMGetSimpleBindEntry(bindData,i);
-	    procs = simpleBindProcs->procs;
-	    simpleBindProcs->procs = NULL;
-	    bindWidget = widget;
-	}
-	RemoveFromBindCache(bindWidget, procs);
-      }
+        if (bindData->simple.isComplex) {
+            TMComplexBindProcs complexBindProcs;
+
+            complexBindProcs = TMGetComplexBindEntry(bindData, i);
+
+            if (complexBindProcs->widget) {
+                /*
+                 * check for this being an accelerator binding whose
+                 * source is gone ( set by RemoveAccelerators)
+                 */
+                if (complexBindProcs->procs == NULL)
+                    continue;
+
+                XtRemoveCallback(complexBindProcs->widget,
+                                 XtNdestroyCallback,
+                                 RemoveAccelerators, (XtPointer) widget);
+                bindWidget = complexBindProcs->widget;
+            }
+            else
+                bindWidget = widget;
+            procs = complexBindProcs->procs;
+            complexBindProcs->procs = NULL;
+        }
+        else {
+            TMSimpleBindProcs simpleBindProcs;
+
+            simpleBindProcs = TMGetSimpleBindEntry(bindData, i);
+            procs = simpleBindProcs->procs;
+            simpleBindProcs->procs = NULL;
+            bindWidget = widget;
+        }
+        RemoveFromBindCache(bindWidget, procs);
+    }
 }
 
 #ifdef notdef
-void _XtRemoveBindProcsByIndex(
-    Widget	w,
-    TMBindData	bindData,
-    TMShortCard	ndx)
+void
+_XtRemoveBindProcsByIndex(Widget w, TMBindData bindData, TMShortCard ndx)
 {
-    TMShortCard	i = ndx;
-    TMBindProcs	bindProcs = (TMBindProcs)&bindData->bindTbl[0];
+    TMShortCard i = ndx;
+    TMBindProcs bindProcs = (TMBindProcs) &bindData->bindTbl[0];
 
     RemoveFromBindCache(bindProcs->widget ? bindProcs->widget : w,
-			bindProcs[i].procs);
+                        bindProcs[i].procs);
 
     for (; i < bindData->bindTblSize; i++)
-      bindProcs[i] = bindProcs[i+1];
+        bindProcs[i] = bindProcs[i + 1];
 }
-#endif /* notdef */
+#endif                          /* notdef */
 
 /*
  * used to free all copied action tables, called from DestroyAppContext
  */
-void _XtFreeActions(
-    ActionList	actions)
+void
+_XtFreeActions(ActionList actions)
 {
-    ActionList	curr, next;
+    ActionList curr, next;
 
     for (curr = actions; curr;) {
-	next = curr->next;
-	XtFree((char *)curr->table);
-	XtFree((char *)curr);
-	curr = next;
+        next = curr->next;
+        XtFree((char *) curr->table);
+        XtFree((char *) curr);
+        curr = next;
     }
 }
 
-void XtAddActions(
-    XtActionList actions,
-    Cardinal num_actions)
+void
+XtAddActions(XtActionList actions, Cardinal num_actions)
 {
     XtAppAddActions(_XtDefaultAppContext(), actions, num_actions);
 }
 
-void XtAppAddActions(
-    XtAppContext app,
-    XtActionList actions,
-    Cardinal num_actions)
+void
+XtAppAddActions(XtAppContext app, XtActionList actions, Cardinal num_actions)
 {
     register ActionList rec;
 
@@ -779,10 +740,10 @@ void XtAppAddActions(
     UNLOCK_APP(app);
 }
 
-void XtGetActionList(
-    WidgetClass widget_class,
-    XtActionList* actions_return,
-    Cardinal* num_actions_return)
+void
+XtGetActionList(WidgetClass widget_class,
+                XtActionList *actions_return,
+                Cardinal *num_actions_return)
 {
     CompiledActionTable table;
 
@@ -790,28 +751,30 @@ void XtGetActionList(
     *num_actions_return = 0;
 
     LOCK_PROCESS;
-    if (! widget_class->core_class.class_inited) {
-	UNLOCK_PROCESS;
-	return;
+    if (!widget_class->core_class.class_inited) {
+        UNLOCK_PROCESS;
+        return;
     }
-    if (! (widget_class->core_class.class_inited & WidgetClassFlag)) {
-	UNLOCK_PROCESS;
-	return;
+    if (!(widget_class->core_class.class_inited & WidgetClassFlag)) {
+        UNLOCK_PROCESS;
+        return;
     }
     *num_actions_return = widget_class->core_class.num_actions;
     if (*num_actions_return) {
-	XtActionList list = *actions_return = (XtActionList)
-	    __XtMalloc((Cardinal)((size_t)*num_actions_return * sizeof(XtActionsRec)));
-
-	table = GetClassActions(widget_class);
-
-	if (table != NULL) {
-	    int i;
-	    for (i= (int)(*num_actions_return); --i >= 0; list++, table++) {
-		list->string = XrmQuarkToString(table->signature);
-		list->proc = table->proc;
-	    }
-	}
+        XtActionList list = *actions_return = (XtActionList)
+            __XtMalloc((Cardinal)
+                       ((size_t) *num_actions_return * sizeof(XtActionsRec)));
+
+        table = GetClassActions(widget_class);
+
+        if (table != NULL) {
+            int i;
+
+            for (i = (int) (*num_actions_return); --i >= 0; list++, table++) {
+                list->string = XrmQuarkToString(table->signature);
+                list->proc = table->proc;
+            }
+        }
     }
     UNLOCK_PROCESS;
 }
@@ -822,9 +785,8 @@ void XtGetActionList(
  *
  ***********************************************************************/
 
-static Widget _XtFindPopup(
-    Widget widget,
-    String name)
+static Widget
+_XtFindPopup(Widget widget, String name)
 {
     register Cardinal i;
     register XrmQuark q;
@@ -832,19 +794,19 @@ static Widget _XtFindPopup(
 
     q = XrmStringToQuark(name);
 
-    for (w=widget; w != NULL; w=w->core.parent)
-	for (i=0; i<w->core.num_popups; i++)
-	    if (w->core.popup_list[i]->core.xrm_name == q)
-		return w->core.popup_list[i];
+    for (w = widget; w != NULL; w = w->core.parent)
+        for (i = 0; i < w->core.num_popups; i++)
+            if (w->core.popup_list[i]->core.xrm_name == q)
+                return w->core.popup_list[i];
 
     return NULL;
 }
 
-void XtMenuPopupAction(
-    Widget widget,
-    XEvent *event,
-    String *params,
-    Cardinal *num_params)
+void
+XtMenuPopupAction(Widget widget,
+                  XEvent *event,
+                  String *params,
+                  Cardinal *num_params)
 {
     Boolean spring_loaded;
     register Widget popup_shell;
@@ -852,87 +814,91 @@ void XtMenuPopupAction(
 
     LOCK_APP(app);
     if (*num_params != 1) {
-	XtAppWarningMsg(app,
-		      "invalidParameters","xtMenuPopupAction",XtCXtToolkitError,
-			"MenuPopup wants exactly one argument",
-			NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        "invalidParameters", "xtMenuPopupAction",
+                        XtCXtToolkitError,
+                        "MenuPopup wants exactly one argument", NULL, NULL);
+        UNLOCK_APP(app);
+        return;
     }
 
     if (event->type == ButtonPress)
-	spring_loaded = True;
+        spring_loaded = True;
     else if (event->type == KeyPress || event->type == EnterNotify)
-	spring_loaded = False;
+        spring_loaded = False;
     else {
-	XtAppWarningMsg(app,
-		"invalidPopup","unsupportedOperation",XtCXtToolkitError,
-"Pop-up menu creation is only supported on ButtonPress, KeyPress or EnterNotify events.",
-                  NULL, NULL);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        "invalidPopup", "unsupportedOperation",
+                        XtCXtToolkitError,
+                        "Pop-up menu creation is only supported on ButtonPress, KeyPress or EnterNotify events.",
+                        NULL, NULL);
+        UNLOCK_APP(app);
+        return;
     }
 
     popup_shell = _XtFindPopup(widget, params[0]);
     if (popup_shell == NULL) {
-	XtAppWarningMsg(app,
-			"invalidPopup","xtMenuPopup",XtCXtToolkitError,
-			"Can't find popup widget \"%s\" in XtMenuPopup",
-			params, num_params);
-	UNLOCK_APP(app);
-	return;
+        XtAppWarningMsg(app,
+                        "invalidPopup", "xtMenuPopup", XtCXtToolkitError,
+                        "Can't find popup widget \"%s\" in XtMenuPopup",
+                        params, num_params);
+        UNLOCK_APP(app);
+        return;
     }
 
-    if (spring_loaded) _XtPopup(popup_shell, XtGrabExclusive, TRUE);
-    else _XtPopup(popup_shell, XtGrabNonexclusive, FALSE);
+    if (spring_loaded)
+        _XtPopup(popup_shell, XtGrabExclusive, TRUE);
+    else
+        _XtPopup(popup_shell, XtGrabNonexclusive, FALSE);
     UNLOCK_APP(app);
 }
 
-
-/*ARGSUSED*/
-static void _XtMenuPopdownAction(
-    Widget widget,
-    XEvent *event,
-    String *params,
-    Cardinal *num_params)
+static void
+_XtMenuPopdownAction(Widget widget,
+                     XEvent *event _X_UNUSED,
+                     String *params,
+                     Cardinal *num_params)
 {
     Widget popup_shell;
 
     if (*num_params == 0) {
-	XtPopdown(widget);
-    } else if (*num_params == 1) {
-	popup_shell = _XtFindPopup(widget, params[0]);
-	if (popup_shell == NULL) {
+        XtPopdown(widget);
+    }
+    else if (*num_params == 1) {
+        popup_shell = _XtFindPopup(widget, params[0]);
+        if (popup_shell == NULL) {
             XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-			    "invalidPopup","xtMenuPopdown",XtCXtToolkitError,
-			    "Can't find popup widget \"%s\" in XtMenuPopdown",
-			    params, num_params);
-	    return;
-	}
-	XtPopdown(popup_shell);
-    } else {
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-			"invalidParameters","xtMenuPopdown",XtCXtToolkitError,
-			"XtMenuPopdown called with num_params != 0 or 1",
-			NULL, NULL);
+                            "invalidPopup", "xtMenuPopdown", XtCXtToolkitError,
+                            "Can't find popup widget \"%s\" in XtMenuPopdown",
+                            params, num_params);
+            return;
+        }
+        XtPopdown(popup_shell);
+    }
+    else {
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidParameters", "xtMenuPopdown", XtCXtToolkitError,
+                        "XtMenuPopdown called with num_params != 0 or 1",
+                        NULL, NULL);
     }
 }
 
+/* *INDENT-OFF* */
 static XtActionsRec RConst tmActions[] = {
-    {"XtMenuPopup", XtMenuPopupAction},
-    {"XtMenuPopdown", _XtMenuPopdownAction},
-    {"MenuPopup", XtMenuPopupAction}, /* old & obsolete */
-    {"MenuPopdown", _XtMenuPopdownAction}, /* ditto */
+    {"XtMenuPopup",                    XtMenuPopupAction},
+    {"XtMenuPopdown",                  _XtMenuPopdownAction},
+    {"MenuPopup",                      XtMenuPopupAction},      /* old & obsolete */
+    {"MenuPopdown",                    _XtMenuPopdownAction},   /* ditto */
 #ifndef NO_MIT_HACKS
-    {"XtDisplayTranslations", _XtDisplayTranslations},
-    {"XtDisplayAccelerators", _XtDisplayAccelerators},
+    {"XtDisplayTranslations",          _XtDisplayTranslations},
+    {"XtDisplayAccelerators",          _XtDisplayAccelerators},
     {"XtDisplayInstalledAccelerators", _XtDisplayInstalledAccelerators},
 #endif
 };
+/* *INDENT-ON* */
 
-
-void _XtPopupInitialize(
-    XtAppContext app)
+void
+_XtPopupInitialize(XtAppContext app)
 {
     register ActionList rec;
 
@@ -954,21 +920,20 @@ void _XtPopupInitialize(
     app->action_table = rec;
     LOCK_PROCESS;
     rec->table = CompileActionTable(tmActions, XtNumber(tmActions), False,
-				    True);
+                                    True);
     rec->count = XtNumber(tmActions);
     UNLOCK_PROCESS;
     _XtGrabInitialize(app);
 }
 
-
-void XtCallActionProc(
-    Widget widget,
-    _Xconst char* action,
-    XEvent *event,
-    String *params,
-    Cardinal num_params)
+void
+XtCallActionProc(Widget widget,
+                 _Xconst char *action,
+                 XEvent *event,
+                 String *params,
+                 Cardinal num_params)
 {
-    CompiledAction* actionP;
+    CompiledAction *actionP;
     XrmQuark q = XrmStringToQuark(action);
     Widget w = widget;
     XtAppContext app = XtWidgetToApplicationContext(widget);
@@ -977,91 +942,88 @@ void XtCallActionProc(
 
     LOCK_APP(app);
     XtCheckSubclass(widget, coreWidgetClass,
-		    "XtCallActionProc first argument is not a subclass of Core");
+                    "XtCallActionProc first argument is not a subclass of Core");
     LOCK_PROCESS;
     do {
-	WidgetClass class = XtClass(w);
-	do {
-	    if ((actionP = GetClassActions(class)) != NULL)
-	      for (i = 0;
-		   i < class->core_class.num_actions;
-		   i++, actionP++) {
-
-		  if (actionP->signature == q) {
-		      ActionHook hook = app->action_hook_list;
-		      while (hook != NULL) {
-			  (*hook->proc)( widget,
-					hook->closure,
-					(String)action,
-					event,
-					params,
-					&num_params
-					);
-			  hook= hook->next;
-		      }
-		      (*(actionP->proc))
-			(widget, event, params, &num_params);
-		      UNLOCK_PROCESS;
-		      UNLOCK_APP(app);
-		      return;
-		  }
-	      }
-	    class = class->core_class.superclass;
-	} while (class != NULL);
-	w = XtParent(w);
+        WidgetClass class = XtClass(w);
+
+        do {
+            if ((actionP = GetClassActions(class)) != NULL)
+                for (i = 0; i < class->core_class.num_actions; i++, actionP++) {
+
+                    if (actionP->signature == q) {
+                        ActionHook hook = app->action_hook_list;
+
+                        while (hook != NULL) {
+                            (*hook->proc) (widget,
+                                           hook->closure,
+                                           (String) action,
+                                           event,
+                                           params,
+                                           &num_params);
+                            hook = hook->next;
+                        }
+                        (*(actionP->proc))
+                            (widget, event, params, &num_params);
+                        UNLOCK_PROCESS;
+                        UNLOCK_APP(app);
+                        return;
+                    }
+                }
+            class = class->core_class.superclass;
+        } while (class != NULL);
+        w = XtParent(w);
     } while (w != NULL);
     UNLOCK_PROCESS;
 
     for (actionList = app->action_table;
-	 actionList != NULL;
-	 actionList = actionList->next) {
-
-	for (i = 0, actionP = actionList->table;
-	     i < actionList->count;
-	     i++, actionP++) {
-	    if (actionP->signature == q) {
-		ActionHook hook = app->action_hook_list;
-		while (hook != NULL) {
-		    (*hook->proc)( widget,
-				  hook->closure,
-				  (String)action,
-				  event,
-				  params,
-				  &num_params
-				  );
-		    hook= hook->next;
-		}
-		(*(actionP->proc))
-		  (widget, event, params, &num_params);
-		UNLOCK_APP(app);
-		return;
-	    }
-	}
+         actionList != NULL; actionList = actionList->next) {
+
+        for (i = 0, actionP = actionList->table;
+             i < actionList->count; i++, actionP++) {
+            if (actionP->signature == q) {
+                ActionHook hook = app->action_hook_list;
+
+                while (hook != NULL) {
+                    (*hook->proc) (widget,
+                                   hook->closure,
+                                   (String) action,
+                                   event,
+                                   params,
+                                   &num_params);
+                    hook = hook->next;
+                }
+                (*(actionP->proc))
+                    (widget, event, params, &num_params);
+                UNLOCK_APP(app);
+                return;
+            }
+        }
 
     }
 
     {
-	String par[2];
-	Cardinal num_par = 2;
-	par[0] = (String)action;
-	par[1] = XtName(widget);
-	XtAppWarningMsg(app,
-			"noActionProc", "xtCallActionProc", XtCXtToolkitError,
-			"No action proc named \"%s\" is registered for widget \"%s\"",
-			par, &num_par
-			);
+        String par[2];
+        Cardinal num_par = 2;
+
+        par[0] = (String) action;
+        par[1] = XtName(widget);
+        XtAppWarningMsg(app,
+                        "noActionProc", "xtCallActionProc", XtCXtToolkitError,
+                        "No action proc named \"%s\" is registered for widget \"%s\"",
+                        par, &num_par);
     }
     UNLOCK_APP(app);
 }
 
-void _XtDoFreeBindings(
-    XtAppContext app)
+void
+_XtDoFreeBindings(XtAppContext app)
 {
     TMBindCache bcp;
 
     while (app->free_bindings) {
-	bcp = app->free_bindings->next;
-	XtFree ((char *) app->free_bindings);
-	app->free_bindings = bcp;
+        bcp = app->free_bindings->next;
+        XtFree((char *) app->free_bindings);
+        app->free_bindings = bcp;
     }
 }
diff --git a/src/TMgrab.c b/src/TMgrab.c
index 5ffcebf..352d2ee 100644
--- a/src/TMgrab.c
+++ b/src/TMgrab.c
@@ -68,14 +68,13 @@ in this Software without prior written authorization from The Open Group.
 
 */
 
-/*LINTLIBRARY*/
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
 
 typedef struct _GrabActionRec {
-    struct _GrabActionRec* next;
+    struct _GrabActionRec *next;
     XtActionProc action_proc;
     Boolean owner_events;
     unsigned int event_mask;
@@ -84,11 +83,10 @@ typedef struct _GrabActionRec {
 
 static GrabActionRec *grabActionList = NULL;
 
-static void GrabAllCorrectKeys(
-    Widget widget,
-    TMTypeMatch typeMatch,
-    TMModifierMatch modMatch,
-    GrabActionRec* grabP)
+static void
+GrabAllCorrectKeys(Widget widget,
+                   TMTypeMatch typeMatch,
+                   TMModifierMatch modMatch, GrabActionRec * grabP)
 {
     Display *dpy = XtDisplay(widget);
     KeyCode *keycodes, *keycodeP;
@@ -97,253 +95,247 @@ static void GrabAllCorrectKeys(
     Modifiers careMask = 0;
 
     if (modMatch->lateModifiers) {
-	Boolean resolved;
-	resolved = _XtComputeLateBindings(dpy, modMatch->lateModifiers,
-					  &careOn, &careMask);
-	if (!resolved) return;
+        Boolean resolved;
+
+        resolved = _XtComputeLateBindings(dpy, modMatch->lateModifiers,
+                                          &careOn, &careMask);
+        if (!resolved)
+            return;
     }
-    careOn = (careOn | (Modifiers)modMatch->modifiers);
-    careMask = (careMask | (Modifiers)modMatch->modifierMask);
+    careOn = (careOn | (Modifiers) modMatch->modifiers);
+    careMask = (careMask | (Modifiers) modMatch->modifierMask);
 
     keycodes = NULL;
-    XtKeysymToKeycodeList(
-	    dpy,
-	    (KeySym)typeMatch->eventCode,
-	    &keycodes,
-	    &keycount
-			 );
+    XtKeysymToKeycodeList(dpy,
+                          (KeySym) typeMatch->eventCode, &keycodes, &keycount);
     if (keycount == 0) {
-	XtFree((char *)keycodes);
-	return;
+        XtFree((char *) keycodes);
+        return;
     }
     for (keycodeP = keycodes; keycount--; keycodeP++) {
-	if (modMatch->standard) {
-	    /* find standard modifiers that produce this keysym */
-	    KeySym keysym;
-	    int std_mods, least_mod;
-	    Modifiers modifiers_return;
-	    XtTranslateKeycode( dpy, *keycodeP, (Modifiers)0,
-			        &modifiers_return, &keysym );
-	    if (careOn & modifiers_return) {
-		XtFree((char *)keycodes);
-		return;
-	    }
-	    if (keysym == typeMatch->eventCode) {
-		XtGrabKey(widget, *keycodeP, careOn,
-			  grabP->owner_events,
-			  grabP->pointer_mode,
-			  grabP->keyboard_mode
-			);
-		/* continue; */		/* grab all modifier combinations */
-	    }
-	    least_mod = (int) (modifiers_return & (~modifiers_return + 1));
-	    for (std_mods = (int) modifiers_return;
-		 std_mods >= least_mod; std_mods--) {
-		Modifiers dummy;
-		 /* check all useful combinations of modifier bits */
-		if ((modifiers_return & (Modifiers)std_mods) &&
-		    !(~modifiers_return & (Modifiers)std_mods)) {
-		    XtTranslateKeycode( dpy, *keycodeP,
-					(Modifiers)std_mods,
-					&dummy, &keysym );
-		    if (keysym == typeMatch->eventCode) {
-			XtGrabKey(widget, *keycodeP,
-				  careOn | (Modifiers) std_mods,
-				  grabP->owner_events,
-				  grabP->pointer_mode,
-				  grabP->keyboard_mode
-				);
-			/* break; */	/* grab all modifier combinations */
-		    }
-		}
-	    }
-	} else /* !event->standard */ {
-	    XtGrabKey(widget, *keycodeP, careOn,
-		      grabP->owner_events,
-		      grabP->pointer_mode,
-		      grabP->keyboard_mode
-		    );
-	}
+        if (modMatch->standard) {
+            /* find standard modifiers that produce this keysym */
+            KeySym keysym;
+            int std_mods, least_mod;
+            Modifiers modifiers_return;
+
+            XtTranslateKeycode(dpy, *keycodeP, (Modifiers) 0,
+                               &modifiers_return, &keysym);
+            if (careOn & modifiers_return) {
+                XtFree((char *) keycodes);
+                return;
+            }
+            if (keysym == typeMatch->eventCode) {
+                XtGrabKey(widget, *keycodeP, careOn,
+                          grabP->owner_events,
+                          grabP->pointer_mode, grabP->keyboard_mode);
+                /* continue; *//* grab all modifier combinations */
+            }
+            least_mod = (int) (modifiers_return & (~modifiers_return + 1));
+            for (std_mods = (int) modifiers_return;
+                 std_mods >= least_mod; std_mods--) {
+                Modifiers dummy;
+
+                /* check all useful combinations of modifier bits */
+                if ((modifiers_return & (Modifiers) std_mods) &&
+                    !(~modifiers_return & (Modifiers) std_mods)) {
+                    XtTranslateKeycode(dpy, *keycodeP,
+                                       (Modifiers) std_mods, &dummy, &keysym);
+                    if (keysym == typeMatch->eventCode) {
+                        XtGrabKey(widget, *keycodeP,
+                                  careOn | (Modifiers) std_mods,
+                                  grabP->owner_events,
+                                  grabP->pointer_mode, grabP->keyboard_mode);
+                        /* break; *//* grab all modifier combinations */
+                    }
+                }
+            }
+        }
+        else {                  /* !event->standard */
+
+            XtGrabKey(widget, *keycodeP, careOn,
+                      grabP->owner_events,
+                      grabP->pointer_mode, grabP->keyboard_mode);
+        }
     }
-    XtFree((char *)keycodes);
+    XtFree((char *) keycodes);
 }
 
 typedef struct {
     TMShortCard count;
-    Widget	widget;
+    Widget widget;
     GrabActionRec *grabP;
-}DoGrabRec;
+} DoGrabRec;
 
-static Boolean DoGrab(
-    StatePtr		state,
-    XtPointer		data)
+static Boolean
+DoGrab(StatePtr state, XtPointer data)
 {
-    DoGrabRec		*doGrabP = (DoGrabRec *)data;
-    GrabActionRec* 	grabP = doGrabP->grabP;
-    Widget		widget = doGrabP->widget;
-    TMShortCard		count = doGrabP->count;
-    TMShortCard		typeIndex = state->typeIndex;
-    TMShortCard		modIndex = state->modIndex;
-    ActionRec		*action;
-    TMTypeMatch		typeMatch;
-    TMModifierMatch	modMatch;
-    Modifiers		careOn = 0;
-    Modifiers		careMask = 0;
+    /* *INDENT-EQLS* */
+    DoGrabRec *doGrabP     = (DoGrabRec *) data;
+    GrabActionRec *grabP   = doGrabP->grabP;
+    Widget widget          = doGrabP->widget;
+    TMShortCard count      = doGrabP->count;
+    TMShortCard typeIndex  = state->typeIndex;
+    TMShortCard modIndex   = state->modIndex;
+    ActionRec *action;
+    TMTypeMatch typeMatch;
+    TMModifierMatch modMatch;
+    Modifiers careOn = 0;
+    Modifiers careMask = 0;
 
     LOCK_PROCESS;
     typeMatch = TMGetTypeMatch(typeIndex);
     modMatch = TMGetModifierMatch(modIndex);
 
     for (action = state->actions; action; action = action->next)
-      if (count == action->idx) break;
+        if (count == action->idx)
+            break;
     if (!action) {
-	UNLOCK_PROCESS;
-	return False;
+        UNLOCK_PROCESS;
+        return False;
     }
 
     switch (typeMatch->eventType) {
-      case ButtonPress:
-      case ButtonRelease:
-	if (modMatch->lateModifiers) {
-	    Boolean resolved = _XtComputeLateBindings(XtDisplay(widget),
-						      modMatch->lateModifiers,
-						      &careOn, &careMask);
-	    if (!resolved) break;
-	}
-	careOn = (careOn | (Modifiers) modMatch->modifiers);
-	XtGrabButton(
-		     widget,
-		     (int) typeMatch->eventCode,
-		     careOn,
-		     grabP->owner_events,
-		     grabP->event_mask,
-		     grabP->pointer_mode,
-		     grabP->keyboard_mode,
-		     None,
-		     None
-		     );
-	break;
-
-      case KeyPress:
-      case KeyRelease:
-	GrabAllCorrectKeys(widget, typeMatch, modMatch, grabP);
-	break;
-
-      case EnterNotify:
-	break;
-
-      default:
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-			"invalidPopup","unsupportedOperation",XtCXtToolkitError,
-			"Pop-up menu creation is only supported on Button, Key or EnterNotify events.",
-			NULL, NULL);
-	break;
+    case ButtonPress:
+    case ButtonRelease:
+        if (modMatch->lateModifiers) {
+            Boolean resolved = _XtComputeLateBindings(XtDisplay(widget),
+                                                      modMatch->lateModifiers,
+                                                      &careOn, &careMask);
+
+            if (!resolved)
+                break;
+        }
+        careOn = (careOn | (Modifiers) modMatch->modifiers);
+        XtGrabButton(widget,
+                     (int) typeMatch->eventCode,
+                     careOn,
+                     grabP->owner_events,
+                     grabP->event_mask,
+                     grabP->pointer_mode,
+                     grabP->keyboard_mode,
+                     None,
+                     None);
+        break;
+
+    case KeyPress:
+    case KeyRelease:
+        GrabAllCorrectKeys(widget, typeMatch, modMatch, grabP);
+        break;
+
+    case EnterNotify:
+        break;
+
+    default:
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "invalidPopup", "unsupportedOperation",
+                        XtCXtToolkitError,
+                        "Pop-up menu creation is only supported on Button, Key or EnterNotify events.",
+                        NULL, NULL);
+        break;
     }
     UNLOCK_PROCESS;
     return False;
 }
 
-void _XtRegisterGrabs(
-    Widget widget)
+void
+_XtRegisterGrabs(Widget widget)
 {
-    XtTranslations 	xlations = widget->core.tm.translations;
-    TMComplexStateTree 	*stateTreePtr;
-    unsigned int 	count;
-    TMShortCard		i;
-    TMBindData   	bindData = (TMBindData) widget->core.tm.proc_table;
-    XtActionProc	*procs;
+    XtTranslations xlations = widget->core.tm.translations;
+    TMComplexStateTree *stateTreePtr;
+    unsigned int count;
+    TMShortCard i;
+    TMBindData bindData = (TMBindData) widget->core.tm.proc_table;
+    XtActionProc *procs;
 
-    if (! XtIsRealized(widget) || widget->core.being_destroyed)
-	return;
+    if (!XtIsRealized(widget) || widget->core.being_destroyed)
+        return;
 
     /* walk the widget instance action bindings table looking for */
     /* actions registered as grab actions. */
     /* when you find one, do a grab on the triggering event */
 
-    if (xlations == NULL) return;
+    if (xlations == NULL)
+        return;
     stateTreePtr = (TMComplexStateTree *) xlations->stateTreeTbl;
-    if (*stateTreePtr == NULL) return;
+    if (*stateTreePtr == NULL)
+        return;
     for (i = 0; i < xlations->numStateTrees; i++, stateTreePtr++) {
-	if (bindData->simple.isComplex)
-	  procs = TMGetComplexBindEntry(bindData, i)->procs;
-	else
-	  procs = TMGetSimpleBindEntry(bindData, i)->procs;
-	for (count=0; count < (*stateTreePtr)->numQuarks; count++) {
-	    GrabActionRec* grabP;
-	    DoGrabRec      doGrab;
-
-	    LOCK_PROCESS;
-	    for (grabP = grabActionList; grabP != NULL; grabP = grabP->next) {
-		if (grabP->action_proc == procs[count]) {
-		    /* we've found a "grabber" in the action table. Find the
-		     * states that call this action.  Note that if there is
-		     * more than one "grabber" in the action table, we end
-		     * up searching all of the states multiple times.
-		     */
-		    doGrab.widget = widget;
-		    doGrab.grabP = grabP;
-		    doGrab.count = (TMShortCard) count;
-		    _XtTraverseStateTree((TMStateTree)*stateTreePtr,
-					 DoGrab,
-					 (XtPointer)&doGrab);
-		}
-	    }
-	    UNLOCK_PROCESS;
-	}
+        if (bindData->simple.isComplex)
+            procs = TMGetComplexBindEntry(bindData, i)->procs;
+        else
+            procs = TMGetSimpleBindEntry(bindData, i)->procs;
+        for (count = 0; count < (*stateTreePtr)->numQuarks; count++) {
+            GrabActionRec *grabP;
+            DoGrabRec doGrab;
+
+            LOCK_PROCESS;
+            for (grabP = grabActionList; grabP != NULL; grabP = grabP->next) {
+                if (grabP->action_proc == procs[count]) {
+                    /* we've found a "grabber" in the action table. Find the
+                     * states that call this action.  Note that if there is
+                     * more than one "grabber" in the action table, we end
+                     * up searching all of the states multiple times.
+                     */
+                    doGrab.widget = widget;
+                    doGrab.grabP = grabP;
+                    doGrab.count = (TMShortCard) count;
+                    _XtTraverseStateTree((TMStateTree) *stateTreePtr,
+                                         DoGrab, (XtPointer) &doGrab);
+                }
+            }
+            UNLOCK_PROCESS;
+        }
     }
 }
 
-void XtRegisterGrabAction(
-    XtActionProc action_proc,
-    _XtBoolean owner_events,
-    unsigned int event_mask,
-    int pointer_mode,
-    int keyboard_mode)
+void
+XtRegisterGrabAction(XtActionProc action_proc,
+                     _XtBoolean owner_events,
+                     unsigned int event_mask,
+                     int pointer_mode,
+                     int keyboard_mode)
 {
-    GrabActionRec* actionP;
+    GrabActionRec *actionP;
 
     LOCK_PROCESS;
     for (actionP = grabActionList; actionP != NULL; actionP = actionP->next) {
-	if (actionP->action_proc == action_proc) break;
+        if (actionP->action_proc == action_proc)
+            break;
     }
     if (actionP == NULL) {
-	actionP = XtNew(GrabActionRec);
-	actionP->action_proc = action_proc;
-	actionP->next = grabActionList;
-	grabActionList = actionP;
+        actionP = XtNew(GrabActionRec);
+        actionP->action_proc = action_proc;
+        actionP->next = grabActionList;
+        grabActionList = actionP;
     }
 #ifdef DEBUG
-    else
-	if (   actionP->owner_events != owner_events
-	    || actionP->event_mask != event_mask
-	    || actionP->pointer_mode != pointer_mode
-	    || actionP->keyboard_mode != keyboard_mode) {
-	    Cardinal n = 0;
-	    XtWarningMsg(
-		"argsReplaced", "xtRegisterGrabAction", XtCXtToolkitError,
-		"XtRegisterGrabAction called on same proc with different args",
-			 NULL, &n);
-	}
+    else if (actionP->owner_events != owner_events
+             || actionP->event_mask != event_mask
+             || actionP->pointer_mode != pointer_mode
+             || actionP->keyboard_mode != keyboard_mode) {
+        Cardinal n = 0;
+
+        XtWarningMsg("argsReplaced", "xtRegisterGrabAction", XtCXtToolkitError,
+                     "XtRegisterGrabAction called on same proc with different args",
+                     NULL, &n);
+    }
 #endif /*DEBUG*/
-
-    actionP->owner_events = (Boolean) owner_events;
+        actionP->owner_events = (Boolean) owner_events;
     actionP->event_mask = event_mask;
     actionP->pointer_mode = pointer_mode;
     actionP->keyboard_mode = keyboard_mode;
     UNLOCK_PROCESS;
 }
 
-/*ARGSUSED*/
-void _XtGrabInitialize(
-    XtAppContext	app)
+void
+_XtGrabInitialize(XtAppContext app _X_UNUSED)
 {
     LOCK_PROCESS;
     if (grabActionList == NULL)
-	XtRegisterGrabAction( XtMenuPopupAction, True,
-			      (unsigned)(ButtonPressMask | ButtonReleaseMask),
-			      GrabModeAsync,
-			      GrabModeAsync
-			    );
+        XtRegisterGrabAction(XtMenuPopupAction, True,
+                             (unsigned) (ButtonPressMask | ButtonReleaseMask),
+                             GrabModeAsync, GrabModeAsync);
     UNLOCK_PROCESS;
 
 }
diff --git a/src/TMkey.c b/src/TMkey.c
index 06924ac..b747f07 100644
--- a/src/TMkey.c
+++ b/src/TMkey.c
@@ -1,5 +1,3 @@
-/*LINTLIBRARY*/
-
 /***********************************************************
 Copyright (c) 1993, Oracle and/or its affiliates. All rights reserved.
 
@@ -86,7 +84,7 @@ in this Software without prior written authorization from The Open Group.
 #endif
 
 #define FLUSHKEYCACHE(ctx) \
-	memset((void *)&ctx->keycache, 0, sizeof(TMKeyCache))
+        memset((void *)&ctx->keycache, 0, sizeof(TMKeyCache))
 
 /*
  * The following array reorders the modifier bits so that the most common ones
@@ -96,6 +94,8 @@ in this Software without prior written authorization from The Open Group.
  */
 
 #define FM(i) i >> (8 - TMKEYCACHELOG2)
+
+/* *INDENT-OFF* */
 static const unsigned char modmix[256] = {
 FM(0x0f), FM(0x8f), FM(0x4f), FM(0xcf), FM(0x2f), FM(0xaf), FM(0x6f), FM(0xef),
 FM(0x1f), FM(0x9f), FM(0x5f), FM(0xdf), FM(0x3f), FM(0xbf), FM(0x7f), FM(0xff),
@@ -130,6 +130,7 @@ FM(0x16), FM(0x96), FM(0x56), FM(0xd6), FM(0x36), FM(0xb6), FM(0x76), FM(0xf6),
 FM(0x0e), FM(0x8e), FM(0x4e), FM(0xce), FM(0x2e), FM(0xae), FM(0x6e), FM(0xee),
 FM(0x1e), FM(0x9e), FM(0x5e), FM(0xde), FM(0x3e), FM(0xbe), FM(0x7e), FM(0xfe)
 };
+/* *INDENT-ON* */
 #undef FM
 
 #define MOD_RETURN(ctx, key) (ctx)->keycache.modifiers_return[key]
@@ -137,28 +138,28 @@ FM(0x1e), FM(0x9e), FM(0x5e), FM(0xde), FM(0x3e), FM(0xbe), FM(0x7e), FM(0xfe)
 #define TRANSLATE(ctx,pd,dpy,key,mod,mod_ret,sym_ret) \
 { \
     int _i_ = (((key) - (TMLongCard) (pd)->min_keycode + modmix[(mod) & 0xff]) & \
-	       (TMKEYCACHESIZE-1)); \
+               (TMKEYCACHESIZE-1)); \
     if ((key) == 0) { /* Xlib XIM composed input */ \
-	mod_ret = 0; \
-	sym_ret = 0; \
+        mod_ret = 0; \
+        sym_ret = 0; \
     } else if (   /* not Xlib XIM composed input */ \
-	(ctx)->keycache.keycode[_i_] == (key) && \
-	(ctx)->keycache.modifiers[_i_] == (mod)) { \
-	mod_ret = MOD_RETURN(ctx, key); \
-	sym_ret = (ctx)->keycache.keysym[_i_]; \
+        (ctx)->keycache.keycode[_i_] == (key) && \
+        (ctx)->keycache.modifiers[_i_] == (mod)) { \
+        mod_ret = MOD_RETURN(ctx, key); \
+        sym_ret = (ctx)->keycache.keysym[_i_]; \
     } else { \
-	XtTranslateKeycode(dpy, (KeyCode) key, mod, &mod_ret, &sym_ret); \
-	(ctx)->keycache.keycode[_i_] = (KeyCode) (key); \
-	(ctx)->keycache.modifiers[_i_] = (unsigned char)(mod); \
-	(ctx)->keycache.keysym[_i_] = sym_ret; \
-	MOD_RETURN(ctx, key) = (unsigned char)mod_ret; \
+        XtTranslateKeycode(dpy, (KeyCode) key, mod, &mod_ret, &sym_ret); \
+        (ctx)->keycache.keycode[_i_] = (KeyCode) (key); \
+        (ctx)->keycache.modifiers[_i_] = (unsigned char)(mod); \
+        (ctx)->keycache.keysym[_i_] = sym_ret; \
+        MOD_RETURN(ctx, key) = (unsigned char)mod_ret; \
     } \
 }
 
 #define UPDATE_CACHE(ctx, pd, key, mod, mod_ret, sym_ret) \
 { \
     int _i_ = (((key) - (TMLongCard) (pd)->min_keycode + modmix[(mod) & 0xff]) & \
-	       (TMKEYCACHESIZE-1)); \
+               (TMKEYCACHESIZE-1)); \
     (ctx)->keycache.keycode[_i_] = (KeyCode) (key); \
     (ctx)->keycache.modifiers[_i_] = (unsigned char)(mod); \
     (ctx)->keycache.keysym[_i_] = sym_ret; \
@@ -168,43 +169,45 @@ FM(0x1e), FM(0x9e), FM(0x5e), FM(0xde), FM(0x3e), FM(0xbe), FM(0x7e), FM(0xfe)
 /* usual number of expected keycodes in XtKeysymToKeycodeList */
 #define KEYCODE_ARRAY_SIZE 10
 
-Boolean _XtComputeLateBindings(
-    Display *dpy,
-    LateBindingsPtr lateModifiers,
-    Modifiers *computed,
-    Modifiers *computedMask)
+Boolean
+_XtComputeLateBindings(Display *dpy,
+                       LateBindingsPtr lateModifiers,
+                       Modifiers *computed,
+                       Modifiers *computedMask)
 {
-    int i,j,ref;
-    ModToKeysymTable* temp;
+    int i, j, ref;
+    ModToKeysymTable *temp;
     XtPerDisplay perDisplay;
     KeySym tempKeysym = NoSymbol;
 
     perDisplay = _XtGetPerDisplay(dpy);
     if (perDisplay == NULL) {
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-		"displayError","invalidDisplay",XtCXtToolkitError,
-            "Can't find display structure",
-            NULL, NULL);
-         return FALSE;
+                        "displayError", "invalidDisplay", XtCXtToolkitError,
+                        "Can't find display structure", NULL, NULL);
+        return FALSE;
     }
     _InitializeKeysymTables(dpy, perDisplay);
-    for (ref=0; lateModifiers[ref].keysym; ref++) {
+    for (ref = 0; lateModifiers[ref].keysym; ref++) {
         Boolean found = FALSE;
-        for (i=0;i<8;i++) {
+
+        for (i = 0; i < 8; i++) {
             temp = &(perDisplay->modsToKeysyms[i]);
-            for (j=0;j<temp->count;j++){
-                if (perDisplay->modKeysyms[temp->idx+j] ==
-		    lateModifiers[ref].keysym) {
+            for (j = 0; j < temp->count; j++) {
+                if (perDisplay->modKeysyms[temp->idx + j] ==
+                    lateModifiers[ref].keysym) {
                     *computedMask = *computedMask | temp->mask;
                     if (!lateModifiers[ref].knot)
-		      *computed |= temp->mask;
+                        *computed |= temp->mask;
                     tempKeysym = lateModifiers[ref].keysym;
-                    found = TRUE; break;
+                    found = TRUE;
+                    break;
                 }
             }
-            if (found) break;
+            if (found)
+                break;
         }
-        if (!found  && !lateModifiers[ref].knot)
+        if (!found && !lateModifiers[ref].knot)
             if (!lateModifiers[ref].pair && (tempKeysym == NoSymbol))
                 return FALSE;
         /* if you didn't find the modifier and the modifier must be
@@ -213,17 +216,18 @@ Boolean _XtComputeLateBindings(
            return FALSE if this is the first member of a pair or if
            it is the second member of a pair when the first member
            was bound to a modifier */
-    if (!lateModifiers[ref].pair) tempKeysym = NoSymbol;
+        if (!lateModifiers[ref].pair)
+            tempKeysym = NoSymbol;
     }
     return TRUE;
 }
 
-void _XtAllocTMContext(
-    XtPerDisplay pd)
+void
+_XtAllocTMContext(XtPerDisplay pd)
 {
     TMKeyContext ctx;
-    ctx = (TMKeyContext)_XtHeapAlloc(&pd->heap,
-				     sizeof(TMKeyContextRec));
+
+    ctx = (TMKeyContext) _XtHeapAlloc(&pd->heap, sizeof(TMKeyContextRec));
     ctx->event = NULL;
     ctx->serial = 0;
     ctx->keysym = NoSymbol;
@@ -232,19 +236,20 @@ void _XtAllocTMContext(
     pd->tm_context = ctx;
 }
 
-static unsigned int num_bits(unsigned long mask)
+static unsigned int
+num_bits(unsigned long mask)
 {
     register unsigned long y;
 
-    y = (mask >> 1) &033333333333;
-    y = mask - y - ((y >>1) & 033333333333);
+    y = (mask >> 1) & 033333333333;
+    y = mask - y - ((y >> 1) & 033333333333);
     return ((unsigned int) (((y + (y >> 3)) & 030707070707) % 077));
 }
 
-Boolean _XtMatchUsingDontCareMods(
-    TMTypeMatch 	typeMatch,
-    TMModifierMatch 	modMatch,
-    TMEventPtr 		eventSeq)
+Boolean
+_XtMatchUsingDontCareMods(TMTypeMatch typeMatch,
+                          TMModifierMatch modMatch,
+                          TMEventPtr eventSeq)
 {
     Modifiers modifiers_return;
     KeySym keysym_return;
@@ -256,123 +261,128 @@ Boolean _XtMatchUsingDontCareMods(
     XtPerDisplay pd;
 
     if (modMatch->lateModifiers != NULL)
-	resolved = _XtComputeLateBindings(dpy, modMatch->lateModifiers,
-					  &computed, &computedMask);
-    if (!resolved) return FALSE;
+        resolved = _XtComputeLateBindings(dpy, modMatch->lateModifiers,
+                                          &computed, &computedMask);
+    if (!resolved)
+        return FALSE;
     computed = (Modifiers) (computed | modMatch->modifiers);
     computedMask = (Modifiers) (computedMask | modMatch->modifierMask); /* gives do-care mask */
 
-    if ( (computed & computedMask) ==
-        (eventSeq->event.modifiers & computedMask) ) {
-	TMKeyContext tm_context;
-	int num_modbits;
-	int i;
-
-	pd = _XtGetPerDisplay(dpy);
-	tm_context = pd->tm_context;
-	TRANSLATE(tm_context, pd, dpy, (KeyCode)eventSeq->event.eventCode,
-			    (unsigned)0, modifiers_return, keysym_return);
-
-        if ((keysym_return & typeMatch->eventCodeMask)  == typeMatch->eventCode ) {
-	    tm_context->event = eventSeq->xev;
-	    tm_context->serial = eventSeq->xev->xany.serial;
-	    tm_context->keysym = keysym_return;
-	    tm_context->modifiers = (Modifiers)0;
-	    return TRUE;
-	}
+    if ((computed & computedMask) == (eventSeq->event.modifiers & computedMask)) {
+        TMKeyContext tm_context;
+        int num_modbits;
+        int i;
+
+        pd = _XtGetPerDisplay(dpy);
+        tm_context = pd->tm_context;
+        TRANSLATE(tm_context, pd, dpy, (KeyCode) eventSeq->event.eventCode,
+                  (unsigned) 0, modifiers_return, keysym_return);
+
+        if ((keysym_return & typeMatch->eventCodeMask) == typeMatch->eventCode) {
+            tm_context->event = eventSeq->xev;
+            tm_context->serial = eventSeq->xev->xany.serial;
+            tm_context->keysym = keysym_return;
+            tm_context->modifiers = (Modifiers) 0;
+            return TRUE;
+        }
         useful_mods = ~computedMask & modifiers_return;
-        if (useful_mods == 0) return FALSE;
-
-	switch (num_modbits = (int) num_bits(useful_mods)) {
-	case 1:
-	case 8:
-	    /*
-	     * one modbit should never happen, in fact the implementation
-	     * of XtTranslateKey and XmTranslateKey guarantee that it
-	     * won't, so don't care if the loop is set up for the case
-	     * when one modbit is set.
-	     * The performance implications of all eight modbits being
-	     * set is horrendous. This isn't a problem with Xt/Xaw based
-	     * applications. We can only hope that Motif's virtual
-	     * modifiers won't result in all eight modbits being set.
-	     */
-	    for (i = (int) useful_mods; i > 0; i--) {
-		TRANSLATE(tm_context, pd, dpy, eventSeq->event.eventCode,
-			  (Modifiers)i, modifiers_return, keysym_return);
-		if (keysym_return ==
-		    (typeMatch->eventCode & typeMatch->eventCodeMask)) {
-		    tm_context->event = eventSeq->xev;
-		    tm_context->serial = eventSeq->xev->xany.serial;
-		    tm_context->keysym = keysym_return;
-		    tm_context->modifiers = (Modifiers)i;
-		    return TRUE;
-		}
-	    }
-	    break;
-	default: /* (2..7) */
-	    {
-	    /*
-	     * Only translate using combinations of the useful modifiers.
-	     * to minimize the chance of invalidating the cache.
-	     */
-		static char pows[] = { 0, 1, 3, 7, 15, 31, 63, 127 };
-		Modifiers tmod, mod_masks[8];
-		int j;
-		for (tmod = 1, i = 0; tmod <= (Mod5Mask<<1); tmod <<= 1)
-		    if (tmod & useful_mods) mod_masks[i++] = tmod;
-		for (j = (int) pows[num_modbits]; j > 0; j--) {
-		    tmod = 0;
-		    for (i = 0; i < num_modbits; i++)
-			if (j & (1<<i)) tmod |= mod_masks[i];
-		    TRANSLATE(tm_context, pd, dpy, eventSeq->event.eventCode,
-			      tmod, modifiers_return, keysym_return);
-		    if (keysym_return ==
-			(typeMatch->eventCode & typeMatch->eventCodeMask)) {
-			tm_context->event = eventSeq->xev;
-			tm_context->serial = eventSeq->xev->xany.serial;
-			tm_context->keysym = keysym_return;
-			tm_context->modifiers = (Modifiers)i;
-			return TRUE;
-		    }
-		}
-	    }
-	    break;
-	} /* switch (num_modbits) */
+        if (useful_mods == 0)
+            return FALSE;
+
+        switch (num_modbits = (int) num_bits(useful_mods)) {
+        case 1:
+        case 8:
+            /*
+             * one modbit should never happen, in fact the implementation
+             * of XtTranslateKey and XmTranslateKey guarantee that it
+             * won't, so don't care if the loop is set up for the case
+             * when one modbit is set.
+             * The performance implications of all eight modbits being
+             * set is horrendous. This isn't a problem with Xt/Xaw based
+             * applications. We can only hope that Motif's virtual
+             * modifiers won't result in all eight modbits being set.
+             */
+            for (i = (int) useful_mods; i > 0; i--) {
+                TRANSLATE(tm_context, pd, dpy, eventSeq->event.eventCode,
+                          (Modifiers) i, modifiers_return, keysym_return);
+                if (keysym_return ==
+                    (typeMatch->eventCode & typeMatch->eventCodeMask)) {
+                    tm_context->event = eventSeq->xev;
+                    tm_context->serial = eventSeq->xev->xany.serial;
+                    tm_context->keysym = keysym_return;
+                    tm_context->modifiers = (Modifiers) i;
+                    return TRUE;
+                }
+            }
+            break;
+        default:               /* (2..7) */
+        {
+            /*
+             * Only translate using combinations of the useful modifiers.
+             * to minimize the chance of invalidating the cache.
+             */
+            static char pows[] = { 0, 1, 3, 7, 15, 31, 63, 127 };
+            Modifiers tmod, mod_masks[8];
+            int j;
+
+            for (tmod = 1, i = 0; tmod <= (Mod5Mask << 1); tmod <<= 1)
+                if (tmod & useful_mods)
+                    mod_masks[i++] = tmod;
+            for (j = (int) pows[num_modbits]; j > 0; j--) {
+                tmod = 0;
+                for (i = 0; i < num_modbits; i++)
+                    if (j & (1 << i))
+                        tmod |= mod_masks[i];
+                TRANSLATE(tm_context, pd, dpy, eventSeq->event.eventCode,
+                          tmod, modifiers_return, keysym_return);
+                if (keysym_return ==
+                    (typeMatch->eventCode & typeMatch->eventCodeMask)) {
+                    tm_context->event = eventSeq->xev;
+                    tm_context->serial = eventSeq->xev->xany.serial;
+                    tm_context->keysym = keysym_return;
+                    tm_context->modifiers = (Modifiers) i;
+                    return TRUE;
+                }
+            }
+        }
+            break;
+        }                       /* switch (num_modbits) */
     }
     return FALSE;
 }
 
-void XtConvertCase(
-    Display *dpy,
-    KeySym keysym,
-    KeySym *lower_return,
-    KeySym *upper_return)
+void
+XtConvertCase(Display *dpy,
+              KeySym keysym,
+              KeySym *lower_return,
+              KeySym *upper_return)
 {
     XtPerDisplay pd;
     CaseConverterPtr ptr;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     pd = _XtGetPerDisplay(dpy);
 
     *lower_return = *upper_return = keysym;
-    for (ptr=pd->case_cvt;  ptr; ptr = ptr->next)
-	if (ptr->start <= keysym && keysym <= ptr->stop) {
-	    (*ptr->proc)(dpy, keysym, lower_return, upper_return);
-	    return;
-	}
+    for (ptr = pd->case_cvt; ptr; ptr = ptr->next)
+        if (ptr->start <= keysym && keysym <= ptr->stop) {
+            (*ptr->proc) (dpy, keysym, lower_return, upper_return);
+            return;
+        }
     XConvertCase(keysym, lower_return, upper_return);
     UNLOCK_APP(app);
 }
 
-Boolean _XtMatchUsingStandardMods (
-    TMTypeMatch typeMatch,
-    TMModifierMatch modMatch,
-    TMEventPtr eventSeq)
+Boolean
+_XtMatchUsingStandardMods(TMTypeMatch typeMatch,
+                          TMModifierMatch modMatch,
+                          TMEventPtr eventSeq)
 {
     Modifiers modifiers_return;
     KeySym keysym_return;
-    Modifiers computed= 0;
+    Modifiers computed = 0;
     Modifiers computedMask = 0;
     Display *dpy = eventSeq->xev->xany.display;
     XtPerDisplay pd = _XtGetPerDisplay(dpy);
@@ -387,68 +397,74 @@ Boolean _XtMatchUsingStandardMods (
 
     modifiers_return = MOD_RETURN(tm_context, eventSeq->event.eventCode);
     if (!modifiers_return) {
-	XtTranslateKeycode(dpy, (KeyCode)eventSeq->event.eventCode,
-			   (Modifiers)eventSeq->event.modifiers, &modifiers_return,
-			   &keysym_return);
-	translateModifiers = (Modifiers) (eventSeq->event.modifiers & modifiers_return);
-	UPDATE_CACHE(tm_context, pd, eventSeq->event.eventCode,
-		     translateModifiers, modifiers_return, keysym_return);
-    } else {
-	translateModifiers = (Modifiers) (eventSeq->event.modifiers & modifiers_return);
-	TRANSLATE(tm_context, pd, dpy, (KeyCode)eventSeq->event.eventCode,
-		  translateModifiers, modifiers_return, keysym_return);
+        XtTranslateKeycode(dpy, (KeyCode) eventSeq->event.eventCode,
+                           (Modifiers) eventSeq->event.modifiers,
+                           &modifiers_return, &keysym_return);
+        translateModifiers =
+            (Modifiers) (eventSeq->event.modifiers & modifiers_return);
+        UPDATE_CACHE(tm_context, pd, eventSeq->event.eventCode,
+                     translateModifiers, modifiers_return, keysym_return);
+    }
+    else {
+        translateModifiers =
+            (Modifiers) (eventSeq->event.modifiers & modifiers_return);
+        TRANSLATE(tm_context, pd, dpy, (KeyCode) eventSeq->event.eventCode,
+                  translateModifiers, modifiers_return, keysym_return);
     }
 
     if ((typeMatch->eventCode & typeMatch->eventCodeMask) ==
-             (keysym_return & typeMatch->eventCodeMask)) {
-	Boolean resolved = TRUE;
+        (keysym_return & typeMatch->eventCodeMask)) {
+        Boolean resolved = TRUE;
 
         if (modMatch->lateModifiers != NULL)
             resolved = _XtComputeLateBindings(dpy, modMatch->lateModifiers,
-					      &computed, &computedMask);
-        if (!resolved) return FALSE;
+                                              &computed, &computedMask);
+        if (!resolved)
+            return FALSE;
         computed = (Modifiers) (computed | modMatch->modifiers);
         computedMask = (Modifiers) (computedMask | modMatch->modifierMask);
 
         if ((computed & computedMask) ==
-	    (eventSeq->event.modifiers & ~modifiers_return & computedMask)) {
-	    tm_context->event = eventSeq->xev;
-	    tm_context->serial = eventSeq->xev->xany.serial;
-	    tm_context->keysym = keysym_return;
-	    tm_context->modifiers = translateModifiers;
-	    return TRUE;
-	}
+            (eventSeq->event.modifiers & ~modifiers_return & computedMask)) {
+            tm_context->event = eventSeq->xev;
+            tm_context->serial = eventSeq->xev->xany.serial;
+            tm_context->keysym = keysym_return;
+            tm_context->modifiers = translateModifiers;
+            return TRUE;
+        }
     }
     return FALSE;
 }
 
-
-void _XtBuildKeysymTables(
-    Display *dpy,
-    register XtPerDisplay pd)
+void
+_XtBuildKeysymTables(Display *dpy, register XtPerDisplay pd)
 {
     ModToKeysymTable *table;
-    int maxCount,i,j,k,tempCount,idx;
-    KeySym keysym,tempKeysym;
-    XModifierKeymap* modKeymap;
+    int maxCount, i, j, k, tempCount, idx;
+    KeySym keysym, tempKeysym;
+    XModifierKeymap *modKeymap;
     KeyCode keycode;
+
 #define KeysymTableSize 16
 
     FLUSHKEYCACHE(pd->tm_context);
 
-    XFree( (char *)pd->keysyms );
+    XFree((char *) pd->keysyms);
     pd->keysyms_serial = NextRequest(dpy);
     pd->keysyms = XGetKeyboardMapping(dpy, (KeyCode) pd->min_keycode,
-				      pd->max_keycode-pd->min_keycode+1,
-				      &pd->keysyms_per_keycode);
-    XtFree((char *)pd->modKeysyms);
+                                      pd->max_keycode - pd->min_keycode + 1,
+                                      &pd->keysyms_per_keycode);
+    XtFree((char *) pd->modKeysyms);
 
-    pd->modKeysyms = (KeySym*)__XtMalloc((Cardinal)KeysymTableSize*sizeof(KeySym));
+    pd->modKeysyms =
+        (KeySym *) __XtMalloc((Cardinal) KeysymTableSize * sizeof(KeySym));
     maxCount = KeysymTableSize;
     tempCount = 0;
 
-    XtFree((char *)pd->modsToKeysyms);
-    table = (ModToKeysymTable*)__XtMalloc((Cardinal)8*sizeof(ModToKeysymTable));
+    XtFree((char *) pd->modsToKeysyms);
+    table =
+        (ModToKeysymTable *) __XtMalloc((Cardinal) 8 *
+                                        sizeof(ModToKeysymTable));
     pd->modsToKeysyms = table;
 
     table[0].mask = ShiftMask;
@@ -462,31 +478,33 @@ void _XtBuildKeysymTables(
     tempKeysym = 0;
 
     modKeymap = XGetModifierMapping(dpy);
-    for (i=0;i<32;i++)
-	pd->isModifier[i] = 0;
+    for (i = 0; i < 32; i++)
+        pd->isModifier[i] = 0;
     pd->mode_switch = 0;
     pd->num_lock = 0;
-    for (i=0;i<8;i++) {
+    for (i = 0; i < 8; i++) {
         table[i].idx = tempCount;
         table[i].count = 0;
-        for (j=0;j<modKeymap->max_keypermod;j++) {
-            keycode = modKeymap->modifiermap[i*modKeymap->max_keypermod+j];
+        for (j = 0; j < modKeymap->max_keypermod; j++) {
+            keycode = modKeymap->modifiermap[i * modKeymap->max_keypermod + j];
             if (keycode != 0) {
-		pd->isModifier[keycode>>3] |= (unsigned char) (1 << (keycode & 7));
-                for (k=0; k<pd->keysyms_per_keycode;k++) {
-                    idx = ((keycode-pd->min_keycode)*
-                             pd->keysyms_per_keycode)+k;
+                pd->isModifier[keycode >> 3] |=
+                    (unsigned char) (1 << (keycode & 7));
+                for (k = 0; k < pd->keysyms_per_keycode; k++) {
+                    idx = ((keycode - pd->min_keycode) *
+                           pd->keysyms_per_keycode) + k;
                     keysym = pd->keysyms[idx];
-		    if ((keysym == XK_Mode_switch) && (i > 2))
-			pd->mode_switch = (pd->mode_switch | (Modifiers) (1 << i));
-		    if ((keysym == XK_Num_Lock) && (i > 2))
-			pd->num_lock = (pd->num_lock | (Modifiers) (1 << i));
-                    if (keysym != 0 && keysym != tempKeysym ){
-                        if (tempCount==maxCount) {
+                    if ((keysym == XK_Mode_switch) && (i > 2))
+                        pd->mode_switch =
+                            (pd->mode_switch | (Modifiers) (1 << i));
+                    if ((keysym == XK_Num_Lock) && (i > 2))
+                        pd->num_lock = (pd->num_lock | (Modifiers) (1 << i));
+                    if (keysym != 0 && keysym != tempKeysym) {
+                        if (tempCount == maxCount) {
                             maxCount += KeysymTableSize;
-                            pd->modKeysyms = (KeySym*)XtRealloc(
-                                (char*)pd->modKeysyms,
-                                (unsigned) ((size_t)maxCount * sizeof(KeySym)) );
+                            pd->modKeysyms = (KeySym *) XtRealloc((char *) pd->
+                                                                  modKeysyms,
+                                                                  (unsigned) ((size_t) maxCount * sizeof(KeySym)));
                         }
                         pd->modKeysyms[tempCount++] = keysym;
                         table[i].count++;
@@ -498,107 +516,113 @@ void _XtBuildKeysymTables(
     }
     pd->lock_meaning = NoSymbol;
     for (i = 0; i < table[1].count; i++) {
-	keysym = pd->modKeysyms[table[1].idx + i];
-	if (keysym == XK_Caps_Lock) {
-	    pd->lock_meaning = XK_Caps_Lock;
-	    break;
-	} else if (keysym == XK_Shift_Lock) {
-	    pd->lock_meaning = XK_Shift_Lock;
-	}
+        keysym = pd->modKeysyms[table[1].idx + i];
+        if (keysym == XK_Caps_Lock) {
+            pd->lock_meaning = XK_Caps_Lock;
+            break;
+        }
+        else if (keysym == XK_Shift_Lock) {
+            pd->lock_meaning = XK_Shift_Lock;
+        }
     }
     XFreeModifiermap(modKeymap);
 }
 
-void XtTranslateKeycode (
-    Display *dpy,
-    _XtKeyCode keycode,
-    Modifiers modifiers,
-    Modifiers *modifiers_return,
-    KeySym *keysym_return)
+void
+XtTranslateKeycode(Display *dpy,
+                   _XtKeyCode keycode,
+                   Modifiers modifiers,
+                   Modifiers *modifiers_return,
+                   KeySym *keysym_return)
 {
     XtPerDisplay pd;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     pd = _XtGetPerDisplay(dpy);
     _InitializeKeysymTables(dpy, pd);
-    (*pd->defaultKeycodeTranslator)(
-            dpy,keycode,modifiers,modifiers_return,keysym_return);
+    (*pd->defaultKeycodeTranslator) (dpy, keycode, modifiers, modifiers_return,
+                                     keysym_return);
     UNLOCK_APP(app);
 }
 
 /* This code should match XTranslateKey (internal, sigh) in Xlib */
-void XtTranslateKey(
-    register Display *dpy,
-    _XtKeyCode keycode,
-    Modifiers modifiers,
-    Modifiers *modifiers_return,
-    KeySym *keysym_return)
+void
+XtTranslateKey(register Display *dpy,
+               _XtKeyCode keycode,
+               Modifiers modifiers,
+               Modifiers *modifiers_return,
+               KeySym *keysym_return)
 {
 #ifndef XKB
     XtPerDisplay pd;
     int per;
     register KeySym *syms;
     KeySym sym, lsym, usym;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     pd = _XtGetPerDisplay(dpy);
-    *modifiers_return = (ShiftMask|LockMask) | pd->mode_switch | pd->num_lock;
-    if (((int)keycode < pd->min_keycode) || ((int)keycode > pd->max_keycode)) {
-	*keysym_return = NoSymbol;
-	UNLOCK_APP(app);
-	return;
+    *modifiers_return = (ShiftMask | LockMask) | pd->mode_switch | pd->num_lock;
+    if (((int) keycode < pd->min_keycode) || ((int) keycode > pd->max_keycode)) {
+        *keysym_return = NoSymbol;
+        UNLOCK_APP(app);
+        return;
     }
     per = pd->keysyms_per_keycode;
     syms = &pd->keysyms[(keycode - pd->min_keycode) * per];
     while ((per > 2) && (syms[per - 1] == NoSymbol))
-	per--;
+        per--;
     if ((per > 2) && (modifiers & pd->mode_switch)) {
-	syms += 2;
-	per -= 2;
+        syms += 2;
+        per -= 2;
     }
     if ((modifiers & pd->num_lock) &&
-	(per > 1 && (IsKeypadKey(syms[1]) || IsPrivateKeypadKey(syms[1])))) {
-	if ((modifiers & ShiftMask) ||
-	    ((modifiers & LockMask) && (pd->lock_meaning == XK_Shift_Lock)))
-	    *keysym_return = syms[0];
-	else
-	    *keysym_return = syms[1];
-    } else if (!(modifiers & ShiftMask) &&
-	(!(modifiers & LockMask) || (pd->lock_meaning == NoSymbol))) {
-	if ((per == 1) || (syms[1] == NoSymbol))
-	    XtConvertCase(dpy, syms[0], keysym_return, &usym);
-	else
-	    *keysym_return = syms[0];
-    } else if (!(modifiers & LockMask) ||
-	       (pd->lock_meaning != XK_Caps_Lock)) {
-	if ((per == 1) || ((usym = syms[1]) == NoSymbol))
-	    XtConvertCase(dpy, syms[0], &lsym, &usym);
-	*keysym_return = usym;
-    } else {
-	if ((per == 1) || ((sym = syms[1]) == NoSymbol))
-	    sym = syms[0];
-	XtConvertCase(dpy, sym, &lsym, &usym);
-	if (!(modifiers & ShiftMask) && (sym != syms[0]) &&
-	    ((sym != usym) || (lsym == usym)))
-	    XtConvertCase(dpy, syms[0], &lsym, &usym);
-	*keysym_return = usym;
+        (per > 1 && (IsKeypadKey(syms[1]) || IsPrivateKeypadKey(syms[1])))) {
+        if ((modifiers & ShiftMask) ||
+            ((modifiers & LockMask) && (pd->lock_meaning == XK_Shift_Lock)))
+            *keysym_return = syms[0];
+        else
+            *keysym_return = syms[1];
+    }
+    else if (!(modifiers & ShiftMask) &&
+             (!(modifiers & LockMask) || (pd->lock_meaning == NoSymbol))) {
+        if ((per == 1) || (syms[1] == NoSymbol))
+            XtConvertCase(dpy, syms[0], keysym_return, &usym);
+        else
+            *keysym_return = syms[0];
+    }
+    else if (!(modifiers & LockMask) || (pd->lock_meaning != XK_Caps_Lock)) {
+        if ((per == 1) || ((usym = syms[1]) == NoSymbol))
+            XtConvertCase(dpy, syms[0], &lsym, &usym);
+        *keysym_return = usym;
+    }
+    else {
+        if ((per == 1) || ((sym = syms[1]) == NoSymbol))
+            sym = syms[0];
+        XtConvertCase(dpy, sym, &lsym, &usym);
+        if (!(modifiers & ShiftMask) && (sym != syms[0]) &&
+            ((sym != usym) || (lsym == usym)))
+            XtConvertCase(dpy, syms[0], &lsym, &usym);
+        *keysym_return = usym;
     }
 
     if (*keysym_return == XK_VoidSymbol)
-	*keysym_return = NoSymbol;
+        *keysym_return = NoSymbol;
     UNLOCK_APP(app);
 #else
-    XkbLookupKeySym(dpy, (KeyCode) keycode, modifiers, modifiers_return, keysym_return);
+    XkbLookupKeySym(dpy, (KeyCode) keycode, modifiers, modifiers_return,
+                    keysym_return);
 #endif
 }
 
-void XtSetKeyTranslator(
-    Display *dpy,
-    XtKeyProc translator)
+void
+XtSetKeyTranslator(Display *dpy, XtKeyProc translator)
 {
     XtPerDisplay pd;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
@@ -610,14 +634,15 @@ void XtSetKeyTranslator(
     UNLOCK_APP(app);
 }
 
-void XtRegisterCaseConverter(
-    Display *dpy,
-    XtCaseProc proc,
-    KeySym start,
-    KeySym stop)
+void
+XtRegisterCaseConverter(Display *dpy,
+                        XtCaseProc proc,
+                        KeySym start,
+                        KeySym stop)
 {
     XtPerDisplay pd;
     CaseConverterPtr ptr, prev;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
@@ -632,42 +657,44 @@ void XtRegisterCaseConverter(
 
     /* Remove obsolete case converters from the list */
     prev = ptr;
-    for (ptr=ptr->next; ptr; ptr=prev->next) {
-	if (start <= ptr->start && stop >= ptr->stop) {
-	    prev->next = ptr->next;
-	    XtFree((char *)ptr);
-	}
-	else prev = ptr;
+    for (ptr = ptr->next; ptr; ptr = prev->next) {
+        if (start <= ptr->start && stop >= ptr->stop) {
+            prev->next = ptr->next;
+            XtFree((char *) ptr);
+        }
+        else
+            prev = ptr;
     }
     FLUSHKEYCACHE(pd->tm_context);
     /* XXX should now redo grabs */
     UNLOCK_APP(app);
 }
 
-KeySym *XtGetKeysymTable(
-    Display *dpy,
-    KeyCode *min_keycode_return,
-    int *keysyms_per_keycode_return)
+KeySym *
+XtGetKeysymTable(Display *dpy,
+                 KeyCode *min_keycode_return,
+                 int *keysyms_per_keycode_return)
 {
     XtPerDisplay pd;
-    KeySym* retval;
+    KeySym *retval;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
     pd = _XtGetPerDisplay(dpy);
     _InitializeKeysymTables(dpy, pd);
-    *min_keycode_return = (KeyCode) pd->min_keycode; /* %%% */
+    *min_keycode_return = (KeyCode) pd->min_keycode;    /* %%% */
     *keysyms_per_keycode_return = pd->keysyms_per_keycode;
     retval = pd->keysyms;
     UNLOCK_APP(app);
     return retval;
 }
 
-void XtKeysymToKeycodeList(
-    Display *dpy,
-    KeySym keysym,
-    KeyCode **keycodes_return,
-    Cardinal *keycount_return)
+void
+XtKeysymToKeycodeList(Display *dpy,
+                      KeySym keysym,
+                      KeyCode **keycodes_return,
+                      Cardinal *keycount_return)
 {
     XtPerDisplay pd;
     unsigned keycode;
@@ -678,6 +705,7 @@ void XtKeysymToKeycodeList(
     unsigned maxcodes = 0;
     unsigned ncodes = 0;
     KeyCode *keycodes, *codeP = NULL;
+
     DPY_TO_APPCON(dpy);
 
     LOCK_APP(app);
@@ -686,40 +714,41 @@ void XtKeysymToKeycodeList(
     keycodes = NULL;
     per = pd->keysyms_per_keycode;
     for (syms = pd->keysyms, keycode = (unsigned) pd->min_keycode;
-	 (int)keycode <= pd->max_keycode;
-	 syms += per, keycode++) {
-	int match = 0;
-	for (j = 0; j < per; j++) {
-	    if (syms[j] == keysym) {
-		match = 1;
-		break;
-	    }
-	}
-	if (!match)
-	    for (i = 1; i < 5; i += 2) {
-		if ((per == i) || ((per > i) && (syms[i] == NoSymbol))) {
-		    XtConvertCase(dpy, syms[i-1], &lsym, &usym);
-		    if ((lsym == keysym) || (usym == keysym)) {
-			match = 1;
-			break;
-		    }
-		}
-	    }
-	if (match) {
-	    if (ncodes == maxcodes) {
-		KeyCode *old = keycodes;
-		maxcodes += KEYCODE_ARRAY_SIZE;
-		keycodes = (KeyCode*)__XtMalloc(maxcodes*sizeof(KeyCode));
-		if (ncodes) {
-		    (void) memmove((char *)keycodes, (char *)old,
-				   ncodes*sizeof(KeyCode) );
-		    XtFree((char *)old);
-		}
-		codeP = &keycodes[ncodes];
-	    }
-	    *codeP++ = (KeyCode) keycode;
-	    ncodes++;
-	}
+         (int) keycode <= pd->max_keycode; syms += per, keycode++) {
+        int match = 0;
+
+        for (j = 0; j < per; j++) {
+            if (syms[j] == keysym) {
+                match = 1;
+                break;
+            }
+        }
+        if (!match)
+            for (i = 1; i < 5; i += 2) {
+                if ((per == i) || ((per > i) && (syms[i] == NoSymbol))) {
+                    XtConvertCase(dpy, syms[i - 1], &lsym, &usym);
+                    if ((lsym == keysym) || (usym == keysym)) {
+                        match = 1;
+                        break;
+                    }
+                }
+            }
+        if (match) {
+            if (ncodes == maxcodes) {
+                KeyCode *old = keycodes;
+
+                maxcodes += KEYCODE_ARRAY_SIZE;
+                keycodes = (KeyCode *) __XtMalloc(maxcodes * sizeof(KeyCode));
+                if (ncodes) {
+                    (void) memmove((char *) keycodes, (char *) old,
+                                   ncodes * sizeof(KeyCode));
+                    XtFree((char *) old);
+                }
+                codeP = &keycodes[ncodes];
+            }
+            *codeP++ = (KeyCode) keycode;
+            ncodes++;
+        }
     }
     *keycodes_return = keycodes;
     *keycount_return = ncodes;
diff --git a/src/TMparse.c b/src/TMparse.c
index 9582b0c..62f2940 100644
--- a/src/TMparse.c
+++ b/src/TMparse.c
@@ -82,13 +82,13 @@ in this Software without prior written authorization from The Open Group.
 #include <X11/keysymdef.h>
 
 #ifdef CACHE_TRANSLATIONS
-# ifdef REFCNT_TRANSLATIONS
-#  define CACHED XtCacheAll | XtCacheRefCount
-# else
-#  define CACHED XtCacheAll
-# endif
+#ifdef REFCNT_TRANSLATIONS
+#define CACHED XtCacheAll | XtCacheRefCount
 #else
-# define CACHED XtCacheNone
+#define CACHED XtCacheAll
+#endif
+#else
+#define CACHED XtCacheNone
 #endif
 
 #ifndef MAX
@@ -101,134 +101,135 @@ in this Software without prior written authorization from The Open Group.
 
 static _Xconst char *XtNtranslationParseError = "translationParseError";
 
-typedef int		EventType;
+typedef int EventType;
 
 #define PARSE_PROC_DECL String, Opaque, EventPtr, Boolean*
 
-typedef String (*ParseProc)(
-    String /* str; */,
-    Opaque /* closure; */,
-    EventPtr /* event; */,
-    Boolean* /* error */);
+typedef String(*ParseProc) (String /* str; */ ,
+                            Opaque /* closure; */ ,
+                            EventPtr /* event; */ ,
+                            Boolean * /* error */ );
 
-typedef TMShortCard	Value;
-typedef void (*ModifierProc)(Value, LateBindingsPtr*, Boolean, Value*);
+typedef TMShortCard Value;
+typedef void (*ModifierProc) (Value, LateBindingsPtr *, Boolean, Value *);
 
 typedef struct _ModifierRec {
     const char *name;
-    XrmQuark   signature;
+    XrmQuark signature;
     ModifierProc modifierParseProc;
-    Value      value;
+    Value value;
 } ModifierRec, *ModifierKeys;
 
 typedef struct _EventKey {
-    const char  *event;
-    XrmQuark	signature;
-    EventType	eventType;
-    ParseProc	parseDetail;
-    Opaque	closure;
-}EventKey, *EventKeys;
+    const char *event;
+    XrmQuark signature;
+    EventType eventType;
+    ParseProc parseDetail;
+    Opaque closure;
+} EventKey, *EventKeys;
 
 typedef struct {
-    const char	*name;
-    XrmQuark	signature;
-    Value	value;
+    const char *name;
+    XrmQuark signature;
+    Value value;
 } NameValueRec, *NameValueTable;
 
-static void ParseModImmed(Value, LateBindingsPtr*, Boolean, Value*);
-static void ParseModSym(Value, LateBindingsPtr*, Boolean, Value*);
+static void ParseModImmed(Value, LateBindingsPtr *, Boolean, Value *);
+static void ParseModSym(Value, LateBindingsPtr *, Boolean, Value *);
 static String PanicModeRecovery(String);
 static String CheckForPoundSign(String, _XtTranslateOp, _XtTranslateOp *);
 static KeySym StringToKeySym(String, Boolean *);
+/* *INDENT-OFF* */
 static ModifierRec modifiers[] = {
-    {"Shift",	0,	ParseModImmed,ShiftMask},
-    {"Lock",	0,	ParseModImmed,LockMask},
-    {"Ctrl",	0,	ParseModImmed,ControlMask},
-    {"Mod1",	0,	ParseModImmed,Mod1Mask},
-    {"Mod2",	0,	ParseModImmed,Mod2Mask},
-    {"Mod3",	0,	ParseModImmed,Mod3Mask},
-    {"Mod4",	0,	ParseModImmed,Mod4Mask},
-    {"Mod5",	0,	ParseModImmed,Mod5Mask},
-    {"Meta",	0,	ParseModSym,  XK_Meta_L},
-    {"m",       0,      ParseModSym,  XK_Meta_L},
-    {"h",       0,      ParseModSym,  XK_Hyper_L},
-    {"su",      0,      ParseModSym,  XK_Super_L},
-    {"a",       0,      ParseModSym,  XK_Alt_L},
-    {"Hyper",   0,      ParseModSym,  XK_Hyper_L},
-    {"Super",   0,      ParseModSym,  XK_Super_L},
-    {"Alt",     0,      ParseModSym,  XK_Alt_L},
-    {"Button1",	0,	ParseModImmed,Button1Mask},
-    {"Button2",	0,	ParseModImmed,Button2Mask},
-    {"Button3",	0,	ParseModImmed,Button3Mask},
-    {"Button4",	0,	ParseModImmed,Button4Mask},
-    {"Button5",	0,	ParseModImmed,Button5Mask},
-    {"c",	0,	ParseModImmed,ControlMask},
-    {"s",	0,	ParseModImmed,ShiftMask},
-    {"l",	0,	ParseModImmed,LockMask},
+    {"Shift",   0,      ParseModImmed, ShiftMask},
+    {"Lock",    0,      ParseModImmed, LockMask},
+    {"Ctrl",    0,      ParseModImmed, ControlMask},
+    {"Mod1",    0,      ParseModImmed, Mod1Mask},
+    {"Mod2",    0,      ParseModImmed, Mod2Mask},
+    {"Mod3",    0,      ParseModImmed, Mod3Mask},
+    {"Mod4",    0,      ParseModImmed, Mod4Mask},
+    {"Mod5",    0,      ParseModImmed, Mod5Mask},
+    {"Meta",    0,      ParseModSym,   XK_Meta_L},
+    {"m",       0,      ParseModSym,   XK_Meta_L},
+    {"h",       0,      ParseModSym,   XK_Hyper_L},
+    {"su",      0,      ParseModSym,   XK_Super_L},
+    {"a",       0,      ParseModSym,   XK_Alt_L},
+    {"Hyper",   0,      ParseModSym,   XK_Hyper_L},
+    {"Super",   0,      ParseModSym,   XK_Super_L},
+    {"Alt",     0,      ParseModSym,   XK_Alt_L},
+    {"Button1", 0,      ParseModImmed, Button1Mask},
+    {"Button2", 0,      ParseModImmed, Button2Mask},
+    {"Button3", 0,      ParseModImmed, Button3Mask},
+    {"Button4", 0,      ParseModImmed, Button4Mask},
+    {"Button5", 0,      ParseModImmed, Button5Mask},
+    {"c",       0,      ParseModImmed, ControlMask},
+    {"s",       0,      ParseModImmed, ShiftMask},
+    {"l",       0,      ParseModImmed, LockMask},
 };
 
 static NameValueRec buttonNames[] = {
-    {"Button1",	0,	Button1},
-    {"Button2", 0,	Button2},
-    {"Button3", 0,	Button3},
-    {"Button4", 0,	Button4},
-    {"Button5", 0,	Button5},
-    {NULL, NULLQUARK, 0},
+    {"Button1",             0,         Button1},
+    {"Button2",             0,         Button2},
+    {"Button3",             0,         Button3},
+    {"Button4",             0,         Button4},
+    {"Button5",             0,         Button5},
+    {NULL,                  NULLQUARK, 0},
 };
 
 static NameValueRec motionDetails[] = {
-    {"Normal",		0,	NotifyNormal},
-    {"Hint",		0,	NotifyHint},
-    {NULL, NULLQUARK, 0},
+    {"Normal",              0,         NotifyNormal},
+    {"Hint",                0,         NotifyHint},
+    {NULL,                  NULLQUARK, 0},
 };
 
 static NameValueRec notifyModes[] = {
-    {"Normal",		0,	NotifyNormal},
-    {"Grab",		0,	NotifyGrab},
-    {"Ungrab",		0,	NotifyUngrab},
-    {"WhileGrabbed",    0,	NotifyWhileGrabbed},
-    {NULL, NULLQUARK, 0},
+    {"Normal",              0,         NotifyNormal},
+    {"Grab",                0,         NotifyGrab},
+    {"Ungrab",              0,         NotifyUngrab},
+    {"WhileGrabbed",        0,         NotifyWhileGrabbed},
+    {NULL,                  NULLQUARK, 0},
 };
 
 #if 0
 static NameValueRec notifyDetail[] = {
-    {"Ancestor",	    0,	NotifyAncestor},
-    {"Virtual",		    0,	NotifyVirtual},
-    {"Inferior",	    0,	NotifyInferior},
-    {"Nonlinear",	    0,	NotifyNonlinear},
-    {"NonlinearVirtual",    0,	NotifyNonlinearVirtual},
-    {"Pointer",		    0,	NotifyPointer},
-    {"PointerRoot",	    0,	NotifyPointerRoot},
-    {"DetailNone",	    0,	NotifyDetailNone},
-    {NULL, NULLQUARK, 0},
+    {"Ancestor",            0,         NotifyAncestor},
+    {"Virtual",             0,         NotifyVirtual},
+    {"Inferior",            0,         NotifyInferior},
+    {"Nonlinear",           0,         NotifyNonlinear},
+    {"NonlinearVirtual",    0,         NotifyNonlinearVirtual},
+    {"Pointer",             0,         NotifyPointer},
+    {"PointerRoot",         0,         NotifyPointerRoot},
+    {"DetailNone",          0,         NotifyDetailNone},
+    {NULL,                  NULLQUARK, 0},
 };
 
 static NameValueRec visibilityNotify[] = {
-    {"Unobscured",	    0,	VisibilityUnobscured},
-    {"PartiallyObscured",   0,	VisibilityPartiallyObscured},
-    {"FullyObscured",       0,	VisibilityFullyObscured},
-    {NULL, NULLQUARK, 0},
+    {"Unobscured",          0,         VisibilityUnobscured},
+    {"PartiallyObscured",   0,         VisibilityPartiallyObscured},
+    {"FullyObscured",       0,         VisibilityFullyObscured},
+    {NULL,                  NULLQUARK, 0},
 };
 
 static NameValueRec circulation[] = {
-    {"OnTop",       0,	PlaceOnTop},
-    {"OnBottom",    0,	PlaceOnBottom},
-    {NULL, NULLQUARK, 0},
+    {"OnTop",               0,         PlaceOnTop},
+    {"OnBottom",            0,         PlaceOnBottom},
+    {NULL,                  NULLQUARK, 0},
 };
 
 static NameValueRec propertyChanged[] = {
-    {"NewValue",    0,	PropertyNewValue},
-    {"Delete",      0,	PropertyDelete},
-    {NULL, NULLQUARK, 0},
+    {"NewValue",            0,         PropertyNewValue},
+    {"Delete",              0,         PropertyDelete},
+    {NULL,                  NULLQUARK, 0},
 };
 #endif /*0*/
 
 static NameValueRec mappingNotify[] = {
-    {"Modifier",	0,	MappingModifier},
-    {"Keyboard",	0,	MappingKeyboard},
-    {"Pointer",	0,	MappingPointer},
-    {NULL, NULLQUARK, 0},
+    {"Modifier",            0,         MappingModifier},
+    {"Keyboard",            0,         MappingKeyboard},
+    {"Pointer",             0,         MappingPointer},
+    {NULL,                  NULLQUARK, 0},
 };
+/* *INDENT-ON* */
 
 static String ParseKeySym(PARSE_PROC_DECL);
 static String ParseKeyAndModifiers(PARSE_PROC_DECL);
@@ -238,149 +239,151 @@ static String ParseAddModifier(PARSE_PROC_DECL);
 static String ParseNone(PARSE_PROC_DECL);
 static String ParseAtom(PARSE_PROC_DECL);
 
+/* *INDENT-OFF* */
 static EventKey events[] = {
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"KeyPress",	    NULLQUARK, KeyPress,	ParseKeySym,	NULL},
-{"Key", 	    NULLQUARK, KeyPress,	ParseKeySym,	NULL},
-{"KeyDown",	    NULLQUARK, KeyPress,	ParseKeySym,	NULL},
-{"Ctrl",            NULLQUARK, KeyPress, ParseKeyAndModifiers,(Opaque)ControlMask},
-{"Shift",           NULLQUARK, KeyPress, ParseKeyAndModifiers,(Opaque)ShiftMask},
-{"Meta",            NULLQUARK, KeyPress,   ParseKeyAndModifiers,(Opaque)NULL},
-{"KeyUp",	    NULLQUARK, KeyRelease,	ParseKeySym,	NULL},
-{"KeyRelease",	    NULLQUARK, KeyRelease,	ParseKeySym,	NULL},
+{"KeyPress",        NULLQUARK, KeyPress,        ParseKeySym,    NULL},
+{"Key",             NULLQUARK, KeyPress,        ParseKeySym,    NULL},
+{"KeyDown",         NULLQUARK, KeyPress,        ParseKeySym,    NULL},
+{"Ctrl",            NULLQUARK, KeyPress,        ParseKeyAndModifiers, (Opaque)ControlMask},
+{"Shift",           NULLQUARK, KeyPress,        ParseKeyAndModifiers, (Opaque)ShiftMask},
+{"Meta",            NULLQUARK, KeyPress,        ParseKeyAndModifiers, (Opaque)NULL},
+{"KeyUp",           NULLQUARK, KeyRelease,      ParseKeySym,    NULL},
+{"KeyRelease",      NULLQUARK, KeyRelease,      ParseKeySym,    NULL},
 
-{"ButtonPress",     NULLQUARK, ButtonPress,  ParseTable,(Opaque)buttonNames},
-{"BtnDown",	    NULLQUARK, ButtonPress,  ParseTable,(Opaque)buttonNames},
-{"Btn1Down",	    NULLQUARK, ButtonPress,	ParseImmed,(Opaque)Button1},
-{"Btn2Down", 	    NULLQUARK, ButtonPress,	ParseImmed,(Opaque)Button2},
-{"Btn3Down", 	    NULLQUARK, ButtonPress,	ParseImmed,(Opaque)Button3},
-{"Btn4Down", 	    NULLQUARK, ButtonPress,	ParseImmed,(Opaque)Button4},
-{"Btn5Down", 	    NULLQUARK, ButtonPress,	ParseImmed,(Opaque)Button5},
+{"ButtonPress",     NULLQUARK, ButtonPress,     ParseTable, (Opaque)buttonNames},
+{"BtnDown",         NULLQUARK, ButtonPress,     ParseTable, (Opaque)buttonNames},
+{"Btn1Down",        NULLQUARK, ButtonPress,     ParseImmed, (Opaque)Button1},
+{"Btn2Down",        NULLQUARK, ButtonPress,     ParseImmed, (Opaque)Button2},
+{"Btn3Down",        NULLQUARK, ButtonPress,     ParseImmed, (Opaque)Button3},
+{"Btn4Down",        NULLQUARK, ButtonPress,     ParseImmed, (Opaque)Button4},
+{"Btn5Down",        NULLQUARK, ButtonPress,     ParseImmed, (Opaque)Button5},
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"ButtonRelease",   NULLQUARK, ButtonRelease,  ParseTable,(Opaque)buttonNames},
-{"BtnUp", 	    NULLQUARK, ButtonRelease,  ParseTable,(Opaque)buttonNames},
-{"Btn1Up", 	    NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button1},
-{"Btn2Up", 	    NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button2},
-{"Btn3Up", 	    NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button3},
-{"Btn4Up", 	    NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button4},
-{"Btn5Up", 	    NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button5},
+{"ButtonRelease",   NULLQUARK, ButtonRelease,   ParseTable, (Opaque)buttonNames},
+{"BtnUp",           NULLQUARK, ButtonRelease,   ParseTable, (Opaque)buttonNames},
+{"Btn1Up",          NULLQUARK, ButtonRelease,   ParseImmed, (Opaque)Button1},
+{"Btn2Up",          NULLQUARK, ButtonRelease,   ParseImmed, (Opaque)Button2},
+{"Btn3Up",          NULLQUARK, ButtonRelease,   ParseImmed, (Opaque)Button3},
+{"Btn4Up",          NULLQUARK, ButtonRelease,   ParseImmed, (Opaque)Button4},
+{"Btn5Up",          NULLQUARK, ButtonRelease,   ParseImmed, (Opaque)Button5},
 
-{"MotionNotify",    NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
-{"PtrMoved", 	    NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
-{"Motion", 	    NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
-{"MouseMoved", 	    NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
-{"BtnMotion",  NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)AnyButtonMask},
-{"Btn1Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button1Mask},
-{"Btn2Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button2Mask},
-{"Btn3Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button3Mask},
-{"Btn4Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button4Mask},
-{"Btn5Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button5Mask},
+{"MotionNotify",    NULLQUARK, MotionNotify,    ParseTable, (Opaque)motionDetails},
+{"PtrMoved",        NULLQUARK, MotionNotify,    ParseTable, (Opaque)motionDetails},
+{"Motion",          NULLQUARK, MotionNotify,    ParseTable, (Opaque)motionDetails},
+{"MouseMoved",      NULLQUARK, MotionNotify,    ParseTable, (Opaque)motionDetails},
+{"BtnMotion",       NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)AnyButtonMask},
+{"Btn1Motion",      NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)Button1Mask},
+{"Btn2Motion",      NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)Button2Mask},
+{"Btn3Motion",      NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)Button3Mask},
+{"Btn4Motion",      NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)Button4Mask},
+{"Btn5Motion",      NULLQUARK, MotionNotify,    ParseAddModifier, (Opaque)Button5Mask},
 
-{"EnterNotify",     NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
-{"Enter",	    NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
-{"EnterWindow",     NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
+{"EnterNotify",     NULLQUARK, EnterNotify,     ParseTable, (Opaque)notifyModes},
+{"Enter",           NULLQUARK, EnterNotify,     ParseTable, (Opaque)notifyModes},
+{"EnterWindow",     NULLQUARK, EnterNotify,     ParseTable, (Opaque)notifyModes},
 
-{"LeaveNotify",     NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
-{"LeaveWindow",     NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
-{"Leave",	    NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
+{"LeaveNotify",     NULLQUARK, LeaveNotify,     ParseTable, (Opaque)notifyModes},
+{"LeaveWindow",     NULLQUARK, LeaveNotify,     ParseTable, (Opaque)notifyModes},
+{"Leave",           NULLQUARK, LeaveNotify,     ParseTable, (Opaque)notifyModes},
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"FocusIn",	    NULLQUARK, FocusIn,	  ParseTable,(Opaque)notifyModes},
+{"FocusIn",         NULLQUARK, FocusIn,         ParseTable, (Opaque)notifyModes},
 
-{"FocusOut",	    NULLQUARK, FocusOut,       ParseTable,(Opaque)notifyModes},
+{"FocusOut",        NULLQUARK, FocusOut,        ParseTable, (Opaque)notifyModes},
 
-{"KeymapNotify",    NULLQUARK, KeymapNotify,	ParseNone,	NULL},
-{"Keymap",	    NULLQUARK, KeymapNotify,	ParseNone,	NULL},
+{"KeymapNotify",    NULLQUARK, KeymapNotify,    ParseNone,      NULL},
+{"Keymap",          NULLQUARK, KeymapNotify,    ParseNone,      NULL},
 
-{"Expose", 	    NULLQUARK, Expose,		ParseNone,	NULL},
+{"Expose",          NULLQUARK, Expose,          ParseNone,      NULL},
 
-{"GraphicsExpose",  NULLQUARK, GraphicsExpose,	ParseNone,	NULL},
-{"GrExp",	    NULLQUARK, GraphicsExpose,	ParseNone,	NULL},
+{"GraphicsExpose",  NULLQUARK, GraphicsExpose,  ParseNone,      NULL},
+{"GrExp",           NULLQUARK, GraphicsExpose,  ParseNone,      NULL},
 
-{"NoExpose",	    NULLQUARK, NoExpose,	ParseNone,	NULL},
-{"NoExp",	    NULLQUARK, NoExpose,	ParseNone,	NULL},
+{"NoExpose",        NULLQUARK, NoExpose,        ParseNone,      NULL},
+{"NoExp",           NULLQUARK, NoExpose,        ParseNone,      NULL},
 
-{"VisibilityNotify",NULLQUARK, VisibilityNotify,ParseNone,	NULL},
-{"Visible",	    NULLQUARK, VisibilityNotify,ParseNone,	NULL},
+{"VisibilityNotify",NULLQUARK, VisibilityNotify,ParseNone,      NULL},
+{"Visible",         NULLQUARK, VisibilityNotify,ParseNone,      NULL},
 
-{"CreateNotify",    NULLQUARK, CreateNotify,	ParseNone,	NULL},
-{"Create",	    NULLQUARK, CreateNotify,	ParseNone,	NULL},
+{"CreateNotify",    NULLQUARK, CreateNotify,    ParseNone,      NULL},
+{"Create",          NULLQUARK, CreateNotify,    ParseNone,      NULL},
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"DestroyNotify",   NULLQUARK, DestroyNotify,	ParseNone,	NULL},
-{"Destroy",	    NULLQUARK, DestroyNotify,	ParseNone,	NULL},
+{"DestroyNotify",   NULLQUARK, DestroyNotify,   ParseNone,      NULL},
+{"Destroy",         NULLQUARK, DestroyNotify,   ParseNone,      NULL},
 
-{"UnmapNotify",     NULLQUARK, UnmapNotify,	ParseNone,	NULL},
-{"Unmap",	    NULLQUARK, UnmapNotify,	ParseNone,	NULL},
+{"UnmapNotify",     NULLQUARK, UnmapNotify,     ParseNone,      NULL},
+{"Unmap",           NULLQUARK, UnmapNotify,     ParseNone,      NULL},
 
-{"MapNotify",	    NULLQUARK, MapNotify,	ParseNone,	NULL},
-{"Map",		    NULLQUARK, MapNotify,	ParseNone,	NULL},
+{"MapNotify",       NULLQUARK, MapNotify,       ParseNone,      NULL},
+{"Map",             NULLQUARK, MapNotify,       ParseNone,      NULL},
 
-{"MapRequest",	    NULLQUARK, MapRequest,	ParseNone,	NULL},
-{"MapReq",	    NULLQUARK, MapRequest,	ParseNone,	NULL},
+{"MapRequest",      NULLQUARK, MapRequest,      ParseNone,      NULL},
+{"MapReq",          NULLQUARK, MapRequest,      ParseNone,      NULL},
 
-{"ReparentNotify",  NULLQUARK, ReparentNotify,	ParseNone,	NULL},
-{"Reparent",	    NULLQUARK, ReparentNotify,	ParseNone,	NULL},
+{"ReparentNotify",  NULLQUARK, ReparentNotify,  ParseNone,      NULL},
+{"Reparent",        NULLQUARK, ReparentNotify,  ParseNone,      NULL},
 
-{"ConfigureNotify", NULLQUARK, ConfigureNotify,	ParseNone,	NULL},
-{"Configure",	    NULLQUARK, ConfigureNotify,	ParseNone,	NULL},
+{"ConfigureNotify", NULLQUARK, ConfigureNotify, ParseNone,      NULL},
+{"Configure",       NULLQUARK, ConfigureNotify, ParseNone,      NULL},
 
-{"ConfigureRequest",NULLQUARK, ConfigureRequest,ParseNone,	NULL},
-{"ConfigureReq",    NULLQUARK, ConfigureRequest,ParseNone,	NULL},
+{"ConfigureRequest",NULLQUARK, ConfigureRequest,ParseNone,      NULL},
+{"ConfigureReq",    NULLQUARK, ConfigureRequest,ParseNone,      NULL},
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"GravityNotify",   NULLQUARK, GravityNotify,	ParseNone,	NULL},
-{"Grav",	    NULLQUARK, GravityNotify,	ParseNone,	NULL},
+{"GravityNotify",   NULLQUARK, GravityNotify,   ParseNone,      NULL},
+{"Grav",            NULLQUARK, GravityNotify,   ParseNone,      NULL},
 
-{"ResizeRequest",   NULLQUARK, ResizeRequest,	ParseNone,	NULL},
-{"ResReq",	    NULLQUARK, ResizeRequest,	ParseNone,	NULL},
+{"ResizeRequest",   NULLQUARK, ResizeRequest,   ParseNone,      NULL},
+{"ResReq",          NULLQUARK, ResizeRequest,   ParseNone,      NULL},
 
-{"CirculateNotify", NULLQUARK, CirculateNotify,	ParseNone,	NULL},
-{"Circ",	    NULLQUARK, CirculateNotify,	ParseNone,	NULL},
+{"CirculateNotify", NULLQUARK, CirculateNotify, ParseNone,      NULL},
+{"Circ",            NULLQUARK, CirculateNotify, ParseNone,      NULL},
 
-{"CirculateRequest",NULLQUARK, CirculateRequest,ParseNone,	NULL},
-{"CircReq",	    NULLQUARK, CirculateRequest,ParseNone,	NULL},
+{"CirculateRequest",NULLQUARK, CirculateRequest,ParseNone,      NULL},
+{"CircReq",         NULLQUARK, CirculateRequest,ParseNone,      NULL},
 
-{"PropertyNotify",  NULLQUARK, PropertyNotify,	ParseAtom,	NULL},
-{"Prop",	    NULLQUARK, PropertyNotify,	ParseAtom,	NULL},
+{"PropertyNotify",  NULLQUARK, PropertyNotify,  ParseAtom,      NULL},
+{"Prop",            NULLQUARK, PropertyNotify,  ParseAtom,      NULL},
 
-{"SelectionClear",  NULLQUARK, SelectionClear,	ParseAtom,	NULL},
-{"SelClr",	    NULLQUARK, SelectionClear,	ParseAtom,	NULL},
+{"SelectionClear",  NULLQUARK, SelectionClear,  ParseAtom,      NULL},
+{"SelClr",          NULLQUARK, SelectionClear,  ParseAtom,      NULL},
 
-{"SelectionRequest",NULLQUARK, SelectionRequest,ParseAtom,	NULL},
-{"SelReq",	    NULLQUARK, SelectionRequest,ParseAtom,	NULL},
+{"SelectionRequest",NULLQUARK, SelectionRequest,ParseAtom,      NULL},
+{"SelReq",          NULLQUARK, SelectionRequest,ParseAtom,      NULL},
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
-{"SelectionNotify", NULLQUARK, SelectionNotify,	ParseAtom,	NULL},
-{"Select",	    NULLQUARK, SelectionNotify,	ParseAtom,	NULL},
+{"SelectionNotify", NULLQUARK, SelectionNotify, ParseAtom,      NULL},
+{"Select",          NULLQUARK, SelectionNotify, ParseAtom,      NULL},
 
-{"ColormapNotify",  NULLQUARK, ColormapNotify,	ParseNone,	NULL},
-{"Clrmap",	    NULLQUARK, ColormapNotify,	ParseNone,	NULL},
+{"ColormapNotify",  NULLQUARK, ColormapNotify,  ParseNone,      NULL},
+{"Clrmap",          NULLQUARK, ColormapNotify,  ParseNone,      NULL},
 
-{"ClientMessage",   NULLQUARK, ClientMessage,	ParseAtom,	NULL},
-{"Message",	    NULLQUARK, ClientMessage,	ParseAtom,	NULL},
+{"ClientMessage",   NULLQUARK, ClientMessage,   ParseAtom,      NULL},
+{"Message",         NULLQUARK, ClientMessage,   ParseAtom,      NULL},
 
-{"MappingNotify",   NULLQUARK, MappingNotify, ParseTable, (Opaque)mappingNotify},
-{"Mapping",	    NULLQUARK, MappingNotify, ParseTable, (Opaque)mappingNotify},
+{"MappingNotify",   NULLQUARK, MappingNotify,   ParseTable, (Opaque)mappingNotify},
+{"Mapping",         NULLQUARK, MappingNotify,   ParseTable, (Opaque)mappingNotify},
 
 #ifdef DEBUG
 # ifdef notdef
-{"Timer",	    NULLQUARK, _XtTimerEventType,ParseNone,	NULL},
-{"EventTimer",	    NULLQUARK, _XtEventTimerEventType,ParseNone,NULL},
+{"Timer",           NULLQUARK, _XtTimerEventType, ParseNone,     NULL},
+{"EventTimer",      NULLQUARK, _XtEventTimerEventType, ParseNone,NULL},
 # endif /* notdef */
 #endif /* DEBUG */
 
-/* Event Name,	  Quark, Event Type,	Detail Parser, Closure */
+/* Event Name,    Quark, Event Type,    Detail Parser, Closure */
 
 };
+/* *INDENT-ON* */
 
 #define IsNewline(str) ((str) == '\n')
 
@@ -403,169 +406,175 @@ static XrmQuark QCtrl;
 static XrmQuark QNone;
 static XrmQuark QAny;
 
-static void FreeEventSeq(
-    EventSeqPtr eventSeq)
+static void
+FreeEventSeq(EventSeqPtr eventSeq)
 {
     register EventSeqPtr evs = eventSeq;
 
     while (evs != NULL) {
-	evs->state = (StatePtr) evs;
-	if (evs->next != NULL
-	    && evs->next->state == (StatePtr) evs->next)
-	    evs->next = NULL;
-	evs = evs->next;
+        evs->state = (StatePtr) evs;
+        if (evs->next != NULL && evs->next->state == (StatePtr) evs->next)
+            evs->next = NULL;
+        evs = evs->next;
     }
 
     evs = eventSeq;
     while (evs != NULL) {
-	register EventPtr event = evs;
-	evs = evs->next;
-	if (evs == event) evs = NULL;
-	XtFree((char *)event);
+        register EventPtr event = evs;
+
+        evs = evs->next;
+        if (evs == event)
+            evs = NULL;
+        XtFree((char *) event);
     }
 }
 
-static void CompileNameValueTable(
-    NameValueTable table)
+static void
+CompileNameValueTable(NameValueTable table)
 {
     register int i;
 
-    for (i=0; table[i].name; i++)
+    for (i = 0; table[i].name; i++)
         table[i].signature = XrmPermStringToQuark(table[i].name);
 }
 
-static int OrderEvents(_Xconst void *a, _Xconst void *b)
+static int
+OrderEvents(_Xconst void *a, _Xconst void *b)
 {
-    return ((((_Xconst EventKey *)a)->signature <
-	     ((_Xconst EventKey *)b)->signature) ? -1 : 1);
+    return ((((_Xconst EventKey *) a)->signature <
+             ((_Xconst EventKey *) b)->signature) ? -1 : 1);
 }
 
-static void Compile_XtEventTable(
-    EventKeys	table,
-    Cardinal	count)
+static void
+Compile_XtEventTable(EventKeys table, Cardinal count)
 {
     register int i;
     register EventKeys entry = table;
 
-    for (i= (int)count; --i >= 0; entry++)
-	entry->signature = XrmPermStringToQuark(entry->event);
+    for (i = (int) count; --i >= 0; entry++)
+        entry->signature = XrmPermStringToQuark(entry->event);
     qsort(table, count, sizeof(EventKey), OrderEvents);
 }
 
-static int OrderModifiers(_Xconst void *a, _Xconst void *b)
+static int
+OrderModifiers(_Xconst void *a, _Xconst void *b)
 {
-    return ((((_Xconst ModifierRec *)a)->signature <
-	     ((_Xconst ModifierRec *)b)->signature) ? -1 : 1);
+    return ((((_Xconst ModifierRec *) a)->signature <
+             ((_Xconst ModifierRec *) b)->signature) ? -1 : 1);
 }
 
-static void Compile_XtModifierTable(
-    ModifierKeys table,
-    Cardinal count)
+static void
+Compile_XtModifierTable(ModifierKeys table, Cardinal count)
 {
     register int i;
     register ModifierKeys entry = table;
 
-    for (i= (int)count; --i >= 0; entry++)
-	entry->signature = XrmPermStringToQuark(entry->name);
+    for (i = (int) count; --i >= 0; entry++)
+        entry->signature = XrmPermStringToQuark(entry->name);
     qsort(table, count, sizeof(ModifierRec), OrderModifiers);
 }
 
-static String PanicModeRecovery(
-    String str)
+static String
+PanicModeRecovery(String str)
 {
-     ScanFor(str,'\n');
-     if (*str == '\n') str++;
-     return str;
+    ScanFor(str, '\n');
+    if (*str == '\n')
+        str++;
+    return str;
 
 }
 
-
-static void Syntax(
-    _Xconst char *str0, _Xconst char *str1)
+static void
+Syntax(_Xconst char *str0, _Xconst char *str1)
 {
     Cardinal num_params = 2;
     String params[2];
 
     params[0] = (String) str0;
     params[1] = (String) str1;
-    XtWarningMsg(XtNtranslationParseError,"parseError",XtCXtToolkitError,
-		 "translation table syntax error: %s %s",params,&num_params);
+    XtWarningMsg(XtNtranslationParseError, "parseError", XtCXtToolkitError,
+                 "translation table syntax error: %s %s", params, &num_params);
 }
 
-
-
-static Cardinal LookupTMEventType(
-  String eventStr,
-  Boolean *error)
+static Cardinal
+LookupTMEventType(String eventStr, Boolean *error)
 {
-    register int   i = 0, left, right;
-    register XrmQuark	signature;
-    static int 	previous = 0;
+    register int i = 0, left, right;
+    register XrmQuark signature;
+    static int previous = 0;
 
     LOCK_PROCESS;
     if ((signature = StringToQuark(eventStr)) == events[previous].signature) {
-	UNLOCK_PROCESS;
-	return (Cardinal) previous;
+        UNLOCK_PROCESS;
+        return (Cardinal) previous;
     }
 
     left = 0;
     right = XtNumber(events) - 1;
     while (left <= right) {
-	i = (left + right) >> 1;
-	if (signature < events[i].signature)
-	    right = i - 1;
-	else if (signature > events[i].signature)
-	    left = i + 1;
-	else {
-	    previous = i;
-	    UNLOCK_PROCESS;
-	    return (Cardinal) i;
-	}
-    }
-
-    Syntax("Unknown event type :  ",eventStr);
+        i = (left + right) >> 1;
+        if (signature < events[i].signature)
+            right = i - 1;
+        else if (signature > events[i].signature)
+            left = i + 1;
+        else {
+            previous = i;
+            UNLOCK_PROCESS;
+            return (Cardinal) i;
+        }
+    }
+
+    Syntax("Unknown event type :  ", eventStr);
     *error = TRUE;
     UNLOCK_PROCESS;
     return (Cardinal) i;
 }
 
-static void StoreLateBindings(
-    KeySym  keysymL,
-    Boolean notL,
-    KeySym keysymR,
-    Boolean notR,
-    LateBindingsPtr* lateBindings)
+static void
+StoreLateBindings(KeySym keysymL,
+                  Boolean notL,
+                  KeySym keysymR,
+                  Boolean notR,
+                  LateBindingsPtr *lateBindings)
 {
     LateBindingsPtr temp;
 
-    if (lateBindings != NULL){
-	Boolean pair = FALSE;
-	unsigned long count;
-	unsigned long number;
+    if (lateBindings != NULL) {
+        Boolean pair = FALSE;
+        unsigned long count;
+        unsigned long number;
 
         temp = *lateBindings;
         if (temp != NULL) {
-            for (count = 0; temp[count].keysym; count++){/*EMPTY*/}
+            for (count = 0; temp[count].keysym; count++) {
+                /*EMPTY*/
+            }
         }
-        else count = 0;
-        if (! keysymR){
-             number = 1;pair = FALSE;
-        } else{
-             number = 2;pair = TRUE;
+        else
+            count = 0;
+        if (!keysymR) {
+            number = 1;
+            pair = FALSE;
+        }
+        else {
+            number = 2;
+            pair = TRUE;
         }
 
-        temp = (LateBindingsPtr)XtRealloc((char *)temp,
-            (unsigned)((count+number+1) * sizeof(LateBindings)) );
+        temp = (LateBindingsPtr) XtRealloc((char *) temp,
+                                           (unsigned) ((count + number +
+                                                        1) *
+                                                       sizeof(LateBindings)));
         *lateBindings = temp;
         XtSetBit(temp[count].knot, notL);
         XtSetBit(temp[count].pair, pair);
-	if (count == 0)
-	    temp[count].ref_count = 1;
+        if (count == 0)
+            temp[count].ref_count = 1;
         temp[count++].keysym = keysymL;
-        if (keysymR){
+        if (keysymR) {
             XtSetBit(temp[count].knot, notR);
             temp[count].pair = FALSE;
-	    temp[count].ref_count = 0;
+            temp[count].ref_count = 0;
             temp[count++].keysym = keysymR;
         }
         temp[count].knot = temp[count].pair = FALSE;
@@ -574,112 +583,115 @@ static void StoreLateBindings(
     }
 }
 
-static void _XtParseKeysymMod(
-    String name,
-    LateBindingsPtr* lateBindings,
-    Boolean notFlag,
-    Value *valueP,
-    Boolean *error)
+static void
+_XtParseKeysymMod(String name,
+                  LateBindingsPtr *lateBindings,
+                  Boolean notFlag,
+                  Value *valueP,
+                  Boolean *error)
 {
     KeySym keySym;
+
     keySym = StringToKeySym(name, error);
     *valueP = 0;
     if (keySym != NoSymbol) {
-        StoreLateBindings(keySym,notFlag,(KeySym) NULL,FALSE,lateBindings);
+        StoreLateBindings(keySym, notFlag, (KeySym) NULL, FALSE, lateBindings);
     }
 }
 
-static Boolean _XtLookupModifier(
-    XrmQuark signature,
-    LateBindingsPtr* lateBindings,
-    Boolean notFlag,
-    Value *valueP,
-    Bool constMask)
+static Boolean
+_XtLookupModifier(XrmQuark signature,
+                  LateBindingsPtr *lateBindings,
+                  Boolean notFlag,
+                  Value *valueP,
+                  Bool constMask)
 {
     int left, right;
     static int previous = 0;
 
     LOCK_PROCESS;
     if (signature == modifiers[previous].signature) {
-	if (constMask)  *valueP = modifiers[previous].value;
-	else /* if (modifiers[previous].modifierParseProc) always true */
-	   (*modifiers[previous].modifierParseProc)
-	      (modifiers[previous].value, lateBindings, notFlag, valueP);
-	UNLOCK_PROCESS;
-	return TRUE;
+        if (constMask)
+            *valueP = modifiers[previous].value;
+        else                    /* if (modifiers[previous].modifierParseProc) always true */
+            (*modifiers[previous].modifierParseProc)
+                (modifiers[previous].value, lateBindings, notFlag, valueP);
+        UNLOCK_PROCESS;
+        return TRUE;
     }
 
     left = 0;
     right = XtNumber(modifiers) - 1;
     while (left <= right) {
-	int i = (left + right) >> 1;
-	if (signature < modifiers[i].signature)
-	    right = i - 1;
-	else if (signature > modifiers[i].signature)
-	    left = i + 1;
-	else {
-	    previous = i;
-	    if (constMask)  *valueP = modifiers[i].value;
-	    else /* if (modifiers[i].modifierParseProc) always true */
-		(*modifiers[i].modifierParseProc)
-		    (modifiers[i].value, lateBindings, notFlag, valueP);
-	    UNLOCK_PROCESS;
-	    return TRUE;
-	}
+        int i = (left + right) >> 1;
+
+        if (signature < modifiers[i].signature)
+            right = i - 1;
+        else if (signature > modifiers[i].signature)
+            left = i + 1;
+        else {
+            previous = i;
+            if (constMask)
+                *valueP = modifiers[i].value;
+            else                /* if (modifiers[i].modifierParseProc) always true */
+                (*modifiers[i].modifierParseProc)
+                    (modifiers[i].value, lateBindings, notFlag, valueP);
+            UNLOCK_PROCESS;
+            return TRUE;
+        }
     }
     UNLOCK_PROCESS;
     return FALSE;
 }
 
-
-static String ScanIdent(
-    register String str)
+static String
+ScanIdent(register String str)
 {
     ScanAlphanumeric(str);
-    while (
-	   ('A' <= *str && *str <= 'Z')
-	|| ('a' <= *str && *str <= 'z')
-	|| ('0' <= *str && *str <= '9')
-	|| (*str == '-')
-	|| (*str == '_')
-	|| (*str == '$')
-	) str++;
+    while (('A' <= *str && *str <= 'Z')
+           || ('a' <= *str && *str <= 'z')
+           || ('0' <= *str && *str <= '9')
+           || (*str == '-')
+           || (*str == '_')
+           || (*str == '$')
+        )
+        str++;
     return str;
 }
 
-static String FetchModifierToken(
-    String str,
-    XrmQuark *token_return)
+static String
+FetchModifierToken(String str, XrmQuark *token_return)
 {
     String start = str;
 
     if (*str == '$') {
         *token_return = QMeta;
         str++;
-    } else if (*str == '^') {
+    }
+    else if (*str == '^') {
         *token_return = QCtrl;
         str++;
-    } else {
-	str = ScanIdent(str);
-	if (start != str) {
-	    char modStrbuf[100];
-	    char* modStr;
-
-	    modStr = XtStackAlloc ((size_t)(str - start + 1), modStrbuf);
-	    if (modStr == NULL) _XtAllocError (NULL);
-	    (void) memmove(modStr, start, (size_t) (str - start));
-	    modStr[str-start] = '\0';
-	    *token_return = XrmStringToQuark(modStr);
-	    XtStackFree (modStr, modStrbuf);
-	}
+    }
+    else {
+        str = ScanIdent(str);
+        if (start != str) {
+            char modStrbuf[100];
+            char *modStr;
+
+            modStr = XtStackAlloc((size_t) (str - start + 1), modStrbuf);
+            if (modStr == NULL)
+                _XtAllocError(NULL);
+            (void) memmove(modStr, start, (size_t) (str - start));
+            modStr[str - start] = '\0';
+            *token_return = XrmStringToQuark(modStr);
+            XtStackFree(modStr, modStrbuf);
+        }
     }
     return str;
 }
 
-static String ParseModifiers(
-    register String str,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseModifiers(register String str, EventPtr event, Boolean *error)
 {
     register String start;
     Boolean notFlag, exclusive, keysymAsMod;
@@ -691,200 +703,223 @@ static String ParseModifiers(
     str = FetchModifierToken(str, &Qmod);
     exclusive = FALSE;
     if (start != str) {
-	if (Qmod == QNone) {
-	    event->event.modifierMask = (unsigned long) (~0);
-	    event->event.modifiers = 0;
-	    ScanWhitespace(str);
-	    return str;
-	} else if (Qmod == QAny) { /*backward compatability*/
-	    event->event.modifierMask = 0;
-	    event->event.modifiers = AnyModifier;
-	    ScanWhitespace(str);
-	    return str;
-	}
-	str = start; /*if plain modifier, reset to beginning */
-    }
-    else while (*str == '!' || *str == ':') {
-        if (*str == '!') {
-             exclusive = TRUE;
-             str++;
-             ScanWhitespace(str);
+        if (Qmod == QNone) {
+            event->event.modifierMask = (unsigned long) (~0);
+            event->event.modifiers = 0;
+            ScanWhitespace(str);
+            return str;
         }
-        if (*str == ':') {
-             event->event.standard = TRUE;
-             str++;
-             ScanWhitespace(str);
+        else if (Qmod == QAny) {        /*backward compatability */
+            event->event.modifierMask = 0;
+            event->event.modifiers = AnyModifier;
+            ScanWhitespace(str);
+            return str;
         }
+        str = start;            /*if plain modifier, reset to beginning */
     }
+    else
+        while (*str == '!' || *str == ':') {
+            if (*str == '!') {
+                exclusive = TRUE;
+                str++;
+                ScanWhitespace(str);
+            }
+            if (*str == ':') {
+                event->event.standard = TRUE;
+                str++;
+                ScanWhitespace(str);
+            }
+        }
 
     while (*str != '<') {
         if (*str == '~') {
-             notFlag = TRUE;
-             str++;
-          } else
-              notFlag = FALSE;
+            notFlag = TRUE;
+            str++;
+        }
+        else
+            notFlag = FALSE;
         if (*str == '@') {
             keysymAsMod = TRUE;
             str++;
         }
-        else keysymAsMod = FALSE;
-	start = str;
+        else
+            keysymAsMod = FALSE;
+        start = str;
         str = FetchModifierToken(str, &Qmod);
         if (start == str) {
-            Syntax("Modifier or '<' expected","");
+            Syntax("Modifier or '<' expected", "");
+            *error = TRUE;
+            return PanicModeRecovery(str);
+        }
+        if (keysymAsMod) {
+            _XtParseKeysymMod(XrmQuarkToString(Qmod),
+                              &event->event.lateModifiers,
+                              notFlag, &maskBit, error);
+            if (*error)
+                return PanicModeRecovery(str);
+
+        }
+        else if (!_XtLookupModifier(Qmod, &event->event.lateModifiers,
+                                    notFlag, &maskBit, FALSE)) {
+            Syntax("Unknown modifier name:  ", XrmQuarkToString(Qmod));
             *error = TRUE;
             return PanicModeRecovery(str);
         }
-         if (keysymAsMod) {
-             _XtParseKeysymMod(XrmQuarkToString(Qmod),
-			       &event->event.lateModifiers,
-			       notFlag,&maskBit, error);
-	     if (*error)
-                 return PanicModeRecovery(str);
-
-         } else
-  	     if (!_XtLookupModifier(Qmod, &event->event.lateModifiers,
-				    notFlag, &maskBit, FALSE)) {
-	         Syntax("Unknown modifier name:  ", XrmQuarkToString(Qmod));
-                 *error = TRUE;
-                 return PanicModeRecovery(str);
-             }
         event->event.modifierMask |= maskBit;
-	if (notFlag) event->event.modifiers = (event->event.modifiers & (TMLongCard) (~maskBit));
-	else event->event.modifiers |= maskBit;
+        if (notFlag)
+            event->event.modifiers =
+                (event->event.modifiers & (TMLongCard) (~maskBit));
+        else
+            event->event.modifiers |= maskBit;
         ScanWhitespace(str);
     }
-    if (exclusive) event->event.modifierMask = (unsigned long) (~0);
+    if (exclusive)
+        event->event.modifierMask = (unsigned long) (~0);
     return str;
 }
 
-static String ParseXtEventType(
-    register String str,
-    EventPtr event,
-    Cardinal *tmEventP,
-    Boolean* error)
+static String
+ParseXtEventType(register String str,
+                 EventPtr event,
+                 Cardinal *tmEventP,
+                 Boolean *error)
 {
     String start = str;
     char eventTypeStrbuf[100];
-    char* eventTypeStr;
+    char *eventTypeStr;
 
     ScanAlphanumeric(str);
-    eventTypeStr = XtStackAlloc ((size_t)(str - start + 1), eventTypeStrbuf);
-    if (eventTypeStr == NULL) _XtAllocError (NULL);
-    (void) memmove(eventTypeStr, start, (size_t)(str-start));
-    eventTypeStr[str-start] = '\0';
-    *tmEventP = LookupTMEventType(eventTypeStr,error);
-    XtStackFree (eventTypeStr, eventTypeStrbuf);
+    eventTypeStr = XtStackAlloc((size_t) (str - start + 1), eventTypeStrbuf);
+    if (eventTypeStr == NULL)
+        _XtAllocError(NULL);
+    (void) memmove(eventTypeStr, start, (size_t) (str - start));
+    eventTypeStr[str - start] = '\0';
+    *tmEventP = LookupTMEventType(eventTypeStr, error);
+    XtStackFree(eventTypeStr, eventTypeStrbuf);
     if (*error)
         return PanicModeRecovery(str);
     event->event.eventType = (TMLongCard) events[*tmEventP].eventType;
     return str;
 }
 
-static unsigned long StrToHex(
-    String str)
+static unsigned long
+StrToHex(String str)
 {
-    register char   c;
-    register unsigned long    val = 0;
+    register char c;
+    register unsigned long val = 0;
 
     while ((c = *str)) {
-	if ('0' <= c && c <= '9') val = (unsigned long) (val * 16 + (unsigned long)c - '0');
-	else if ('a' <= c && c <= 'z') val = (unsigned long) (val*16+(unsigned long)c-'a'+10);
-	else if ('A' <= c && c <= 'Z') val = (unsigned long) (val*16+(unsigned long)c-'A'+10);
-	else return 0;
-	str++;
+        if ('0' <= c && c <= '9')
+            val = (unsigned long) (val * 16 + (unsigned long) c - '0');
+        else if ('a' <= c && c <= 'z')
+            val = (unsigned long) (val * 16 + (unsigned long) c - 'a' + 10);
+        else if ('A' <= c && c <= 'Z')
+            val = (unsigned long) (val * 16 + (unsigned long) c - 'A' + 10);
+        else
+            return 0;
+        str++;
     }
 
     return val;
 }
 
-static unsigned long StrToOct(
-    String str)
+static unsigned long
+StrToOct(String str)
 {
     register char c;
-    register unsigned long  val = 0;
+    register unsigned long val = 0;
 
     while ((c = *str)) {
-        if ('0' <= c && c <= '7') val = val*8+(unsigned long)c-'0'; else return 0;
-	str++;
+        if ('0' <= c && c <= '7')
+            val = val * 8 + (unsigned long) c - '0';
+        else
+            return 0;
+        str++;
     }
 
     return val;
 }
 
-static unsigned long StrToNum(
-    String str)
+static unsigned long
+StrToNum(String str)
 {
     register char c;
     register unsigned long val = 0;
 
     if (*str == '0') {
-	str++;
-	if (*str == 'x' || *str == 'X') return StrToHex(++str);
-	else return StrToOct(str);
+        str++;
+        if (*str == 'x' || *str == 'X')
+            return StrToHex(++str);
+        else
+            return StrToOct(str);
     }
 
     while ((c = *str)) {
-	if ('0' <= c && c <= '9') val = val*10+(unsigned long)c-'0';
-	else return 0;
-	str++;
+        if ('0' <= c && c <= '9')
+            val = val * 10 + (unsigned long) c - '0';
+        else
+            return 0;
+        str++;
     }
 
     return val;
 }
 
-static KeySym StringToKeySym(
-    String str,
-    Boolean *error)
+static KeySym
+StringToKeySym(String str, Boolean *error)
 {
     KeySym k;
 
-    if (str == NULL || *str == '\0') return (KeySym) 0;
+    if (str == NULL || *str == '\0')
+        return (KeySym) 0;
 
 #ifndef NOTASCII
     /* special case single character ASCII, for speed */
-    if (*(str+1) == '\0') {
-	if (' ' <= *str && *str <= '~') return (KeySym) (XK_space + (*str - ' '));
+    if (*(str + 1) == '\0') {
+        if (' ' <= *str && *str <= '~')
+            return (KeySym) (XK_space + (*str - ' '));
     }
 #endif
 
-    if ('0' <= *str && *str <= '9') return (KeySym) StrToNum(str);
+    if ('0' <= *str && *str <= '9')
+        return (KeySym) StrToNum(str);
     k = XStringToKeysym(str);
-    if (k != NoSymbol) return k;
+    if (k != NoSymbol)
+        return k;
 
 #ifdef NOTASCII
     /* fall-back case to preserve backwards compatibility; no-one
      * should be relying upon this!
      */
-    if (*(str+1) == '\0') return (KeySym) *str;
+    if (*(str + 1) == '\0')
+        return (KeySym) * str;
 #endif
 
     Syntax("Unknown keysym name: ", str);
     *error = TRUE;
     return NoSymbol;
 }
-/* ARGSUSED */
-static void ParseModImmed(
-    Value value,
-    LateBindingsPtr* lateBindings,
-    Boolean notFlag,
-    Value* valueP)
+
+static void
+ParseModImmed(Value value,
+              LateBindingsPtr *lateBindings _X_UNUSED,
+              Boolean notFlag _X_UNUSED,
+              Value *valueP)
 {
     *valueP = value;
 }
 
- /* is only valid with keysyms that have an _L and _R in their name;
-  * and ignores keysym lookup errors (i.e. assumes only valid keysyms)
-  */
-static void ParseModSym(
-    Value value,
-    LateBindingsPtr* lateBindings,
-    Boolean notFlag,
-    Value* valueP)
+/* is only valid with keysyms that have an _L and _R in their name;
+ * and ignores keysym lookup errors (i.e. assumes only valid keysyms)
+ */
+static void
+ParseModSym(Value value,
+            LateBindingsPtr *lateBindings, Boolean notFlag, Value *valueP)
 {
-    register KeySym keysymL = (KeySym)value;
-    register KeySym keysymR = keysymL + 1; /* valid for supported keysyms */
-    StoreLateBindings(keysymL,notFlag,keysymR,notFlag,lateBindings);
+    register KeySym keysymL = (KeySym) value;
+    register KeySym keysymR = keysymL + 1;      /* valid for supported keysyms */
+
+    StoreLateBindings(keysymL, notFlag, keysymR, notFlag, lateBindings);
     *valueP = 0;
 }
 
@@ -895,131 +930,128 @@ static void ParseModSym(
  * of the value passed in.
  */
 static String stupid_optimizer_kludge;
+
 #define BROKEN_OPTIMIZER_HACK(val) stupid_optimizer_kludge = (val)
 #else
 #define BROKEN_OPTIMIZER_HACK(val) val
 #endif
 
-/* ARGSUSED */
-static String ParseImmed(
-    register String str,
-    register Opaque closure,
-    register EventPtr event,
-    Boolean* error)
+static String
+ParseImmed(register String str,
+           register Opaque closure,
+           register EventPtr event,
+           Boolean *error _X_UNUSED)
 {
-    event->event.eventCode = (unsigned long)closure;
+    event->event.eventCode = (unsigned long) closure;
     event->event.eventCodeMask = (unsigned long) (~0UL);
 
     return BROKEN_OPTIMIZER_HACK(str);
 }
 
-/* ARGSUSED */
-static String ParseAddModifier(
-    register String str,
-    register Opaque closure,
-    register EventPtr event,
-    Boolean* error)
+static String
+ParseAddModifier(register String str,
+                 register Opaque closure,
+                 register EventPtr event,
+                 Boolean *error _X_UNUSED)
 {
-    register unsigned long modval = (unsigned long)closure;
+    register unsigned long modval = (unsigned long) closure;
+
     event->event.modifiers |= modval;
-    if (modval != AnyButtonMask) /* AnyButtonMask is don't-care mask */
-	event->event.modifierMask |= modval;
+    if (modval != AnyButtonMask)        /* AnyButtonMask is don't-care mask */
+        event->event.modifierMask |= modval;
 
     return BROKEN_OPTIMIZER_HACK(str);
 }
 
-
-static String ParseKeyAndModifiers(
-    String str,
-    Opaque closure,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseKeyAndModifiers(String str,
+                     Opaque closure,
+                     EventPtr event,
+                     Boolean *error)
 {
-    str = ParseKeySym(str, closure, event,error);
+    str = ParseKeySym(str, closure, event, error);
     if ((unsigned long) closure == 0) {
-	Value metaMask; /* unused */
-	(void) _XtLookupModifier(QMeta, &event->event.lateModifiers, FALSE,
-				 &metaMask, FALSE);
-    } else {
-	event->event.modifiers |= (unsigned long) closure;
-	event->event.modifierMask |= (unsigned long) closure;
+        Value metaMask;         /* unused */
+
+        (void) _XtLookupModifier(QMeta, &event->event.lateModifiers, FALSE,
+                                 &metaMask, FALSE);
+    }
+    else {
+        event->event.modifiers |= (unsigned long) closure;
+        event->event.modifierMask |= (unsigned long) closure;
     }
     return str;
 }
 
-/*ARGSUSED*/
-static String ParseKeySym(
-    register String str,
-    Opaque closure,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseKeySym(register String str,
+            Opaque closure _X_UNUSED,
+            EventPtr event,
+            Boolean *error)
 {
     String start;
     char keySymNamebuf[100];
-    char* keySymName = NULL;
+    char *keySymName = NULL;
 
     ScanWhitespace(str);
 
     if (*str == '\\') {
-	keySymName = keySymNamebuf;
-	str++;
-	keySymName[0] = *str;
-	if (*str != '\0' && !IsNewline(*str)) str++;
-	keySymName[1] = '\0';
-	event->event.eventCode = StringToKeySym(keySymName, error);
-	event->event.eventCodeMask = (unsigned long) (~0L);
-    } else if (*str == ',' || *str == ':' ||
+        keySymName = keySymNamebuf;
+        str++;
+        keySymName[0] = *str;
+        if (*str != '\0' && !IsNewline(*str))
+            str++;
+        keySymName[1] = '\0';
+        event->event.eventCode = StringToKeySym(keySymName, error);
+        event->event.eventCodeMask = (unsigned long) (~0L);
+    }
+    else if (*str == ',' || *str == ':' ||
              /* allow leftparen to be single char symbol,
               * for backwards compatibility
               */
-             (*str == '(' && *(str+1) >= '0' && *(str+1) <= '9')) {
-	keySymName = keySymNamebuf; /* just so we can stackfree it later */
-	/* no detail */
-	event->event.eventCode = 0L;
+             (*str == '(' && *(str + 1) >= '0' && *(str + 1) <= '9')) {
+        keySymName = keySymNamebuf;     /* just so we can stackfree it later */
+        /* no detail */
+        event->event.eventCode = 0L;
         event->event.eventCodeMask = 0L;
-    } else {
-	start = str;
-	while (
-		*str != ','
-		&& *str != ':'
-		&& *str != ' '
-		&& *str != '\t'
-                && !IsNewline(*str)
-                && (*str != '(' || *(str+1) <= '0' || *(str+1) >= '9')
-		&& *str != '\0') str++;
-	keySymName = XtStackAlloc ((size_t)(str - start + 1), keySymNamebuf);
-	(void) memmove(keySymName, start, (size_t) (str-start));
-	keySymName[str-start] = '\0';
-	event->event.eventCode = StringToKeySym(keySymName, error);
-	event->event.eventCodeMask = (unsigned long) (~0L);
+    }
+    else {
+        start = str;
+        while (*str != ','
+               && *str != ':' && *str != ' ' && *str != '\t' && !IsNewline(*str)
+               && (*str != '(' || *(str + 1) <= '0' || *(str + 1) >= '9')
+               && *str != '\0')
+            str++;
+        keySymName = XtStackAlloc((size_t) (str - start + 1), keySymNamebuf);
+        (void) memmove(keySymName, start, (size_t) (str - start));
+        keySymName[str - start] = '\0';
+        event->event.eventCode = StringToKeySym(keySymName, error);
+        event->event.eventCodeMask = (unsigned long) (~0L);
     }
     if (*error && keySymName) {
-	/* We never get here when keySymName hasn't been allocated */
-	if (keySymName[0] == '<') {
-	    /* special case for common error */
-	    XtWarningMsg(XtNtranslationParseError, "missingComma",
-			 XtCXtToolkitError,
-		     "... possibly due to missing ',' in event sequence.",
-		     (String*)NULL, (Cardinal*)NULL);
-	}
-	XtStackFree (keySymName, keySymNamebuf);
-	return PanicModeRecovery(str);
+        /* We never get here when keySymName hasn't been allocated */
+        if (keySymName[0] == '<') {
+            /* special case for common error */
+            XtWarningMsg(XtNtranslationParseError, "missingComma",
+                         XtCXtToolkitError,
+                         "... possibly due to missing ',' in event sequence.",
+                         (String *) NULL, (Cardinal *) NULL);
+        }
+        XtStackFree(keySymName, keySymNamebuf);
+        return PanicModeRecovery(str);
     }
     if (event->event.standard)
-	event->event.matchEvent = _XtMatchUsingStandardMods;
+        event->event.matchEvent = _XtMatchUsingStandardMods;
     else
-	event->event.matchEvent = _XtMatchUsingDontCareMods;
+        event->event.matchEvent = _XtMatchUsingDontCareMods;
 
-    XtStackFree (keySymName, keySymNamebuf);
+    XtStackFree(keySymName, keySymNamebuf);
 
     return str;
 }
 
-static String ParseTable(
-    register String str,
-    Opaque closure,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseTable(register String str, Opaque closure, EventPtr event, Boolean *error)
 {
     register String start = str;
     register XrmQuark signature;
@@ -1028,33 +1060,35 @@ static String ParseTable(
 
     event->event.eventCode = 0L;
     ScanAlphanumeric(str);
-    if (str == start) {event->event.eventCodeMask = 0L; return str; }
-    if (str-start >= 99) {
-	Syntax("Invalid Detail Type (string is too long).", "");
-	*error = TRUE;
-	return str;
-    }
-    (void) memmove(tableSymName, start, (size_t) (str-start));
-    tableSymName[str-start] = '\0';
+    if (str == start) {
+        event->event.eventCodeMask = 0L;
+        return str;
+    }
+    if (str - start >= 99) {
+        Syntax("Invalid Detail Type (string is too long).", "");
+        *error = TRUE;
+        return str;
+    }
+    (void) memmove(tableSymName, start, (size_t) (str - start));
+    tableSymName[str - start] = '\0';
     signature = StringToQuark(tableSymName);
     for (; table->signature != NULLQUARK; table++)
-	if (table->signature == signature) {
-	    event->event.eventCode = table->value;
-	    event->event.eventCodeMask = (unsigned long) (~0L);
-	    return str;
-	}
+        if (table->signature == signature) {
+            event->event.eventCode = table->value;
+            event->event.eventCodeMask = (unsigned long) (~0L);
+            return str;
+        }
 
     Syntax("Unknown Detail Type:  ", tableSymName);
     *error = TRUE;
     return PanicModeRecovery(str);
 }
 
-/*ARGSUSED*/
-static String ParseNone(
-    String str,
-    Opaque closure,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseNone(String str,
+          Opaque closure _X_UNUSED,
+          EventPtr event,
+          Boolean *error _X_UNUSED)
 {
     event->event.eventCode = 0;
     event->event.eventCodeMask = 0;
@@ -1062,39 +1096,34 @@ static String ParseNone(
     return BROKEN_OPTIMIZER_HACK(str);
 }
 
-/*ARGSUSED*/
-static String ParseAtom(
-    String str,
-    Opaque closure,
-    EventPtr event,
-    Boolean* error)
+static String
+ParseAtom(String str, Opaque closure _X_UNUSED, EventPtr event, Boolean *error)
 {
     ScanWhitespace(str);
 
     if (*str == ',' || *str == ':') {
-	/* no detail */
-	event->event.eventCode = 0L;
+        /* no detail */
+        event->event.eventCode = 0L;
         event->event.eventCodeMask = 0L;
-    } else {
-	String start;
-	char atomName[1000];
-	start = str;
-	while (
-		*str != ','
-		&& *str != ':'
-		&& *str != ' '
-		&& *str != '\t'
-                && !IsNewline(*str)
-		&& *str != '\0') str++;
-	if (str-start >= 999) {
-	    Syntax( "Atom name must be less than 1000 characters long.", "" );
-	    *error = TRUE;
-	    return str;
-	}
-	(void) memmove(atomName, start, (size_t) (str-start));
-	atomName[str-start] = '\0';
-	event->event.eventCode = (TMLongCard) XrmStringToQuark(atomName);
-	event->event.matchEvent = _XtMatchAtom;
+    }
+    else {
+        String start;
+        char atomName[1000];
+
+        start = str;
+        while (*str != ','
+               && *str != ':' && *str != ' ' && *str != '\t' && !IsNewline(*str)
+               && *str != '\0')
+            str++;
+        if (str - start >= 999) {
+            Syntax("Atom name must be less than 1000 characters long.", "");
+            *error = TRUE;
+            return str;
+        }
+        (void) memmove(atomName, start, (size_t) (str - start));
+        atomName[str - start] = '\0';
+        event->event.eventCode = (TMLongCard) XrmStringToQuark(atomName);
+        event->event.matchEvent = _XtMatchAtom;
     }
     return str;
 }
@@ -1102,80 +1131,91 @@ static String ParseAtom(
 static ModifierMask buttonModifierMasks[] = {
     0, Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask
 };
+
 static String ParseRepeat(String, int *, Boolean *, Boolean *);
 
-static String ParseEvent(
-    register String str,
-    EventPtr	event,
-    int*	reps,
-    Boolean*	plus,
-    Boolean* error)
+static String
+ParseEvent(register String str,
+           EventPtr event, int *reps,
+           Boolean *plus,
+           Boolean *error)
 {
-    Cardinal	tmEvent;
+    Cardinal tmEvent;
 
-    str = ParseModifiers(str, event,error);
-    if (*error) return str;
+    str = ParseModifiers(str, event, error);
+    if (*error)
+        return str;
     if (*str != '<') {
-         Syntax("Missing '<' while parsing event type.","");
-         *error = TRUE;
-         return PanicModeRecovery(str);
-    }
-    else str++;
-    str = ParseXtEventType(str, event, &tmEvent,error);
-    if (*error) return str;
-    if (*str != '>'){
-         Syntax("Missing '>' while parsing event type","");
-         *error = TRUE;
-         return PanicModeRecovery(str);
-    }
-    else str++;
+        Syntax("Missing '<' while parsing event type.", "");
+        *error = TRUE;
+        return PanicModeRecovery(str);
+    }
+    else
+        str++;
+    str = ParseXtEventType(str, event, &tmEvent, error);
+    if (*error)
+        return str;
+    if (*str != '>') {
+        Syntax("Missing '>' while parsing event type", "");
+        *error = TRUE;
+        return PanicModeRecovery(str);
+    }
+    else
+        str++;
     if (*str == '(') {
-	str = ParseRepeat(str, reps, plus, error);
-	if (*error) return str;
+        str = ParseRepeat(str, reps, plus, error);
+        if (*error)
+            return str;
     }
-    str = (*(events[tmEvent].parseDetail))(
-        str, events[tmEvent].closure, event,error);
-    if (*error) return str;
+    str =
+        (*(events[tmEvent].parseDetail)) (str, events[tmEvent].closure, event,
+                                          error);
+    if (*error)
+        return str;
 
 /* gross hack! ||| this kludge is related to the X11 protocol deficiency w.r.t.
  * modifiers in grabs.
  */
     if ((event->event.eventType == ButtonRelease)
-	&& (event->event.modifiers | event->event.modifierMask) /* any */
-        && (event->event.modifiers != AnyModifier))
-    {
-	event->event.modifiers = (event->event.modifiers 
-	    | (TMLongCard) buttonModifierMasks[event->event.eventCode]);
-	/* the button that is going up will always be in the modifiers... */
+        && (event->event.modifiers | event->event.modifierMask) /* any */
+        &&(event->event.modifiers != AnyModifier)) {
+        event->event.modifiers = (event->event.modifiers
+                                  | (TMLongCard) buttonModifierMasks[event->
+                                                                     event.
+                                                                     eventCode]);
+        /* the button that is going up will always be in the modifiers... */
     }
 
     return str;
 }
 
-static String ParseQuotedStringEvent(
-    register String str,
-    register EventPtr event,
-    Boolean *error)
+static String
+ParseQuotedStringEvent(register String str,
+                       register EventPtr event,
+                       Boolean *error)
 {
     Value metaMask;
-    char	s[2];
+    char s[2];
 
-    if (*str=='^') {
-	str++;
-	event->event.modifiers = ControlMask;
-    } else if (*str == '$') {
-	str++;
-	(void) _XtLookupModifier(QMeta, &event->event.lateModifiers, FALSE,
-				 &metaMask, FALSE);
+    if (*str == '^') {
+        str++;
+        event->event.modifiers = ControlMask;
+    }
+    else if (*str == '$') {
+        str++;
+        (void) _XtLookupModifier(QMeta, &event->event.lateModifiers, FALSE,
+                                 &metaMask, FALSE);
     }
     if (*str == '\\')
-	str++;
+        str++;
     s[0] = *str;
     s[1] = '\0';
-    if (*str != '\0' && !IsNewline(*str)) str++;
+    if (*str != '\0' && !IsNewline(*str))
+        str++;
     event->event.eventType = KeyPress;
     event->event.eventCode = StringToKeySym(s, error);
-    if (*error) return PanicModeRecovery(str);
+    if (*error)
+        return PanicModeRecovery(str);
     event->event.eventCodeMask = (unsigned long) (~0L);
     event->event.matchEvent = _XtMatchUsingStandardMods;
     event->event.standard = TRUE;
@@ -1183,7 +1223,6 @@ static String ParseQuotedStringEvent(
     return str;
 }
 
-
 static EventSeqRec timerEventRec = {
     {0, 0, NULL, _XtEventTimerEventType, 0L, 0L, NULL, False},
     /* (StatePtr) -1 */ NULL,
@@ -1191,10 +1230,8 @@ static EventSeqRec timerEventRec = {
     NULL
 };
 
-static void RepeatDown(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatDown(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     EventRec upEventRec;
     register EventPtr event, downEvent;
@@ -1204,32 +1241,36 @@ static void RepeatDown(
     downEvent = event = *eventP;
     *upEvent = *downEvent;
     upEvent->event.eventType = ((event->event.eventType == ButtonPress) ?
-	ButtonRelease : KeyRelease);
+                                ButtonRelease : KeyRelease);
     if ((upEvent->event.eventType == ButtonRelease)
-	&& (upEvent->event.modifiers != AnyModifier)
+        && (upEvent->event.modifiers != AnyModifier)
         && (upEvent->event.modifiers | upEvent->event.modifierMask))
-	upEvent->event.modifiers = (upEvent->event.modifiers 
-	    | (TMLongCard) buttonModifierMasks[event->event.eventCode]);
+        upEvent->event.modifiers = (upEvent->event.modifiers
+                                    | (TMLongCard) buttonModifierMasks[event->
+                                                                       event.
+                                                                       eventCode]);
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + (reps - 1) * 2);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count +
+                              (reps - 1) * 2);
 
-    for (i=1; i<reps; i++) {
+    for (i = 1; i < reps; i++) {
 
-	/* up */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *upEvent;
+        /* up */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *upEvent;
 
-	/* timer */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = timerEventRec;
+        /* timer */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = timerEventRec;
 
-	/* down */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *downEvent;
+        /* down */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *downEvent;
 
     }
 
@@ -1238,10 +1279,8 @@ static void RepeatDown(
     *actionsP = &event->actions;
 }
 
-static void RepeatDownPlus(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatDownPlus(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     EventRec upEventRec;
     register EventPtr event, downEvent, lastDownEvent = NULL;
@@ -1251,35 +1290,39 @@ static void RepeatDownPlus(
     downEvent = event = *eventP;
     *upEvent = *downEvent;
     upEvent->event.eventType = ((event->event.eventType == ButtonPress) ?
-	ButtonRelease : KeyRelease);
+                                ButtonRelease : KeyRelease);
     if ((upEvent->event.eventType == ButtonRelease)
-	&& (upEvent->event.modifiers != AnyModifier)
+        && (upEvent->event.modifiers != AnyModifier)
         && (upEvent->event.modifiers | upEvent->event.modifierMask))
-	upEvent->event.modifiers = (upEvent->event.modifiers 
-	    | (TMLongCard) buttonModifierMasks[event->event.eventCode]);
+        upEvent->event.modifiers = (upEvent->event.modifiers
+                                    | (TMLongCard) buttonModifierMasks[event->
+                                                                       event.
+                                                                       eventCode]);
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + reps * 2 - 1);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count + reps * 2 -
+                              1);
 
-    for (i=0; i<reps; i++) {
+    for (i = 0; i < reps; i++) {
 
-	if (i > 0) {
-	/* down */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *downEvent;
-	}
-	lastDownEvent = event;
+        if (i > 0) {
+            /* down */
+            event->next = XtNew(EventSeqRec);
+            event = event->next;
+            *event = *downEvent;
+        }
+        lastDownEvent = event;
 
-	/* up */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *upEvent;
+        /* up */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *upEvent;
 
-	/* timer */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = timerEventRec;
+        /* timer */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = timerEventRec;
 
     }
 
@@ -1288,10 +1331,8 @@ static void RepeatDownPlus(
     *actionsP = &lastDownEvent->actions;
 }
 
-static void RepeatUp(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatUp(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     EventRec upEventRec;
     register EventPtr event, downEvent;
@@ -1305,49 +1346,51 @@ static void RepeatUp(
     downEvent = event = *eventP;
     *upEvent = *downEvent;
     downEvent->event.eventType = ((event->event.eventType == ButtonRelease) ?
-	ButtonPress : KeyPress);
+                                  ButtonPress : KeyPress);
     if ((downEvent->event.eventType == ButtonPress)
-	&& (downEvent->event.modifiers != AnyModifier)
+        && (downEvent->event.modifiers != AnyModifier)
         && (downEvent->event.modifiers | downEvent->event.modifierMask))
-	downEvent->event.modifiers = (downEvent->event.modifiers 
-	    & (TMLongCard) (~buttonModifierMasks[event->event.eventCode]));
+        downEvent->event.modifiers = (downEvent->event.modifiers
+                                      &
+                                      (TMLongCard) (~buttonModifierMasks
+                                                    [event->event.eventCode]));
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + reps * 2 - 1);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count + reps * 2 -
+                              1);
 
     /* up */
     event->next = XtNew(EventSeqRec);
     event = event->next;
     *event = *upEvent;
 
-    for (i=1; i<reps; i++) {
+    for (i = 1; i < reps; i++) {
 
-	/* timer */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = timerEventRec;
+        /* timer */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = timerEventRec;
 
-	/* down */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *downEvent;
+        /* down */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *downEvent;
 
-	/* up */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *upEvent;
+        /* up */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *upEvent;
 
-	}
+    }
 
     event->next = NULL;
     *eventP = event;
     *actionsP = &event->actions;
 }
 
-static void RepeatUpPlus(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatUpPlus(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     EventRec upEventRec;
     register EventPtr event, downEvent, lastUpEvent = NULL;
@@ -1361,44 +1404,45 @@ static void RepeatUpPlus(
     downEvent = event = *eventP;
     *upEvent = *downEvent;
     downEvent->event.eventType = ((event->event.eventType == ButtonRelease) ?
-	ButtonPress : KeyPress);
+                                  ButtonPress : KeyPress);
     if ((downEvent->event.eventType == ButtonPress)
-	&& (downEvent->event.modifiers != AnyModifier)
+        && (downEvent->event.modifiers != AnyModifier)
         && (downEvent->event.modifiers | downEvent->event.modifierMask))
-	downEvent->event.modifiers = (downEvent->event.modifiers 
-	    & (TMLongCard) (~buttonModifierMasks[event->event.eventCode]));
+        downEvent->event.modifiers = (downEvent->event.modifiers
+                                      &
+                                      (TMLongCard) (~buttonModifierMasks
+                                                    [event->event.eventCode]));
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + reps * 2);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count + reps * 2);
 
-    for (i=0; i<reps; i++) {
+    for (i = 0; i < reps; i++) {
 
-	/* up */
-	event->next = XtNew(EventSeqRec);
-	lastUpEvent = event = event->next;
-	*event = *upEvent;
+        /* up */
+        event->next = XtNew(EventSeqRec);
+        lastUpEvent = event = event->next;
+        *event = *upEvent;
 
-	/* timer */
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = timerEventRec;
+        /* timer */
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = timerEventRec;
 
-	/* down */
-	event->next = XtNew(EventSeqRec);
+        /* down */
+        event->next = XtNew(EventSeqRec);
         event = event->next;
-	*event = *downEvent;
+        *event = *downEvent;
 
-	}
+    }
 
     event->next = lastUpEvent;
     *eventP = event;
     *actionsP = &lastUpEvent->actions;
 }
 
-static void RepeatOther(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatOther(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     register EventPtr event, tempEvent;
     register int i;
@@ -1406,22 +1450,21 @@ static void RepeatOther(
     tempEvent = event = *eventP;
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + reps - 1);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count + reps - 1);
 
-    for (i=1; i<reps; i++) {
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *tempEvent;
+    for (i = 1; i < reps; i++) {
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *tempEvent;
     }
 
     *eventP = event;
     *actionsP = &event->actions;
 }
 
-static void RepeatOtherPlus(
-    EventPtr *eventP,
-    int reps,
-    ActionPtr **actionsP)
+static void
+RepeatOtherPlus(EventPtr *eventP, int reps, ActionPtr **actionsP)
 {
     register EventPtr event, tempEvent;
     register int i;
@@ -1429,12 +1472,13 @@ static void RepeatOtherPlus(
     tempEvent = event = *eventP;
 
     if (event->event.lateModifiers)
-	event->event.lateModifiers->ref_count = (unsigned short) (event->event.lateModifiers->ref_count + reps - 1);
+        event->event.lateModifiers->ref_count =
+            (unsigned short) (event->event.lateModifiers->ref_count + reps - 1);
 
-    for (i=1; i<reps; i++) {
-	event->next = XtNew(EventSeqRec);
-	event = event->next;
-	*event = *tempEvent;
+    for (i = 1; i < reps; i++) {
+        event->next = XtNew(EventSeqRec);
+        event = event->next;
+        *event = *tempEvent;
     }
 
     event->next = event;
@@ -1442,74 +1486,77 @@ static void RepeatOtherPlus(
     *actionsP = &event->actions;
 }
 
-static void RepeatEvent(
-    EventPtr *eventP,
-    int reps,
-    Boolean plus,
-    ActionPtr **actionsP)
+static void
+RepeatEvent(EventPtr *eventP, int reps, Boolean plus, ActionPtr **actionsP)
 {
     switch ((*eventP)->event.eventType) {
 
-	case ButtonPress:
-	case KeyPress:
-	    if (plus) RepeatDownPlus(eventP, reps, actionsP);
-	    else RepeatDown(eventP, reps, actionsP);
-	    break;
-
-	case ButtonRelease:
-	case KeyRelease:
-	    if (plus) RepeatUpPlus(eventP, reps, actionsP);
-	    else RepeatUp(eventP, reps, actionsP);
-	    break;
-
-	default:
-	    if (plus) RepeatOtherPlus(eventP, reps, actionsP);
-	    else RepeatOther(eventP, reps, actionsP);
+    case ButtonPress:
+    case KeyPress:
+        if (plus)
+            RepeatDownPlus(eventP, reps, actionsP);
+        else
+            RepeatDown(eventP, reps, actionsP);
+        break;
+
+    case ButtonRelease:
+    case KeyRelease:
+        if (plus)
+            RepeatUpPlus(eventP, reps, actionsP);
+        else
+            RepeatUp(eventP, reps, actionsP);
+        break;
+
+    default:
+        if (plus)
+            RepeatOtherPlus(eventP, reps, actionsP);
+        else
+            RepeatOther(eventP, reps, actionsP);
     }
 }
 
-static String ParseRepeat(
-    register String str,
-    int	*reps,
-    Boolean *plus, Boolean *error)
+static String
+ParseRepeat(register String str, int *reps, Boolean *plus, Boolean *error)
 {
 
     /*** Parse the repetitions, for double click etc... ***/
-    if (*str != '(' || !(isdigit((unsigned char)str[1]) || str[1] == '+' || str[1] == ')'))
-	return str;
+    if (*str != '(' ||
+        !(isdigit((unsigned char) str[1]) || str[1] == '+' || str[1] == ')'))
+        return str;
     str++;
-    if (isdigit((unsigned char)*str)) {
-	String start = str;
-	char repStr[7];
-	size_t len;
-
-	ScanNumeric(str);
-	len = (size_t) (str - start);
-	if (len < sizeof repStr) {
-	    (void) memmove(repStr, start, len);
-	    repStr[len] = '\0';
-	    *reps = (int) StrToNum(repStr);
-	} else {
-	    Syntax("Repeat count too large.", "");
-	    *error = TRUE;
-	    return str;
-	}
+    if (isdigit((unsigned char) *str)) {
+        String start = str;
+        char repStr[7];
+        size_t len;
+
+        ScanNumeric(str);
+        len = (size_t) (str - start);
+        if (len < sizeof repStr) {
+            (void) memmove(repStr, start, len);
+            repStr[len] = '\0';
+            *reps = (int) StrToNum(repStr);
+        }
+        else {
+            Syntax("Repeat count too large.", "");
+            *error = TRUE;
+            return str;
+        }
     }
     if (*reps == 0) {
-	Syntax("Missing repeat count.","");
-	*error = True;
-	return str;
+        Syntax("Missing repeat count.", "");
+        *error = True;
+        return str;
     }
 
     if (*str == '+') {
-	*plus = TRUE;
-	str++;
+        *plus = TRUE;
+        str++;
     }
     if (*str == ')')
-	str++;
+        str++;
     else {
-	Syntax("Missing ')'.","");
-	*error = TRUE;
+        Syntax("Missing ')'.", "");
+        *error = TRUE;
     }
 
     return str;
@@ -1523,53 +1570,55 @@ static String ParseRepeat(
  * event seq (in a passed in variable), having updated the String
  **********************************************************************/
 
-static String ParseEventSeq(
-    register String str,
-    EventSeqPtr *eventSeqP,
-    ActionPtr	**actionsP,
-    Boolean *error)
+static String
+ParseEventSeq(register String str,
+              EventSeqPtr *eventSeqP,
+              ActionPtr ** actionsP,
+              Boolean *error)
 {
     EventSeqPtr *nextEvent = eventSeqP;
 
     *eventSeqP = NULL;
 
-    while ( *str != '\0' && !IsNewline(*str)) {
-	static Event	nullEvent =
-             {0, 0,NULL, 0, 0L, 0L,_XtRegularMatch,FALSE};
-	EventPtr	event;
+    while (*str != '\0' && !IsNewline(*str)) {
+        static Event nullEvent =
+            { 0, 0, NULL, 0, 0L, 0L, _XtRegularMatch, FALSE };
+        EventPtr event;
 
-	ScanWhitespace(str);
+        ScanWhitespace(str);
 
-	if (*str == '"') {
-	    str++;
-	    while (*str != '"' && *str != '\0' && !IsNewline(*str)) {
+        if (*str == '"') {
+            str++;
+            while (*str != '"' && *str != '\0' && !IsNewline(*str)) {
                 event = XtNew(EventRec);
                 event->event = nullEvent;
                 event->state = /* (StatePtr) -1 */ NULL;
                 event->next = NULL;
                 event->actions = NULL;
-		str = ParseQuotedStringEvent(str, event,error);
-		if (*error) {
-		    XtWarningMsg(XtNtranslationParseError, "nonLatin1",
-			XtCXtToolkitError,
-			"... probably due to non-Latin1 character in quoted string",
-			(String*)NULL, (Cardinal*)NULL);
-		    XtFree((char *)event);
-		    return PanicModeRecovery(str);
-		}
-		*nextEvent = event;
-		*actionsP = &event->actions;
-		nextEvent = &event->next;
-	    }
-	    if (*str != '"') {
-                Syntax("Missing '\"'.","");
+                str = ParseQuotedStringEvent(str, event, error);
+                if (*error) {
+                    XtWarningMsg(XtNtranslationParseError, "nonLatin1",
+                                 XtCXtToolkitError,
+                                 "... probably due to non-Latin1 character in quoted string",
+                                 (String *) NULL, (Cardinal *) NULL);
+                    XtFree((char *) event);
+                    return PanicModeRecovery(str);
+                }
+                *nextEvent = event;
+                *actionsP = &event->actions;
+                nextEvent = &event->next;
+            }
+            if (*str != '"') {
+                Syntax("Missing '\"'.", "");
                 *error = TRUE;
                 return PanicModeRecovery(str);
-             }
-             else str++;
-	} else {
-	    int reps = 0;
-	    Boolean plus = FALSE;
+            }
+            else
+                str++;
+        }
+        else {
+            int reps = 0;
+            Boolean plus = FALSE;
 
             event = XtNew(EventRec);
             event->event = nullEvent;
@@ -1577,120 +1626,121 @@ static String ParseEventSeq(
             event->next = NULL;
             event->actions = NULL;
 
-	    str = ParseEvent(str, event, &reps, &plus, error);
-            if (*error) return str;
-	    *nextEvent = event;
-	    *actionsP = &event->actions;
-	    if (reps > 1 || plus)
-		RepeatEvent(&event, reps, plus, actionsP);
-	    nextEvent = &event->next;
-	}
-	ScanWhitespace(str);
-        if (*str == ':') break;
+            str = ParseEvent(str, event, &reps, &plus, error);
+            if (*error)
+                return str;
+            *nextEvent = event;
+            *actionsP = &event->actions;
+            if (reps > 1 || plus)
+                RepeatEvent(&event, reps, plus, actionsP);
+            nextEvent = &event->next;
+        }
+        ScanWhitespace(str);
+        if (*str == ':')
+            break;
         else {
             if (*str != ',') {
-                Syntax("',' or ':' expected while parsing event sequence.","");
+                Syntax("',' or ':' expected while parsing event sequence.", "");
                 *error = TRUE;
                 return PanicModeRecovery(str);
-	    } else str++;
+            }
+            else
+                str++;
         }
     }
 
     if (*str != ':') {
-        Syntax("Missing ':'after event sequence.","");
+        Syntax("Missing ':'after event sequence.", "");
         *error = TRUE;
         return PanicModeRecovery(str);
-    } else str++;
+    }
+    else
+        str++;
 
     return str;
 }
 
-
-static String ParseActionProc(
-    register String str,
-    XrmQuark *actionProcNameP,
-    Boolean *error)
+static String
+ParseActionProc(register String str, XrmQuark *actionProcNameP, Boolean *error)
 {
     register String start = str;
     char procName[200];
 
     str = ScanIdent(str);
-    if (str-start >= 199) {
-	Syntax("Action procedure name is longer than 199 chars","");
-	*error = TRUE;
-	return str;
-    }
-    (void) memmove(procName, start, (size_t) (str-start));
-    procName[str-start] = '\0';
-    *actionProcNameP = XrmStringToQuark( procName );
+    if (str - start >= 199) {
+        Syntax("Action procedure name is longer than 199 chars", "");
+        *error = TRUE;
+        return str;
+    }
+    (void) memmove(procName, start, (size_t) (str - start));
+    procName[str - start] = '\0';
+    *actionProcNameP = XrmStringToQuark(procName);
     return str;
 }
 
-
-static String ParseString(
-    register String str,
-    _XtString *strP)
+static String
+ParseString(register String str, _XtString *strP)
 {
     register String start;
 
     if (*str == '"') {
-	register unsigned prev_len, len;
-	str++;
-	start = str;
-	*strP = NULL;
-	prev_len = 0;
-
-	while (*str != '"' && *str != '\0') {
-	    /* \"  produces double quote embedded in a quoted parameter
-	     * \\" produces backslash as last character of a quoted parameter
-	     */
-	    if (*str == '\\' &&
-		(*(str+1) == '"' || (*(str+1) == '\\' && *(str+2) == '"'))) {
-		len = (unsigned) (prev_len + (str-start+2));
-		*strP = XtRealloc(*strP, len);
-		(void) memmove(*strP + prev_len, start, (size_t) (str-start));
-		prev_len = len-1;
-		str++;
-		(*strP)[prev_len-1] = *str;
-		(*strP)[prev_len] = '\0';
-		start = str+1;
-	    }
-	    str++;
-	}
-	len = (unsigned) (prev_len + (str-start+1));
-	*strP = XtRealloc(*strP, len);
-	(void) memmove( *strP + prev_len, start, (size_t) (str-start));
-	(*strP)[len-1] = '\0';
-	if (*str == '"') str++; else
-            XtWarningMsg(XtNtranslationParseError,"parseString",
-                      XtCXtToolkitError,"Missing '\"'.",
-		      (String *)NULL, (Cardinal *)NULL);
-    } else {
-	/* scan non-quoted string, stop on whitespace, ',' or ')' */
-	start = str;
-	while (*str != ' '
-		&& *str != '\t'
-		&& *str != ','
-		&& *str != ')'
-                && !IsNewline(*str)
-		&& *str != '\0') str++;
-	*strP = __XtMalloc((unsigned)(str-start+1));
-	(void) memmove(*strP, start, (size_t) (str-start));
-	(*strP)[str-start] = '\0';
+        register unsigned prev_len, len;
+
+        str++;
+        start = str;
+        *strP = NULL;
+        prev_len = 0;
+
+        while (*str != '"' && *str != '\0') {
+            /* \"  produces double quote embedded in a quoted parameter
+             * \\" produces backslash as last character of a quoted parameter
+             */
+            if (*str == '\\' &&
+                (*(str + 1) == '"' ||
+                 (*(str + 1) == '\\' && *(str + 2) == '"'))) {
+                len = (unsigned) (prev_len + (str - start + 2));
+                *strP = XtRealloc(*strP, len);
+                (void) memmove(*strP + prev_len, start, (size_t) (str - start));
+                prev_len = len - 1;
+                str++;
+                (*strP)[prev_len - 1] = *str;
+                (*strP)[prev_len] = '\0';
+                start = str + 1;
+            }
+            str++;
+        }
+        len = (unsigned) (prev_len + (str - start + 1));
+        *strP = XtRealloc(*strP, len);
+        (void) memmove(*strP + prev_len, start, (size_t) (str - start));
+        (*strP)[len - 1] = '\0';
+        if (*str == '"')
+            str++;
+        else
+            XtWarningMsg(XtNtranslationParseError, "parseString",
+                         XtCXtToolkitError, "Missing '\"'.",
+                         (String *) NULL, (Cardinal *) NULL);
+    }
+    else {
+        /* scan non-quoted string, stop on whitespace, ',' or ')' */
+        start = str;
+        while (*str != ' '
+               && *str != '\t' && *str != ',' && *str != ')' && !IsNewline(*str)
+               && *str != '\0')
+            str++;
+        *strP = __XtMalloc((unsigned) (str - start + 1));
+        (void) memmove(*strP, start, (size_t) (str - start));
+        (*strP)[str - start] = '\0';
     }
     return str;
 }
 
-
-static String ParseParamSeq(
-    register String str,
-    String **paramSeqP,
-    Cardinal *paramNumP)
+static String
+ParseParamSeq(register String str, String **paramSeqP, Cardinal *paramNumP)
 {
     typedef struct _ParamRec *ParamPtr;
     typedef struct _ParamRec {
-	ParamPtr next;
-	String	param;
+        ParamPtr next;
+        String param;
     } ParamRec;
 
     ParamPtr params = NULL;
@@ -1698,116 +1748,120 @@ static String ParseParamSeq(
 
     ScanWhitespace(str);
     while (*str != ')' && *str != '\0' && !IsNewline(*str)) {
-	_XtString newStr;
-	str = ParseString(str, &newStr);
-	if (newStr != NULL) {
-	    ParamPtr temp = (ParamRec*)
-		ALLOCATE_LOCAL( (unsigned)sizeof(ParamRec) );
-	    if (temp == NULL) _XtAllocError (NULL);
-
-	    num_params++;
-	    temp->next = params;
-	    params = temp;
-	    temp->param = newStr;
-	    ScanWhitespace(str);
-	    if (*str == ',') {
-		str++;
-		ScanWhitespace(str);
-	    }
-	}
+        _XtString newStr;
+
+        str = ParseString(str, &newStr);
+        if (newStr != NULL) {
+            ParamPtr temp = (ParamRec *)
+                ALLOCATE_LOCAL((unsigned) sizeof(ParamRec));
+
+            if (temp == NULL)
+                _XtAllocError(NULL);
+
+            num_params++;
+            temp->next = params;
+            params = temp;
+            temp->param = newStr;
+            ScanWhitespace(str);
+            if (*str == ',') {
+                str++;
+                ScanWhitespace(str);
+            }
+        }
     }
 
     if (num_params != 0) {
-	String *paramP = (String *)
-		__XtMalloc( (Cardinal)((num_params+1) * sizeof(String)) );
-	Cardinal i;
-
-	*paramSeqP = paramP;
-	*paramNumP = num_params;
-	paramP += num_params; /* list is LIFO right now */
-	*paramP-- = NULL;
-	for (i=0; i < num_params; i++) {
-	    ParamPtr next = params->next;
-	    *paramP-- = params->param;
-	    DEALLOCATE_LOCAL( (char *)params );
-	    params = next;
-	}
-    } else {
-	*paramSeqP = NULL;
-	*paramNumP = 0;
+        String *paramP = (String *)
+            __XtMalloc((Cardinal) ((num_params + 1) * sizeof(String)));
+        Cardinal i;
+
+        *paramSeqP = paramP;
+        *paramNumP = num_params;
+        paramP += num_params;   /* list is LIFO right now */
+        *paramP-- = NULL;
+        for (i = 0; i < num_params; i++) {
+            ParamPtr next = params->next;
+
+            *paramP-- = params->param;
+            DEALLOCATE_LOCAL((char *) params);
+            params = next;
+        }
+    }
+    else {
+        *paramSeqP = NULL;
+        *paramNumP = 0;
     }
 
     return str;
 }
 
-static String ParseAction(
-    String str,
-    ActionPtr actionP,
-    XrmQuark* quarkP,
-    Boolean* error)
+static String
+ParseAction(String str, ActionPtr actionP, XrmQuark *quarkP, Boolean *error)
 {
     str = ParseActionProc(str, quarkP, error);
-    if (*error) return str;
+    if (*error)
+        return str;
 
     if (*str == '(') {
-	str++;
-	str = ParseParamSeq(str, &actionP->params, &actionP->num_params);
-    } else {
-        Syntax("Missing '(' while parsing action sequence","");
+        str++;
+        str = ParseParamSeq(str, &actionP->params, &actionP->num_params);
+    }
+    else {
+        Syntax("Missing '(' while parsing action sequence", "");
         *error = TRUE;
         return str;
     }
-    if (*str == ')') str++;
-    else{
-        Syntax("Missing ')' while parsing action sequence","");
+    if (*str == ')')
+        str++;
+    else {
+        Syntax("Missing ')' while parsing action sequence", "");
         *error = TRUE;
         return str;
     }
     return str;
 }
 
-
-static String ParseActionSeq(
-    TMParseStateTree   	parseTree,
-    String 		str,
-    ActionPtr 		*actionsP,
-    Boolean		*error)
+static String
+ParseActionSeq(TMParseStateTree parseTree,
+               String str,
+               ActionPtr *actionsP,
+               Boolean *error)
 {
     ActionPtr *nextActionP;
 
     if ((nextActionP = actionsP) != NULL)
-	*actionsP = NULL;
+        *actionsP = NULL;
 
     while (*str != '\0' && !IsNewline(*str)) {
-	register ActionPtr	action;
-	XrmQuark quark;
+        register ActionPtr action;
+        XrmQuark quark = NULLQUARK;
 
-	action = XtNew(ActionRec);
+        action = XtNew(ActionRec);
         action->params = NULL;
         action->num_params = 0;
         action->next = NULL;
 
-	str = ParseAction(str, action, &quark, error);
-	if (*error) {
-	    XtFree((char *)action);
-	    return PanicModeRecovery(str);
-	}
+        str = ParseAction(str, action, &quark, error);
+        if (*error) {
+            XtFree((char *) action);
+            return PanicModeRecovery(str);
+        }
 
-	action->idx = _XtGetQuarkIndex(parseTree, quark);
-	ScanWhitespace(str);
-	if (nextActionP) {
-	    *nextActionP = action;
-	    nextActionP = &action->next;
-	}
+        action->idx = _XtGetQuarkIndex(parseTree, quark);
+        ScanWhitespace(str);
+        if (nextActionP) {
+            *nextActionP = action;
+            nextActionP = &action->next;
+        }
     }
-    if (IsNewline(*str)) str++;
+    if (IsNewline(*str))
+        str++;
     ScanWhitespace(str);
     return str;
 }
 
-
-static void ShowProduction(
-  String currentProduction)
+static void
+ShowProduction(String currentProduction)
 {
     Cardinal num_params = 1;
     String params[1];
@@ -1815,18 +1869,21 @@ static void ShowProduction(
     char *eol, *production, productionbuf[500];
 
     eol = strchr(currentProduction, '\n');
-    if (eol) len = (size_t) (eol - currentProduction);
-    else len = strlen (currentProduction);
-    production = XtStackAlloc (len + 1, productionbuf);
-    if (production == NULL) _XtAllocError (NULL);
+    if (eol)
+        len = (size_t) (eol - currentProduction);
+    else
+        len = strlen(currentProduction);
+    production = XtStackAlloc(len + 1, productionbuf);
+    if (production == NULL)
+        _XtAllocError(NULL);
     (void) memmove(production, currentProduction, len);
     production[len] = '\0';
 
     params[0] = production;
     XtWarningMsg(XtNtranslationParseError, "showLine", XtCXtToolkitError,
-		 "... found while parsing '%s'", params, &num_params);
+                 "... found while parsing '%s'", params, &num_params);
 
-    XtStackFree (production, productionbuf);
+    XtStackFree(production, productionbuf);
 }
 
 /***********************************************************************
@@ -1834,36 +1891,38 @@ static void ShowProduction(
  * Parses one line of event bindings.
  ***********************************************************************/
 
-static String ParseTranslationTableProduction(
-    TMParseStateTree	 parseTree,
-    register String str,
-    Boolean* error)
+static String
+ParseTranslationTableProduction(TMParseStateTree parseTree,
+                                register String str,
+                                Boolean *error)
 {
-    EventSeqPtr	eventSeq = NULL;
-    ActionPtr	*actionsP;
-    String	production = str;
+    EventSeqPtr eventSeq = NULL;
+    ActionPtr *actionsP;
+    String production = str;
 
     actionsP = NULL;
     str = ParseEventSeq(str, &eventSeq, &actionsP, error);
     if (*error == TRUE) {
-	ShowProduction(production);
-    } else {
-	ScanWhitespace(str);
-	str = ParseActionSeq(parseTree, str, actionsP, error);
-	if (*error == TRUE) {
-	    ShowProduction(production);
-	} else {
-	    _XtAddEventSeqToStateTree(eventSeq, parseTree);
-	}
+        ShowProduction(production);
+    }
+    else {
+        ScanWhitespace(str);
+        str = ParseActionSeq(parseTree, str, actionsP, error);
+        if (*error == TRUE) {
+            ShowProduction(production);
+        }
+        else {
+            _XtAddEventSeqToStateTree(eventSeq, parseTree);
+        }
     }
     FreeEventSeq(eventSeq);
     return (str);
 }
 
-static String CheckForPoundSign(
-    String str,
-    _XtTranslateOp defaultOp,
-    _XtTranslateOp *actualOpRtn)
+static String
+CheckForPoundSign(String str,
+                  _XtTranslateOp defaultOp,
+                  _XtTranslateOp *actualOpRtn)
 {
     _XtTranslateOp opType;
 
@@ -1871,234 +1930,243 @@ static String CheckForPoundSign(
     ScanWhitespace(str);
 
     if (*str == '#') {
-	String start;
-	char operation[20];
-	int len;
-
-	str++;
-	start = str;
-	str = ScanIdent(str);
-	len = MIN(19, (int)(str - start));
-	(void) memmove(operation, start, (size_t) len);
-	operation[len] = '\0';
-	if (!strcmp(operation,"replace"))
-	  opType = XtTableReplace;
-	else if (!strcmp(operation,"augment"))
-	  opType = XtTableAugment;
-	else if (!strcmp(operation,"override"))
-	  opType = XtTableOverride;
-	ScanWhitespace(str);
-	if (IsNewline(*str)) {
-	    str++;
-	    ScanWhitespace(str);
-	}
+        String start;
+        char operation[20];
+        int len;
+
+        str++;
+        start = str;
+        str = ScanIdent(str);
+        len = MIN(19, (int) (str - start));
+        (void) memmove(operation, start, (size_t) len);
+        operation[len] = '\0';
+        if (!strcmp(operation, "replace"))
+            opType = XtTableReplace;
+        else if (!strcmp(operation, "augment"))
+            opType = XtTableAugment;
+        else if (!strcmp(operation, "override"))
+            opType = XtTableOverride;
+        ScanWhitespace(str);
+        if (IsNewline(*str)) {
+            str++;
+            ScanWhitespace(str);
+        }
     }
     *actualOpRtn = opType;
     return str;
 }
 
-static XtTranslations ParseTranslationTable(
-    String 	source,
-    Boolean	isAccelerator,
-    _XtTranslateOp defaultOp,
-    Boolean*	error)
+static XtTranslations
+ParseTranslationTable(String source,
+                      Boolean isAccelerator,
+                      _XtTranslateOp defaultOp,
+                      Boolean *error)
 {
-    XtTranslations		xlations;
-    TMStateTree			stateTrees[8];
-    TMParseStateTreeRec		parseTreeRec, *parseTree = &parseTreeRec;
-    XrmQuark			stackQuarks[200];
-    TMBranchHeadRec		stackBranchHeads[200];
-    StatePtr			stackComplexBranchHeads[200];
-    _XtTranslateOp		actualOp;
+    XtTranslations xlations;
+    TMStateTree stateTrees[8];
+    TMParseStateTreeRec parseTreeRec, *parseTree = &parseTreeRec;
+    XrmQuark stackQuarks[200];
+    TMBranchHeadRec stackBranchHeads[200];
+    StatePtr stackComplexBranchHeads[200];
+    _XtTranslateOp actualOp;
 
     if (source == NULL)
-      return (XtTranslations)NULL;
+        return (XtTranslations) NULL;
 
     source = CheckForPoundSign(source, defaultOp, &actualOp);
     if (isAccelerator && actualOp == XtTableReplace)
-	actualOp = defaultOp;
+        actualOp = defaultOp;
 
     parseTree->isSimple = TRUE;
     parseTree->mappingNotifyInterest = FALSE;
     XtSetBit(parseTree->isAccelerator, isAccelerator);
     parseTree->isStackBranchHeads =
-      parseTree->isStackQuarks =
-	parseTree->isStackComplexBranchHeads = TRUE;
+        parseTree->isStackQuarks = parseTree->isStackComplexBranchHeads = TRUE;
 
     parseTree->numQuarks =
-      parseTree->numBranchHeads =
-	parseTree->numComplexBranchHeads = 0;
+        parseTree->numBranchHeads = parseTree->numComplexBranchHeads = 0;
 
     parseTree->quarkTblSize =
-      parseTree->branchHeadTblSize =
-	parseTree->complexBranchHeadTblSize = 200;
+        parseTree->branchHeadTblSize =
+        parseTree->complexBranchHeadTblSize = 200;
 
     parseTree->quarkTbl = stackQuarks;
     parseTree->branchHeadTbl = stackBranchHeads;
     parseTree->complexBranchHeadTbl = stackComplexBranchHeads;
 
     while (source != NULL && *source != '\0') {
-	source =  ParseTranslationTableProduction(parseTree, source, error);
-	if (*error == TRUE) break;
+        source = ParseTranslationTableProduction(parseTree, source, error);
+        if (*error == TRUE)
+            break;
     }
     stateTrees[0] = _XtParseTreeToStateTree(parseTree);
 
     if (!parseTree->isStackQuarks)
-      XtFree((char *)parseTree->quarkTbl);
+        XtFree((char *) parseTree->quarkTbl);
     if (!parseTree->isStackBranchHeads)
-      XtFree((char *)parseTree->branchHeadTbl);
+        XtFree((char *) parseTree->branchHeadTbl);
     if (!parseTree->isStackComplexBranchHeads)
-      XtFree((char *)parseTree->complexBranchHeadTbl);
+        XtFree((char *) parseTree->complexBranchHeadTbl);
 
     xlations = _XtCreateXlations(stateTrees, 1, NULL, NULL);
     xlations->operation = (unsigned char) actualOp;
 
 #ifdef notdef
     XtFree(stateTrees);
-#endif /* notdef */
+#endif                          /* notdef */
     return xlations;
 }
 
 /*** public procedures ***/
 
-/*ARGSUSED*/
-Boolean XtCvtStringToAcceleratorTable(
-    Display*	dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr from,
-    XrmValuePtr to,
-    XtPointer	*closure)
+Boolean
+XtCvtStringToAcceleratorTable(Display *dpy,
+                              XrmValuePtr args _X_UNUSED,
+                              Cardinal *num_args,
+                              XrmValuePtr from,
+                              XrmValuePtr to,
+                              XtPointer *closure _X_UNUSED)
 {
     String str;
     Boolean error = FALSE;
 
     if (*num_args != 0)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  "wrongParameters","cvtStringToAcceleratorTable",XtCXtToolkitError,
-          "String to AcceleratorTable conversion needs no extra arguments",
-	  (String *)NULL, (Cardinal *)NULL);
-    str = (String)(from->addr);
+                        "wrongParameters", "cvtStringToAcceleratorTable",
+                        XtCXtToolkitError,
+                        "String to AcceleratorTable conversion needs no extra arguments",
+                        (String *) NULL, (Cardinal *) NULL);
+    str = (String) (from->addr);
     if (str == NULL) {
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  "badParameters","cvtStringToAcceleratorTable",XtCXtToolkitError,
-          "String to AcceleratorTable conversion needs string",
-	  (String *)NULL, (Cardinal *)NULL);
-	return FALSE;
+                        "badParameters", "cvtStringToAcceleratorTable",
+                        XtCXtToolkitError,
+                        "String to AcceleratorTable conversion needs string",
+                        (String *) NULL, (Cardinal *) NULL);
+        return FALSE;
     }
     if (to->addr != NULL) {
-	if (to->size < sizeof(XtAccelerators)) {
-	    to->size = sizeof(XtAccelerators);
-	    return FALSE;
-	}
-	*(XtAccelerators*)to->addr =
-	    (XtAccelerators) ParseTranslationTable(str, TRUE, XtTableAugment, &error);
+        if (to->size < sizeof(XtAccelerators)) {
+            to->size = sizeof(XtAccelerators);
+            return FALSE;
+        }
+        *(XtAccelerators *) to->addr =
+            (XtAccelerators) ParseTranslationTable(str, TRUE, XtTableAugment,
+                                                   &error);
     }
     else {
-	static XtAccelerators staticStateTable;
-	staticStateTable =
-	    (XtAccelerators) ParseTranslationTable(str, TRUE, XtTableAugment, &error);
-	to->addr = (XPointer) &staticStateTable;
-	to->size = sizeof(XtAccelerators);
+        static XtAccelerators staticStateTable;
+
+        staticStateTable =
+            (XtAccelerators) ParseTranslationTable(str, TRUE, XtTableAugment,
+                                                   &error);
+        to->addr = (XPointer) &staticStateTable;
+        to->size = sizeof(XtAccelerators);
     }
     if (error == TRUE)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  "parseError","cvtStringToAcceleratorTable",XtCXtToolkitError,
-          "String to AcceleratorTable conversion encountered errors",
-	  (String *)NULL, (Cardinal *)NULL);
+                        "parseError", "cvtStringToAcceleratorTable",
+                        XtCXtToolkitError,
+                        "String to AcceleratorTable conversion encountered errors",
+                        (String *) NULL, (Cardinal *) NULL);
     return (error != TRUE);
 }
 
-
-/*ARGSUSED*/
 Boolean
-XtCvtStringToTranslationTable(
-    Display	*dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr from,
-    XrmValuePtr to,
-    XtPointer	*closure_ret)
+XtCvtStringToTranslationTable(Display *dpy,
+                              XrmValuePtr args _X_UNUSED,
+                              Cardinal *num_args,
+                              XrmValuePtr from,
+                              XrmValuePtr to,
+                              XtPointer *closure_ret _X_UNUSED)
 {
     String str;
     Boolean error = FALSE;
 
     if (*num_args != 0)
-      XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	    "wrongParameters","cvtStringToTranslationTable",XtCXtToolkitError,
-	    "String to TranslationTable conversion needs no extra arguments",
-	    (String *)NULL, (Cardinal *)NULL);
-    str = (String)(from->addr);
+        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
+                        "wrongParameters", "cvtStringToTranslationTable",
+                        XtCXtToolkitError,
+                        "String to TranslationTable conversion needs no extra arguments",
+                        (String *) NULL, (Cardinal *) NULL);
+    str = (String) (from->addr);
     if (str == NULL) {
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  "badParameters","cvtStringToTranslation",XtCXtToolkitError,
-          "String to TranslationTable conversion needs string",
-	  (String *)NULL, (Cardinal *)NULL);
-	return FALSE;
+                        "badParameters", "cvtStringToTranslation",
+                        XtCXtToolkitError,
+                        "String to TranslationTable conversion needs string",
+                        (String *) NULL, (Cardinal *) NULL);
+        return FALSE;
     }
     if (to->addr != NULL) {
-	if (to->size < sizeof(XtTranslations)) {
-	    to->size = sizeof(XtTranslations);
-	    return FALSE;
-	}
-	*(XtTranslations*)to->addr =
-	    ParseTranslationTable(str, FALSE, XtTableReplace, &error);
+        if (to->size < sizeof(XtTranslations)) {
+            to->size = sizeof(XtTranslations);
+            return FALSE;
+        }
+        *(XtTranslations *) to->addr =
+            ParseTranslationTable(str, FALSE, XtTableReplace, &error);
     }
     else {
-	static XtTranslations staticStateTable;
-	staticStateTable =
-	    ParseTranslationTable(str, FALSE, XtTableReplace, &error);
-	to->addr = (XPointer) &staticStateTable;
-	to->size = sizeof(XtTranslations);
+        static XtTranslations staticStateTable;
+
+        staticStateTable =
+            ParseTranslationTable(str, FALSE, XtTableReplace, &error);
+        to->addr = (XPointer) &staticStateTable;
+        to->size = sizeof(XtTranslations);
     }
     if (error == TRUE)
         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
-	  "parseError","cvtStringToTranslationTable",XtCXtToolkitError,
-          "String to TranslationTable conversion encountered errors",
-	  (String *)NULL, (Cardinal *)NULL);
+                        "parseError", "cvtStringToTranslationTable",
+                        XtCXtToolkitError,
+                        "String to TranslationTable conversion encountered errors",
+                        (String *) NULL, (Cardinal *) NULL);
     return (error != TRUE);
 }
 
-
 /*
  * Parses a user's or applications translation table
  */
-XtAccelerators XtParseAcceleratorTable(
-    _Xconst char* source)
+XtAccelerators
+XtParseAcceleratorTable(_Xconst char *source)
 {
     Boolean error = FALSE;
     XtAccelerators ret =
-	(XtAccelerators) ParseTranslationTable ((char *)source, TRUE, XtTableAugment, &error);
+        (XtAccelerators) ParseTranslationTable(source, TRUE, XtTableAugment,
+                                               &error);
+
     if (error == TRUE)
-        XtWarningMsg ("parseError", "cvtStringToAcceleratorTable",
-	  XtCXtToolkitError,
-          "String to AcceleratorTable conversion encountered errors",
-	  (String *)NULL, (Cardinal *)NULL);
+        XtWarningMsg("parseError", "cvtStringToAcceleratorTable",
+                     XtCXtToolkitError,
+                     "String to AcceleratorTable conversion encountered errors",
+                     (String *) NULL, (Cardinal *) NULL);
     return ret;
 }
 
-XtTranslations XtParseTranslationTable(
-    _Xconst char* source)
+XtTranslations
+XtParseTranslationTable(_Xconst char *source)
 {
     Boolean error = FALSE;
-    XtTranslations ret = ParseTranslationTable((char *)source, FALSE, XtTableReplace, &error);
+    XtTranslations ret =
+        ParseTranslationTable(source, FALSE, XtTableReplace, &error);
     if (error == TRUE)
-        XtWarningMsg ("parseError",
-	  "cvtStringToTranslationTable", XtCXtToolkitError,
-          "String to TranslationTable conversion encountered errors",
-	  (String *)NULL, (Cardinal *)NULL);
+        XtWarningMsg("parseError",
+                     "cvtStringToTranslationTable", XtCXtToolkitError,
+                     "String to TranslationTable conversion encountered errors",
+                     (String *) NULL, (Cardinal *) NULL);
     return ret;
 }
 
-void _XtTranslateInitialize(void)
+void
+_XtTranslateInitialize(void)
 {
     LOCK_PROCESS;
     if (initialized) {
-	XtWarningMsg("translationError","xtTranslateInitialize",
-                  XtCXtToolkitError,"Initializing Translation manager twice.",
-                    (String *)NULL, (Cardinal *)NULL);
-	UNLOCK_PROCESS;
-	return;
+        XtWarningMsg("translationError", "xtTranslateInitialize",
+                     XtCXtToolkitError,
+                     "Initializing Translation manager twice.", (String *) NULL,
+                     (Cardinal *) NULL);
+        UNLOCK_PROCESS;
+        return;
     }
 
     initialized = TRUE;
@@ -2106,37 +2174,37 @@ void _XtTranslateInitialize(void)
     QMeta = XrmPermStringToQuark("Meta");
     QCtrl = XrmPermStringToQuark("Ctrl");
     QNone = XrmPermStringToQuark("None");
-    QAny  = XrmPermStringToQuark("Any");
+    QAny = XrmPermStringToQuark("Any");
 
-    Compile_XtEventTable( events, XtNumber(events) );
-    Compile_XtModifierTable( modifiers, XtNumber(modifiers) );
-    CompileNameValueTable( buttonNames );
-    CompileNameValueTable( notifyModes );
-    CompileNameValueTable( motionDetails );
+    Compile_XtEventTable(events, XtNumber(events));
+    Compile_XtModifierTable(modifiers, XtNumber(modifiers));
+    CompileNameValueTable(buttonNames);
+    CompileNameValueTable(notifyModes);
+    CompileNameValueTable(motionDetails);
 #if 0
-    CompileNameValueTable( notifyDetail );
-    CompileNameValueTable( visibilityNotify );
-    CompileNameValueTable( circulation );
-    CompileNameValueTable( propertyChanged );
+    CompileNameValueTable(notifyDetail);
+    CompileNameValueTable(visibilityNotify);
+    CompileNameValueTable(circulation);
+    CompileNameValueTable(propertyChanged);
 #endif
-    CompileNameValueTable( mappingNotify );
+    CompileNameValueTable(mappingNotify);
 }
 
-void _XtAddTMConverters(
-    ConverterTable table)
+void
+_XtAddTMConverters(ConverterTable table)
 {
-     _XtTableAddConverter(table,
-	     _XtQString,
-	     XrmPermStringToQuark(XtRTranslationTable),
- 	     XtCvtStringToTranslationTable, (XtConvertArgList) NULL,
-	     (Cardinal)0, True, CACHED, _XtFreeTranslations, True);
-     _XtTableAddConverter(table, _XtQString,
-	     XrmPermStringToQuark(XtRAcceleratorTable),
- 	     XtCvtStringToAcceleratorTable, (XtConvertArgList) NULL,
-	     (Cardinal)0, True, CACHED, _XtFreeTranslations, True);
-     _XtTableAddConverter(table,
-	     XrmPermStringToQuark( _XtRStateTablePair ),
-	     XrmPermStringToQuark(XtRTranslationTable),
- 	     _XtCvtMergeTranslations, (XtConvertArgList) NULL,
-	     (Cardinal)0, True, CACHED, _XtFreeTranslations, True);
+    _XtTableAddConverter(table,
+                         _XtQString,
+                         XrmPermStringToQuark(XtRTranslationTable),
+                         XtCvtStringToTranslationTable, (XtConvertArgList) NULL,
+                         (Cardinal) 0, True, CACHED, _XtFreeTranslations, True);
+    _XtTableAddConverter(table, _XtQString,
+                         XrmPermStringToQuark(XtRAcceleratorTable),
+                         XtCvtStringToAcceleratorTable, (XtConvertArgList) NULL,
+                         (Cardinal) 0, True, CACHED, _XtFreeTranslations, True);
+    _XtTableAddConverter(table,
+                         XrmPermStringToQuark(_XtRStateTablePair),
+                         XrmPermStringToQuark(XtRTranslationTable),
+                         _XtCvtMergeTranslations, (XtConvertArgList) NULL,
+                         (Cardinal) 0, True, CACHED, _XtFreeTranslations, True);
 }
diff --git a/src/TMprint.c b/src/TMprint.c
index 397189c..1208cbf 100644
--- a/src/TMprint.c
+++ b/src/TMprint.c
@@ -68,71 +68,71 @@ in this Software without prior written authorization from The Open Group.
 
 */
 
-/*LINTLIBRARY*/
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
 #include <stdio.h>
 
-typedef struct _TMStringBufRec{
-    _XtString	start;
-    _XtString	current;
-    Cardinal	max;
-}TMStringBufRec, *TMStringBuf;
-
+typedef struct _TMStringBufRec {
+    _XtString start;
+    _XtString current;
+    Cardinal max;
+} TMStringBufRec, *TMStringBuf;
 
 #define STR_THRESHOLD 25
 #define STR_INCAMOUNT 100
+
 #define CHECK_STR_OVERFLOW(sb) \
-if (sb->current - sb->start > (int)sb->max - STR_THRESHOLD) 	\
-{ _XtString old = sb->start; \
-  sb->start = XtRealloc(old, (Cardinal)(sb->max += STR_INCAMOUNT)); \
-  sb->current = sb->current - old + sb->start; \
-}
+    if (sb->current - sb->start > (int)sb->max - STR_THRESHOLD)           \
+    {                                                                     \
+        _XtString old = sb->start;                                        \
+        sb->start = XtRealloc(old, (Cardinal)(sb->max += STR_INCAMOUNT)); \
+        sb->current = sb->current - old + sb->start;                      \
+    }
 
-#define ExpandForChars(sb, nchars ) \
+#define ExpandForChars(sb, nchars )                                       \
     if ((unsigned)(sb->current - sb->start) > (sb->max - STR_THRESHOLD - (Cardinal) nchars)) { \
-	_XtString old = sb->start;				\
-	sb->start = XtRealloc(old,				\
-	    (Cardinal)(sb->max = (Cardinal)(sb->max + STR_INCAMOUNT + (Cardinal) nchars)));	\
-	sb->current = sb->current - old + sb->start;		\
+        _XtString old = sb->start;                                        \
+        sb->start = XtRealloc(old,                                        \
+            (Cardinal)(sb->max = (Cardinal)(sb->max + STR_INCAMOUNT + (Cardinal) nchars)));     \
+        sb->current = sb->current - old + sb->start;                      \
     }
 
 #define ExpandToFit(sb, more) \
-{								\
-	size_t l = strlen(more);				\
-	ExpandForChars(sb, l);					\
+{                                                               \
+        size_t l = strlen(more);                                \
+        ExpandForChars(sb, l);                                  \
       }
 
-static void PrintModifiers(
-    TMStringBuf	sb,
-    unsigned long mask, unsigned long mod)
+static void
+PrintModifiers(TMStringBuf sb, unsigned long mask, unsigned long mod)
 {
     Boolean notfirst = False;
+
     CHECK_STR_OVERFLOW(sb);
 
     if (mask == ~0UL && mod == 0) {
-	*sb->current++ = '!';
-	*sb->current = '\0';
-	return;
+        *sb->current++ = '!';
+        *sb->current = '\0';
+        return;
     }
 
-#define PRINTMOD(modmask,modstring) \
-    if (mask & modmask) {		 \
-	if (! (mod & modmask)) {	 \
-	    *sb->current++ = '~';		 \
-	    notfirst = True;		 \
-	}				 \
-	else if (notfirst)		 \
-	    *sb->current++ = ' ';		 \
-	else notfirst = True;		 \
-	strcpy(sb->current, modstring);		 \
-	sb->current += strlen(sb->current);		 \
+#define PRINTMOD(modmask,modstring)                     \
+    if (mask & modmask) {                               \
+        if (! (mod & modmask)) {                        \
+            *sb->current++ = '~';                       \
+            notfirst = True;                            \
+        }                                               \
+        else if (notfirst)                              \
+            *sb->current++ = ' ';                       \
+        else notfirst = True;                           \
+        strcpy(sb->current, modstring);                 \
+        sb->current += strlen(sb->current);             \
     }
 
     PRINTMOD(ShiftMask, "Shift");
-    PRINTMOD(ControlMask, "Ctrl");	/* name is not CtrlMask... */
+    PRINTMOD(ControlMask, "Ctrl");      /* name is not CtrlMask... */
     PRINTMOD(LockMask, "Lock");
     PRINTMOD(Mod1Mask, "Mod1");
     CHECK_STR_OVERFLOW(sb);
@@ -152,220 +152,219 @@ static void PrintModifiers(
 #undef PRINTMOD
 }
 
-static void PrintEventType(
-    TMStringBuf	sb,
-    unsigned long event)
+static void
+PrintEventType(TMStringBuf sb, unsigned long event)
 {
     CHECK_STR_OVERFLOW(sb);
     switch (event) {
 #define PRINTEVENT(event, name) case event: (void) strcpy(sb->current, name); break;
-	PRINTEVENT(KeyPress, "<KeyPress>")
-	PRINTEVENT(KeyRelease, "<KeyRelease>")
-	PRINTEVENT(ButtonPress, "<ButtonPress>")
-	PRINTEVENT(ButtonRelease, "<ButtonRelease>")
-	PRINTEVENT(MotionNotify, "<MotionNotify>")
-	PRINTEVENT(EnterNotify, "<EnterNotify>")
-	PRINTEVENT(LeaveNotify, "<LeaveNotify>")
-	PRINTEVENT(FocusIn, "<FocusIn>")
-	PRINTEVENT(FocusOut, "<FocusOut>")
-	PRINTEVENT(KeymapNotify, "<KeymapNotify>")
-	PRINTEVENT(Expose, "<Expose>")
-	PRINTEVENT(GraphicsExpose, "<GraphicsExpose>")
-	PRINTEVENT(NoExpose, "<NoExpose>")
-	PRINTEVENT(VisibilityNotify, "<VisibilityNotify>")
-	PRINTEVENT(CreateNotify, "<CreateNotify>")
-	PRINTEVENT(DestroyNotify, "<DestroyNotify>")
-	PRINTEVENT(UnmapNotify, "<UnmapNotify>")
-	PRINTEVENT(MapNotify, "<MapNotify>")
-	PRINTEVENT(MapRequest, "<MapRequest>")
-	PRINTEVENT(ReparentNotify, "<ReparentNotify>")
-	PRINTEVENT(ConfigureNotify, "<ConfigureNotify>")
-	PRINTEVENT(ConfigureRequest, "<ConfigureRequest>")
-	PRINTEVENT(GravityNotify, "<GravityNotify>")
-	PRINTEVENT(ResizeRequest, "<ResizeRequest>")
-	PRINTEVENT(CirculateNotify, "<CirculateNotify>")
-	PRINTEVENT(CirculateRequest, "<CirculateRequest>")
-	PRINTEVENT(PropertyNotify, "<PropertyNotify>")
-	PRINTEVENT(SelectionClear, "<SelectionClear>")
-	PRINTEVENT(SelectionRequest, "<SelectionRequest>")
-	PRINTEVENT(SelectionNotify, "<SelectionNotify>")
-	PRINTEVENT(ColormapNotify, "<ColormapNotify>")
-	PRINTEVENT(ClientMessage, "<ClientMessage>")
-	case _XtEventTimerEventType:
-	    (void) strcpy(sb->current,"<EventTimer>");
-	    break;
-	default:
-	    (void) sprintf(sb->current, "<0x%x>", (int) event);
+        PRINTEVENT(KeyPress, "<KeyPress>")
+            PRINTEVENT(KeyRelease, "<KeyRelease>")
+            PRINTEVENT(ButtonPress, "<ButtonPress>")
+            PRINTEVENT(ButtonRelease, "<ButtonRelease>")
+            PRINTEVENT(MotionNotify, "<MotionNotify>")
+            PRINTEVENT(EnterNotify, "<EnterNotify>")
+            PRINTEVENT(LeaveNotify, "<LeaveNotify>")
+            PRINTEVENT(FocusIn, "<FocusIn>")
+            PRINTEVENT(FocusOut, "<FocusOut>")
+            PRINTEVENT(KeymapNotify, "<KeymapNotify>")
+            PRINTEVENT(Expose, "<Expose>")
+            PRINTEVENT(GraphicsExpose, "<GraphicsExpose>")
+            PRINTEVENT(NoExpose, "<NoExpose>")
+            PRINTEVENT(VisibilityNotify, "<VisibilityNotify>")
+            PRINTEVENT(CreateNotify, "<CreateNotify>")
+            PRINTEVENT(DestroyNotify, "<DestroyNotify>")
+            PRINTEVENT(UnmapNotify, "<UnmapNotify>")
+            PRINTEVENT(MapNotify, "<MapNotify>")
+            PRINTEVENT(MapRequest, "<MapRequest>")
+            PRINTEVENT(ReparentNotify, "<ReparentNotify>")
+            PRINTEVENT(ConfigureNotify, "<ConfigureNotify>")
+            PRINTEVENT(ConfigureRequest, "<ConfigureRequest>")
+            PRINTEVENT(GravityNotify, "<GravityNotify>")
+            PRINTEVENT(ResizeRequest, "<ResizeRequest>")
+            PRINTEVENT(CirculateNotify, "<CirculateNotify>")
+            PRINTEVENT(CirculateRequest, "<CirculateRequest>")
+            PRINTEVENT(PropertyNotify, "<PropertyNotify>")
+            PRINTEVENT(SelectionClear, "<SelectionClear>")
+            PRINTEVENT(SelectionRequest, "<SelectionRequest>")
+            PRINTEVENT(SelectionNotify, "<SelectionNotify>")
+            PRINTEVENT(ColormapNotify, "<ColormapNotify>")
+            PRINTEVENT(ClientMessage, "<ClientMessage>")
+    case _XtEventTimerEventType:
+        (void) strcpy(sb->current, "<EventTimer>");
+        break;
+    default:
+        (void) sprintf(sb->current, "<0x%x>", (int) event);
 #undef PRINTEVENT
     }
     sb->current += strlen(sb->current);
 }
 
-static void PrintCode(
-    TMStringBuf sb,
-    unsigned long mask, unsigned long code)
+static void
+PrintCode(TMStringBuf sb, unsigned long mask, unsigned long code)
 {
     CHECK_STR_OVERFLOW(sb);
     if (mask != 0) {
-	if (mask != ~0UL)
-	    (void) sprintf(sb->current, "0x%lx:0x%lx", mask, code);
-	else (void) sprintf(sb->current, /*"0x%lx"*/ "%u", (unsigned)code);
-	sb->current += strlen(sb->current);
+        if (mask != ~0UL)
+            (void) sprintf(sb->current, "0x%lx:0x%lx", mask, code);
+        else
+            (void) sprintf(sb->current, /*"0x%lx" */ "%u", (unsigned) code);
+        sb->current += strlen(sb->current);
     }
 }
 
-static void PrintKeysym(
-    TMStringBuf sb,
-    KeySym keysym)
+static void
+PrintKeysym(TMStringBuf sb, KeySym keysym)
 {
     String keysymName;
 
-    if (keysym == 0) return;
+    if (keysym == 0)
+        return;
 
     CHECK_STR_OVERFLOW(sb);
     keysymName = XKeysymToString(keysym);
     if (keysymName == NULL)
-      PrintCode(sb,~0UL,(unsigned long)keysym);
+        PrintCode(sb, ~0UL, (unsigned long) keysym);
     else {
-      ExpandToFit(sb, keysymName);
-      strcpy(sb->current, keysymName);
-      sb->current += strlen(sb->current);
+        ExpandToFit(sb, keysymName);
+        strcpy(sb->current, keysymName);
+        sb->current += strlen(sb->current);
     }
 }
 
-static void PrintAtom(
-    TMStringBuf sb,
-    Display *dpy,
-    Atom atom)
+static void
+PrintAtom(TMStringBuf sb, Display *dpy, Atom atom)
 {
     _XtString atomName;
 
-    if (atom == 0) return;
+    if (atom == 0)
+        return;
 
     atomName = (dpy ? XGetAtomName(dpy, atom) : NULL);
 
-    if (! atomName)
-      PrintCode(sb,~0UL,(unsigned long)atom);
+    if (!atomName)
+        PrintCode(sb, ~0UL, (unsigned long) atom);
     else {
-      ExpandToFit( sb, atomName );
-      strcpy(sb->current, atomName);
-      sb->current += strlen(sb->current);
-      XFree(atomName);
+        ExpandToFit(sb, atomName);
+        strcpy(sb->current, atomName);
+        sb->current += strlen(sb->current);
+        XFree(atomName);
     }
 }
 
-static	void PrintLateModifiers(
-    TMStringBuf	sb,
-    LateBindingsPtr lateModifiers)
+static void
+PrintLateModifiers(TMStringBuf sb, LateBindingsPtr lateModifiers)
 {
     for (; lateModifiers->keysym; lateModifiers++) {
-	CHECK_STR_OVERFLOW(sb);
-	if (lateModifiers->knot) {
-	    *sb->current++ = '~';
-	} else {
-	    *sb->current++ = ' ';
-	}
-	strcpy(sb->current, XKeysymToString(lateModifiers->keysym));
-	sb->current += strlen(sb->current);
-	if (lateModifiers->pair) {
-	    *(sb->current -= 2) = '\0';	/* strip "_L" */
-	    lateModifiers++;	/* skip _R keysym */
-	}
+        CHECK_STR_OVERFLOW(sb);
+        if (lateModifiers->knot) {
+            *sb->current++ = '~';
+        }
+        else {
+            *sb->current++ = ' ';
+        }
+        strcpy(sb->current, XKeysymToString(lateModifiers->keysym));
+        sb->current += strlen(sb->current);
+        if (lateModifiers->pair) {
+            *(sb->current -= 2) = '\0'; /* strip "_L" */
+            lateModifiers++;    /* skip _R keysym */
+        }
     }
 }
 
-static void PrintEvent(
-    TMStringBuf sb,
-    register TMTypeMatch typeMatch,
-    register TMModifierMatch modMatch,
-    Display *dpy)
+static void
+PrintEvent(TMStringBuf sb,
+           register TMTypeMatch typeMatch,
+           register TMModifierMatch modMatch,
+           Display *dpy)
 {
-    if (modMatch->standard) *sb->current++ = ':';
+    if (modMatch->standard)
+        *sb->current++ = ':';
 
     PrintModifiers(sb, modMatch->modifierMask, modMatch->modifiers);
     if (modMatch->lateModifiers != NULL)
-      PrintLateModifiers(sb, modMatch->lateModifiers);
+        PrintLateModifiers(sb, modMatch->lateModifiers);
     PrintEventType(sb, typeMatch->eventType);
     switch (typeMatch->eventType) {
-      case KeyPress:
-      case KeyRelease:
-	PrintKeysym(sb, (KeySym)typeMatch->eventCode);
-	break;
-
-      case PropertyNotify:
-      case SelectionClear:
-      case SelectionRequest:
-      case SelectionNotify:
-      case ClientMessage:
-	PrintAtom(sb, dpy, (Atom)typeMatch->eventCode);
-	break;
-
-      default:
-	PrintCode(sb, typeMatch->eventCodeMask, typeMatch->eventCode);
+    case KeyPress:
+    case KeyRelease:
+        PrintKeysym(sb, (KeySym) typeMatch->eventCode);
+        break;
+
+    case PropertyNotify:
+    case SelectionClear:
+    case SelectionRequest:
+    case SelectionNotify:
+    case ClientMessage:
+        PrintAtom(sb, dpy, (Atom) typeMatch->eventCode);
+        break;
+
+    default:
+        PrintCode(sb, typeMatch->eventCodeMask, typeMatch->eventCode);
     }
 }
 
-static void PrintParams(
-    TMStringBuf	sb,
-    String	*params,
-    Cardinal num_params)
+static void
+PrintParams(TMStringBuf sb, String *params, Cardinal num_params)
 {
     register Cardinal i;
-    for (i = 0; i<num_params; i++) {
-	ExpandToFit( sb, params[i] );
-	if (i != 0) {
-	    *sb->current++ = ',';
-	    *sb->current++ = ' ';
-	}
-	*sb->current++ = '"';
-	strcpy(sb->current, params[i]);
-	sb->current += strlen(sb->current);
-	*sb->current++ = '"';
+
+    for (i = 0; i < num_params; i++) {
+        ExpandToFit(sb, params[i]);
+        if (i != 0) {
+            *sb->current++ = ',';
+            *sb->current++ = ' ';
+        }
+        *sb->current++ = '"';
+        strcpy(sb->current, params[i]);
+        sb->current += strlen(sb->current);
+        *sb->current++ = '"';
     }
     *sb->current = '\0';
 }
 
-static void PrintActions(
-    TMStringBuf	sb,
-    register ActionPtr actions,
-    XrmQuark *quarkTbl,
-    Widget   accelWidget)
+static void
+PrintActions(TMStringBuf sb,
+             register ActionPtr actions,
+             XrmQuark *quarkTbl,
+             Widget accelWidget)
 {
     while (actions != NULL) {
-	String proc;
-
-	*sb->current++ = ' ';
-
-	if (accelWidget) {
-	    /* accelerator */
-	    String name = XtName(accelWidget);
-	    int nameLen = (int) strlen(name);
-	    ExpandForChars(sb,  nameLen );
-	    XtMemmove(sb->current, name, nameLen );
-	    sb->current += nameLen;
-	    *sb->current++ = '`';
-	}
-	proc = XrmQuarkToString(quarkTbl[actions->idx]);
-	ExpandToFit( sb, proc );
-	strcpy(sb->current, proc);
-	sb->current += strlen(proc);
-	*sb->current++ = '(';
-	PrintParams(sb, actions->params, actions->num_params);
-	*sb->current++ = ')';
-	actions = actions->next;
+        String proc;
+
+        *sb->current++ = ' ';
+
+        if (accelWidget) {
+            /* accelerator */
+            String name = XtName(accelWidget);
+            int nameLen = (int) strlen(name);
+
+            ExpandForChars(sb, nameLen);
+            XtMemmove(sb->current, name, nameLen);
+            sb->current += nameLen;
+            *sb->current++ = '`';
+        }
+        proc = XrmQuarkToString(quarkTbl[actions->idx]);
+        ExpandToFit(sb, proc);
+        strcpy(sb->current, proc);
+        sb->current += strlen(proc);
+        *sb->current++ = '(';
+        PrintParams(sb, actions->params, actions->num_params);
+        *sb->current++ = ')';
+        actions = actions->next;
     }
     *sb->current = '\0';
 }
 
-static Boolean LookAheadForCycleOrMulticlick(
-    register StatePtr state,
-    StatePtr *state_return,	/* state to print, usually startState */
-    int *countP,
-    StatePtr *nextLevelP)
+static Boolean
+LookAheadForCycleOrMulticlick(register StatePtr state,
+                              StatePtr *state_return, /* state to print, usually startState */
+                              int *countP,
+                              StatePtr *nextLevelP)
 {
     int repeatCount = 0;
-    StatePtr	startState = state;
-    Boolean	isCycle = startState->isCycleEnd;
+    StatePtr startState = state;
+    Boolean isCycle = startState->isCycleEnd;
     TMTypeMatch sTypeMatch;
     TMModifierMatch sModMatch;
 
@@ -376,524 +375,503 @@ static Boolean LookAheadForCycleOrMulticlick(
     *state_return = startState;
 
     for (state = state->nextLevel; state != NULL; state = state->nextLevel) {
-	TMTypeMatch typeMatch = TMGetTypeMatch(state->typeIndex);
-	TMModifierMatch modMatch = TMGetModifierMatch(state->modIndex);
-
-	/* try to pick up the correct state with actions, to be printed */
-	/* This is to accommodate <ButtonUp>(2+), for example */
-	if (state->isCycleStart)
-	    *state_return = state;
-
-	if (state->isCycleEnd) {
-	    *countP = repeatCount;
-	    UNLOCK_PROCESS;
-	    return True;
-	}
-	if ((startState->typeIndex == state->typeIndex) &&
-	    (startState->modIndex == state->modIndex)) {
-	    repeatCount++;
-	    *nextLevelP = state;
-	}
-	else if (typeMatch->eventType == _XtEventTimerEventType)
-	  continue;
-	else /* not same event as starting event and not timer */ {
-	    unsigned int type = (unsigned) sTypeMatch->eventType;
-	    unsigned int t = (unsigned) typeMatch->eventType;
-	    if (   (type == ButtonPress	  && t != ButtonRelease)
-		|| (type == ButtonRelease && t != ButtonPress)
-		|| (type == KeyPress	  && t != KeyRelease)
-		|| (type == KeyRelease	  && t != KeyPress)
-		|| typeMatch->eventCode != sTypeMatch->eventCode
-		|| modMatch->modifiers != sModMatch->modifiers
-		|| modMatch->modifierMask != sModMatch->modifierMask
-		|| modMatch->lateModifiers != sModMatch->lateModifiers
-		|| typeMatch->eventCodeMask != sTypeMatch->eventCodeMask
-		|| typeMatch->matchEvent != sTypeMatch->matchEvent
-		|| modMatch->standard != sModMatch->standard)
-		/* not inverse of starting event, either */
-		break;
-	}
+        TMTypeMatch typeMatch = TMGetTypeMatch(state->typeIndex);
+        TMModifierMatch modMatch = TMGetModifierMatch(state->modIndex);
+
+        /* try to pick up the correct state with actions, to be printed */
+        /* This is to accommodate <ButtonUp>(2+), for example */
+        if (state->isCycleStart)
+            *state_return = state;
+
+        if (state->isCycleEnd) {
+            *countP = repeatCount;
+            UNLOCK_PROCESS;
+            return True;
+        }
+        if ((startState->typeIndex == state->typeIndex) &&
+            (startState->modIndex == state->modIndex)) {
+            repeatCount++;
+            *nextLevelP = state;
+        }
+        else if (typeMatch->eventType == _XtEventTimerEventType)
+            continue;
+        else {                  /* not same event as starting event and not timer */
+
+            unsigned int type = (unsigned) sTypeMatch->eventType;
+            unsigned int t = (unsigned) typeMatch->eventType;
+
+            if ((type == ButtonPress && t != ButtonRelease)
+                || (type == ButtonRelease && t != ButtonPress)
+                || (type == KeyPress && t != KeyRelease)
+                || (type == KeyRelease && t != KeyPress)
+                || typeMatch->eventCode != sTypeMatch->eventCode
+                || modMatch->modifiers != sModMatch->modifiers
+                || modMatch->modifierMask != sModMatch->modifierMask
+                || modMatch->lateModifiers != sModMatch->lateModifiers
+                || typeMatch->eventCodeMask != sTypeMatch->eventCodeMask
+                || typeMatch->matchEvent != sTypeMatch->matchEvent
+                || modMatch->standard != sModMatch->standard)
+                /* not inverse of starting event, either */
+                break;
+        }
     }
     *countP = repeatCount;
     UNLOCK_PROCESS;
     return isCycle;
 }
 
-static void PrintComplexState(
-    TMStringBuf	sb,
-    Boolean	includeRHS,
-    StatePtr 	state,
-    TMStateTree stateTree,
-    Widget	accelWidget,
-    Display 	*dpy)
+static void
+PrintComplexState(TMStringBuf sb,
+                  Boolean includeRHS,
+                  StatePtr state,
+                  TMStateTree stateTree,
+                  Widget accelWidget,
+                  Display *dpy)
 {
-    int 		clickCount = 0;
-    Boolean 		cycle;
-    StatePtr 		nextLevel = NULL;
-    StatePtr		triggerState = NULL;
+    int clickCount = 0;
+    Boolean cycle;
+    StatePtr nextLevel = NULL;
+    StatePtr triggerState = NULL;
 
     /* print the current state */
-    if (! state) return;
+    if (!state)
+        return;
     LOCK_PROCESS;
     cycle = LookAheadForCycleOrMulticlick(state, &triggerState, &clickCount,
-					  &nextLevel);
+                                          &nextLevel);
 
     PrintEvent(sb, TMGetTypeMatch(triggerState->typeIndex),
-	       TMGetModifierMatch(triggerState->modIndex), dpy);
+               TMGetModifierMatch(triggerState->modIndex), dpy);
 
     if (cycle || clickCount) {
-	if (clickCount)
-	    sprintf(sb->current, "(%d%s)", clickCount+1, cycle ? "+" : "");
-	else
-	    (void) strncpy(sb->current, "(+)", 4);
-	sb->current += strlen(sb->current);
-	if (! state->actions && nextLevel)
-	    state = nextLevel;
-	while (! state->actions && ! state->isCycleEnd)
-	    state = state->nextLevel;	/* should be trigger state */
+        if (clickCount)
+            sprintf(sb->current, "(%d%s)", clickCount + 1, cycle ? "+" : "");
+        else
+            (void) strncpy(sb->current, "(+)", 4);
+        sb->current += strlen(sb->current);
+        if (!state->actions && nextLevel)
+            state = nextLevel;
+        while (!state->actions && !state->isCycleEnd)
+            state = state->nextLevel;   /* should be trigger state */
     }
 
     if (state->actions) {
-	if (includeRHS) {
-	    CHECK_STR_OVERFLOW(sb);
-	    *sb->current++ = ':';
-	    PrintActions(sb,
-			 state->actions,
-			 ((TMSimpleStateTree)stateTree)->quarkTbl,
-			 accelWidget);
-	    *sb->current++ = '\n';
-	}
+        if (includeRHS) {
+            CHECK_STR_OVERFLOW(sb);
+            *sb->current++ = ':';
+            PrintActions(sb,
+                         state->actions,
+                         ((TMSimpleStateTree) stateTree)->quarkTbl,
+                         accelWidget);
+            *sb->current++ = '\n';
+        }
     }
     else {
-	if (state->nextLevel && !cycle && !clickCount)
-	    *sb->current++ = ',';
-	else {
-	    /* no actions are attached to this production */
-	    *sb->current++ = ':';
-	    *sb->current++ = '\n';
-	}
+        if (state->nextLevel && !cycle && !clickCount)
+            *sb->current++ = ',';
+        else {
+            /* no actions are attached to this production */
+            *sb->current++ = ':';
+            *sb->current++ = '\n';
+        }
     }
     *sb->current = '\0';
 
     /* print succeeding states */
     if (state->nextLevel && !cycle && !clickCount)
-	PrintComplexState(sb, includeRHS, state->nextLevel,
-			  stateTree, accelWidget, dpy);
+        PrintComplexState(sb, includeRHS, state->nextLevel,
+                          stateTree, accelWidget, dpy);
     UNLOCK_PROCESS;
 }
 
-typedef struct{
-    TMShortCard	tIndex;
-    TMShortCard	bIndex;
-}PrintRec, *Print;
-
-static int FindNextMatch(
-    PrintRec		*printData,
-    TMShortCard		numPrints,
-    XtTranslations 	xlations,
-    TMBranchHead	branchHead,
-    StatePtr 		nextLevel,
-    TMShortCard		startIndex)
+typedef struct {
+    TMShortCard tIndex;
+    TMShortCard bIndex;
+} PrintRec, *Print;
+
+static int
+FindNextMatch(PrintRec *printData,
+              TMShortCard numPrints,
+              XtTranslations xlations,
+              TMBranchHead branchHead,
+              StatePtr nextLevel,
+              TMShortCard startIndex)
 {
-    TMShortCard		i;
-    StatePtr		currState, candState;
-    Boolean		noMatch = True;
+    TMShortCard i;
+    StatePtr currState, candState;
+    Boolean noMatch = True;
 
     for (i = startIndex; noMatch && i < numPrints; i++) {
-	TMBranchHead prBranchHead;
-	TMComplexStateTree stateTree;
-
-	stateTree = (TMComplexStateTree)
-	  xlations->stateTreeTbl[printData[i].tIndex];
-	prBranchHead =
-	  &(stateTree->branchHeadTbl[printData[i].bIndex]);
-
-	if ((prBranchHead->typeIndex == branchHead->typeIndex) &&
-	    (prBranchHead->modIndex == branchHead->modIndex)) {
-	    if (prBranchHead->isSimple) {
-		if (!nextLevel)
-		  return i;
-	    }
-	    else {
-		currState = TMComplexBranchHead(stateTree, prBranchHead);
-		currState = currState->nextLevel;
-		candState = nextLevel;
-		for (;
-		     ((currState && !currState->isCycleEnd) &&
-		      (candState && !candState->isCycleEnd));
-		     currState = currState->nextLevel,
-		     candState = candState->nextLevel) {
-		    if ((currState->typeIndex != candState->typeIndex) ||
-			(currState->modIndex != candState->modIndex))
-		      break;
-		}
-		if (candState == currState) {
-		    return i;
-		}
-	    }
-	}
+        TMBranchHead prBranchHead;
+        TMComplexStateTree stateTree;
+
+        stateTree = (TMComplexStateTree)
+            xlations->stateTreeTbl[printData[i].tIndex];
+        prBranchHead = &(stateTree->branchHeadTbl[printData[i].bIndex]);
+
+        if ((prBranchHead->typeIndex == branchHead->typeIndex) &&
+            (prBranchHead->modIndex == branchHead->modIndex)) {
+            if (prBranchHead->isSimple) {
+                if (!nextLevel)
+                    return i;
+            }
+            else {
+                currState = TMComplexBranchHead(stateTree, prBranchHead);
+                currState = currState->nextLevel;
+                candState = nextLevel;
+                for (;
+                     ((currState && !currState->isCycleEnd) &&
+                      (candState && !candState->isCycleEnd));
+                     currState = currState->nextLevel,
+                     candState = candState->nextLevel) {
+                    if ((currState->typeIndex != candState->typeIndex) ||
+                        (currState->modIndex != candState->modIndex))
+                        break;
+                }
+                if (candState == currState) {
+                    return i;
+                }
+            }
+        }
     }
     return TM_NO_MATCH;
 }
 
-static void ProcessLaterMatches(
-    PrintRec	*printData,
-    XtTranslations xlations,
-    TMShortCard	tIndex,
-    int bIndex,
-    TMShortCard	*numPrintsRtn)
+static void
+ProcessLaterMatches(PrintRec *printData,
+                    XtTranslations xlations,
+                    TMShortCard tIndex,
+                    int bIndex,
+                    TMShortCard *numPrintsRtn)
 {
-    TMComplexStateTree 	stateTree;
-    int			i, j;
-    TMBranchHead	branchHead, matchBranch = NULL;
-
-    for (i = tIndex; i < (int)xlations->numStateTrees; i++) {
-	stateTree = (TMComplexStateTree)xlations->stateTreeTbl[i];
-	if (i == tIndex) {
-	    matchBranch = &stateTree->branchHeadTbl[bIndex];
-	    j = bIndex+1;
-	}
-	else j = 0;
-	for (branchHead = &stateTree->branchHeadTbl[j];
-	     j < (int)stateTree->numBranchHeads;
-	     j++, branchHead++) {
-	    if ((branchHead->typeIndex == matchBranch->typeIndex) &&
-		(branchHead->modIndex == matchBranch->modIndex)) {
-		StatePtr state;
-		if (!branchHead->isSimple)
-		  state = TMComplexBranchHead(stateTree, branchHead);
-		else
-		  state = NULL;
-		if ((!branchHead->isSimple || branchHead->hasActions) &&
-		    (FindNextMatch(printData,
-				   *numPrintsRtn,
-				   xlations,
-				   branchHead,
-				   (state ? state->nextLevel : NULL),
-				   0) == TM_NO_MATCH)) {
-		    printData[*numPrintsRtn].tIndex = (TMShortCard) i;
-		    printData[*numPrintsRtn].bIndex = (TMShortCard) j;
-		    (*numPrintsRtn)++;
-		}
-	    }
-	}
+    TMComplexStateTree stateTree;
+    int i, j;
+    TMBranchHead branchHead, matchBranch = NULL;
+
+    for (i = tIndex; i < (int) xlations->numStateTrees; i++) {
+        stateTree = (TMComplexStateTree) xlations->stateTreeTbl[i];
+        if (i == tIndex) {
+            matchBranch = &stateTree->branchHeadTbl[bIndex];
+            j = bIndex + 1;
+        }
+        else
+            j = 0;
+        for (branchHead = &stateTree->branchHeadTbl[j];
+             j < (int) stateTree->numBranchHeads; j++, branchHead++) {
+            if ((branchHead->typeIndex == matchBranch->typeIndex) &&
+                (branchHead->modIndex == matchBranch->modIndex)) {
+                StatePtr state;
+
+                if (!branchHead->isSimple)
+                    state = TMComplexBranchHead(stateTree, branchHead);
+                else
+                    state = NULL;
+                if ((!branchHead->isSimple || branchHead->hasActions) &&
+                    (FindNextMatch(printData,
+                                   *numPrintsRtn,
+                                   xlations,
+                                   branchHead,
+                                   (state ? state->nextLevel : NULL),
+                                   0) == TM_NO_MATCH)) {
+                    printData[*numPrintsRtn].tIndex = (TMShortCard) i;
+                    printData[*numPrintsRtn].bIndex = (TMShortCard) j;
+                    (*numPrintsRtn)++;
+                }
+            }
+        }
     }
 }
 
-static void ProcessStateTree(
-    PrintRec	*printData,
-    XtTranslations xlations,
-    TMShortCard	tIndex,
-    TMShortCard	*numPrintsRtn)
+static void
+ProcessStateTree(PrintRec *printData,
+                 XtTranslations xlations,
+                 TMShortCard tIndex,
+                 TMShortCard *numPrintsRtn)
 {
     TMComplexStateTree stateTree;
-    int			i;
-    TMBranchHead	branchHead;
+    int i;
+    TMBranchHead branchHead;
 
-    stateTree = (TMComplexStateTree)xlations->stateTreeTbl[tIndex];
+    stateTree = (TMComplexStateTree) xlations->stateTreeTbl[tIndex];
 
     for (i = 0, branchHead = stateTree->branchHeadTbl;
-	 i < (int)stateTree->numBranchHeads;
-	 i++, branchHead++) {
-	StatePtr state;
-	if (!branchHead->isSimple)
-	  state = TMComplexBranchHead(stateTree, branchHead);
-	else
-	  state = NULL;
-	if (FindNextMatch(printData, *numPrintsRtn, xlations, branchHead,
-			  (state ? state->nextLevel : NULL), 0)
-	    == TM_NO_MATCH) {
-	    if (!branchHead->isSimple || branchHead->hasActions) {
-		printData[*numPrintsRtn].tIndex = tIndex;
-		printData[*numPrintsRtn].bIndex = (TMShortCard) i;
-		(*numPrintsRtn)++;
-	    }
-	    LOCK_PROCESS;
-	    if (_XtGlobalTM.newMatchSemantics == False)
-	      ProcessLaterMatches(printData,
-				  xlations,
-				  tIndex,
-				  i,
-				  numPrintsRtn);
-	    UNLOCK_PROCESS;
-	}
+         i < (int) stateTree->numBranchHeads; i++, branchHead++) {
+        StatePtr state;
+
+        if (!branchHead->isSimple)
+            state = TMComplexBranchHead(stateTree, branchHead);
+        else
+            state = NULL;
+        if (FindNextMatch(printData, *numPrintsRtn, xlations, branchHead,
+                          (state ? state->nextLevel : NULL), 0)
+            == TM_NO_MATCH) {
+            if (!branchHead->isSimple || branchHead->hasActions) {
+                printData[*numPrintsRtn].tIndex = tIndex;
+                printData[*numPrintsRtn].bIndex = (TMShortCard) i;
+                (*numPrintsRtn)++;
+            }
+            LOCK_PROCESS;
+            if (_XtGlobalTM.newMatchSemantics == False)
+                ProcessLaterMatches(printData,
+                                    xlations, tIndex, i, numPrintsRtn);
+            UNLOCK_PROCESS;
+        }
     }
 }
 
-static void PrintState(
-    TMStringBuf	sb,
-    TMStateTree	tree,
-    TMBranchHead branchHead,
-    Boolean	includeRHS,
-    Widget	accelWidget,
-    Display 	*dpy)
+static void
+PrintState(TMStringBuf sb,
+           TMStateTree tree,
+           TMBranchHead branchHead,
+           Boolean includeRHS,
+           Widget accelWidget,
+           Display *dpy)
 {
-    TMComplexStateTree stateTree = (TMComplexStateTree)tree;
+    TMComplexStateTree stateTree = (TMComplexStateTree) tree;
+
     LOCK_PROCESS;
     if (branchHead->isSimple) {
-	PrintEvent(sb,
-		   TMGetTypeMatch(branchHead->typeIndex),
-		   TMGetModifierMatch(branchHead->modIndex),
-		   dpy);
-	if (includeRHS) {
-	    ActionRec	actRec;
-
-	    CHECK_STR_OVERFLOW(sb);
-	    *sb->current++ = ':';
-	    actRec.idx = TMBranchMore(branchHead);
-	    actRec.num_params = 0;
-	    actRec.params = NULL;
-	    actRec.next = NULL;
-	    PrintActions(sb,
-			 &actRec,
-			 stateTree->quarkTbl,
-			 accelWidget);
-	    *sb->current++ = '\n';
-	}
-	else
-	  *sb->current++ = ',';
+        PrintEvent(sb,
+                   TMGetTypeMatch(branchHead->typeIndex),
+                   TMGetModifierMatch(branchHead->modIndex), dpy);
+        if (includeRHS) {
+            ActionRec actRec;
+
+            CHECK_STR_OVERFLOW(sb);
+            *sb->current++ = ':';
+            actRec.idx = TMBranchMore(branchHead);
+            actRec.num_params = 0;
+            actRec.params = NULL;
+            actRec.next = NULL;
+            PrintActions(sb, &actRec, stateTree->quarkTbl, accelWidget);
+            *sb->current++ = '\n';
+        }
+        else
+            *sb->current++ = ',';
 #ifdef TRACE_TM
-	if (!branchHead->hasActions)
-	  printf(" !! no actions !! ");
+        if (!branchHead->hasActions)
+            printf(" !! no actions !! ");
 #endif
     }
-	else { /* it's a complex branchHead */
-	    StatePtr state = TMComplexBranchHead(stateTree, branchHead);
-	    PrintComplexState(sb,
-			      includeRHS,
-			      state,
-			      tree,
-			      accelWidget,
-			      (Display *)NULL);
-	}
+    else {                      /* it's a complex branchHead */
+        StatePtr state = TMComplexBranchHead(stateTree, branchHead);
+
+        PrintComplexState(sb,
+                          includeRHS,
+                          state, tree, accelWidget, (Display *) NULL);
+    }
     *sb->current = '\0';
     UNLOCK_PROCESS;
 }
 
-_XtString _XtPrintXlations(
-    Widget		w,
-    XtTranslations 	xlations,
-    Widget		accelWidget,
-    _XtBoolean		includeRHS)
+_XtString
+_XtPrintXlations(Widget w,
+                 XtTranslations xlations,
+                 Widget accelWidget,
+                 _XtBoolean includeRHS)
 {
-    register Cardinal 	i;
+    register Cardinal i;
+
 #define STACKPRINTSIZE 250
-    PrintRec		stackPrints[STACKPRINTSIZE];
-    PrintRec		*prints;
-    TMStringBufRec	sbRec, *sb = &sbRec;
-    TMShortCard		numPrints, maxPrints;
+    PrintRec stackPrints[STACKPRINTSIZE];
+    PrintRec *prints;
+    TMStringBufRec sbRec, *sb = &sbRec;
+    TMShortCard numPrints, maxPrints;
+
 #ifdef TRACE_TM
-    TMBindData		bindData = (TMBindData)w->core.tm.proc_table;
-    Boolean		hasAccel = (accelWidget ? True : False);
-#endif /* TRACE_TM */
-    if (xlations == NULL) return NULL;
+    TMBindData bindData = (TMBindData) w->core.tm.proc_table;
+    Boolean hasAccel = (accelWidget ? True : False);
+#endif                          /* TRACE_TM */
+    if (xlations == NULL)
+        return NULL;
 
-    sb->current = sb->start = __XtMalloc((Cardinal)1000);
+    sb->current = sb->start = __XtMalloc((Cardinal) 1000);
     sb->max = 1000;
     maxPrints = 0;
     for (i = 0; i < xlations->numStateTrees; i++)
-	maxPrints = (TMShortCard) (maxPrints +
-	  ((TMSimpleStateTree)(xlations->stateTreeTbl[i]))->numBranchHeads);
+        maxPrints = (TMShortCard) (maxPrints +
+                                   ((TMSimpleStateTree)
+                                    (xlations->stateTreeTbl[i]))->
+                                   numBranchHeads);
     prints = (PrintRec *)
-      XtStackAlloc(maxPrints * sizeof(PrintRec), stackPrints);
+        XtStackAlloc(maxPrints * sizeof(PrintRec), stackPrints);
 
     numPrints = 0;
     for (i = 0; i < xlations->numStateTrees; i++)
-      ProcessStateTree(prints, xlations, (TMShortCard) i, &numPrints);
+        ProcessStateTree(prints, xlations, (TMShortCard) i, &numPrints);
 
     for (i = 0; i < numPrints; i++) {
-	TMSimpleStateTree stateTree = (TMSimpleStateTree)
-	  xlations->stateTreeTbl[prints[i].tIndex];
-	TMBranchHead branchHead =
-	  &stateTree->branchHeadTbl[prints[i].bIndex];
+        TMSimpleStateTree stateTree = (TMSimpleStateTree)
+            xlations->stateTreeTbl[prints[i].tIndex];
+        TMBranchHead branchHead = &stateTree->branchHeadTbl[prints[i].bIndex];
+
 #ifdef TRACE_TM
-	TMComplexBindProcs	complexBindProcs;
-
-	if (hasAccel == False) {
-	    accelWidget = NULL;
-	    if (bindData->simple.isComplex) {
-		complexBindProcs = TMGetComplexBindEntry(bindData, 0);
-		accelWidget = complexBindProcs[prints[i].tIndex].widget;
-	    }
-	}
-#endif /* TRACE_TM */
-	PrintState(sb, (TMStateTree)stateTree, branchHead,
-		   (Boolean) includeRHS, accelWidget, XtDisplay(w));
+        TMComplexBindProcs complexBindProcs;
+
+        if (hasAccel == False) {
+            accelWidget = NULL;
+            if (bindData->simple.isComplex) {
+                complexBindProcs = TMGetComplexBindEntry(bindData, 0);
+                accelWidget = complexBindProcs[prints[i].tIndex].widget;
+            }
+        }
+#endif                          /* TRACE_TM */
+        PrintState(sb, (TMStateTree) stateTree, branchHead,
+                   (Boolean) includeRHS, accelWidget, XtDisplay(w));
     }
-    XtStackFree((XtPointer)prints, (XtPointer)stackPrints);
+    XtStackFree((XtPointer) prints, (XtPointer) stackPrints);
     return (sb->start);
 }
 
-
 #ifndef NO_MIT_HACKS
-/*ARGSUSED*/
-void _XtDisplayTranslations(
-    Widget widget,
-    XEvent *event,
-    String *params,
-    Cardinal *num_params)
+void
+_XtDisplayTranslations(Widget widget,
+                       XEvent *event _X_UNUSED,
+                       String *params _X_UNUSED,
+                       Cardinal *num_params _X_UNUSED)
 {
-    _XtString 	xString;
+    _XtString xString;
 
-    xString =  _XtPrintXlations(widget,
-				widget->core.tm.translations,
-				NULL,
-				True);
+    xString = _XtPrintXlations(widget,
+                               widget->core.tm.translations, NULL, True);
     if (xString) {
-	printf("%s\n",xString);
-	XtFree(xString);
+        printf("%s\n", xString);
+        XtFree(xString);
     }
 }
 
-/*ARGSUSED*/
-void _XtDisplayAccelerators(
-    Widget widget,
-    XEvent *event,
-    String *params,
-    Cardinal *num_params)
+void
+_XtDisplayAccelerators(Widget widget,
+                       XEvent *event _X_UNUSED,
+                       String *params _X_UNUSED,
+                       Cardinal *num_params _X_UNUSED)
 {
-    _XtString 	xString;
+    _XtString xString;
 
-
-    xString =  _XtPrintXlations(widget,
-				widget->core.accelerators,
-				NULL,
-				True);
+    xString = _XtPrintXlations(widget, widget->core.accelerators, NULL, True);
     if (xString) {
-	printf("%s\n",xString);
-	XtFree(xString);
+        printf("%s\n", xString);
+        XtFree(xString);
     }
 }
 
-/*ARGSUSED*/
-void _XtDisplayInstalledAccelerators(
-    Widget widget,
-    XEvent *event,
-    String *params,
-    Cardinal *num_params)
+void
+_XtDisplayInstalledAccelerators(Widget widget,
+                                XEvent *event,
+                                String *params _X_UNUSED,
+                                Cardinal *num_params _X_UNUSED)
 {
     Widget eventWidget
-	= XtWindowToWidget(event->xany.display, event->xany.window);
-    register Cardinal 	i;
-    TMStringBufRec	sbRec, *sb = &sbRec;
-    XtTranslations	xlations;
+        = XtWindowToWidget(event->xany.display, event->xany.window);
+    register Cardinal i;
+    TMStringBufRec sbRec, *sb = &sbRec;
+    XtTranslations xlations;
+
 #define STACKPRINTSIZE 250
-    PrintRec		stackPrints[STACKPRINTSIZE];
-    PrintRec		*prints;
-    TMShortCard		numPrints, maxPrints;
-    TMBindData	bindData ;
-    TMComplexBindProcs	complexBindProcs;
+    PrintRec stackPrints[STACKPRINTSIZE];
+    PrintRec *prints;
+    TMShortCard numPrints, maxPrints;
+    TMBindData bindData;
+    TMComplexBindProcs complexBindProcs;
 
-    if ((eventWidget == NULL) ||
-	(eventWidget->core.tm.translations == NULL) )
-      return;
+    if ((eventWidget == NULL) || (eventWidget->core.tm.translations == NULL))
+        return;
 
     xlations = eventWidget->core.tm.translations;
     bindData = (TMBindData) eventWidget->core.tm.proc_table;
     if (bindData->simple.isComplex == False)
-      return;
+        return;
 
-    sb->current = sb->start = __XtMalloc((Cardinal)1000);
+    sb->current = sb->start = __XtMalloc((Cardinal) 1000);
     sb->start[0] = '\0';
     sb->max = 1000;
     maxPrints = 0;
     for (i = 0; i < xlations->numStateTrees; i++)
-	maxPrints = (TMShortCard) (maxPrints +
-	  ((TMSimpleStateTree)xlations->stateTreeTbl[i])->numBranchHeads);
+        maxPrints = (TMShortCard) (maxPrints +
+                                   ((TMSimpleStateTree) xlations->
+                                    stateTreeTbl[i])->numBranchHeads);
     prints = (PrintRec *)
-      XtStackAlloc(maxPrints * sizeof(PrintRec), stackPrints);
+        XtStackAlloc(maxPrints * sizeof(PrintRec), stackPrints);
 
     numPrints = 0;
 
     complexBindProcs = TMGetComplexBindEntry(bindData, 0);
-    for (i = 0;
-	 i < xlations->numStateTrees;
-	 i++, complexBindProcs++) {
-	if (complexBindProcs->widget)
-	  {
-	      ProcessStateTree(prints, xlations, (TMShortCard) i, &numPrints);
-	  }
+    for (i = 0; i < xlations->numStateTrees; i++, complexBindProcs++) {
+        if (complexBindProcs->widget) {
+            ProcessStateTree(prints, xlations, (TMShortCard) i, &numPrints);
+        }
     }
     for (i = 0; i < numPrints; i++) {
-	TMSimpleStateTree stateTree = (TMSimpleStateTree)
-	  xlations->stateTreeTbl[prints[i].tIndex];
-	TMBranchHead branchHead =
-	  &stateTree->branchHeadTbl[prints[i].bIndex];
+        TMSimpleStateTree stateTree = (TMSimpleStateTree)
+            xlations->stateTreeTbl[prints[i].tIndex];
+        TMBranchHead branchHead = &stateTree->branchHeadTbl[prints[i].bIndex];
 
-	complexBindProcs = TMGetComplexBindEntry(bindData, 0);
+        complexBindProcs = TMGetComplexBindEntry(bindData, 0);
 
-	PrintState(sb, (TMStateTree)stateTree, branchHead, True,
-		   complexBindProcs[prints[i].tIndex].widget,
-		   XtDisplay(widget));
+        PrintState(sb, (TMStateTree) stateTree, branchHead, True,
+                   complexBindProcs[prints[i].tIndex].widget,
+                   XtDisplay(widget));
     }
-    XtStackFree((XtPointer)prints, (XtPointer)stackPrints);
+    XtStackFree((XtPointer) prints, (XtPointer) stackPrints);
     printf("%s\n", sb->start);
     XtFree(sb->start);
 }
-#endif /*NO_MIT_HACKS*/
+#endif                          /*NO_MIT_HACKS */
 
-String _XtPrintActions(
-    register ActionRec *actions,
-    XrmQuark		*quarkTbl)
+String
+_XtPrintActions(register ActionRec *actions, XrmQuark *quarkTbl)
 {
-    TMStringBufRec	sbRec, *sb = &sbRec;
+    TMStringBufRec sbRec, *sb = &sbRec;
 
     sb->max = 1000;
-    sb->current = sb->start = __XtMalloc((Cardinal)1000);
-    PrintActions(sb,
-		 actions,
-		 quarkTbl,
-		 (Widget)NULL);
+    sb->current = sb->start = __XtMalloc((Cardinal) 1000);
+    PrintActions(sb, actions, quarkTbl, (Widget) NULL);
     return sb->start;
 }
 
-String _XtPrintState(
-    TMStateTree		stateTree,
-    TMBranchHead	branchHead)
+String
+_XtPrintState(TMStateTree stateTree, TMBranchHead branchHead)
 {
-    TMStringBufRec	sbRec, *sb = &sbRec;
+    TMStringBufRec sbRec, *sb = &sbRec;
 
-    sb->current = sb->start = __XtMalloc((Cardinal)1000);
+    sb->current = sb->start = __XtMalloc((Cardinal) 1000);
     sb->max = 1000;
     PrintState(sb, stateTree, branchHead,
-	       True, (Widget)NULL, (Display *)NULL);
+               True, (Widget) NULL, (Display *) NULL);
     return sb->start;
 }
 
-
-String _XtPrintEventSeq(
-    register EventSeqPtr eventSeq,
-    Display *dpy)
+String
+_XtPrintEventSeq(register EventSeqPtr eventSeq, Display *dpy)
 {
-    TMStringBufRec	sbRec, *sb = &sbRec;
+    TMStringBufRec sbRec, *sb = &sbRec;
+
 #define MAXSEQS 100
-    EventSeqPtr		eventSeqs[MAXSEQS];
-    TMShortCard		i, j;
-    Boolean		cycle = False;
+    EventSeqPtr eventSeqs[MAXSEQS];
+    TMShortCard i, j;
+    Boolean cycle = False;
 
-    sb->current = sb->start = __XtMalloc((Cardinal)1000);
+    sb->current = sb->start = __XtMalloc((Cardinal) 1000);
     sb->max = 1000;
     for (i = 0;
-	 i < MAXSEQS && eventSeq != NULL && !cycle;
-	 eventSeq = eventSeq->next, i++)
-      {
-	  eventSeqs[i] = eventSeq;
-	  for (j = 0; j < i && !cycle; j++)
-	    if (eventSeqs[j] == eventSeq)
-	      cycle = True;
-      }
+         i < MAXSEQS && eventSeq != NULL && !cycle;
+         eventSeq = eventSeq->next, i++) {
+        eventSeqs[i] = eventSeq;
+        for (j = 0; j < i && !cycle; j++)
+            if (eventSeqs[j] == eventSeq)
+                cycle = True;
+    }
     LOCK_PROCESS;
     for (j = 0; j < i; j++) {
-	TMTypeMatch typeMatch;
-	TMModifierMatch modMatch;
-
-	typeMatch =
-	  TMGetTypeMatch(_XtGetTypeIndex(&eventSeqs[j]->event));
-	modMatch =
-	  TMGetModifierMatch(_XtGetModifierIndex(&eventSeqs[j]->event));
-	PrintEvent(sb, typeMatch, modMatch, dpy);
-	if (j < i)
-	  *sb->current++ = ',';
+        TMTypeMatch typeMatch;
+        TMModifierMatch modMatch;
+
+        typeMatch = TMGetTypeMatch(_XtGetTypeIndex(&eventSeqs[j]->event));
+        modMatch =
+            TMGetModifierMatch(_XtGetModifierIndex(&eventSeqs[j]->event));
+        PrintEvent(sb, typeMatch, modMatch, dpy);
+        if (j < i)
+            *sb->current++ = ',';
     }
     UNLOCK_PROCESS;
     return sb->start;
diff --git a/src/TMstate.c b/src/TMstate.c
index 910788a..897d535 100644
--- a/src/TMstate.c
+++ b/src/TMstate.c
@@ -71,27 +71,22 @@ in this Software without prior written authorization from The Open Group.
 /* TMstate.c -- maintains the state table of actions for the translation
  *              manager.
  */
-/*LINTLIBRARY*/
-
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include "IntrinsicI.h"
-
 #ifndef TM_NO_MATCH
 #define TM_NO_MATCH (-2)
-#endif /* TM_NO_MATCH */
-
+#endif                          /* TM_NO_MATCH */
 /* forward definitions */
 static StatePtr NewState(TMParseStateTree, TMShortCard, TMShortCard);
 
-
 static String XtNtranslationError = "translationError";
 
 #ifndef __EMX__
-TMGlobalRec _XtGlobalTM; /* initialized to zero K&R */
+TMGlobalRec _XtGlobalTM;        /* initialized to zero K&R */
 #else
-TMGlobalRec _XtGlobalTM = {0};
+TMGlobalRec _XtGlobalTM = { 0 };
 #endif
 
 #define MatchIncomingEvent(tmEvent, typeMatch, modMatch) \
@@ -99,64 +94,68 @@ TMGlobalRec _XtGlobalTM = {0};
    (typeMatch->matchEvent != NULL) && \
    (*typeMatch->matchEvent)(typeMatch, modMatch, tmEvent))
 
-
 #define NumStateTrees(xlations) \
   ((translateData->isSimple) ? 1 : (TMComplexXlations(xlations))->numTrees)
 
-static TMShortCard GetBranchHead(
-    TMParseStateTree	parseTree,
-    TMShortCard		typeIndex,
-    TMShortCard		modIndex,
-    Boolean		isDummy)
+static TMShortCard
+GetBranchHead(TMParseStateTree parseTree,
+              TMShortCard typeIndex,
+              TMShortCard modIndex,
+              Boolean isDummy)
 {
-#define TM_BRANCH_HEAD_TBL_ALLOC 	8
-#define TM_BRANCH_HEAD_TBL_REALLOC 	8
+#define TM_BRANCH_HEAD_TBL_ALLOC        8
+#define TM_BRANCH_HEAD_TBL_REALLOC      8
 
     TMBranchHead branchHead = parseTree->branchHeadTbl;
+
     /*
      * dummy is used as a place holder for later matching in old-style
      * matching behavior. If there's already an entry we don't need
      * another dummy.
      */
     if (isDummy) {
-        TMShortCard	i;
-
-	for (i = 0; i < parseTree->numBranchHeads; i++, branchHead++) {
-	    if ((branchHead->typeIndex == typeIndex) &&
-		(branchHead->modIndex == modIndex))
-	      return i;
-	}
-    }
-    if (parseTree->numBranchHeads == parseTree->branchHeadTblSize)
-      {
-          TMShortCard	newSize;
-
-	  if (parseTree->branchHeadTblSize == 0)
-	    parseTree->branchHeadTblSize = (TMShortCard) (parseTree->branchHeadTblSize + TM_BRANCH_HEAD_TBL_ALLOC);
-	  else
-	    parseTree->branchHeadTblSize = (TMShortCard) (parseTree->branchHeadTblSize +
-	      TM_BRANCH_HEAD_TBL_REALLOC);
-	  newSize = (TMShortCard) (parseTree->branchHeadTblSize * sizeof(TMBranchHeadRec));
-	  if (parseTree->isStackBranchHeads) {
-	      TMBranchHead	oldBranchHeadTbl = parseTree->branchHeadTbl;
-	      parseTree->branchHeadTbl = (TMBranchHead) __XtMalloc(newSize);
-	      XtMemmove(parseTree->branchHeadTbl, oldBranchHeadTbl, newSize);
-	      parseTree->isStackBranchHeads = False;
-	  }
-	  else {
-	      parseTree->branchHeadTbl = (TMBranchHead)
-		XtRealloc((char *)parseTree->branchHeadTbl,
-			  (Cardinal)(parseTree->branchHeadTblSize *
-			   sizeof(TMBranchHeadRec)));
-	  }
-      }
+        TMShortCard i;
+
+        for (i = 0; i < parseTree->numBranchHeads; i++, branchHead++) {
+            if ((branchHead->typeIndex == typeIndex) &&
+                (branchHead->modIndex == modIndex))
+                return i;
+        }
+    }
+    if (parseTree->numBranchHeads == parseTree->branchHeadTblSize) {
+        TMShortCard newSize;
+
+        if (parseTree->branchHeadTblSize == 0)
+            parseTree->branchHeadTblSize =
+                (TMShortCard) (parseTree->branchHeadTblSize +
+                               TM_BRANCH_HEAD_TBL_ALLOC);
+        else
+            parseTree->branchHeadTblSize =
+                (TMShortCard) (parseTree->branchHeadTblSize +
+                               TM_BRANCH_HEAD_TBL_REALLOC);
+        newSize =
+            (TMShortCard) (parseTree->branchHeadTblSize *
+                           sizeof(TMBranchHeadRec));
+        if (parseTree->isStackBranchHeads) {
+            TMBranchHead oldBranchHeadTbl = parseTree->branchHeadTbl;
+
+            parseTree->branchHeadTbl = (TMBranchHead) __XtMalloc(newSize);
+            XtMemmove(parseTree->branchHeadTbl, oldBranchHeadTbl, newSize);
+            parseTree->isStackBranchHeads = False;
+        }
+        else {
+            parseTree->branchHeadTbl = (TMBranchHead)
+                XtRealloc((char *) parseTree->branchHeadTbl,
+                          (Cardinal) (parseTree->branchHeadTblSize *
+                                      sizeof(TMBranchHeadRec)));
+        }
+    }
 #ifdef TRACE_TM
     LOCK_PROCESS;
     _XtGlobalTM.numBranchHeads++;
     UNLOCK_PROCESS;
-#endif /* TRACE_TM */
-    branchHead =
-      &parseTree->branchHeadTbl[parseTree->numBranchHeads++];
+#endif                          /* TRACE_TM */
+    branchHead = &parseTree->branchHeadTbl[parseTree->numBranchHeads++];
     branchHead->typeIndex = typeIndex;
     branchHead->modIndex = modIndex;
     branchHead->more = 0;
@@ -166,45 +165,48 @@ static TMShortCard GetBranchHead(
     return (TMShortCard) (parseTree->numBranchHeads - 1);
 }
 
-TMShortCard _XtGetQuarkIndex(
-    TMParseStateTree	parseTree,
-    XrmQuark		quark)
+TMShortCard
+_XtGetQuarkIndex(TMParseStateTree parseTree, XrmQuark quark)
 {
-#define TM_QUARK_TBL_ALLOC 	16
-#define TM_QUARK_TBL_REALLOC 	16
+#define TM_QUARK_TBL_ALLOC      16
+#define TM_QUARK_TBL_REALLOC    16
     TMShortCard i;
 
-    for (i=0; i < parseTree->numQuarks; i++)
-      if (parseTree->quarkTbl[i] == quark)
-	    break;
-
-    if (i == parseTree->numQuarks)
-      {
-	  if (parseTree->numQuarks == parseTree->quarkTblSize)
-	    {
-		TMShortCard	newSize;
-
-		if (parseTree->quarkTblSize == 0)
-		  parseTree->quarkTblSize = (TMShortCard) (parseTree->quarkTblSize + TM_QUARK_TBL_ALLOC);
-		else
-		  parseTree->quarkTblSize = (TMShortCard) (parseTree->quarkTblSize + TM_QUARK_TBL_REALLOC);
-		newSize = (TMShortCard) (parseTree->quarkTblSize * sizeof(XrmQuark));
-
-		if (parseTree->isStackQuarks) {
-		    XrmQuark	*oldquarkTbl = parseTree->quarkTbl;
-		    parseTree->quarkTbl = (XrmQuark *) __XtMalloc(newSize);
-		    XtMemmove(parseTree->quarkTbl, oldquarkTbl, newSize);
-		    parseTree->isStackQuarks = False;
-		}
-		else {
-		    parseTree->quarkTbl = (XrmQuark *)
-		      XtRealloc((char *)parseTree->quarkTbl,
-				(Cardinal)(parseTree->quarkTblSize *
-				 sizeof(XrmQuark)));
-		}
-	    }
-	  parseTree->quarkTbl[parseTree->numQuarks++] = quark;
-      }
+    for (i = 0; i < parseTree->numQuarks; i++)
+        if (parseTree->quarkTbl[i] == quark)
+            break;
+
+    if (i == parseTree->numQuarks) {
+        if (parseTree->numQuarks == parseTree->quarkTblSize) {
+            TMShortCard newSize;
+
+            if (parseTree->quarkTblSize == 0)
+                parseTree->quarkTblSize =
+                    (TMShortCard) (parseTree->quarkTblSize +
+                                   TM_QUARK_TBL_ALLOC);
+            else
+                parseTree->quarkTblSize =
+                    (TMShortCard) (parseTree->quarkTblSize +
+                                   TM_QUARK_TBL_REALLOC);
+            newSize =
+                (TMShortCard) (parseTree->quarkTblSize * sizeof(XrmQuark));
+
+            if (parseTree->isStackQuarks) {
+                XrmQuark *oldquarkTbl = parseTree->quarkTbl;
+
+                parseTree->quarkTbl = (XrmQuark *) __XtMalloc(newSize);
+                XtMemmove(parseTree->quarkTbl, oldquarkTbl, newSize);
+                parseTree->isStackQuarks = False;
+            }
+            else {
+                parseTree->quarkTbl = (XrmQuark *)
+                    XtRealloc((char *) parseTree->quarkTbl,
+                              (Cardinal) (parseTree->quarkTblSize *
+                                          sizeof(XrmQuark)));
+            }
+        }
+        parseTree->quarkTbl[parseTree->numQuarks++] = quark;
+    }
     return i;
 }
 
@@ -212,81 +214,88 @@ TMShortCard _XtGetQuarkIndex(
  * Get an entry from the parseTrees complex branchHead tbl. If there's none
  * there then allocate one
  */
-/*ARGSUSED*/
-static TMShortCard GetComplexBranchIndex(
-    TMParseStateTree	parseTree,
-    TMShortCard		typeIndex,
-    TMShortCard		modIndex)
+static TMShortCard
+GetComplexBranchIndex(TMParseStateTree parseTree,
+                      TMShortCard typeIndex _X_UNUSED,
+                      TMShortCard modIndex _X_UNUSED)
 {
 #define TM_COMPLEXBRANCH_HEAD_TBL_ALLOC 8
 #define TM_COMPLEXBRANCH_HEAD_TBL_REALLOC 4
 
     if (parseTree->numComplexBranchHeads == parseTree->complexBranchHeadTblSize) {
-	TMShortCard	newSize;
-
-	if (parseTree->complexBranchHeadTblSize == 0)
-	  parseTree->complexBranchHeadTblSize = (TMShortCard) (parseTree->complexBranchHeadTblSize + TM_COMPLEXBRANCH_HEAD_TBL_ALLOC);
-	else
-	  parseTree->complexBranchHeadTblSize = (TMShortCard) (parseTree->complexBranchHeadTblSize + TM_COMPLEXBRANCH_HEAD_TBL_REALLOC);
-
-	newSize = (TMShortCard) (parseTree->complexBranchHeadTblSize * sizeof(StatePtr));
-
-	if (parseTree->isStackComplexBranchHeads) {
-	    StatePtr *oldcomplexBranchHeadTbl
-	      = parseTree->complexBranchHeadTbl;
-	    parseTree->complexBranchHeadTbl = (StatePtr *) __XtMalloc(newSize);
-	    XtMemmove(parseTree->complexBranchHeadTbl,
-		      oldcomplexBranchHeadTbl, newSize);
-	    parseTree->isStackComplexBranchHeads = False;
-	}
-	else {
-	    parseTree->complexBranchHeadTbl = (StatePtr *)
-	      XtRealloc((char *)parseTree->complexBranchHeadTbl,
-			(Cardinal)(parseTree->complexBranchHeadTblSize *
-			 sizeof(StatePtr)));
-	}
+        TMShortCard newSize;
+
+        if (parseTree->complexBranchHeadTblSize == 0)
+            parseTree->complexBranchHeadTblSize =
+                (TMShortCard) (parseTree->complexBranchHeadTblSize +
+                               TM_COMPLEXBRANCH_HEAD_TBL_ALLOC);
+        else
+            parseTree->complexBranchHeadTblSize =
+                (TMShortCard) (parseTree->complexBranchHeadTblSize +
+                               TM_COMPLEXBRANCH_HEAD_TBL_REALLOC);
+
+        newSize =
+            (TMShortCard) (parseTree->complexBranchHeadTblSize *
+                           sizeof(StatePtr));
+
+        if (parseTree->isStackComplexBranchHeads) {
+            StatePtr *oldcomplexBranchHeadTbl = parseTree->complexBranchHeadTbl;
+
+            parseTree->complexBranchHeadTbl = (StatePtr *) __XtMalloc(newSize);
+            XtMemmove(parseTree->complexBranchHeadTbl,
+                      oldcomplexBranchHeadTbl, newSize);
+            parseTree->isStackComplexBranchHeads = False;
+        }
+        else {
+            parseTree->complexBranchHeadTbl = (StatePtr *)
+                XtRealloc((char *) parseTree->complexBranchHeadTbl,
+                          (Cardinal) (parseTree->complexBranchHeadTblSize *
+                                      sizeof(StatePtr)));
+        }
     }
     parseTree->complexBranchHeadTbl[parseTree->numComplexBranchHeads++] = NULL;
     return (TMShortCard) (parseTree->numComplexBranchHeads - 1);
 }
 
-TMShortCard _XtGetTypeIndex(
-    Event	*event)
+TMShortCard
+_XtGetTypeIndex(Event *event)
 {
-    TMShortCard		i, j = TM_TYPE_SEGMENT_SIZE;
-    TMShortCard		typeIndex = 0;
-    TMTypeMatch 	typeMatch;
-    TMTypeMatch		segment = NULL;
+    TMShortCard i, j = TM_TYPE_SEGMENT_SIZE;
+    TMShortCard typeIndex = 0;
+    TMTypeMatch typeMatch;
+    TMTypeMatch segment = NULL;
 
     LOCK_PROCESS;
     for (i = 0; i < _XtGlobalTM.numTypeMatchSegments; i++) {
-	segment = _XtGlobalTM.typeMatchSegmentTbl[i];
-	for (j = 0;
-	     typeIndex < _XtGlobalTM.numTypeMatches && j <  TM_TYPE_SEGMENT_SIZE;
-	     j++, typeIndex++)
-	  {
-	      typeMatch = &(segment[j]);
-	      if (event->eventType == typeMatch->eventType &&
-		  event->eventCode == typeMatch->eventCode &&
-		  event->eventCodeMask == typeMatch->eventCodeMask &&
-		  event->matchEvent == typeMatch->matchEvent) {
-		    UNLOCK_PROCESS;
-		    return typeIndex;
-		  }
-	  }
+        segment = _XtGlobalTM.typeMatchSegmentTbl[i];
+        for (j = 0;
+             typeIndex < _XtGlobalTM.numTypeMatches && j < TM_TYPE_SEGMENT_SIZE;
+             j++, typeIndex++) {
+            typeMatch = &(segment[j]);
+            if (event->eventType == typeMatch->eventType &&
+                event->eventCode == typeMatch->eventCode &&
+                event->eventCodeMask == typeMatch->eventCodeMask &&
+                event->matchEvent == typeMatch->matchEvent) {
+                UNLOCK_PROCESS;
+                return typeIndex;
+            }
+        }
     }
 
     if (j == TM_TYPE_SEGMENT_SIZE) {
-	if (_XtGlobalTM.numTypeMatchSegments == _XtGlobalTM.typeMatchSegmentTblSize) {
-	    _XtGlobalTM.typeMatchSegmentTblSize = (TMShortCard) (_XtGlobalTM.typeMatchSegmentTblSize + 4);
-	    _XtGlobalTM.typeMatchSegmentTbl = (TMTypeMatch *)
-	      XtRealloc((char *)_XtGlobalTM.typeMatchSegmentTbl,
-			(Cardinal)(_XtGlobalTM.typeMatchSegmentTblSize * sizeof(TMTypeMatch)));
-	}
-	_XtGlobalTM.typeMatchSegmentTbl[_XtGlobalTM.numTypeMatchSegments++] =
-	  segment = (TMTypeMatch)
-	    __XtMalloc(TM_TYPE_SEGMENT_SIZE * sizeof(TMTypeMatchRec));
-	j = 0;
+        if (_XtGlobalTM.numTypeMatchSegments ==
+            _XtGlobalTM.typeMatchSegmentTblSize) {
+            _XtGlobalTM.typeMatchSegmentTblSize =
+                (TMShortCard) (_XtGlobalTM.typeMatchSegmentTblSize + 4);
+            _XtGlobalTM.typeMatchSegmentTbl = (TMTypeMatch *)
+                XtRealloc((char *) _XtGlobalTM.typeMatchSegmentTbl,
+                          (Cardinal) (_XtGlobalTM.typeMatchSegmentTblSize *
+                                      sizeof(TMTypeMatch)));
+        }
+        _XtGlobalTM.typeMatchSegmentTbl[_XtGlobalTM.numTypeMatchSegments++] =
+            segment = (TMTypeMatch)
+            __XtMalloc(TM_TYPE_SEGMENT_SIZE * sizeof(TMTypeMatchRec));
+        j = 0;
     }
     typeMatch = &segment[j];
     typeMatch->eventType = event->eventType;
@@ -298,90 +307,97 @@ TMShortCard _XtGetTypeIndex(
     return typeIndex;
 }
 
-static Boolean CompareLateModifiers(
-    LateBindingsPtr lateBind1P,
-    LateBindingsPtr lateBind2P)
+static Boolean
+CompareLateModifiers(LateBindingsPtr lateBind1P, LateBindingsPtr lateBind2P)
 {
     LateBindingsPtr late1P = lateBind1P;
     LateBindingsPtr late2P = lateBind2P;
 
     if (late1P != NULL || late2P != NULL) {
-	int i = 0;
-	int j = 0;
-	if (late1P != NULL)
-	  for (; late1P->keysym != NoSymbol; i++) late1P++;
-	if (late2P != NULL)
-	  for (; late2P->keysym != NoSymbol; j++) late2P++;
-	if (i != j) return FALSE;
-	late1P--;
-	while (late1P >= lateBind1P) {
-	    Boolean last = True;
-	    for (late2P = lateBind2P + i - 1;
-		 late2P >= lateBind2P;
-		 late2P--) {
-		if (late1P->keysym == late2P->keysym
-		    && late1P->knot == late2P->knot) {
-		    j--;
-		    if (last) i--;
-		    break;
-		}
-		last = False;
-	    }
-	    late1P--;
-	}
-	if (j != 0) return FALSE;
+        int i = 0;
+        int j = 0;
+
+        if (late1P != NULL)
+            for (; late1P->keysym != NoSymbol; i++)
+                late1P++;
+        if (late2P != NULL)
+            for (; late2P->keysym != NoSymbol; j++)
+                late2P++;
+        if (i != j)
+            return FALSE;
+        late1P--;
+        while (late1P >= lateBind1P) {
+            Boolean last = True;
+
+            for (late2P = lateBind2P + i - 1; late2P >= lateBind2P; late2P--) {
+                if (late1P->keysym == late2P->keysym
+                    && late1P->knot == late2P->knot) {
+                    j--;
+                    if (last)
+                        i--;
+                    break;
+                }
+                last = False;
+            }
+            late1P--;
+        }
+        if (j != 0)
+            return FALSE;
     }
     return TRUE;
 }
 
-TMShortCard _XtGetModifierIndex(
-    Event	*event)
+TMShortCard
+_XtGetModifierIndex(Event *event)
 {
-    TMShortCard		i, j = TM_MOD_SEGMENT_SIZE;
-    TMShortCard		modIndex = 0;
-    TMModifierMatch 	modMatch;
-    TMModifierMatch	segment = NULL;
+    TMShortCard i, j = TM_MOD_SEGMENT_SIZE;
+    TMShortCard modIndex = 0;
+    TMModifierMatch modMatch;
+    TMModifierMatch segment = NULL;
 
     LOCK_PROCESS;
     for (i = 0; i < _XtGlobalTM.numModMatchSegments; i++) {
-	segment = _XtGlobalTM.modMatchSegmentTbl[i];
-	for (j = 0;
-	     modIndex < _XtGlobalTM.numModMatches && j <  TM_MOD_SEGMENT_SIZE;
-	     j++, modIndex++) {
-	    modMatch = &(segment[j]);
-	    if (event->modifiers == modMatch->modifiers &&
-		event->modifierMask == modMatch->modifierMask &&
-		event->standard == modMatch->standard &&
-		((!event->lateModifiers && !modMatch->lateModifiers) ||
-		 CompareLateModifiers(event->lateModifiers,
-				      modMatch->lateModifiers))) {
-		/*
-		 * if we found a match then we can free the parser's
-		 * late modifiers. If there isn't a match we use the
-		 * parser's copy
-		 */
-		if (event->lateModifiers &&
-		    --event->lateModifiers->ref_count == 0) {
-		    XtFree((char *)event->lateModifiers);
-		    event->lateModifiers = NULL;
-		}
-		UNLOCK_PROCESS;
-		return modIndex;
-	    }
-	}
+        segment = _XtGlobalTM.modMatchSegmentTbl[i];
+        for (j = 0;
+             modIndex < _XtGlobalTM.numModMatches && j < TM_MOD_SEGMENT_SIZE;
+             j++, modIndex++) {
+            modMatch = &(segment[j]);
+            if (event->modifiers == modMatch->modifiers &&
+                event->modifierMask == modMatch->modifierMask &&
+                event->standard == modMatch->standard &&
+                ((!event->lateModifiers && !modMatch->lateModifiers) ||
+                 CompareLateModifiers(event->lateModifiers,
+                                      modMatch->lateModifiers))) {
+                /*
+                 * if we found a match then we can free the parser's
+                 * late modifiers. If there isn't a match we use the
+                 * parser's copy
+                 */
+                if (event->lateModifiers &&
+                    --event->lateModifiers->ref_count == 0) {
+                    XtFree((char *) event->lateModifiers);
+                    event->lateModifiers = NULL;
+                }
+                UNLOCK_PROCESS;
+                return modIndex;
+            }
+        }
     }
 
     if (j == TM_MOD_SEGMENT_SIZE) {
-	if (_XtGlobalTM.numModMatchSegments == _XtGlobalTM.modMatchSegmentTblSize) {
-	    _XtGlobalTM.modMatchSegmentTblSize = (TMShortCard) (_XtGlobalTM.modMatchSegmentTblSize + 4);
-	    _XtGlobalTM.modMatchSegmentTbl = (TMModifierMatch *)
-	      XtRealloc((char *)_XtGlobalTM.modMatchSegmentTbl,
-			(Cardinal)(_XtGlobalTM.modMatchSegmentTblSize * sizeof(TMModifierMatch)));
-	}
-	_XtGlobalTM.modMatchSegmentTbl[_XtGlobalTM.numModMatchSegments++] =
-	  segment = (TMModifierMatch)
-	    __XtMalloc(TM_MOD_SEGMENT_SIZE * sizeof(TMModifierMatchRec));
-	j = 0;
+        if (_XtGlobalTM.numModMatchSegments ==
+            _XtGlobalTM.modMatchSegmentTblSize) {
+            _XtGlobalTM.modMatchSegmentTblSize =
+                (TMShortCard) (_XtGlobalTM.modMatchSegmentTblSize + 4);
+            _XtGlobalTM.modMatchSegmentTbl = (TMModifierMatch *)
+                XtRealloc((char *) _XtGlobalTM.modMatchSegmentTbl,
+                          (Cardinal) (_XtGlobalTM.modMatchSegmentTblSize *
+                                      sizeof(TMModifierMatch)));
+        }
+        _XtGlobalTM.modMatchSegmentTbl[_XtGlobalTM.numModMatchSegments++] =
+            segment = (TMModifierMatch)
+            __XtMalloc(TM_MOD_SEGMENT_SIZE * sizeof(TMModifierMatchRec));
+        j = 0;
     }
     modMatch = &segment[j];
     modMatch->modifiers = event->modifiers;
@@ -392,80 +408,76 @@ TMShortCard _XtGetModifierIndex(
      */
 #ifdef TRACE_TM
     if (event->lateModifiers)
-      _XtGlobalTM.numLateBindings++;
-#endif /* TRACE_TM */
+        _XtGlobalTM.numLateBindings++;
+#endif                          /* TRACE_TM */
     modMatch->lateModifiers = event->lateModifiers;
     _XtGlobalTM.numModMatches++;
     UNLOCK_PROCESS;
     return modIndex;
 }
 
-
 /*
  * This is called from the SimpleStateHandler to match a stateTree
  * entry to the event coming in
  */
-static int MatchBranchHead(
-    TMSimpleStateTree 	stateTree,
-    int			startIndex,
-    TMEventPtr		event)
+static int
+MatchBranchHead(TMSimpleStateTree stateTree, int startIndex, TMEventPtr event)
 {
     TMBranchHead branchHead = &stateTree->branchHeadTbl[startIndex];
     int i;
 
     LOCK_PROCESS;
-    for (i = startIndex;
-	 i < (int)stateTree->numBranchHeads;
-	 i++, branchHead++)
-      {
-	  TMTypeMatch 		typeMatch;
-	  TMModifierMatch	modMatch;
-
-	  typeMatch  = TMGetTypeMatch(branchHead->typeIndex);
-	  modMatch = TMGetModifierMatch(branchHead->modIndex);
-
-	  if (MatchIncomingEvent(event, typeMatch, modMatch)) {
-	    UNLOCK_PROCESS;
-	    return i;
-	  }
-      }
+    for (i = startIndex; i < (int) stateTree->numBranchHeads; i++, branchHead++) {
+        TMTypeMatch typeMatch;
+        TMModifierMatch modMatch;
+
+        typeMatch = TMGetTypeMatch(branchHead->typeIndex);
+        modMatch = TMGetModifierMatch(branchHead->modIndex);
+
+        if (MatchIncomingEvent(event, typeMatch, modMatch)) {
+            UNLOCK_PROCESS;
+            return i;
+        }
+    }
     UNLOCK_PROCESS;
     return (TM_NO_MATCH);
 }
 
-Boolean _XtRegularMatch(
-    TMTypeMatch 	typeMatch,
-    TMModifierMatch	modMatch,
-    TMEventPtr 		eventSeq)
+Boolean
+_XtRegularMatch(TMTypeMatch typeMatch,
+                TMModifierMatch modMatch,
+                TMEventPtr eventSeq)
 {
-    Modifiers computed =0;
-    Modifiers computedMask =0;
+    Modifiers computed = 0;
+    Modifiers computedMask = 0;
     Boolean resolved = TRUE;
+
     if (typeMatch->eventCode != (eventSeq->event.eventCode &
-				  typeMatch->eventCodeMask)) return FALSE;
+                                 typeMatch->eventCodeMask))
+        return FALSE;
     if (modMatch->lateModifiers != NULL)
-	resolved = _XtComputeLateBindings(eventSeq->xev->xany.display,
-					  modMatch->lateModifiers,
-					  &computed, &computedMask);
-    if (!resolved) return FALSE;
+        resolved = _XtComputeLateBindings(eventSeq->xev->xany.display,
+                                          modMatch->lateModifiers,
+                                          &computed, &computedMask);
+    if (!resolved)
+        return FALSE;
     computed = (Modifiers) (computed | modMatch->modifiers);
     computedMask = (Modifiers) (computedMask | modMatch->modifierMask);
 
-    return ( (computed & computedMask) ==
-	    (eventSeq->event.modifiers & computedMask));
+    return ((computed & computedMask) ==
+            (eventSeq->event.modifiers & computedMask));
 }
 
-/*ARGSUSED*/
-Boolean _XtMatchAtom(
-    TMTypeMatch 	typeMatch,
-    TMModifierMatch	modMatch,
-    TMEventPtr 		eventSeq)
+Boolean
+_XtMatchAtom(TMTypeMatch typeMatch,
+             TMModifierMatch modMatch _X_UNUSED,
+             TMEventPtr eventSeq)
 {
-    Atom	atom;
+    Atom atom;
 
     atom = XInternAtom(eventSeq->xev->xany.display,
-		       XrmQuarkToString((XrmQuark)(typeMatch->eventCode)),
-		       False);
+                       XrmQuarkToString((XrmQuark) (typeMatch->eventCode)),
+                       False);
     return (atom == eventSeq->event.eventCode);
 }
 
@@ -475,27 +487,26 @@ Boolean _XtMatchAtom(
  * there are certain cases where you want to ignore the event and stay
  * in the same state.
  */
-static Boolean Ignore(
-    TMEventPtr event)
+static Boolean
+Ignore(TMEventPtr event)
 {
     Display *dpy;
     XtPerDisplay pd;
 
     if (event->event.eventType == MotionNotify)
-	return TRUE;
+        return TRUE;
     if (!(event->event.eventType == KeyPress ||
-	  event->event.eventType == KeyRelease))
-	return FALSE;
+          event->event.eventType == KeyRelease))
+        return FALSE;
     dpy = event->xev->xany.display;
+
     pd = _XtGetPerDisplay(dpy);
     _InitializeKeysymTables(dpy, pd);
     return IsOn(pd->isModifier, event->event.eventCode) ? TRUE : FALSE;
 }
 
-
-static void XEventToTMEvent(
-    XEvent *event,
-    TMEventPtr tmEvent)
+static void
+XEventToTMEvent(XEvent *event, TMEventPtr tmEvent)
 {
     tmEvent->xev = event;
     tmEvent->event.eventCodeMask = 0;
@@ -507,147 +518,142 @@ static void XEventToTMEvent(
 
     switch (event->type) {
 
-	case KeyPress:
-	case KeyRelease:
-            tmEvent->event.eventCode = event->xkey.keycode;
-	    tmEvent->event.modifiers = event->xkey.state;
-	    break;
-
-	case ButtonPress:
-	case ButtonRelease:
-	    tmEvent->event.eventCode = event->xbutton.button;
-	    tmEvent->event.modifiers = event->xbutton.state;
-	    break;
-
-	case MotionNotify:
-	    tmEvent->event.eventCode = (TMLongCard) event->xmotion.is_hint;
-	    tmEvent->event.modifiers = event->xmotion.state;
-	    break;
-
-	case EnterNotify:
-	case LeaveNotify:
-	    tmEvent->event.eventCode = (TMLongCard) event->xcrossing.mode;
-	    tmEvent->event.modifiers = event->xcrossing.state;
-	    break;
-
-	case PropertyNotify:
-	    tmEvent->event.eventCode = event->xproperty.atom;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case SelectionClear:
-	    tmEvent->event.eventCode = event->xselectionclear.selection;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case SelectionRequest:
-	    tmEvent->event.eventCode = event->xselectionrequest.selection;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case SelectionNotify:
-	    tmEvent->event.eventCode = event->xselection.selection;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case ClientMessage:
-	    tmEvent->event.eventCode = event->xclient.message_type;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case MappingNotify:
-	    tmEvent->event.eventCode = (TMLongCard) event->xmapping.request;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	case FocusIn:
-	case FocusOut:
-	    tmEvent->event.eventCode = (TMLongCard) event->xfocus.mode;
-	    tmEvent->event.modifiers = 0;
-	    break;
-
-	default:
-	    tmEvent->event.eventCode = 0;
-	    tmEvent->event.modifiers = 0;
-	    break;
+    case KeyPress:
+    case KeyRelease:
+        tmEvent->event.eventCode = event->xkey.keycode;
+        tmEvent->event.modifiers = event->xkey.state;
+        break;
+
+    case ButtonPress:
+    case ButtonRelease:
+        tmEvent->event.eventCode = event->xbutton.button;
+        tmEvent->event.modifiers = event->xbutton.state;
+        break;
+
+    case MotionNotify:
+        tmEvent->event.eventCode = (TMLongCard) event->xmotion.is_hint;
+        tmEvent->event.modifiers = event->xmotion.state;
+        break;
+
+    case EnterNotify:
+    case LeaveNotify:
+        tmEvent->event.eventCode = (TMLongCard) event->xcrossing.mode;
+        tmEvent->event.modifiers = event->xcrossing.state;
+        break;
+
+    case PropertyNotify:
+        tmEvent->event.eventCode = event->xproperty.atom;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case SelectionClear:
+        tmEvent->event.eventCode = event->xselectionclear.selection;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case SelectionRequest:
+        tmEvent->event.eventCode = event->xselectionrequest.selection;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case SelectionNotify:
+        tmEvent->event.eventCode = event->xselection.selection;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case ClientMessage:
+        tmEvent->event.eventCode = event->xclient.message_type;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case MappingNotify:
+        tmEvent->event.eventCode = (TMLongCard) event->xmapping.request;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    case FocusIn:
+    case FocusOut:
+        tmEvent->event.eventCode = (TMLongCard) event->xfocus.mode;
+        tmEvent->event.modifiers = 0;
+        break;
+
+    default:
+        tmEvent->event.eventCode = 0;
+        tmEvent->event.modifiers = 0;
+        break;
     }
 }
 
-
-static unsigned long GetTime(
-    XtTM tm,
-    XEvent *event)
+static unsigned long
+GetTime(XtTM tm, XEvent *event)
 {
     switch (event->type) {
 
-        case KeyPress:
-	case KeyRelease:
-	    return event->xkey.time;
+    case KeyPress:
+    case KeyRelease:
+        return event->xkey.time;
 
-        case ButtonPress:
-	case ButtonRelease:
-	    return event->xbutton.time;
+    case ButtonPress:
+    case ButtonRelease:
+        return event->xbutton.time;
 
-	default:
-	    return tm->lastEventTime;
+    default:
+        return tm->lastEventTime;
 
     }
 
 }
 
-static void HandleActions(
-    Widget		w,
-    XEvent		*event,
-    TMSimpleStateTree	stateTree,
-    Widget		accelWidget,
-    XtActionProc	*procs,
-    ActionRec		*actions)
+static void
+HandleActions(Widget w,
+              XEvent *event,
+              TMSimpleStateTree stateTree,
+              Widget accelWidget,
+              XtActionProc *procs,
+              ActionRec *actions)
 {
-    ActionHook	 	actionHookList;
-    Widget		bindWidget;
+    ActionHook actionHookList;
+    Widget bindWidget;
 
     bindWidget = accelWidget ? accelWidget : w;
     if (accelWidget && !XtIsSensitive(accelWidget) &&
-	(event->type == KeyPress || event->type == KeyRelease ||
-	event->type == ButtonPress || event->type == ButtonRelease ||
-	event->type == MotionNotify || event->type == EnterNotify ||
-	event->type == LeaveNotify || event->type == FocusIn ||
-	event->type == FocusOut))
-	return;
+        (event->type == KeyPress || event->type == KeyRelease ||
+         event->type == ButtonPress || event->type == ButtonRelease ||
+         event->type == MotionNotify || event->type == EnterNotify ||
+         event->type == LeaveNotify || event->type == FocusIn ||
+         event->type == FocusOut))
+        return;
 
     actionHookList = XtWidgetToApplicationContext(w)->action_hook_list;
 
     while (actions != NULL) {
-	/* perform any actions */
-	if (procs[actions->idx] != NULL) {
-	    if (actionHookList) {
-		ActionHook hook;
-		ActionHook next_hook;
-		String procName =
-		    XrmQuarkToString(stateTree->quarkTbl[actions->idx] );
-
-		for (hook = actionHookList; hook != NULL; ) {
-		    /*
-		     * Need to cache hook->next because the following action
-		     * proc may free hook via XtRemoveActionHook making
-		     * hook->next invalid upon return from the action proc.
-		     */
-		    next_hook = hook->next;
-		    (*hook->proc)(bindWidget,
-				  hook->closure,
-				  procName,
-				  event,
-				  actions->params,
-				  &actions->num_params
-				  );
-		    hook = next_hook;
-		}
-	    }
-	    (*(procs[actions->idx]))
-	      (bindWidget, event,
-	       actions->params, &actions->num_params );
-	}
-	actions = actions->next;
+        /* perform any actions */
+        if (procs[actions->idx] != NULL) {
+            if (actionHookList) {
+                ActionHook hook;
+                ActionHook next_hook;
+                String procName =
+                    XrmQuarkToString(stateTree->quarkTbl[actions->idx]);
+
+                for (hook = actionHookList; hook != NULL;) {
+                    /*
+                     * Need to cache hook->next because the following action
+                     * proc may free hook via XtRemoveActionHook making
+                     * hook->next invalid upon return from the action proc.
+                     */
+                    next_hook = hook->next;
+                    (*hook->proc) (bindWidget,
+                                   hook->closure,
+                                   procName,
+                                   event,
+                                   actions->params, &actions->num_params);
+                    hook = next_hook;
+                }
+            }
+            (*(procs[actions->idx]))
+                (bindWidget, event, actions->params, &actions->num_params);
+        }
+        actions = actions->next;
     }
 }
 
@@ -656,285 +662,273 @@ typedef struct {
     unsigned int isCycleEnd:1;
     TMShortCard typeIndex;
     TMShortCard modIndex;
-}MatchPairRec, *MatchPair;
+} MatchPairRec, *MatchPair;
 
-typedef struct TMContextRec{
-    TMShortCard	numMatches;
-    TMShortCard	maxMatches;
-    MatchPair	matches;
-}TMContextRec, *TMContext;
+typedef struct TMContextRec {
+    TMShortCard numMatches;
+    TMShortCard maxMatches;
+    MatchPair matches;
+} TMContextRec, *TMContext;
 
-static TMContextRec	contextCache[2];
+static TMContextRec contextCache[2];
 
 #define GetContextPtr(tm) ((TMContext *)&(tm->current_state))
 
 #define TM_CONTEXT_MATCHES_ALLOC 4
 #define TM_CONTEXT_MATCHES_REALLOC 2
 
-static void PushContext(
-    TMContext	*contextPtr,
-    StatePtr	newState)
+static void
+PushContext(TMContext *contextPtr, StatePtr newState)
 {
-    TMContext 		context = *contextPtr;
+    TMContext context = *contextPtr;
 
     LOCK_PROCESS;
-    if (context == NULL)
-      {
-	  if (contextCache[0].numMatches == 0)
-	    context = &contextCache[0];
-	  else if (contextCache[1].numMatches == 0)
-	    context = &contextCache[1];
-	  if (!context)
-	    {
-		context = XtNew(TMContextRec);
-		context->matches = NULL;
-		context->numMatches =
-		  context->maxMatches = 0;
-	    }
-      }
+    if (context == NULL) {
+        if (contextCache[0].numMatches == 0)
+            context = &contextCache[0];
+        else if (contextCache[1].numMatches == 0)
+            context = &contextCache[1];
+        if (!context) {
+            context = XtNew(TMContextRec);
+            context->matches = NULL;
+            context->numMatches = context->maxMatches = 0;
+        }
+    }
     if (context->numMatches &&
-	context->matches[context->numMatches-1].isCycleEnd)
-      {
-	  TMShortCard	i;
-	  for (i = 0;
-	       i < context->numMatches &&
-	       !(context->matches[i].isCycleStart);
-	       i++){};
-	  if (i < context->numMatches)
-	    context->numMatches = (TMShortCard) (i + 1);
+        context->matches[context->numMatches - 1].isCycleEnd) {
+        TMShortCard i;
+
+        for (i = 0;
+             i < context->numMatches &&
+             !(context->matches[i].isCycleStart); i++) {
+        };
+        if (i < context->numMatches)
+            context->numMatches = (TMShortCard) (i + 1);
 #ifdef DEBUG
-	  else
-	    XtWarning("pushing cycle end with no cycle start");
-#endif /* DEBUG */
-      }
-    else
-      {
-	  if (context->numMatches == context->maxMatches)
-	    {
-		if (context->maxMatches == 0)
-		  context->maxMatches = (TMShortCard) (context->maxMatches + TM_CONTEXT_MATCHES_ALLOC);
-		else
-		  context->maxMatches = (TMShortCard) (context->maxMatches + TM_CONTEXT_MATCHES_REALLOC);
-		context->matches = (MatchPairRec *)
-		  XtRealloc((char *)context->matches,
-			    (Cardinal)(context->maxMatches * sizeof(MatchPairRec)));
-	    }
-	  context->matches[context->numMatches].isCycleStart = newState->isCycleStart;
-	  context->matches[context->numMatches].isCycleEnd = newState->isCycleEnd;
-	  context->matches[context->numMatches].typeIndex = newState->typeIndex;
-	  context->matches[context->numMatches++].modIndex = newState->modIndex;
-	  *contextPtr = context;
-      }
-      UNLOCK_PROCESS;
+        else
+            XtWarning("pushing cycle end with no cycle start");
+#endif                          /* DEBUG */
+    }
+    else {
+        if (context->numMatches == context->maxMatches) {
+            if (context->maxMatches == 0)
+                context->maxMatches =
+                    (TMShortCard) (context->maxMatches +
+                                   TM_CONTEXT_MATCHES_ALLOC);
+            else
+                context->maxMatches =
+                    (TMShortCard) (context->maxMatches +
+                                   TM_CONTEXT_MATCHES_REALLOC);
+            context->matches = (MatchPairRec *)
+                XtRealloc((char *) context->matches,
+                          (Cardinal) (context->maxMatches *
+                                      sizeof(MatchPairRec)));
+        }
+        context->matches[context->numMatches].isCycleStart =
+            newState->isCycleStart;
+        context->matches[context->numMatches].isCycleEnd = newState->isCycleEnd;
+        context->matches[context->numMatches].typeIndex = newState->typeIndex;
+        context->matches[context->numMatches++].modIndex = newState->modIndex;
+        *contextPtr = context;
+    }
+    UNLOCK_PROCESS;
 }
 
-static void FreeContext(
-    TMContext	*contextPtr)
+static void
+FreeContext(TMContext *contextPtr)
 {
-    TMContext 		context = NULL;
+    TMContext context = NULL;
 
     LOCK_PROCESS;
 
     if (&contextCache[0] == *contextPtr)
-      context = &contextCache[0];
+        context = &contextCache[0];
     else if (&contextCache[1] == *contextPtr)
-      context = &contextCache[1];
+        context = &contextCache[1];
 
     if (context)
-      context->numMatches = 0;
-    else if (*contextPtr)
-    {
-      XtFree ((char *) ((*contextPtr)->matches));
-      XtFree((char *)*contextPtr);
+        context->numMatches = 0;
+    else if (*contextPtr) {
+        XtFree((char *) ((*contextPtr)->matches));
+        XtFree((char *) *contextPtr);
     }
 
     *contextPtr = NULL;
     UNLOCK_PROCESS;
 }
 
-static int MatchExact(
-    TMSimpleStateTree 	stateTree,
-    int			startIndex,
-    TMShortCard		typeIndex,
-    TMShortCard		modIndex)
+static int
+MatchExact(TMSimpleStateTree stateTree,
+           int startIndex,
+           TMShortCard typeIndex,
+           TMShortCard modIndex)
 {
     TMBranchHead branchHead = &(stateTree->branchHeadTbl[startIndex]);
     int i;
 
-    for (i = startIndex;
-	 i < (int)stateTree->numBranchHeads;
-	 i++, branchHead++)
-      {
-	  if ((branchHead->typeIndex == typeIndex) &&
-	      (branchHead->modIndex == modIndex))
-	    return i;
-      }
+    for (i = startIndex; i < (int) stateTree->numBranchHeads; i++, branchHead++) {
+        if ((branchHead->typeIndex == typeIndex) &&
+            (branchHead->modIndex == modIndex))
+            return i;
+    }
     return (TM_NO_MATCH);
 }
 
-
-
-static void HandleSimpleState(
-    Widget	w,
-    XtTM	tmRecPtr,
-    TMEventRec	*curEventPtr)
+static void
+HandleSimpleState(Widget w, XtTM tmRecPtr, TMEventRec *curEventPtr)
 {
-    XtTranslations	xlations = tmRecPtr->translations;
-    TMContext		*contextPtr = GetContextPtr(tmRecPtr);
-    TMShortCard		i;
-    ActionRec		*actions = NULL;
-    Boolean		matchExact = False;
-    Boolean	       	match = False;
-    StatePtr		complexMatchState = NULL;
-    TMShortCard		typeIndex = 0, modIndex = 0;
-    int			matchTreeIndex = TM_NO_MATCH;
+    XtTranslations xlations = tmRecPtr->translations;
+    TMContext *contextPtr = GetContextPtr(tmRecPtr);
+    TMShortCard i;
+    ActionRec *actions = NULL;
+    Boolean matchExact = False;
+    Boolean match = False;
+    StatePtr complexMatchState = NULL;
+    TMShortCard typeIndex = 0, modIndex = 0;
+    int matchTreeIndex = TM_NO_MATCH;
 
     LOCK_PROCESS;
     for (i = 0;
-	 ((!match || !complexMatchState) && (i < xlations->numStateTrees));
-	 i++){
-	int currIndex = -1;
-	TMSimpleStateTree stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i];
-
-	/*
-	 * don't process this tree if we're only looking for a
-	 * complexMatchState and there are no complex states
-	 */
-	while (!(match && stateTree->isSimple) &&
-	       ((!match || !complexMatchState) && (currIndex != TM_NO_MATCH))) {
-	    currIndex++;
-	    if (matchExact)
-	      currIndex = MatchExact(stateTree,currIndex,typeIndex,modIndex);
-	    else
-	      currIndex = MatchBranchHead(stateTree,currIndex,curEventPtr);
-	    if (currIndex != TM_NO_MATCH) {
-		TMBranchHead branchHead;
-		StatePtr currState;
-
-		branchHead = &stateTree->branchHeadTbl[currIndex];
-		if (branchHead->isSimple)
-		  currState = NULL;
-		else
-		  currState = ((TMComplexStateTree)stateTree)
-		    ->complexBranchHeadTbl[TMBranchMore(branchHead)];
-
-		/*
-		 * first check for a complete match
-		 */
-		if (!match) {
-		    if (branchHead->hasActions) {
-			if (branchHead->isSimple) {
-			    static ActionRec	dummyAction;
-
-			    dummyAction.idx = TMBranchMore(branchHead);
-			    actions = &dummyAction;
-			}
-			else
-			  actions = currState->actions;
-			tmRecPtr->lastEventTime =
-			  GetTime(tmRecPtr, curEventPtr->xev);
-			FreeContext((TMContext
-				     *)&tmRecPtr->current_state);
-			match = True;
-			matchTreeIndex = i;
-		    }
-		    /*
-		     * if it doesn't have actions and
-		     * it's bc mode then it's a potential match node that is
-		     * used to match later sequences.
-		     */
-		    if (!TMNewMatchSemantics() && !matchExact) {
-			matchExact = True;
-			typeIndex = branchHead->typeIndex;
-			modIndex = branchHead->modIndex;
-		    }
-		}
-		/*
-		 * check for it being an event sequence which can be
-		 * a future match
-		 */
-		if (!branchHead->isSimple &&
-		    !branchHead->hasActions &&
-		    !complexMatchState)
-		  complexMatchState = currState;
-	    }
-	}
-    }
-    if (match)
-      {
-	  TMBindData	bindData = (TMBindData) tmRecPtr->proc_table;
-	  XtActionProc	*procs;
-	  Widget	accelWidget;
-
-	  if (bindData->simple.isComplex) {
-	      TMComplexBindProcs bindProcs =
-		TMGetComplexBindEntry(bindData, matchTreeIndex);
-	      procs = bindProcs->procs;
-	      accelWidget = bindProcs->widget;
-	  }
-	  else {
-	      TMSimpleBindProcs bindProcs =
-		TMGetSimpleBindEntry(bindData, matchTreeIndex);
-	      procs = bindProcs->procs;
-	      accelWidget = NULL;
-	  }
-	  HandleActions
-	    (w,
-	     curEventPtr->xev,
-	     (TMSimpleStateTree)xlations->stateTreeTbl[matchTreeIndex],
-	     accelWidget,
-	     procs,
-	     actions);
-      }
+         ((!match || !complexMatchState) && (i < xlations->numStateTrees));
+         i++) {
+        int currIndex = -1;
+        TMSimpleStateTree stateTree =
+            (TMSimpleStateTree) xlations->stateTreeTbl[i];
+
+        /*
+         * don't process this tree if we're only looking for a
+         * complexMatchState and there are no complex states
+         */
+        while (!(match && stateTree->isSimple) &&
+               ((!match || !complexMatchState) && (currIndex != TM_NO_MATCH))) {
+            currIndex++;
+            if (matchExact)
+                currIndex =
+                    MatchExact(stateTree, currIndex, typeIndex, modIndex);
+            else
+                currIndex = MatchBranchHead(stateTree, currIndex, curEventPtr);
+            if (currIndex != TM_NO_MATCH) {
+                TMBranchHead branchHead;
+                StatePtr currState;
+
+                branchHead = &stateTree->branchHeadTbl[currIndex];
+                if (branchHead->isSimple)
+                    currState = NULL;
+                else
+                    currState = ((TMComplexStateTree) stateTree)
+                        ->complexBranchHeadTbl[TMBranchMore(branchHead)];
+
+                /*
+                 * first check for a complete match
+                 */
+                if (!match) {
+                    if (branchHead->hasActions) {
+                        if (branchHead->isSimple) {
+                            static ActionRec dummyAction;
+
+                            dummyAction.idx = TMBranchMore(branchHead);
+                            actions = &dummyAction;
+                        }
+                        else
+                            actions = currState->actions;
+                        tmRecPtr->lastEventTime =
+                            GetTime(tmRecPtr, curEventPtr->xev);
+                        FreeContext((TMContext *) &tmRecPtr->current_state);
+                        match = True;
+                        matchTreeIndex = i;
+                    }
+                    /*
+                     * if it doesn't have actions and
+                     * it's bc mode then it's a potential match node that is
+                     * used to match later sequences.
+                     */
+                    if (!TMNewMatchSemantics() && !matchExact) {
+                        matchExact = True;
+                        typeIndex = branchHead->typeIndex;
+                        modIndex = branchHead->modIndex;
+                    }
+                }
+                /*
+                 * check for it being an event sequence which can be
+                 * a future match
+                 */
+                if (!branchHead->isSimple &&
+                    !branchHead->hasActions && !complexMatchState)
+                    complexMatchState = currState;
+            }
+        }
+    }
+    if (match) {
+        TMBindData bindData = (TMBindData) tmRecPtr->proc_table;
+        XtActionProc *procs;
+        Widget accelWidget;
+
+        if (bindData->simple.isComplex) {
+            TMComplexBindProcs bindProcs =
+                TMGetComplexBindEntry(bindData, matchTreeIndex);
+            procs = bindProcs->procs;
+            accelWidget = bindProcs->widget;
+        }
+        else {
+            TMSimpleBindProcs bindProcs =
+                TMGetSimpleBindEntry(bindData, matchTreeIndex);
+            procs = bindProcs->procs;
+            accelWidget = NULL;
+        }
+        HandleActions
+            (w,
+             curEventPtr->xev,
+             (TMSimpleStateTree) xlations->stateTreeTbl[matchTreeIndex],
+             accelWidget, procs, actions);
+    }
     if (complexMatchState)
-      PushContext(contextPtr, complexMatchState);
+        PushContext(contextPtr, complexMatchState);
     UNLOCK_PROCESS;
 }
 
-static int MatchComplexBranch(
-    TMComplexStateTree	stateTree,
-    int			startIndex,
-    TMContext		context,
-    StatePtr		*leafStateRtn)
+static int
+MatchComplexBranch(TMComplexStateTree stateTree,
+                   int startIndex,
+                   TMContext context,
+                   StatePtr *leafStateRtn)
 {
-    TMShortCard	i;
+    TMShortCard i;
 
     LOCK_PROCESS;
-    for (i = (TMShortCard) startIndex; i < stateTree->numComplexBranchHeads; i++)
-      {
-	  StatePtr	candState;
-	  TMShortCard	numMatches = context->numMatches;
-	  MatchPair	statMatch = context->matches;
-
-	  for (candState = stateTree->complexBranchHeadTbl[i];
-	       numMatches && candState;
-	       numMatches--, statMatch++, candState = candState->nextLevel)
-	    {
-		if ((statMatch->typeIndex != candState->typeIndex) ||
-		    (statMatch->modIndex != candState->modIndex))
-		  break;
-	    }
-	  if (numMatches == 0) {
-	      *leafStateRtn = candState;
-	      UNLOCK_PROCESS;
-	      return i;
-	  }
-      }
+    for (i = (TMShortCard) startIndex; i < stateTree->numComplexBranchHeads;
+         i++) {
+        StatePtr candState;
+        TMShortCard numMatches = context->numMatches;
+        MatchPair statMatch = context->matches;
+
+        for (candState = stateTree->complexBranchHeadTbl[i];
+             numMatches && candState;
+             numMatches--, statMatch++, candState = candState->nextLevel) {
+            if ((statMatch->typeIndex != candState->typeIndex) ||
+                (statMatch->modIndex != candState->modIndex))
+                break;
+        }
+        if (numMatches == 0) {
+            *leafStateRtn = candState;
+            UNLOCK_PROCESS;
+            return i;
+        }
+    }
     *leafStateRtn = NULL;
     UNLOCK_PROCESS;
     return (TM_NO_MATCH);
 }
 
-static StatePtr TryCurrentTree(
-    TMComplexStateTree	*stateTreePtr,
-    XtTM		tmRecPtr,
-    TMEventRec		*curEventPtr)
+static StatePtr
+TryCurrentTree(TMComplexStateTree *stateTreePtr,
+               XtTM tmRecPtr,
+               TMEventRec *curEventPtr)
 {
-    StatePtr		candState = NULL, matchState = NULL;
-    TMContext		*contextPtr = GetContextPtr(tmRecPtr);
-    TMTypeMatch 	typeMatch;
-    TMModifierMatch 	modMatch;
-    int			currIndex = -1;
+    StatePtr candState = NULL, matchState = NULL;
+    TMContext *contextPtr = GetContextPtr(tmRecPtr);
+    TMTypeMatch typeMatch;
+    TMModifierMatch modMatch;
+    int currIndex = -1;
 
     /*
      * we want the first sequence that both matches and has actions.
@@ -942,171 +936,152 @@ static StatePtr TryCurrentTree(
      */
     LOCK_PROCESS;
     while ((currIndex =
-	    MatchComplexBranch(*stateTreePtr,
-			       ++currIndex,
-			       (*contextPtr),
-			       &candState))
-	   != TM_NO_MATCH) {
-	if (candState  != NULL) {
-	    typeMatch  = TMGetTypeMatch(candState->typeIndex);
-	    modMatch = TMGetModifierMatch(candState->modIndex);
-
-	    /* does this state's index match? --> done */
-	    if (MatchIncomingEvent(curEventPtr, typeMatch, modMatch))
-	      {
-		  if (candState->actions) {
-		      UNLOCK_PROCESS;
-		      return candState;
-		  }
-		  else
-		    matchState = candState;
-	      }
-	    /* is this an event timer? */
-	    if (typeMatch->eventType == _XtEventTimerEventType) {
-		StatePtr nextState = candState->nextLevel;
-
-		/* does the succeeding state match? */
-		if (nextState != NULL) {
-		    TMTypeMatch 	nextTypeMatch;
-		    TMModifierMatch	nextModMatch;
-
-		    nextTypeMatch  = TMGetTypeMatch(nextState->typeIndex);
-		    nextModMatch = TMGetModifierMatch(nextState->modIndex);
-
-		    /* is it within the timeout? */
-		    if (MatchIncomingEvent(curEventPtr,
-					   nextTypeMatch,
-					   nextModMatch)) {
-			XEvent *xev = curEventPtr->xev;
-			unsigned long time = GetTime(tmRecPtr, xev);
-			XtPerDisplay pd = _XtGetPerDisplay(xev->xany.display);
-			unsigned long delta = (unsigned long) pd->multi_click_time;
-
-			if ((tmRecPtr->lastEventTime + delta) >= time) {
-			    if (nextState->actions) {
-				UNLOCK_PROCESS;
-				return candState;
-			    }
-			    else
-			      matchState = candState;
-			}
-		    }
-		}
-	    }
-	}
+            MatchComplexBranch(*stateTreePtr,
+                               ++currIndex, (*contextPtr), &candState))
+           != TM_NO_MATCH) {
+        if (candState != NULL) {
+            typeMatch = TMGetTypeMatch(candState->typeIndex);
+            modMatch = TMGetModifierMatch(candState->modIndex);
+
+            /* does this state's index match? --> done */
+            if (MatchIncomingEvent(curEventPtr, typeMatch, modMatch)) {
+                if (candState->actions) {
+                    UNLOCK_PROCESS;
+                    return candState;
+                }
+                else
+                    matchState = candState;
+            }
+            /* is this an event timer? */
+            if (typeMatch->eventType == _XtEventTimerEventType) {
+                StatePtr nextState = candState->nextLevel;
+
+                /* does the succeeding state match? */
+                if (nextState != NULL) {
+                    TMTypeMatch nextTypeMatch;
+                    TMModifierMatch nextModMatch;
+
+                    nextTypeMatch = TMGetTypeMatch(nextState->typeIndex);
+                    nextModMatch = TMGetModifierMatch(nextState->modIndex);
+
+                    /* is it within the timeout? */
+                    if (MatchIncomingEvent(curEventPtr,
+                                           nextTypeMatch, nextModMatch)) {
+                        XEvent *xev = curEventPtr->xev;
+                        unsigned long time = GetTime(tmRecPtr, xev);
+                        XtPerDisplay pd = _XtGetPerDisplay(xev->xany.display);
+                        unsigned long delta =
+                            (unsigned long) pd->multi_click_time;
+
+                        if ((tmRecPtr->lastEventTime + delta) >= time) {
+                            if (nextState->actions) {
+                                UNLOCK_PROCESS;
+                                return candState;
+                            }
+                            else
+                                matchState = candState;
+                        }
+                    }
+                }
+            }
+        }
     }
     UNLOCK_PROCESS;
     return matchState;
 }
 
-static void HandleComplexState(
-    Widget	w,
-    XtTM	tmRecPtr,
-    TMEventRec	*curEventPtr)
+static void
+HandleComplexState(Widget w, XtTM tmRecPtr, TMEventRec *curEventPtr)
 {
-    XtTranslations 	xlations = tmRecPtr->translations;
-    TMContext		*contextPtr = GetContextPtr(tmRecPtr);
-    TMShortCard		i, matchTreeIndex = 0;
-    StatePtr		matchState = NULL, candState;
-    TMComplexStateTree 	*stateTreePtr =
-      (TMComplexStateTree *)&xlations->stateTreeTbl[0];
+    XtTranslations xlations = tmRecPtr->translations;
+    TMContext *contextPtr = GetContextPtr(tmRecPtr);
+    TMShortCard i, matchTreeIndex = 0;
+    StatePtr matchState = NULL, candState;
+    TMComplexStateTree *stateTreePtr =
+        (TMComplexStateTree *) &xlations->stateTreeTbl[0];
 
     LOCK_PROCESS;
-    for (i = 0;
-	 i < xlations->numStateTrees;
-	 i++, stateTreePtr++) {
-	/*
-	 * some compilers sign extend Boolean bit fields so test for
-	 * false |||
-	 */
-	if (((*stateTreePtr)->isSimple == False) &&
-	    (candState = TryCurrentTree(stateTreePtr,
-				       tmRecPtr,
-				       curEventPtr))) {
-	    if (!matchState || candState->actions) {
-		matchTreeIndex = i;
-		matchState = candState;
-		if (candState->actions)
-		    break;
-	    }
-	}
-    }
-    if (matchState == NULL){
-	/* couldn't find it... */
-	if (!Ignore(curEventPtr))
-	  {
-	      FreeContext(contextPtr);
-	      HandleSimpleState(w, tmRecPtr, curEventPtr);
-	  }
+    for (i = 0; i < xlations->numStateTrees; i++, stateTreePtr++) {
+        /*
+         * some compilers sign extend Boolean bit fields so test for
+         * false |||
+         */
+        if (((*stateTreePtr)->isSimple == False) &&
+            (candState = TryCurrentTree(stateTreePtr, tmRecPtr, curEventPtr))) {
+            if (!matchState || candState->actions) {
+                matchTreeIndex = i;
+                matchState = candState;
+                if (candState->actions)
+                    break;
+            }
+        }
+    }
+    if (matchState == NULL) {
+        /* couldn't find it... */
+        if (!Ignore(curEventPtr)) {
+            FreeContext(contextPtr);
+            HandleSimpleState(w, tmRecPtr, curEventPtr);
+        }
     }
     else {
-	TMBindData	bindData = (TMBindData) tmRecPtr->proc_table;
-	XtActionProc	*procs;
-	Widget		accelWidget;
-	TMTypeMatch 	typeMatch;
-
-	typeMatch  = TMGetTypeMatch(matchState->typeIndex);
-
-	PushContext(contextPtr, matchState);
-	if (typeMatch->eventType == _XtEventTimerEventType) {
-	    matchState = matchState->nextLevel;
-	    PushContext(contextPtr, matchState);
-	}
-	tmRecPtr->lastEventTime = GetTime (tmRecPtr, curEventPtr->xev);
-
-	if (bindData->simple.isComplex) {
-	    TMComplexBindProcs bindProcs =
-	      TMGetComplexBindEntry(bindData, matchTreeIndex);
-	    procs = bindProcs->procs;
-	    accelWidget = bindProcs->widget;
-	}
-	else {
-	    TMSimpleBindProcs bindProcs =
-	      TMGetSimpleBindEntry(bindData, matchTreeIndex);
-	    procs = bindProcs->procs;
-	    accelWidget = NULL;
-	}
-	HandleActions(w,
-		      curEventPtr->xev,
-		      (TMSimpleStateTree)
-		      xlations->stateTreeTbl[matchTreeIndex],
-		      accelWidget,
-		      procs,
-		      matchState->actions);
+        TMBindData bindData = (TMBindData) tmRecPtr->proc_table;
+        XtActionProc *procs;
+        Widget accelWidget;
+        TMTypeMatch typeMatch;
+
+        typeMatch = TMGetTypeMatch(matchState->typeIndex);
+
+        PushContext(contextPtr, matchState);
+        if (typeMatch->eventType == _XtEventTimerEventType) {
+            matchState = matchState->nextLevel;
+            PushContext(contextPtr, matchState);
+        }
+        tmRecPtr->lastEventTime = GetTime(tmRecPtr, curEventPtr->xev);
+
+        if (bindData->simple.isComplex) {
+            TMComplexBindProcs bindProcs =
+                TMGetComplexBindEntry(bindData, matchTreeIndex);
+            procs = bindProcs->procs;
+            accelWidget = bindProcs->widget;
+        }
+        else {
+            TMSimpleBindProcs bindProcs =
+                TMGetSimpleBindEntry(bindData, matchTreeIndex);
+            procs = bindProcs->procs;
+            accelWidget = NULL;
+        }
+        HandleActions(w, curEventPtr->xev, (TMSimpleStateTree)
+                      xlations->stateTreeTbl[matchTreeIndex],
+                      accelWidget, procs, matchState->actions);
     }
     UNLOCK_PROCESS;
 }
 
-
-void _XtTranslateEvent (
-    Widget w,
-    XEvent * event)
+void
+_XtTranslateEvent(Widget w, XEvent *event)
 {
-    XtTM	tmRecPtr = &w->core.tm;
-    TMEventRec 	curEvent;
-    StatePtr 	current_state = tmRecPtr->current_state;
+    XtTM tmRecPtr = &w->core.tm;
+    TMEventRec curEvent;
+    StatePtr current_state = tmRecPtr->current_state;
 
-    XEventToTMEvent (event, &curEvent);
+    XEventToTMEvent(event, &curEvent);
 
-    if (! tmRecPtr->translations) {
+    if (!tmRecPtr->translations) {
         XtAppWarningMsg(XtWidgetToApplicationContext(w),
-			XtNtranslationError,"nullTable",XtCXtToolkitError,
-			"Can't translate event through NULL table",
-			NULL, NULL);
-	return ;
+                        XtNtranslationError, "nullTable", XtCXtToolkitError,
+                        "Can't translate event through NULL table", NULL, NULL);
+        return;
     }
     if (current_state == NULL)
-	  HandleSimpleState(w, tmRecPtr, &curEvent);
+        HandleSimpleState(w, tmRecPtr, &curEvent);
     else
-	  HandleComplexState(w, tmRecPtr, &curEvent);
+        HandleComplexState(w, tmRecPtr, &curEvent);
 }
 
-
-/*ARGSUSED*/
-static StatePtr NewState(
-    TMParseStateTree stateTree,
-    TMShortCard	typeIndex,
-    TMShortCard	modIndex)
+static StatePtr
+NewState(TMParseStateTree stateTree _X_UNUSED,
+         TMShortCard typeIndex,
+         TMShortCard modIndex)
 {
     StatePtr state = XtNew(StateRec);
 
@@ -1114,7 +1089,7 @@ static StatePtr NewState(
     LOCK_PROCESS;
     _XtGlobalTM.numComplexStates++;
     UNLOCK_PROCESS;
-#endif /* TRACE_TM */
+#endif                          /* TRACE_TM */
     state->typeIndex = typeIndex;
     state->modIndex = modIndex;
     state->nextLevel = NULL;
@@ -1127,57 +1102,50 @@ static StatePtr NewState(
  * This routine is an iterator for state trees. If the func returns
  * true then iteration is over.
  */
-void _XtTraverseStateTree(
-    TMStateTree	tree,
-    _XtTraversalProc func,
-    XtPointer 	data)
+void
+_XtTraverseStateTree(TMStateTree tree, _XtTraversalProc func, XtPointer data)
 {
-    TMComplexStateTree stateTree = (TMComplexStateTree)tree;
-    TMBranchHead	currBH;
-    TMShortCard		i;
-    StateRec		dummyStateRec, *dummyState = &dummyStateRec;
-    ActionRec		dummyActionRec, *dummyAction = &dummyActionRec;
-    Boolean		firstSimple = True;
-    StatePtr 		currState;
+    TMComplexStateTree stateTree = (TMComplexStateTree) tree;
+    TMBranchHead currBH;
+    TMShortCard i;
+    StateRec dummyStateRec, *dummyState = &dummyStateRec;
+    ActionRec dummyActionRec, *dummyAction = &dummyActionRec;
+    Boolean firstSimple = True;
+    StatePtr currState;
 
     /* first traverse the complex states */
     if (stateTree->isSimple == False)
-      for (i = 0; i < stateTree->numComplexBranchHeads; i++) {
-	  currState = stateTree->complexBranchHeadTbl[i];
-	  for (; currState; currState = currState->nextLevel) {
-	      if (func(currState, data))
-		return;
-	      if (currState->isCycleEnd)
-		break;
-	  }
-      }
+        for (i = 0; i < stateTree->numComplexBranchHeads; i++) {
+            currState = stateTree->complexBranchHeadTbl[i];
+            for (; currState; currState = currState->nextLevel) {
+                if (func(currState, data))
+                    return;
+                if (currState->isCycleEnd)
+                    break;
+            }
+        }
 
     /* now traverse the simple ones */
     for (i = 0, currBH = stateTree->branchHeadTbl;
-	 i < stateTree->numBranchHeads;
-	 i++, currBH++)
-      {
-	  if (currBH->isSimple && currBH->hasActions)
-	    {
-		if (firstSimple)
-		  {
-		      XtBZero((char *) dummyState, sizeof(StateRec));
-		      XtBZero((char *) dummyAction, sizeof(ActionRec));
-		      dummyState->actions = dummyAction;
-		      firstSimple = False;
-		  }
-		dummyState->typeIndex = currBH->typeIndex;
-		dummyState->modIndex = currBH->modIndex;
-		dummyAction->idx = currBH->more;
-		if (func(dummyState, data))
-		  return;
-	    }
-      }
+         i < stateTree->numBranchHeads; i++, currBH++) {
+        if (currBH->isSimple && currBH->hasActions) {
+            if (firstSimple) {
+                XtBZero((char *) dummyState, sizeof(StateRec));
+                XtBZero((char *) dummyAction, sizeof(ActionRec));
+                dummyState->actions = dummyAction;
+                firstSimple = False;
+            }
+            dummyState->typeIndex = currBH->typeIndex;
+            dummyState->modIndex = currBH->modIndex;
+            dummyAction->idx = currBH->more;
+            if (func(dummyState, data))
+                return;
+        }
+    }
 }
 
-static EventMask EventToMask(
-    TMTypeMatch     typeMatch,
-    TMModifierMatch modMatch)
+static EventMask
+EventToMask(TMTypeMatch typeMatch, TMModifierMatch modMatch)
 {
     EventMask returnMask;
     unsigned long eventType = typeMatch->eventType;
@@ -1186,18 +1154,18 @@ static EventMask EventToMask(
         Modifiers modifierMask = (Modifiers) modMatch->modifierMask;
         Modifiers tempMask;
 
-	returnMask = 0;
+        returnMask = 0;
         if (modifierMask == 0) {
-	    if (modMatch->modifiers == AnyButtonMask)
-		return ButtonMotionMask;
-	    else
-		return PointerMotionMask;
-	}
+            if (modMatch->modifiers == AnyButtonMask)
+                return ButtonMotionMask;
+            else
+                return PointerMotionMask;
+        }
         tempMask = modifierMask &
-	    (Button1Mask | Button2Mask | Button3Mask
-	     | Button4Mask | Button5Mask);
+            (Button1Mask | Button2Mask | Button3Mask
+             | Button4Mask | Button5Mask);
         if (tempMask == 0)
-	    return PointerMotionMask;
+            return PointerMotionMask;
         if (tempMask & Button1Mask)
             returnMask |= Button1MotionMask;
         if (tempMask & Button2Mask)
@@ -1210,54 +1178,49 @@ static EventMask EventToMask(
             returnMask |= Button5MotionMask;
         return returnMask;
     }
-    returnMask = _XtConvertTypeToMask((int)eventType);
-    if (returnMask == (StructureNotifyMask|SubstructureNotifyMask))
-	returnMask = StructureNotifyMask;
+    returnMask = _XtConvertTypeToMask((int) eventType);
+    if (returnMask == (StructureNotifyMask | SubstructureNotifyMask))
+        returnMask = StructureNotifyMask;
     return returnMask;
 }
 
-/*ARGSUSED*/
-static void DispatchMappingNotify(
-    Widget widget,		/* will be NULL from _RefreshMapping */
-    XtPointer closure,		/* real Widget */
-    XtPointer call_data)	/* XEvent* */
+static void
+DispatchMappingNotify(Widget widget _X_UNUSED,  /* will be NULL from _RefreshMapping */
+                      XtPointer closure,        /* real Widget */
+                      XtPointer call_data)      /* XEvent* */
 {
-    _XtTranslateEvent( (Widget)closure, (XEvent*)call_data);
+    _XtTranslateEvent((Widget) closure, (XEvent *) call_data);
 }
 
-
-/*ARGSUSED*/
-static void RemoveFromMappingCallbacks(
-    Widget widget,
-    XtPointer closure,		/* target widget */
-    XtPointer call_data)
+static void
+RemoveFromMappingCallbacks(Widget widget,
+                           XtPointer closure,    /* target widget */
+                           XtPointer call_data _X_UNUSED)
 {
-    _XtRemoveCallback( &_XtGetPerDisplay(XtDisplay(widget))->mapping_callbacks,
-		       DispatchMappingNotify,
-		       closure
-		      );
+    _XtRemoveCallback(&_XtGetPerDisplay(XtDisplay(widget))->mapping_callbacks,
+                      DispatchMappingNotify, closure);
 }
 
-static Boolean AggregateEventMask(
-    StatePtr	state,
-    XtPointer	data)
+static Boolean
+AggregateEventMask(StatePtr state, XtPointer data)
 {
     LOCK_PROCESS;
-    *((EventMask *)data) |= EventToMask(TMGetTypeMatch(state->typeIndex),
-					TMGetModifierMatch(state->modIndex));
+    *((EventMask *) data) |= EventToMask(TMGetTypeMatch(state->typeIndex),
+                                         TMGetModifierMatch(state->modIndex));
     UNLOCK_PROCESS;
     return False;
 }
 
-void _XtInstallTranslations(
-    Widget widget)
+void
+_XtInstallTranslations(Widget widget)
 {
     XtTranslations xlations;
-    Cardinal	i;
-    Boolean  mappingNotifyInterest = False;
+    Cardinal i;
+    Boolean mappingNotifyInterest = False;
 
     xlations = widget->core.tm.translations;
-    if (xlations == NULL) return;
+    if (xlations == NULL)
+        return;
 
     /*
      * check for somebody stuffing the translations directly into the
@@ -1265,219 +1228,216 @@ void _XtInstallTranslations(
      * ComposeTranslations but we *should* have bindings by then
      */
     if (widget->core.tm.proc_table == NULL) {
-	_XtMergeTranslations(widget, NULL, XtTableReplace);
-	/*
-	 * if we're realized then we'll be called out of
-	 * ComposeTranslations
-	 */
-	if (XtIsRealized(widget))
-	  return;
+        _XtMergeTranslations(widget, NULL, XtTableReplace);
+        /*
+         * if we're realized then we'll be called out of
+         * ComposeTranslations
+         */
+        if (XtIsRealized(widget))
+            return;
     }
 
     xlations->eventMask = 0;
-    for (i = 0;
-	 i < xlations->numStateTrees;
-	 i++)
-      {
-	  TMStateTree	stateTree = xlations->stateTreeTbl[i];
-	  _XtTraverseStateTree(stateTree,
-			    AggregateEventMask,
-			    (XtPointer)&xlations->eventMask);
-	  mappingNotifyInterest = (Boolean) (mappingNotifyInterest | stateTree->simple.mappingNotifyInterest);
-      }
+    for (i = 0; i < xlations->numStateTrees; i++) {
+        TMStateTree stateTree = xlations->stateTreeTbl[i];
+
+        _XtTraverseStateTree(stateTree,
+                             AggregateEventMask,
+                             (XtPointer) &xlations->eventMask);
+        mappingNotifyInterest =
+            (Boolean) (mappingNotifyInterest |
+                       stateTree->simple.mappingNotifyInterest);
+    }
     /* double click needs to make sure that you have selected on both
-	button down and up. */
+       button down and up. */
 
     if (xlations->eventMask & ButtonPressMask)
-      xlations->eventMask |= ButtonReleaseMask;
+        xlations->eventMask |= ButtonReleaseMask;
     if (xlations->eventMask & ButtonReleaseMask)
-      xlations->eventMask |= ButtonPressMask;
+        xlations->eventMask |= ButtonPressMask;
 
     if (mappingNotifyInterest) {
-	XtPerDisplay pd = _XtGetPerDisplay(XtDisplay(widget));
-	if (pd->mapping_callbacks)
-	    _XtAddCallbackOnce(&(pd->mapping_callbacks),
-			       DispatchMappingNotify,
-			       (XtPointer)widget);
-	else
-	    _XtAddCallback(&(pd->mapping_callbacks),
-			   DispatchMappingNotify,
-			   (XtPointer)widget);
-
-	if (widget->core.destroy_callbacks != NULL)
-	    _XtAddCallbackOnce( (InternalCallbackList *)
-			        &widget->core.destroy_callbacks,
-				RemoveFromMappingCallbacks,
-				(XtPointer)widget
-			       );
-	else
-	    _XtAddCallback((InternalCallbackList *)
-			   &widget->core.destroy_callbacks,
-			   RemoveFromMappingCallbacks,
-			   (XtPointer)widget
-			  );
-    }
-    _XtBindActions(widget, (XtTM)&widget->core.tm);
+        XtPerDisplay pd = _XtGetPerDisplay(XtDisplay(widget));
+
+        if (pd->mapping_callbacks)
+            _XtAddCallbackOnce(&(pd->mapping_callbacks),
+                               DispatchMappingNotify, (XtPointer) widget);
+        else
+            _XtAddCallback(&(pd->mapping_callbacks),
+                           DispatchMappingNotify, (XtPointer) widget);
+
+        if (widget->core.destroy_callbacks != NULL)
+            _XtAddCallbackOnce((InternalCallbackList *)
+                               &widget->core.destroy_callbacks,
+                               RemoveFromMappingCallbacks, (XtPointer) widget);
+        else
+            _XtAddCallback((InternalCallbackList *)
+                           &widget->core.destroy_callbacks,
+                           RemoveFromMappingCallbacks, (XtPointer) widget);
+    }
+    _XtBindActions(widget, (XtTM) &widget->core.tm);
     _XtRegisterGrabs(widget);
 }
 
-void _XtRemoveTranslations(
-    Widget widget)
+void
+_XtRemoveTranslations(Widget widget)
 {
-    Cardinal	i;
-    Boolean  		mappingNotifyInterest = False;
-    XtTranslations		xlations = widget->core.tm.translations;
+    Cardinal i;
+    Boolean mappingNotifyInterest = False;
+    XtTranslations xlations = widget->core.tm.translations;
 
     if (xlations == NULL)
-      return;
-
-    for (i = 0;
-	 i < xlations->numStateTrees;
-	 i++)
-      {
-	  TMSimpleStateTree stateTree = (TMSimpleStateTree)xlations->stateTreeTbl[i];
-	  mappingNotifyInterest = (Boolean) (mappingNotifyInterest | stateTree->mappingNotifyInterest);
-      }
+        return;
+
+    for (i = 0; i < xlations->numStateTrees; i++) {
+        TMSimpleStateTree stateTree =
+            (TMSimpleStateTree) xlations->stateTreeTbl[i];
+        mappingNotifyInterest =
+            (Boolean) (mappingNotifyInterest |
+                       stateTree->mappingNotifyInterest);
+    }
     if (mappingNotifyInterest)
-      RemoveFromMappingCallbacks(widget, (XtPointer)widget, NULL);
+        RemoveFromMappingCallbacks(widget, (XtPointer) widget, NULL);
 }
 
-static void _XtUninstallTranslations(
-    Widget widget)
+static void
+_XtUninstallTranslations(Widget widget)
 {
-    XtTranslations	xlations = widget->core.tm.translations;
+    XtTranslations xlations = widget->core.tm.translations;
 
-    _XtUnbindActions(widget,
-		     xlations,
-		     (TMBindData)widget->core.tm.proc_table);
+    _XtUnbindActions(widget, xlations, (TMBindData) widget->core.tm.proc_table);
     _XtRemoveTranslations(widget);
     widget->core.tm.translations = NULL;
-    FreeContext((TMContext *)&widget->core.tm.current_state);
+    FreeContext((TMContext *) &widget->core.tm.current_state);
 }
 
-void _XtDestroyTMData(
-    Widget	widget)
+void
+_XtDestroyTMData(Widget widget)
 {
-    TMComplexBindData	cBindData;
+    TMComplexBindData cBindData;
 
     _XtUninstallTranslations(widget);
 
-    if ((cBindData = (TMComplexBindData)widget->core.tm.proc_table)) {
-	if (cBindData->isComplex) {
-	    ATranslations nXlations = (ATranslations) cBindData->accel_context;
-	    while (nXlations){
-		ATranslations aXlations = nXlations;
-		nXlations = nXlations->next;
-		XtFree((char *)aXlations);
-	    }
-	}
-	XtFree((char *)cBindData);
+    if ((cBindData = (TMComplexBindData) widget->core.tm.proc_table)) {
+        if (cBindData->isComplex) {
+            ATranslations nXlations = (ATranslations) cBindData->accel_context;
+
+            while (nXlations) {
+                ATranslations aXlations = nXlations;
+
+                nXlations = nXlations->next;
+                XtFree((char *) aXlations);
+            }
+        }
+        XtFree((char *) cBindData);
     }
 }
 
 /*** Public procedures ***/
 
-
-void XtUninstallTranslations(
-    Widget widget)
+void
+XtUninstallTranslations(Widget widget)
 {
-    EventMask	oldMask;
+    EventMask oldMask;
     Widget hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    if (! widget->core.tm.translations) {
-	UNLOCK_APP(app);
-	return;
+    if (!widget->core.tm.translations) {
+        UNLOCK_APP(app);
+        return;
     }
     oldMask = widget->core.tm.translations->eventMask;
     _XtUninstallTranslations(widget);
     if (XtIsRealized(widget) && oldMask)
-	XSelectInput(XtDisplay(widget), XtWindow(widget),
-		     (long) XtBuildEventMask(widget));
+        XSelectInput(XtDisplay(widget), XtWindow(widget),
+                     (long) XtBuildEventMask(widget));
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHuninstallTranslations;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHuninstallTranslations;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_APP(app);
 }
 
-XtTranslations _XtCreateXlations(
-    TMStateTree		*stateTrees,
-    TMShortCard		numStateTrees,
-    XtTranslations	first,
-    XtTranslations	second)
+XtTranslations
+_XtCreateXlations(TMStateTree *stateTrees,
+                  TMShortCard numStateTrees,
+                  XtTranslations first,
+                  XtTranslations second)
 {
-    XtTranslations	xlations;
+    XtTranslations xlations;
     TMShortCard i;
 
     xlations = (XtTranslations)
-      __XtMalloc((Cardinal)(sizeof(TranslationData) +
-	       (size_t)(numStateTrees - 1) * sizeof(TMStateTree)));
+        __XtMalloc((Cardinal) (sizeof(TranslationData) +
+                               (size_t) (numStateTrees -
+                                         1) * sizeof(TMStateTree)));
 #ifdef TRACE_TM
     LOCK_PROCESS;
     if (_XtGlobalTM.numTms == _XtGlobalTM.tmTblSize) {
-	_XtGlobalTM.tmTblSize = (TMShortCard)(_XtGlobalTM.tmTblSize + 16);
-	_XtGlobalTM.tmTbl = (XtTranslations *)
-	  XtRealloc((char *)_XtGlobalTM.tmTbl,
-		    (Cardinal)(_XtGlobalTM.tmTblSize * sizeof(XtTranslations)));
+        _XtGlobalTM.tmTblSize = (TMShortCard) (_XtGlobalTM.tmTblSize + 16);
+        _XtGlobalTM.tmTbl = (XtTranslations *)
+            XtRealloc((char *) _XtGlobalTM.tmTbl,
+                      (Cardinal) (_XtGlobalTM.tmTblSize *
+                                  sizeof(XtTranslations)));
     }
     _XtGlobalTM.tmTbl[_XtGlobalTM.numTms++] = xlations;
     UNLOCK_PROCESS;
-#endif /* TRACE_TM */
+#endif                          /* TRACE_TM */
 
     xlations->composers[0] = first;
     xlations->composers[1] = second;
     xlations->hasBindings = False;
     xlations->operation = XtTableReplace;
 
-    for (i = 0;i < numStateTrees; i++)
-      {
-	  xlations->stateTreeTbl[i] = (TMStateTree) stateTrees[i];
-	  stateTrees[i]->simple.refCount++;
-      }
+    for (i = 0; i < numStateTrees; i++) {
+        xlations->stateTreeTbl[i] = (TMStateTree) stateTrees[i];
+        stateTrees[i]->simple.refCount++;
+    }
     xlations->numStateTrees = numStateTrees;
     xlations->eventMask = 0;
     return xlations;
 }
 
-TMStateTree _XtParseTreeToStateTree(
-    TMParseStateTree	parseTree)
+TMStateTree
+_XtParseTreeToStateTree(TMParseStateTree parseTree)
 {
-    TMSimpleStateTree  simpleTree;
-    unsigned int	tableSize;
+    TMSimpleStateTree simpleTree;
+    unsigned int tableSize;
 
     if (parseTree->numComplexBranchHeads) {
-	TMComplexStateTree complexTree;
-
-	complexTree = XtNew(TMComplexStateTreeRec);
-	complexTree->isSimple = False;
-	tableSize = (unsigned) (parseTree->numComplexBranchHeads * sizeof(StatePtr));
-	complexTree->complexBranchHeadTbl = (StatePtr *)
-	  __XtMalloc(tableSize);
-	XtMemmove(complexTree->complexBranchHeadTbl,
-		  parseTree->complexBranchHeadTbl, tableSize);
-	complexTree->numComplexBranchHeads =
-	  parseTree->numComplexBranchHeads;
-	simpleTree = (TMSimpleStateTree)complexTree;
+        TMComplexStateTree complexTree;
+
+        complexTree = XtNew(TMComplexStateTreeRec);
+        complexTree->isSimple = False;
+        tableSize =
+            (unsigned) (parseTree->numComplexBranchHeads * sizeof(StatePtr));
+        complexTree->complexBranchHeadTbl = (StatePtr *)
+            __XtMalloc(tableSize);
+        XtMemmove(complexTree->complexBranchHeadTbl,
+                  parseTree->complexBranchHeadTbl, tableSize);
+        complexTree->numComplexBranchHeads = parseTree->numComplexBranchHeads;
+        simpleTree = (TMSimpleStateTree) complexTree;
     }
     else {
-	simpleTree = XtNew(TMSimpleStateTreeRec);
-	simpleTree->isSimple = True;
+        simpleTree = XtNew(TMSimpleStateTreeRec);
+        simpleTree->isSimple = True;
     }
     simpleTree->isAccelerator = parseTree->isAccelerator;
     simpleTree->refCount = 0;
     simpleTree->mappingNotifyInterest = parseTree->mappingNotifyInterest;
 
-    tableSize = (unsigned) (parseTree->numBranchHeads * sizeof(TMBranchHeadRec));
+    tableSize =
+        (unsigned) (parseTree->numBranchHeads * sizeof(TMBranchHeadRec));
     simpleTree->branchHeadTbl = (TMBranchHead)
-      __XtMalloc(tableSize);
+        __XtMalloc(tableSize);
     XtMemmove(simpleTree->branchHeadTbl, parseTree->branchHeadTbl, tableSize);
     simpleTree->numBranchHeads = parseTree->numBranchHeads;
 
@@ -1486,67 +1446,66 @@ TMStateTree _XtParseTreeToStateTree(
     XtMemmove(simpleTree->quarkTbl, parseTree->quarkTbl, tableSize);
     simpleTree->numQuarks = parseTree->numQuarks;
 
-    return (TMStateTree)simpleTree;
+    return (TMStateTree) simpleTree;
 }
 
-static void FreeActions(
-    ActionPtr	actions)
+static void
+FreeActions(ActionPtr actions)
 {
     ActionPtr action;
     TMShortCard i;
+
     for (action = actions; action;) {
-	ActionPtr nextAction = action->next;
-	for (i = (TMShortCard) action->num_params; i;) {
-	    XtFree( (_XtString)action->params[--i] );
-	}
-	XtFree( (char*)action->params );
-	XtFree((char*) action);
-	action = nextAction;
+        ActionPtr nextAction = action->next;
+
+        for (i = (TMShortCard) action->num_params; i;) {
+            XtFree((_XtString) action->params[--i]);
+        }
+        XtFree((char *) action->params);
+        XtFree((char *) action);
+        action = nextAction;
     }
 }
 
-/*ARGSUSED*/
-static void AmbigActions(
-    EventSeqPtr	initialEvent,
-    StatePtr	*state,
-    TMParseStateTree stateTree)
+static void
+AmbigActions(EventSeqPtr initialEvent,
+             StatePtr *state,
+             TMParseStateTree stateTree)
 {
-    String 	params[3];
-    Cardinal 	numParams = 0;
+    String params[3];
+    Cardinal numParams = 0;
 
     params[numParams++] = _XtPrintEventSeq(initialEvent, NULL);
     params[numParams++] = _XtPrintActions((*state)->actions,
-					  stateTree->quarkTbl);
-    XtWarningMsg (XtNtranslationError,"oldActions",XtCXtToolkitError,
-		  "Previous entry was: %s %s", params, &numParams);
-    XtFree((char *)params[0]);
-    XtFree((char *)params[1]);
+                                          stateTree->quarkTbl);
+    XtWarningMsg(XtNtranslationError, "oldActions", XtCXtToolkitError,
+                 "Previous entry was: %s %s", params, &numParams);
+    XtFree((char *) params[0]);
+    XtFree((char *) params[1]);
     numParams = 0;
-    params[numParams++]  = _XtPrintActions(initialEvent->actions,
-					   stateTree->quarkTbl);
-    XtWarningMsg (XtNtranslationError,"newActions",XtCXtToolkitError,
-		  "New actions are:%s", params, &numParams);
-    XtFree((char *)params[0]);
-    XtWarningMsg (XtNtranslationError,"ambiguousActions",
-		  XtCXtToolkitError,
-		  "Overriding earlier translation manager actions.",
-		  NULL, NULL);
+    params[numParams++] = _XtPrintActions(initialEvent->actions,
+                                          stateTree->quarkTbl);
+    XtWarningMsg(XtNtranslationError, "newActions", XtCXtToolkitError,
+                 "New actions are:%s", params, &numParams);
+    XtFree((char *) params[0]);
+    XtWarningMsg(XtNtranslationError, "ambiguousActions",
+                 XtCXtToolkitError,
+                 "Overriding earlier translation manager actions.", NULL, NULL);
 
     FreeActions((*state)->actions);
     (*state)->actions = NULL;
 }
 
-
-void _XtAddEventSeqToStateTree(
-    EventSeqPtr 	eventSeq,
-    TMParseStateTree	stateTree)
+void
+_XtAddEventSeqToStateTree(EventSeqPtr eventSeq, TMParseStateTree stateTree)
 {
-    StatePtr		*state;
-    EventSeqPtr		initialEvent = eventSeq;
-    TMBranchHead	branchHead;
-    TMShortCard		idx, modIndex, typeIndex;
+    StatePtr *state;
+    EventSeqPtr initialEvent = eventSeq;
+    TMBranchHead branchHead;
+    TMShortCard idx, modIndex, typeIndex;
 
-    if (eventSeq == NULL) return;
+    if (eventSeq == NULL)
+        return;
 
     /* note that all states in the event seq passed in start out null */
     /* we fill them in with the matching state as we traverse the list */
@@ -1568,165 +1527,161 @@ void _XtAddEventSeqToStateTree(
      * Check for optimized case. Don't assume that the eventSeq has actions.
      */
     if (!eventSeq->next &&
-	 eventSeq->actions &&
-	!eventSeq->actions->next &&
-	!eventSeq->actions->num_params)
-      {
-	  if (eventSeq->event.eventType == MappingNotify)
-	    stateTree->mappingNotifyInterest = True;
-	  branchHead->hasActions = True;
-	  XtSetBits(branchHead->more, eventSeq->actions->idx, 13);
-	  FreeActions(eventSeq->actions);
-	  eventSeq->actions = NULL;
-	  return;
-      }
+        eventSeq->actions &&
+        !eventSeq->actions->next && !eventSeq->actions->num_params) {
+        if (eventSeq->event.eventType == MappingNotify)
+            stateTree->mappingNotifyInterest = True;
+        branchHead->hasActions = True;
+        XtSetBits(branchHead->more, eventSeq->actions->idx, 13);
+        FreeActions(eventSeq->actions);
+        eventSeq->actions = NULL;
+        return;
+    }
 
     branchHead->isSimple = False;
     if (!eventSeq->next)
-      branchHead->hasActions = True;
-    XtSetBits(branchHead->more, GetComplexBranchIndex(stateTree, typeIndex, modIndex), 13);
+        branchHead->hasActions = True;
+    XtSetBits(branchHead->more,
+              GetComplexBranchIndex(stateTree, typeIndex, modIndex), 13);
     state = &stateTree->complexBranchHeadTbl[TMBranchMore(branchHead)];
 
     for (;;) {
-	*state = NewState(stateTree, typeIndex, modIndex);
+        *state = NewState(stateTree, typeIndex, modIndex);
 
-	if (eventSeq->event.eventType == MappingNotify)
-	    stateTree->mappingNotifyInterest = True;
+        if (eventSeq->event.eventType == MappingNotify)
+            stateTree->mappingNotifyInterest = True;
 
-	/* *state now points at state record matching event */
-	eventSeq->state = *state;
+        /* *state now points at state record matching event */
+        eventSeq->state = *state;
 
-	if (eventSeq->actions != NULL) {
-	    if ((*state)->actions != NULL)
-	      AmbigActions(initialEvent, state, stateTree);
-	    (*state)->actions = eventSeq->actions;
+        if (eventSeq->actions != NULL) {
+            if ((*state)->actions != NULL)
+                AmbigActions(initialEvent, state, stateTree);
+            (*state)->actions = eventSeq->actions;
 #ifdef TRACE_TM
-	    LOCK_PROCESS;
-	    _XtGlobalTM.numComplexActions++;
-	    UNLOCK_PROCESS;
-#endif /* TRACE_TM */
-	}
-
-	if (((eventSeq = eventSeq->next) == NULL) || (eventSeq->state))
-	  break;
-
-	state = &(*state)->nextLevel;
-	typeIndex = _XtGetTypeIndex(&eventSeq->event);
-	modIndex = _XtGetModifierIndex(&eventSeq->event);
-	LOCK_PROCESS;
-	if (!TMNewMatchSemantics()) {
-	    /*
-	     * force a potential empty entry into the branch head
-	     * table in order to emulate old matching behavior
-	     */
-	    (void) GetBranchHead(stateTree, typeIndex, modIndex, True);
-	}
-	UNLOCK_PROCESS;
+            LOCK_PROCESS;
+            _XtGlobalTM.numComplexActions++;
+            UNLOCK_PROCESS;
+#endif                          /* TRACE_TM */
+        }
+
+        if (((eventSeq = eventSeq->next) == NULL) || (eventSeq->state))
+            break;
+
+        state = &(*state)->nextLevel;
+        typeIndex = _XtGetTypeIndex(&eventSeq->event);
+        modIndex = _XtGetModifierIndex(&eventSeq->event);
+        LOCK_PROCESS;
+        if (!TMNewMatchSemantics()) {
+            /*
+             * force a potential empty entry into the branch head
+             * table in order to emulate old matching behavior
+             */
+            (void) GetBranchHead(stateTree, typeIndex, modIndex, True);
+        }
+        UNLOCK_PROCESS;
     }
 
     if (eventSeq && eventSeq->state) {
-	/* we've been here before... must be a cycle in the event seq. */
-	branchHead->hasCycles = True;
-	(*state)->nextLevel = eventSeq->state;
-	eventSeq->state->isCycleStart = True;
-	(*state)->isCycleEnd = TRUE;
+        /* we've been here before... must be a cycle in the event seq. */
+        branchHead->hasCycles = True;
+        (*state)->nextLevel = eventSeq->state;
+        eventSeq->state->isCycleStart = True;
+        (*state)->isCycleEnd = TRUE;
     }
 }
 
-
 /*
  * Internal Converter for merging. Old and New must both be valid xlations
  */
-
-/*ARGSUSED*/
-Boolean _XtCvtMergeTranslations(
-    Display	*dpy,
-    XrmValuePtr args,
-    Cardinal    *num_args,
-    XrmValuePtr from,
-    XrmValuePtr to,
-    XtPointer	*closure_ret)
+Boolean
+_XtCvtMergeTranslations(Display *dpy _X_UNUSED,
+                        XrmValuePtr args _X_UNUSED,
+                        Cardinal *num_args,
+                        XrmValuePtr from,
+                        XrmValuePtr to,
+                        XtPointer *closure_ret _X_UNUSED)
 {
-    XtTranslations 	first, second, xlations;
-    TMStateTree		*stateTrees, stackStateTrees[16];
-    TMShortCard		numStateTrees, i;
+    XtTranslations first, second, xlations;
+    TMStateTree *stateTrees, stackStateTrees[16];
+    TMShortCard numStateTrees, i;
 
     if (*num_args != 0)
-	XtWarningMsg("invalidParameters","mergeTranslations",XtCXtToolkitError,
-             "MergeTM to TranslationTable needs no extra arguments",
-               NULL, NULL);
+        XtWarningMsg("invalidParameters", "mergeTranslations",
+                     XtCXtToolkitError,
+                     "MergeTM to TranslationTable needs no extra arguments",
+                     NULL, NULL);
 
     if (to->addr != NULL && to->size < sizeof(XtTranslations)) {
-	to->size = sizeof(XtTranslations);
-	return False;
+        to->size = sizeof(XtTranslations);
+        return False;
     }
 
-    first = ((TMConvertRec*)from->addr)->old;
-    second = ((TMConvertRec*)from->addr)->new;
+    first = ((TMConvertRec *) from->addr)->old;
+    second = ((TMConvertRec *) from->addr)->new;
 
-    numStateTrees = (TMShortCard) (first->numStateTrees + second->numStateTrees);
+    numStateTrees =
+        (TMShortCard) (first->numStateTrees + second->numStateTrees);
 
     stateTrees = (TMStateTree *)
-      XtStackAlloc(numStateTrees * sizeof(TMStateTree), stackStateTrees);
+        XtStackAlloc(numStateTrees * sizeof(TMStateTree), stackStateTrees);
 
     for (i = 0; i < first->numStateTrees; i++)
-      stateTrees[i] = first->stateTreeTbl[i];
+        stateTrees[i] = first->stateTreeTbl[i];
     for (i = 0; i < second->numStateTrees; i++)
-      stateTrees[i + first->numStateTrees] = second->stateTreeTbl[i];
+        stateTrees[i + first->numStateTrees] = second->stateTreeTbl[i];
 
     xlations = _XtCreateXlations(stateTrees, numStateTrees, first, second);
 
     if (to->addr != NULL) {
-	*(XtTranslations*)to->addr = xlations;
+        *(XtTranslations *) to->addr = xlations;
     }
     else {
-	static XtTranslations staticStateTable;
-	staticStateTable = xlations;
-	to->addr= (XPointer)&staticStateTable;
-	to->size = sizeof(XtTranslations);
+        static XtTranslations staticStateTable;
+
+        staticStateTable = xlations;
+        to->addr = (XPointer) &staticStateTable;
+        to->size = sizeof(XtTranslations);
     }
 
-    XtStackFree((XtPointer)stateTrees, (XtPointer)stackStateTrees);
+    XtStackFree((XtPointer) stateTrees, (XtPointer) stackStateTrees);
     return True;
 }
 
-
-static XtTranslations MergeThem(
-    Widget		dest,
-    XtTranslations	first,
-    XtTranslations	second)
+static XtTranslations
+MergeThem(Widget dest, XtTranslations first, XtTranslations second)
 {
-    XtCacheRef 		cache_ref;
-    static XrmQuark 	from_type = NULLQUARK, to_type;
-    XrmValue 		from, to;
-    TMConvertRec 	convert_rec;
-    XtTranslations	newTable;
+    XtCacheRef cache_ref;
+    static XrmQuark from_type = NULLQUARK, to_type;
+    XrmValue from, to;
+    TMConvertRec convert_rec;
+    XtTranslations newTable;
 
     LOCK_PROCESS;
     if (from_type == NULLQUARK) {
-	from_type = XrmPermStringToQuark(_XtRStateTablePair);
-	to_type = XrmPermStringToQuark(XtRTranslationTable);
+        from_type = XrmPermStringToQuark(_XtRStateTablePair);
+        to_type = XrmPermStringToQuark(XtRTranslationTable);
     }
     UNLOCK_PROCESS;
-    from.addr = (XPointer)&convert_rec;
+    from.addr = (XPointer) &convert_rec;
     from.size = sizeof(TMConvertRec);
-    to.addr = (XPointer)&newTable;
+    to.addr = (XPointer) &newTable;
     to.size = sizeof(XtTranslations);
     convert_rec.old = first;
     convert_rec.new = second;
 
     LOCK_PROCESS;
-    if (! _XtConvert(dest, from_type, &from, to_type, &to, &cache_ref)) {
-	UNLOCK_PROCESS;
-	return NULL;
+    if (!_XtConvert(dest, from_type, &from, to_type, &to, &cache_ref)) {
+        UNLOCK_PROCESS;
+        return NULL;
     }
     UNLOCK_PROCESS;
 
 #ifndef REFCNT_TRANSLATIONS
 
     if (cache_ref)
-	XtAddCallback(dest, XtNdestroyCallback,
-		      XtCallbackReleaseCacheRef, (XtPointer)cache_ref);
+        XtAddCallback(dest, XtNdestroyCallback,
+                      XtCallbackReleaseCacheRef, (XtPointer) cache_ref);
 
 #endif
 
@@ -1740,67 +1695,70 @@ static XtTranslations MergeThem(
  * the potential that an xlation will be both an accelerator and
  * normal. This is not supported by the spec anyway.
  */
-static XtTranslations UnmergeTranslations(
-    Widget		widget,
-    XtTranslations	xlations,
-    XtTranslations	unmergeXlations,
-    TMShortCard		currIndex,
-    TMComplexBindProcs	oldBindings,
-    TMShortCard		numOldBindings,
-    TMComplexBindProcs	newBindings,
-    TMShortCard		*numNewBindingsRtn)
-
+static XtTranslations
+UnmergeTranslations(Widget widget,
+                    XtTranslations xlations,
+                    XtTranslations unmergeXlations,
+                    TMShortCard currIndex,
+                    TMComplexBindProcs oldBindings,
+                    TMShortCard numOldBindings,
+                    TMComplexBindProcs newBindings,
+                    TMShortCard *numNewBindingsRtn)
 {
     XtTranslations first, second, result;
 
     if (!xlations || (xlations == unmergeXlations))
-      return NULL;
+        return NULL;
 
     if (xlations->composers[0]) {
-	first = UnmergeTranslations(widget, xlations->composers[0],
-				    unmergeXlations,  currIndex,
-				    oldBindings, numOldBindings,
-				    newBindings, numNewBindingsRtn);
+        first = UnmergeTranslations(widget, xlations->composers[0],
+                                    unmergeXlations, currIndex,
+                                    oldBindings, numOldBindings,
+                                    newBindings, numNewBindingsRtn);
     }
     else
-      first = NULL;
+        first = NULL;
 
     if (xlations->composers[0]
-	&& xlations->composers[1]) {
-	second = UnmergeTranslations(widget, xlations->composers[1],
-				     unmergeXlations,
-				     (TMShortCard)(currIndex +
-				     xlations->composers[0]->numStateTrees),
-				     oldBindings, numOldBindings,
-				     newBindings, numNewBindingsRtn);
+        && xlations->composers[1]) {
+        second = UnmergeTranslations(widget, xlations->composers[1],
+                                     unmergeXlations, (TMShortCard)
+                                     (currIndex +
+                                      xlations->composers[0]->numStateTrees),
+                                     oldBindings,
+                                     numOldBindings, newBindings,
+                                     numNewBindingsRtn);
     }
     else
-      second = NULL;
+        second = NULL;
 
     if (first || second) {
-	if (first && second) {
-	    if ((first != xlations->composers[0]) ||
-		(second != xlations->composers[1]))
-	      result = MergeThem(widget, first, second);
-	    else result = xlations;
-	}
-	else {
-	    if (first)
-	      result = first;
-	    else
-	      result = second;
-	}
-    } else { /* only update for leaf nodes */
-  	if (numOldBindings) {
- 	    Cardinal	i;
- 	    for (i = 0; i < xlations->numStateTrees; i++) {
- 		if (xlations->stateTreeTbl[i]->simple.isAccelerator)
-		    newBindings[*numNewBindingsRtn] =
-			oldBindings[currIndex + i];
- 		(*numNewBindingsRtn)++;
-	    }
-	}
-	result = xlations;
+        if (first && second) {
+            if ((first != xlations->composers[0]) ||
+                (second != xlations->composers[1]))
+                result = MergeThem(widget, first, second);
+            else
+                result = xlations;
+        }
+        else {
+            if (first)
+                result = first;
+            else
+                result = second;
+        }
+    }
+    else {                      /* only update for leaf nodes */
+        if (numOldBindings) {
+            Cardinal i;
+
+            for (i = 0; i < xlations->numStateTrees; i++) {
+                if (xlations->stateTreeTbl[i]->simple.isAccelerator)
+                    newBindings[*numNewBindingsRtn] =
+                        oldBindings[currIndex + i];
+                (*numNewBindingsRtn)++;
+            }
+        }
+        result = xlations;
     }
     return result;
 }
@@ -1808,122 +1766,124 @@ static XtTranslations UnmergeTranslations(
 typedef struct {
     XtTranslations xlations;
     TMComplexBindProcs bindings;
-}MergeBindRec, *MergeBind;
-
-static XtTranslations MergeTranslations(
-    Widget		widget,
-    XtTranslations	oldXlations,
-    XtTranslations	newXlations,
-    _XtTranslateOp	operation,
-    Widget		source,
-    TMComplexBindProcs	oldBindings,
-    TMComplexBindProcs	newBindings,
-    TMShortCard		*numNewRtn)
+} MergeBindRec, *MergeBind;
+
+static XtTranslations
+MergeTranslations(Widget widget,
+                  XtTranslations oldXlations,
+                  XtTranslations newXlations,
+                  _XtTranslateOp operation,
+                  Widget source,
+                  TMComplexBindProcs oldBindings,
+                  TMComplexBindProcs newBindings,
+                  TMShortCard *numNewRtn)
 {
-    XtTranslations      newTable = NULL, xlations;
-    TMComplexBindProcs	bindings;
-    TMShortCard		i, j;
-    TMStateTree 	*treePtr;
-    TMShortCard		numNew;
-    MergeBindRec	bindPair[2];
+    XtTranslations newTable = NULL, xlations;
+    TMComplexBindProcs bindings;
+    TMShortCard i, j;
+    TMStateTree *treePtr;
+    TMShortCard numNew;
+    MergeBindRec bindPair[2];
 
     /* If the new translation has an accelerator context then pull it
      * off and pass it and the real xlations in to the caching merge
      * routine.
      */
     if (newXlations->hasBindings) {
-	xlations = ((ATranslations) newXlations)->xlations;
-	bindings = (TMComplexBindProcs)
-	    &((ATranslations) newXlations)->bindTbl[0];
+        xlations = ((ATranslations) newXlations)->xlations;
+        bindings = (TMComplexBindProcs)
+            &((ATranslations) newXlations)->bindTbl[0];
     }
     else {
-	xlations = newXlations;
-	bindings = NULL;
-    }
-    switch(operation) {
-      case XtTableReplace:
-	newTable = bindPair[0].xlations = xlations;
-	bindPair[0].bindings = bindings;
-	bindPair[1].xlations = NULL;
-	bindPair[1].bindings = NULL;
-	break;
-      case XtTableAugment:
-	bindPair[0].xlations = oldXlations;
-	bindPair[0].bindings = oldBindings;
-	bindPair[1].xlations = xlations;
-	bindPair[1].bindings = bindings;
-	newTable = NULL;
-	break;
-      case XtTableOverride:
-	bindPair[0].xlations = xlations;
-	bindPair[0].bindings = bindings;
-	bindPair[1].xlations = oldXlations;
-	bindPair[1].bindings = oldBindings;
-	newTable = NULL;
-	break;
+        xlations = newXlations;
+        bindings = NULL;
+    }
+    switch (operation) {
+    case XtTableReplace:
+        newTable = bindPair[0].xlations = xlations;
+        bindPair[0].bindings = bindings;
+        bindPair[1].xlations = NULL;
+        bindPair[1].bindings = NULL;
+        break;
+    case XtTableAugment:
+        bindPair[0].xlations = oldXlations;
+        bindPair[0].bindings = oldBindings;
+        bindPair[1].xlations = xlations;
+        bindPair[1].bindings = bindings;
+        newTable = NULL;
+        break;
+    case XtTableOverride:
+        bindPair[0].xlations = xlations;
+        bindPair[0].bindings = bindings;
+        bindPair[1].xlations = oldXlations;
+        bindPair[1].bindings = oldBindings;
+        newTable = NULL;
+        break;
     }
     if (!newTable)
-      newTable = MergeThem(widget, bindPair[0].xlations, bindPair[1].xlations);
+        newTable =
+            MergeThem(widget, bindPair[0].xlations, bindPair[1].xlations);
 
     for (i = 0, numNew = 0; i < 2; i++) {
-	if (bindPair[i].xlations)
-	  for (j = 0; j < bindPair[i].xlations->numStateTrees; j++, numNew++) {
-	      if (bindPair[i].xlations->stateTreeTbl[j]->simple.isAccelerator) {
-		  if (bindPair[i].bindings)
-		    newBindings[numNew] = bindPair[i].bindings[j];
-		  else {
-		      newBindings[numNew].widget = source;
-		      newBindings[numNew].aXlations =
-			bindPair[i].xlations;
-		  }
-		}
-	  }
+        if (bindPair[i].xlations)
+            for (j = 0; j < bindPair[i].xlations->numStateTrees; j++, numNew++) {
+                if (bindPair[i].xlations->stateTreeTbl[j]->simple.isAccelerator) {
+                    if (bindPair[i].bindings)
+                        newBindings[numNew] = bindPair[i].bindings[j];
+                    else {
+                        newBindings[numNew].widget = source;
+                        newBindings[numNew].aXlations = bindPair[i].xlations;
+                    }
+                }
+            }
     }
     *numNewRtn = numNew;
     treePtr = &newTable->stateTreeTbl[0];
     for (i = 0; i < newTable->numStateTrees; i++, treePtr++)
-      (*treePtr)->simple.refCount++;
+        (*treePtr)->simple.refCount++;
     return newTable;
 }
 
-static TMBindData MakeBindData(
-    TMComplexBindProcs	bindings,
-    TMShortCard		numBindings,
-    TMBindData		oldBindData)
+static TMBindData
+MakeBindData(TMComplexBindProcs bindings,
+             TMShortCard numBindings,
+             TMBindData oldBindData)
 {
-    TMLongCard		bytes;
-    TMShortCard		i;
-    Boolean		isComplex;
-    TMBindData		bindData;
+    TMLongCard bytes;
+    TMShortCard i;
+    Boolean isComplex;
+    TMBindData bindData;
 
     if (numBindings == 0)
-      return NULL;
+        return NULL;
     for (i = 0; i < numBindings; i++)
-      if (bindings[i].widget)
-	break;
+        if (bindings[i].widget)
+            break;
     isComplex = (i < numBindings);
     if (isComplex)
-      bytes = (sizeof(TMComplexBindDataRec) +
-	       ((TMLongCard)(numBindings - 1) *
-		sizeof(TMComplexBindProcsRec)));
+        bytes = (sizeof(TMComplexBindDataRec) +
+                 ((TMLongCard) (numBindings - 1) *
+                  sizeof(TMComplexBindProcsRec)));
     else
-      bytes = (sizeof(TMSimpleBindDataRec) +
-	       ((TMLongCard)(numBindings - 1) *
-		sizeof(TMSimpleBindProcsRec)));
+        bytes = (sizeof(TMSimpleBindDataRec) +
+                 ((TMLongCard) (numBindings - 1) *
+                  sizeof(TMSimpleBindProcsRec)));
 
-    bindData = (TMBindData) __XtCalloc((Cardinal) sizeof(char), (Cardinal) bytes);
+    bindData =
+        (TMBindData) __XtCalloc((Cardinal) sizeof(char), (Cardinal) bytes);
     XtSetBit(bindData->simple.isComplex, isComplex);
     if (isComplex) {
-	TMComplexBindData cBindData = (TMComplexBindData)bindData;
-	/*
-	 * If there were any accelerator contexts in the old bindData
-	 * then propagate them to the new one.
-	 */
-	if (oldBindData && oldBindData->simple.isComplex)
-	    cBindData->accel_context =
-		((TMComplexBindData) oldBindData)->accel_context;
-	XtMemmove((char *)&cBindData->bindTbl[0], (char *)bindings,
-		  numBindings * sizeof(TMComplexBindProcsRec));
+        TMComplexBindData cBindData = (TMComplexBindData) bindData;
+
+        /*
+         * If there were any accelerator contexts in the old bindData
+         * then propagate them to the new one.
+         */
+        if (oldBindData && oldBindData->simple.isComplex)
+            cBindData->accel_context =
+                ((TMComplexBindData) oldBindData)->accel_context;
+        XtMemmove((char *) &cBindData->bindTbl[0], (char *) bindings,
+                  numBindings * sizeof(TMComplexBindProcsRec));
     }
     return bindData;
 }
@@ -1934,144 +1894,142 @@ static TMBindData MakeBindData(
  * realize time and calling the converter or doing a straight merge if
  * the destination is empty.
  */
-static Boolean ComposeTranslations(
-    Widget dest,
-    _XtTranslateOp operation,
-    Widget source,
-    XtTranslations newXlations)
+static Boolean
+ComposeTranslations(Widget dest,
+                    _XtTranslateOp operation,
+                    Widget source,
+                    XtTranslations newXlations)
 {
-    XtTranslations 	newTable, oldXlations;
-    XtTranslations	accNewXlations;
-    EventMask		oldMask = 0;
-    TMBindData		bindData;
-    TMComplexBindProcs	oldBindings = NULL;
-    TMShortCard		numOldBindings = 0, numNewBindings = 0, numBytes;
+    XtTranslations newTable, oldXlations;
+    XtTranslations accNewXlations;
+    EventMask oldMask = 0;
+    TMBindData bindData;
+    TMComplexBindProcs oldBindings = NULL;
+    TMShortCard numOldBindings = 0, numNewBindings = 0, numBytes;
     TMComplexBindProcsRec stackBindings[16], *newBindings;
 
     /*
      * how should we be handling the refcount decrement for the
      * replaced translation table ???
      */
-    if (!newXlations)
-      {
-	  XtAppWarningMsg(XtWidgetToApplicationContext(dest),
-			  XtNtranslationError,"nullTable",XtCXtToolkitError,
-			  "table to (un)merge must not be null",
-			  NULL, NULL);
-	  return False;
-      }
+    if (!newXlations) {
+        XtAppWarningMsg(XtWidgetToApplicationContext(dest),
+                        XtNtranslationError, "nullTable", XtCXtToolkitError,
+                        "table to (un)merge must not be null", NULL, NULL);
+        return False;
+    }
 
     accNewXlations = newXlations;
     newXlations = ((newXlations->hasBindings)
-		   ? ((ATranslations)newXlations)->xlations
-		   : newXlations);
+                   ? ((ATranslations) newXlations)->xlations : newXlations);
 
     if (!(oldXlations = dest->core.tm.translations))
-      operation = XtTableReplace;
+        operation = XtTableReplace;
 
     /*
      * try to avoid generation of duplicate state trees. If the source
      * isn't simple (1 state Tree) then it's too much hassle
      */
     if (((operation == XtTableAugment) ||
-	 (operation == XtTableOverride)) &&
-	(newXlations->numStateTrees == 1)) {
-	Cardinal	i;
-	for (i = 0; i < oldXlations->numStateTrees; i++)
-	  if (oldXlations->stateTreeTbl[i] ==
-	      newXlations->stateTreeTbl[0])
-	    break;
-	if (i < oldXlations->numStateTrees) {
-	    if (operation == XtTableAugment) {
-		/*
-		 * we don't need to do anything since it's already
-		 * there
-		 */
-		return True;
-	    }
-	    else {/* operation == XtTableOverride */
-		/*
-		 * We'll get rid of the duplicate trees throughout the
-		 * and leave it with a pruned translation table. This
-		 * will only work if the same table has been merged
-		 * into this table (or one of it's composers
-		 */
-		_XtUnmergeTranslations(dest, newXlations);
-		/*
-		 * reset oldXlations so we're back in sync
-		 */
-		if (!(oldXlations = dest->core.tm.translations))
-		  operation = XtTableReplace;
-	    }
-	}
+         (operation == XtTableOverride)) && (newXlations->numStateTrees == 1)) {
+        Cardinal i;
+
+        for (i = 0; i < oldXlations->numStateTrees; i++)
+            if (oldXlations->stateTreeTbl[i] == newXlations->stateTreeTbl[0])
+                break;
+        if (i < oldXlations->numStateTrees) {
+            if (operation == XtTableAugment) {
+                /*
+                 * we don't need to do anything since it's already
+                 * there
+                 */
+                return True;
+            }
+            else {              /* operation == XtTableOverride */
+                /*
+                 * We'll get rid of the duplicate trees throughout the
+                 * and leave it with a pruned translation table. This
+                 * will only work if the same table has been merged
+                 * into this table (or one of it's composers
+                 */
+                _XtUnmergeTranslations(dest, newXlations);
+                /*
+                 * reset oldXlations so we're back in sync
+                 */
+                if (!(oldXlations = dest->core.tm.translations))
+                    operation = XtTableReplace;
+            }
+        }
     }
 
     bindData = (TMBindData) dest->core.tm.proc_table;
     if (bindData) {
-	numOldBindings = (oldXlations ? oldXlations->numStateTrees : 0);
- 	if (bindData->simple.isComplex)
-	    oldBindings = &((TMComplexBindData)bindData)->bindTbl[0];
- 	else
-	    oldBindings = (TMComplexBindProcs)
-		(&((TMSimpleBindData)bindData)->bindTbl[0]);
+        numOldBindings = (oldXlations ? oldXlations->numStateTrees : 0);
+        if (bindData->simple.isComplex)
+            oldBindings = &((TMComplexBindData) bindData)->bindTbl[0];
+        else
+            oldBindings = (TMComplexBindProcs)
+                (&((TMSimpleBindData) bindData)->bindTbl[0]);
     }
 
-    numBytes =(TMShortCard) ((size_t)((oldXlations ? oldXlations->numStateTrees : 0)
-		+ newXlations->numStateTrees) * sizeof(TMComplexBindProcsRec));
-    newBindings = (TMComplexBindProcs) XtStackAlloc(numBytes,  stackBindings);
-    XtBZero((char *)newBindings, numBytes);
+    numBytes =
+        (TMShortCard) ((size_t) ((oldXlations ? oldXlations->numStateTrees : 0)
+                                 +
+                                 newXlations->numStateTrees) *
+                       sizeof(TMComplexBindProcsRec));
+    newBindings = (TMComplexBindProcs) XtStackAlloc(numBytes, stackBindings);
+    XtBZero((char *) newBindings, numBytes);
 
     if (operation == XtTableUnmerge) {
-	newTable = UnmergeTranslations(dest,
-				       oldXlations,
-				       newXlations,
-				       0,
-				       oldBindings, numOldBindings,
-				       newBindings, &numNewBindings);
+        newTable = UnmergeTranslations(dest,
+                                       oldXlations,
+                                       newXlations,
+                                       0,
+                                       oldBindings, numOldBindings,
+                                       newBindings, &numNewBindings);
 #ifdef DEBUG
-	/* check for no match for unmerge */
-	if (newTable == oldXlations) {
-	    XtWarning("attempt to unmerge invalid table");
-	    XtStackFree((char *)newBindings, (char *)stackBindings);
-	    return(newTable != NULL);
-	}
-#endif /* DEBUG */
+        /* check for no match for unmerge */
+        if (newTable == oldXlations) {
+            XtWarning("attempt to unmerge invalid table");
+            XtStackFree((char *) newBindings, (char *) stackBindings);
+            return (newTable != NULL);
+        }
+#endif                          /* DEBUG */
     }
     else {
-	newTable = MergeTranslations(dest,
-				     oldXlations,
-				     accNewXlations,
-				     operation,
-				     source,
-				     oldBindings,
-				     newBindings,
-				     &numNewBindings);
+        newTable = MergeTranslations(dest,
+                                     oldXlations,
+                                     accNewXlations,
+                                     operation,
+                                     source,
+                                     oldBindings, newBindings, &numNewBindings);
     }
     if (XtIsRealized(dest)) {
-	oldMask = 0;
-	if (oldXlations)
-	    oldMask = oldXlations->eventMask;
-	_XtUninstallTranslations(dest);
+        oldMask = 0;
+        if (oldXlations)
+            oldMask = oldXlations->eventMask;
+        _XtUninstallTranslations(dest);
     }
 
     dest->core.tm.proc_table =
-      (XtActionProc *) MakeBindData(newBindings, numNewBindings, bindData);
+        (XtActionProc *) MakeBindData(newBindings, numNewBindings, bindData);
 
-    XtFree((char *)bindData);
+    XtFree((char *) bindData);
 
     dest->core.tm.translations = newTable;
 
     if (XtIsRealized(dest)) {
-	EventMask mask = 0;
-	_XtInstallTranslations(dest);
-	if (newTable)
-	    mask = newTable->eventMask;
-	if (mask != oldMask)
-	    XSelectInput(XtDisplay(dest), XtWindow(dest),
-			 (long) XtBuildEventMask(dest));
-    }
-    XtStackFree((XtPointer)newBindings, (XtPointer)stackBindings);
-    return(newTable != NULL);
+        EventMask mask = 0;
+
+        _XtInstallTranslations(dest);
+        if (newTable)
+            mask = newTable->eventMask;
+        if (mask != oldMask)
+            XSelectInput(XtDisplay(dest), XtWindow(dest),
+                         (long) XtBuildEventMask(dest));
+    }
+    XtStackFree((XtPointer) newBindings, (XtPointer) stackBindings);
+    return (newTable != NULL);
 }
 
 /*
@@ -2082,129 +2040,125 @@ static Boolean ComposeTranslations(
  * that we return (via a linked list pointed to from the bindData) and
  * free it at destroy time.
  */
-XtTranslations _XtGetTranslationValue(
-    Widget	w)
+XtTranslations
+_XtGetTranslationValue(Widget w)
 {
-    XtTM		tmRecPtr = (XtTM) &w->core.tm;
-    ATranslations	*aXlationsPtr;
-    TMComplexBindData	cBindData = (TMComplexBindData) tmRecPtr->proc_table;
-    XtTranslations	xlations = tmRecPtr->translations;
+    XtTM tmRecPtr = (XtTM) &w->core.tm;
+    ATranslations *aXlationsPtr;
+    TMComplexBindData cBindData = (TMComplexBindData) tmRecPtr->proc_table;
+    XtTranslations xlations = tmRecPtr->translations;
 
     if (!xlations || !cBindData || !cBindData->isComplex)
-	return xlations;
+        return xlations;
 
     /* Walk the list looking to see if we already have generated a
      * header for the currently installed translations.  If we have,
      * just return that header.  Otherwise create a new header.
      */
     for (aXlationsPtr = (ATranslations *) &cBindData->accel_context;
-	 *aXlationsPtr && (*aXlationsPtr)->xlations != xlations;
-	 aXlationsPtr = &(*aXlationsPtr)->next)
-	;
+         *aXlationsPtr && (*aXlationsPtr)->xlations != xlations;
+         aXlationsPtr = &(*aXlationsPtr)->next);
     if (*aXlationsPtr)
-	return (XtTranslations) *aXlationsPtr;
+        return (XtTranslations) *aXlationsPtr;
     else {
-	/* create a new aXlations context */
-	ATranslations	aXlations;
-	Cardinal	numBindings = xlations->numStateTrees;
-
-	(*aXlationsPtr) = aXlations = (ATranslations)
-	    __XtMalloc((Cardinal) (sizeof(ATranslationData) +
-		     (numBindings - 1) * sizeof(TMComplexBindProcsRec)));
-
-	aXlations->hasBindings = True;
-	aXlations->xlations = xlations;
-	aXlations->next = NULL;
-	XtMemmove((char *) &aXlations->bindTbl[0],
-		  (char *) &cBindData->bindTbl[0],
-		  numBindings * sizeof(TMComplexBindProcsRec));
-	return (XtTranslations) aXlations;
+        /* create a new aXlations context */
+        ATranslations aXlations;
+        Cardinal numBindings = xlations->numStateTrees;
+
+        (*aXlationsPtr) = aXlations = (ATranslations)
+            __XtMalloc((Cardinal) (sizeof(ATranslationData) +
+                                   (numBindings -
+                                    1) * sizeof(TMComplexBindProcsRec)));
+
+        aXlations->hasBindings = True;
+        aXlations->xlations = xlations;
+        aXlations->next = NULL;
+        XtMemmove((char *) &aXlations->bindTbl[0],
+                  (char *) &cBindData->bindTbl[0],
+                  numBindings * sizeof(TMComplexBindProcsRec));
+        return (XtTranslations) aXlations;
     }
 }
 
-
-/*ARGSUSED*/
-static void RemoveStateTree(
-    TMStateTree	tree)
+static void
+RemoveStateTree(TMStateTree tree _X_UNUSED)
 {
 #ifdef REFCNT_TRANSLATIONS
-    TMComplexStateTree stateTree = (TMComplexStateTree)tree;
+    TMComplexStateTree stateTree = (TMComplexStateTree) tree;
 
     if (--stateTree->refCount == 0) {
-	/*
-	 * should we free/refcount the match recs ?
-	 */
-	if (!stateTree->isSimple)  {
-	    StatePtr	currState, nextState;
-	    TMShortCard i;
-	    for (i = 0; i < stateTree->numComplexBranchHeads; i++) {
-		currState =
-		  nextState =
-		    stateTree->complexBranchHeadTbl[i];
-		for (; nextState;){
-		    FreeActions(currState->actions);
-		    currState->actions = NULL;
-		    if (!currState->isCycleEnd)
-		      nextState = currState->nextLevel;
-		    else
-		      nextState = NULL;
-		    XtFree( (char*)currState );
-		}
-	    }
-	    XtFree((char*)stateTree->complexBranchHeadTbl);
-	}
-	XtFree((char*)stateTree->branchHeadTbl);
-	XtFree((char*)stateTree);
-    }
-#endif /* REFCNT_TRANSLATIONS */
+        /*
+         * should we free/refcount the match recs ?
+         */
+        if (!stateTree->isSimple) {
+            StatePtr currState, nextState;
+            TMShortCard i;
+
+            for (i = 0; i < stateTree->numComplexBranchHeads; i++) {
+                currState = nextState = stateTree->complexBranchHeadTbl[i];
+                for (; nextState;) {
+                    FreeActions(currState->actions);
+                    currState->actions = NULL;
+                    if (!currState->isCycleEnd)
+                        nextState = currState->nextLevel;
+                    else
+                        nextState = NULL;
+                    XtFree((char *) currState);
+                }
+            }
+            XtFree((char *) stateTree->complexBranchHeadTbl);
+        }
+        XtFree((char *) stateTree->branchHeadTbl);
+        XtFree((char *) stateTree);
+    }
+#endif                          /* REFCNT_TRANSLATIONS */
 }
 
-void _XtRemoveStateTreeByIndex(
-    XtTranslations	xlations,
-    TMShortCard	i)
+void
+_XtRemoveStateTreeByIndex(XtTranslations xlations, TMShortCard i)
 {
-    TMStateTree		*stateTrees = xlations->stateTreeTbl;
+    TMStateTree *stateTrees = xlations->stateTreeTbl;
 
     RemoveStateTree(stateTrees[i]);
     xlations->numStateTrees--;
 
-    for (; i < xlations->numStateTrees; i++)
-      {
-	  stateTrees[i] = stateTrees[i+1];
-      }
+    for (; i < xlations->numStateTrees; i++) {
+        stateTrees[i] = stateTrees[i + 1];
+    }
 }
 
-/* ARGSUSED */
-void _XtFreeTranslations(
-    XtAppContext app,
-    XrmValuePtr	toVal,
-    XtPointer	closure,
-    XrmValuePtr	args,
-    Cardinal	*num_args)
+void
+_XtFreeTranslations(XtAppContext app,
+                    XrmValuePtr toVal,
+                    XtPointer closure _X_UNUSED,
+                    XrmValuePtr args _X_UNUSED,
+                    Cardinal *num_args)
 {
-    XtTranslations 	xlations;
-    int 	i;
+    XtTranslations xlations;
+    int i;
 
     if (*num_args != 0)
-	XtAppWarningMsg(app,
-	  "invalidParameters","freeTranslations",XtCXtToolkitError,
-          "Freeing XtTranslations requires no extra arguments",
-	  NULL, NULL);
-
-    xlations = *(XtTranslations*)toVal->addr;
-    for (i = 0; i < (int)xlations->numStateTrees; i++)
-      RemoveStateTree(xlations->stateTreeTbl[i]);
-    XtFree((char *)xlations);
+        XtAppWarningMsg(app,
+                        "invalidParameters", "freeTranslations",
+                        XtCXtToolkitError,
+                        "Freeing XtTranslations requires no extra arguments",
+                        NULL, NULL);
+
+    xlations = *(XtTranslations *) toVal->addr;
+    for (i = 0; i < (int) xlations->numStateTrees; i++)
+        RemoveStateTree(xlations->stateTreeTbl[i]);
+    XtFree((char *) xlations);
 }
 
 /*  The spec is not clear on when actions specified in accelerators are bound;
  *  Bind them at Realize the same as translations
  */
-void XtInstallAccelerators(
-    Widget destination, Widget source)
+void
+XtInstallAccelerators(Widget destination, Widget source)
 {
-    XtTranslations	aXlations;
-    _XtTranslateOp	op;
+    XtTranslations aXlations;
+    _XtTranslateOp op;
+
     WIDGET_TO_APPCON(destination);
 
     /*
@@ -2215,31 +2169,32 @@ void XtInstallAccelerators(
     LOCK_APP(app);
     LOCK_PROCESS;
     if ((!XtIsWidget(source)) ||
-	((aXlations = source->core.accelerators) == NULL) ||
-	(aXlations->stateTreeTbl[0]->simple.isAccelerator == False)) {
-	UNLOCK_PROCESS;
-	UNLOCK_APP(app);
-	return;
+        ((aXlations = source->core.accelerators) == NULL) ||
+        (aXlations->stateTreeTbl[0]->simple.isAccelerator == False)) {
+        UNLOCK_PROCESS;
+        UNLOCK_APP(app);
+        return;
     }
 
     aXlations = source->core.accelerators;
     op = aXlations->operation;
 
     if (ComposeTranslations(destination, op, source, aXlations) &&
-	(XtClass(source)->core_class.display_accelerator != NULL)) {
-	_XtString buf = _XtPrintXlations(destination, aXlations, source, False);
-	(*(XtClass(source)->core_class.display_accelerator))(source,buf);
-	XtFree(buf);
+        (XtClass(source)->core_class.display_accelerator != NULL)) {
+        _XtString buf = _XtPrintXlations(destination, aXlations, source, False);
+
+        (*(XtClass(source)->core_class.display_accelerator)) (source, buf);
+        XtFree(buf);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void XtInstallAllAccelerators(
-    Widget destination,
-    Widget source)
+void
+XtInstallAllAccelerators(Widget destination, Widget source)
 {
     Cardinal i;
+
     WIDGET_TO_APPCON(destination);
 
     /* Recurse down normal children */
@@ -2247,103 +2202,100 @@ void XtInstallAllAccelerators(
     LOCK_PROCESS;
     if (XtIsComposite(source)) {
         CompositeWidget cw = (CompositeWidget) source;
+
         for (i = 0; i < cw->composite.num_children; i++) {
-            XtInstallAllAccelerators(destination,cw->composite.children[i]);
+            XtInstallAllAccelerators(destination, cw->composite.children[i]);
         }
     }
 
     /* Recurse down popup children */
     if (XtIsWidget(source)) {
         for (i = 0; i < source->core.num_popups; i++) {
-            XtInstallAllAccelerators(destination,source->core.popup_list[i]);
+            XtInstallAllAccelerators(destination, source->core.popup_list[i]);
         }
     }
     /* Finally, apply procedure to this widget */
-    XtInstallAccelerators(destination,source);
+    XtInstallAccelerators(destination, source);
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-#if 0 /* dead code */
-static _XtTranslateOp _XtGetTMOperation(
-    XtTranslations xlations)
+#if 0                           /* dead code */
+static _XtTranslateOp
+_XtGetTMOperation(XtTranslations xlations)
 {
     return ((xlations->hasBindings)
-	    ? ((ATranslations)xlations)->xlations->operation
-	    : xlations->operation);
+            ? ((ATranslations) xlations)->xlations->operation
+            : xlations->operation);
 }
 #endif
 
-void XtAugmentTranslations(
-    Widget widget,
-    XtTranslations new)
+void
+XtAugmentTranslations(Widget widget, XtTranslations new)
 {
     Widget hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     LOCK_PROCESS;
-    (void)ComposeTranslations(widget, XtTableAugment, (Widget)NULL, new);
+    (void) ComposeTranslations(widget, XtTableAugment, (Widget) NULL, new);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHaugmentTranslations;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHaugmentTranslations;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void XtOverrideTranslations(
-    Widget widget,
-    XtTranslations new)
+void
+XtOverrideTranslations(Widget widget, XtTranslations new)
 {
     Widget hookobj;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
     LOCK_PROCESS;
-    (void) ComposeTranslations(widget, XtTableOverride, (Widget)NULL, new);
+    (void) ComposeTranslations(widget, XtTableOverride, (Widget) NULL, new);
     hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
     if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
-	XtChangeHookDataRec call_data;
+        XtChangeHookDataRec call_data;
 
-	call_data.type = XtHoverrideTranslations;
-	call_data.widget = widget;
-	XtCallCallbackList(hookobj,
-		((HookObject)hookobj)->hooks.changehook_callbacks,
-		(XtPointer)&call_data);
+        call_data.type = XtHoverrideTranslations;
+        call_data.widget = widget;
+        XtCallCallbackList(hookobj,
+                           ((HookObject) hookobj)->hooks.changehook_callbacks,
+                           (XtPointer) &call_data);
     }
     UNLOCK_PROCESS;
     UNLOCK_APP(app);
 }
 
-void _XtMergeTranslations(
-    Widget	widget,
-    XtTranslations newXlations,
-    _XtTranslateOp op)
+void
+_XtMergeTranslations(Widget widget,
+                     XtTranslations newXlations,
+                     _XtTranslateOp op)
 {
-    if (!newXlations){
-	if (!widget->core.tm.translations)
-	  return;
-	else {
-	  newXlations = widget->core.tm.translations;
-	  widget->core.tm.translations = NULL;
-      }
-    }
-    (void) ComposeTranslations(widget,
-			     op,
-			     (Widget)NULL,
-			     newXlations);
+    if (!newXlations) {
+        if (!widget->core.tm.translations)
+            return;
+        else {
+            newXlations = widget->core.tm.translations;
+            widget->core.tm.translations = NULL;
+        }
+    }
+    (void) ComposeTranslations(widget, op, (Widget) NULL, newXlations);
 }
 
-void _XtUnmergeTranslations(
-   Widget		widget,
-    XtTranslations	xlations)
+void
+_XtUnmergeTranslations(Widget widget, XtTranslations xlations)
 {
-    ComposeTranslations(widget, XtTableUnmerge, (Widget)NULL, xlations);
+    ComposeTranslations(widget, XtTableUnmerge, (Widget) NULL, xlations);
 }
diff --git a/src/Threads.c b/src/Threads.c
index 14954d0..83f0b74 100644
--- a/src/Threads.c
+++ b/src/Threads.c
@@ -69,8 +69,8 @@ typedef struct _ThreadStack {
     unsigned int size;
     int sp;
     struct _Tstack {
-	xthread_t t;
-	xcondition_t c;
+        xthread_t t;
+        xcondition_t c;
     } *st;
 } ThreadStack;
 
@@ -84,7 +84,6 @@ typedef struct _LockRec {
 #endif
 } LockRec;
 
-
 #define STACK_INCR 16
 
 static LockPtr process_lock = NULL;
@@ -92,15 +91,15 @@ static LockPtr process_lock = NULL;
 static void
 InitProcessLock(void)
 {
-    if(!process_lock) {
-    	process_lock = XtNew(LockRec);
-    	process_lock->mutex = xmutex_malloc();
-    	xmutex_init(process_lock->mutex);
-    	process_lock->level = 0;
+    if (!process_lock) {
+        process_lock = XtNew(LockRec);
+        process_lock->mutex = xmutex_malloc();
+        xmutex_init(process_lock->mutex);
+        process_lock->level = 0;
 #ifndef _XMUTEX_NESTS
-    	process_lock->cond = xcondition_malloc();
-    	xcondition_init(process_lock->cond);
-    	xthread_clear_id(process_lock->holder);
+        process_lock->cond = xcondition_malloc();
+        xcondition_init(process_lock->cond);
+        xthread_clear_id(process_lock->holder);
 #endif
     }
 }
@@ -117,19 +116,19 @@ ProcessLock(void)
     xmutex_lock(process_lock->mutex);
 
     if (!xthread_have_id(process_lock->holder)) {
-	process_lock->holder = this_thread;
-	xmutex_unlock(process_lock->mutex);
-	return;
+        process_lock->holder = this_thread;
+        xmutex_unlock(process_lock->mutex);
+        return;
     }
 
-    if (xthread_equal(process_lock->holder,this_thread)) {
-	process_lock->level++;
-	xmutex_unlock(process_lock->mutex);
-	return;
+    if (xthread_equal(process_lock->holder, this_thread)) {
+        process_lock->level++;
+        xmutex_unlock(process_lock->mutex);
+        return;
     }
 
-    while(xthread_have_id(process_lock->holder))
-	xcondition_wait(process_lock->cond, process_lock->mutex);
+    while (xthread_have_id(process_lock->holder))
+        xcondition_wait(process_lock->cond, process_lock->mutex);
 
     process_lock->holder = this_thread;
     assert(xthread_equal(process_lock->holder, this_thread));
@@ -147,9 +146,9 @@ ProcessUnlock(void)
     xmutex_lock(process_lock->mutex);
     assert(xthread_equal(process_lock->holder, xthread_self()));
     if (process_lock->level != 0) {
-	process_lock->level--;
-	xmutex_unlock(process_lock->mutex);
-	return;
+        process_lock->level--;
+        xmutex_unlock(process_lock->mutex);
+        return;
     }
 
     xthread_clear_id(process_lock->holder);
@@ -159,30 +158,31 @@ ProcessUnlock(void)
 #endif
 }
 
-
 static void
 AppLock(XtAppContext app)
 {
     LockPtr app_lock = app->lock_info;
+
 #ifdef _XMUTEX_NESTS
     xmutex_lock(app_lock->mutex);
     app_lock->level++;
 #else
     xthread_t self = xthread_self();
+
     xmutex_lock(app_lock->mutex);
     if (!xthread_have_id(app_lock->holder)) {
-	app_lock->holder = self;
-    	assert(xthread_equal(app_lock->holder, self));
-	xmutex_unlock(app_lock->mutex);
-	return;
+        app_lock->holder = self;
+        assert(xthread_equal(app_lock->holder, self));
+        xmutex_unlock(app_lock->mutex);
+        return;
     }
     if (xthread_equal(app_lock->holder, self)) {
-	app_lock->level++;
-	xmutex_unlock(app_lock->mutex);
-	return;
+        app_lock->level++;
+        xmutex_unlock(app_lock->mutex);
+        return;
     }
-    while(xthread_have_id(app_lock->holder)) {
-	xcondition_wait(app_lock->cond, app_lock->mutex);
+    while (xthread_have_id(app_lock->holder)) {
+        xcondition_wait(app_lock->cond, app_lock->mutex);
     }
     app_lock->holder = self;
     assert(xthread_equal(app_lock->holder, self));
@@ -194,20 +194,22 @@ static void
 AppUnlock(XtAppContext app)
 {
     LockPtr app_lock = app->lock_info;
+
 #ifdef _XMUTEX_NESTS
     app_lock->level--;
     xmutex_unlock(app_lock->mutex);
 #else
     xthread_t self;
+
     self = xthread_self();
-    (void)self;
+    (void) self;
 
     xmutex_lock(app_lock->mutex);
     assert(xthread_equal(app_lock->holder, self));
     if (app_lock->level != 0) {
-	app_lock->level--;
-	xmutex_unlock(app_lock->mutex);
-	return;
+        app_lock->level--;
+        xmutex_unlock(app_lock->mutex);
+        return;
     }
     xthread_clear_id(app_lock->holder);
     xcondition_signal(app_lock->cond);
@@ -216,41 +218,43 @@ AppUnlock(XtAppContext app)
 }
 
 static void
-YieldAppLock(
-    XtAppContext app,
-    Boolean* push_thread,
-    Boolean* pushed_thread,
-    int* level)
+YieldAppLock(XtAppContext app,
+             Boolean *push_thread,
+             Boolean *pushed_thread,
+             int *level)
 {
     LockPtr app_lock = app->lock_info;
     xthread_t self = xthread_self();
+
 #ifndef _XMUTEX_NESTS
     xmutex_lock(app_lock->mutex);
     assert(xthread_equal(app_lock->holder, self));
 #endif
     *level = app_lock->level;
     if (*push_thread) {
-	*push_thread = FALSE;
-	*pushed_thread = TRUE;
-
-	if(app_lock->stack.sp == (int)app_lock->stack.size - 1) {
-	    unsigned ii;
-	    app_lock->stack.st = (struct _Tstack *)
-		XtRealloc ((char *)app_lock->stack.st,
-		(Cardinal)((app_lock->stack.size + STACK_INCR) * sizeof (struct _Tstack)));
-	    ii = app_lock->stack.size;
-	    app_lock->stack.size += STACK_INCR;
-	    for ( ; ii < app_lock->stack.size; ii++) {
-		app_lock->stack.st[ii].c = xcondition_malloc();
-		xcondition_init(app_lock->stack.st[ii].c);
-	    }
-	}
-	app_lock->stack.st[++(app_lock->stack.sp)].t = self;
+        *push_thread = FALSE;
+        *pushed_thread = TRUE;
+
+        if (app_lock->stack.sp == (int) app_lock->stack.size - 1) {
+            unsigned ii;
+
+            app_lock->stack.st = (struct _Tstack *)
+                XtRealloc((char *) app_lock->stack.st,
+                          (Cardinal) ((app_lock->stack.size +
+                                       STACK_INCR) * sizeof(struct _Tstack)));
+            ii = app_lock->stack.size;
+            app_lock->stack.size += STACK_INCR;
+            for (; ii < app_lock->stack.size; ii++) {
+                app_lock->stack.st[ii].c = xcondition_malloc();
+                xcondition_init(app_lock->stack.st[ii].c);
+            }
+        }
+        app_lock->stack.st[++(app_lock->stack.sp)].t = self;
     }
 #ifdef _XMUTEX_NESTS
     while (app_lock->level > 0) {
-	app_lock->level--;
-	xmutex_unlock(app_lock->mutex);
+        app_lock->level--;
+        xmutex_unlock(app_lock->mutex);
     }
 #else
     xcondition_signal(app_lock->cond);
@@ -261,39 +265,38 @@ YieldAppLock(
 }
 
 static void
-RestoreAppLock(
-    XtAppContext app,
-    int level,
-    Boolean* pushed_thread)
+RestoreAppLock(XtAppContext app, int level, Boolean *pushed_thread)
 {
     LockPtr app_lock = app->lock_info;
     xthread_t self = xthread_self();
+
     xmutex_lock(app_lock->mutex);
 #ifdef _XMUTEX_NESTS
     app_lock->level++;
 #else
-    while(xthread_have_id(app_lock->holder)) {
-	xcondition_wait(app_lock->cond, app_lock->mutex);
+    while (xthread_have_id(app_lock->holder)) {
+        xcondition_wait(app_lock->cond, app_lock->mutex);
     }
 #endif
     if (!xthread_equal(app_lock->stack.st[app_lock->stack.sp].t, self)) {
-	int ii;
-	for (ii = app_lock->stack.sp - 1; ii >= 0; ii--) {
-	    if (xthread_equal(app_lock->stack.st[ii].t, self)) {
-		xcondition_wait(app_lock->stack.st[ii].c, app_lock->mutex);
-		break;
-	    }
-	}
+        int ii;
+
+        for (ii = app_lock->stack.sp - 1; ii >= 0; ii--) {
+            if (xthread_equal(app_lock->stack.st[ii].t, self)) {
+                xcondition_wait(app_lock->stack.st[ii].c, app_lock->mutex);
+                break;
+            }
+        }
 #ifndef _XMUTEX_NESTS
-	while(xthread_have_id(app_lock->holder)) {
-	    xcondition_wait(app_lock->cond, app_lock->mutex);
-	}
+        while (xthread_have_id(app_lock->holder)) {
+            xcondition_wait(app_lock->cond, app_lock->mutex);
+        }
 #endif
     }
 #ifdef _XMUTEX_NESTS
     while (app_lock->level < level) {
-	xmutex_lock(app_lock->mutex);
-	app_lock->level++;
+        xmutex_lock(app_lock->mutex);
+        app_lock->level++;
     }
 #else
     app_lock->holder = self;
@@ -301,11 +304,11 @@ RestoreAppLock(
     assert(xthread_equal(app_lock->holder, self));
 #endif
     if (*pushed_thread) {
-	*pushed_thread = FALSE;
-	(app_lock->stack.sp)--;
-	if (app_lock->stack.sp >= 0) {
-	    xcondition_signal (app_lock->stack.st[app_lock->stack.sp].c);
-	}
+        *pushed_thread = FALSE;
+        (app_lock->stack.sp)--;
+        if (app_lock->stack.sp >= 0) {
+            xcondition_signal(app_lock->stack.st[app_lock->stack.sp].c);
+        }
     }
 #ifndef _XMUTEX_NESTS
     xmutex_unlock(app_lock->mutex);
@@ -318,22 +321,22 @@ FreeAppLock(XtAppContext app)
     unsigned ii;
     LockPtr app_lock = app->lock_info;
 
-    if(app_lock) {
-	xmutex_clear(app_lock->mutex);
-	xmutex_free(app_lock->mutex);
+    if (app_lock) {
+        xmutex_clear(app_lock->mutex);
+        xmutex_free(app_lock->mutex);
 #ifndef _XMUTEX_NESTS
-	xcondition_clear(app_lock->cond);
-	xcondition_free(app_lock->cond);
+        xcondition_clear(app_lock->cond);
+        xcondition_free(app_lock->cond);
 #endif
-	if(app_lock->stack.st != (struct _Tstack *)NULL) {
-	    for (ii = 0; ii < app_lock->stack.size; ii++) {
-		xcondition_clear(app_lock->stack.st[ii].c);
-		xcondition_free(app_lock->stack.st[ii].c);
-	    }
-	    XtFree((char *)app_lock->stack.st);
-	}
-	XtFree((char *)app_lock);
-	app->lock_info = NULL;
+        if (app_lock->stack.st != (struct _Tstack *) NULL) {
+            for (ii = 0; ii < app_lock->stack.size; ii++) {
+                xcondition_clear(app_lock->stack.st[ii].c);
+                xcondition_free(app_lock->stack.st[ii].c);
+            }
+            XtFree((char *) app_lock->stack.st);
+        }
+        XtFree((char *) app_lock);
+        app->lock_info = NULL;
     }
 }
 
@@ -361,62 +364,66 @@ InitAppLock(XtAppContext app)
     app_lock->stack.size = STACK_INCR;
     app_lock->stack.sp = -1;
     app_lock->stack.st =
-	(struct _Tstack *)__XtMalloc(sizeof(struct _Tstack)*STACK_INCR);
+        (struct _Tstack *) __XtMalloc(sizeof(struct _Tstack) * STACK_INCR);
     for (ii = 0; ii < STACK_INCR; ii++) {
-	app_lock->stack.st[ii].c = xcondition_malloc();
-	xcondition_init(app_lock->stack.st[ii].c);
+        app_lock->stack.st[ii].c = xcondition_malloc();
+        xcondition_init(app_lock->stack.st[ii].c);
     }
 }
 
-#endif /* defined(XTHREADS) */
+#endif                          /* defined(XTHREADS) */
 
-void XtAppLock(XtAppContext app)
+void
+XtAppLock(XtAppContext app)
 {
 #ifdef XTHREADS
-    if(app->lock)
-	(*app->lock)(app);
+    if (app->lock)
+        (*app->lock) (app);
 #endif
 }
 
-void XtAppUnlock(XtAppContext app)
+void
+XtAppUnlock(XtAppContext app)
 {
 #ifdef XTHREADS
-    if(app->unlock)
-	(*app->unlock)(app);
+    if (app->unlock)
+        (*app->unlock) (app);
 #endif
 }
 
-void XtProcessLock(void)
+void
+XtProcessLock(void)
 {
 #ifdef XTHREADS
-    if(_XtProcessLock)
-	(*_XtProcessLock)();
+    if (_XtProcessLock)
+        (*_XtProcessLock) ();
 #endif
 }
 
-void XtProcessUnlock(void)
+void
+XtProcessUnlock(void)
 {
 #ifdef XTHREADS
-    if(_XtProcessUnlock)
-	(*_XtProcessUnlock)();
+    if (_XtProcessUnlock)
+        (*_XtProcessUnlock) ();
 #endif
 }
 
-Boolean XtToolkitThreadInitialize(void)
+Boolean
+XtToolkitThreadInitialize(void)
 {
 #ifdef XTHREADS
     if (_XtProcessLock == NULL) {
 #ifdef xthread_init
-	xthread_init();
+        xthread_init();
 #endif
-	InitProcessLock();
-	_XtProcessLock = ProcessLock;
-	_XtProcessUnlock = ProcessUnlock;
-	_XtInitAppLock = InitAppLock;
+        InitProcessLock();
+        _XtProcessLock = ProcessLock;
+        _XtProcessUnlock = ProcessUnlock;
+        _XtInitAppLock = InitAppLock;
     }
     return True;
 #else
     return False;
 #endif
 }
-
diff --git a/src/VarCreate.c b/src/VarCreate.c
index 896935d..d654616 100644
--- a/src/VarCreate.c
+++ b/src/VarCreate.c
@@ -60,145 +60,141 @@ in this Software without prior written authorization from The Open Group.
 
 #if (defined(SUNSHLIB) || defined(AIXSHLIB)) && defined(SHAREDCODE)
 #define XtToolkitInitialize _XtToolkitInitialize
-#endif /* (SUNSHLIB || AIXSHLIB) && SHAREDCODE */
+#endif                          /* (SUNSHLIB || AIXSHLIB) && SHAREDCODE */
 
 static Widget
-_XtVaCreateWidget(
-    String      name,
-    WidgetClass widget_class,
-    Widget      parent,
-    va_list     var,
-    int		count)
+_XtVaCreateWidget(String name,
+                  WidgetClass widget_class,
+                  Widget parent,
+                  va_list var,
+                  int count)
 {
-    register Widget         widget;
-    XtTypedArgList	    typed_args = NULL;
-    Cardinal		    num_args;
+    register Widget widget;
+    XtTypedArgList typed_args = NULL;
+    Cardinal num_args;
 
     _XtVaToTypedArgList(var, count, &typed_args, &num_args);
 
-    widget = _XtCreateWidget(name, widget_class, parent, (ArgList)NULL,
-		    (Cardinal)0, typed_args, num_args);
+    widget = _XtCreateWidget(name, widget_class, parent, (ArgList) NULL,
+                             (Cardinal) 0, typed_args, num_args);
 
-
-    XtFree((XtPointer)typed_args);
+    XtFree((XtPointer) typed_args);
 
     return widget;
 }
 
-
 Widget
-XtVaCreateWidget(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget parent,
-    ...)
+XtVaCreateWidget(_Xconst char *name,
+                 WidgetClass widget_class,
+                 Widget parent,
+                 ...)
 {
-    va_list                 var;
-    register Widget         widget;
-    int			    total_count, typed_count;
+    va_list var;
+    register Widget widget;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
-    va_start(var,parent);
+    va_start(var, parent);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,parent);
-    widget = _XtVaCreateWidget((String)name, widget_class, parent, var,
-				total_count);
+    va_start(var, parent);
+    widget = _XtVaCreateWidget((String) name, widget_class, parent, var,
+                               total_count);
     va_end(var);
     UNLOCK_APP(app);
     return widget;
 }
 
-
 Widget
-XtVaCreateManagedWidget(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget parent,
-    ...)
+XtVaCreateManagedWidget(_Xconst char *name,
+                        WidgetClass widget_class,
+                        Widget parent,
+                        ...)
 {
-    va_list		var;
-    register Widget	widget;
-    int			total_count, typed_count;
+    va_list var;
+    register Widget widget;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
-    va_start(var,parent);
+    va_start(var, parent);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,parent);
-    widget = _XtVaCreateWidget((String)name, widget_class, parent, var,
-				total_count);
+    va_start(var, parent);
+    widget = _XtVaCreateWidget((String) name, widget_class, parent, var,
+                               total_count);
     XtManageChild(widget);
     va_end(var);
     UNLOCK_APP(app);
     return widget;
 }
 
-
 Widget
-XtVaAppCreateShell(
-    _Xconst char* name,
-    _Xconst char* class,
-    WidgetClass widget_class,
-    Display* display,
-    ...)
+XtVaAppCreateShell(_Xconst char *name,
+                   _Xconst char *class,
+                   WidgetClass widget_class,
+                   Display *display,
+                   ...)
 {
-    va_list                 var;
-    register Widget         widget;
-    XtTypedArgList          typed_args = NULL;
-    Cardinal                num_args;
-    int			    total_count, typed_count;
+    va_list var;
+    register Widget widget;
+    XtTypedArgList typed_args = NULL;
+    Cardinal num_args;
+    int total_count, typed_count;
     DPY_TO_APPCON(display);
 
     LOCK_APP(app);
-    va_start(var,display);
+    va_start(var, display);
+
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,display);
+    va_start(var, display);
 
     _XtVaToTypedArgList(var, total_count, &typed_args, &num_args);
-    widget = _XtAppCreateShell((String)name, (String)class, widget_class,
-		display, (ArgList)NULL, (Cardinal)0, typed_args, num_args);
+    widget = _XtAppCreateShell((String) name, (String) class, widget_class,
+                               display, (ArgList) NULL, (Cardinal) 0,
+                               typed_args, num_args);
 
-    XtFree((XtPointer)typed_args);
+    XtFree((XtPointer) typed_args);
 
     va_end(var);
     UNLOCK_APP(app);
     return widget;
 }
 
-
 Widget
-XtVaCreatePopupShell(
-    _Xconst char* name,
-    WidgetClass widget_class,
-    Widget parent,
-    ...)
+XtVaCreatePopupShell(_Xconst char *name,
+                     WidgetClass widget_class,
+                     Widget parent,
+                     ...)
 {
-    va_list                 var;
-    register Widget         widget;
-    XtTypedArgList          typed_args = NULL;
-    Cardinal                num_args;
-    int			    total_count, typed_count;
+    va_list var;
+    register Widget widget;
+    XtTypedArgList typed_args = NULL;
+    Cardinal num_args;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(parent);
 
     LOCK_APP(app);
-    va_start(var,parent);
+    va_start(var, parent);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,parent);
+    va_start(var, parent);
 
     _XtVaToTypedArgList(var, total_count, &typed_args, &num_args);
-    widget = _XtCreatePopupShell((String)name, widget_class, parent,
-		(ArgList)NULL, (Cardinal)0, typed_args, num_args);
+    widget = _XtCreatePopupShell((String) name, widget_class, parent,
+                                 (ArgList) NULL, (Cardinal) 0, typed_args,
+                                 num_args);
 
-    XtFree((XtPointer)typed_args);
+    XtFree((XtPointer) typed_args);
 
     va_end(var);
     UNLOCK_APP(app);
@@ -208,18 +204,19 @@ XtVaCreatePopupShell(
 void
 XtVaSetValues(Widget widget, ...)
 {
-    va_list                 var;
-    ArgList                 args = NULL;
-    Cardinal                num_args;
-    int			    total_count, typed_count;
+    va_list var;
+    ArgList args = NULL;
+    Cardinal num_args;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    va_start(var,widget);
+    va_start(var, widget);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,widget);
+    va_start(var, widget);
 
     _XtVaToArgList(widget, var, total_count, &args, &num_args);
     XtSetValues(widget, args, num_args);
@@ -229,113 +226,113 @@ XtVaSetValues(Widget widget, ...)
     va_end(var);
 }
 
-
 void
-XtVaSetSubvalues(XtPointer base, XtResourceList resources, Cardinal num_resources, ...)
+XtVaSetSubvalues(XtPointer base,
+                 XtResourceList resources,
+                 Cardinal num_resources,
+                 ...)
 {
-    va_list	var;
-    ArgList    	args;
-    Cardinal   	num_args;
-    int		total_count, typed_count;
+    va_list var;
+    ArgList args;
+    Cardinal num_args;
+    int total_count, typed_count;
 
     va_start(var, num_resources);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
     if (typed_count != 0) {
-	XtWarning("XtVaTypedArg is not valid in XtVaSetSubvalues()\n");
+        XtWarning("XtVaTypedArg is not valid in XtVaSetSubvalues()\n");
     }
 
     va_start(var, num_resources);
-    _XtVaToArgList((Widget)NULL, var, total_count, &args, &num_args);
+    _XtVaToArgList((Widget) NULL, var, total_count, &args, &num_args);
 
     XtSetSubvalues(base, resources, num_resources, args, num_args);
 
-    XtFree((XtPointer)args);
+    XtFree((XtPointer) args);
 
     va_end(var);
 }
 
 Widget
-_XtVaOpenApplication(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    _XtString *argv_in_out,
-    String *fallback_resources,
-    WidgetClass widget_class,
-    va_list var_args)
+_XtVaOpenApplication(XtAppContext *app_context_return,
+                     _Xconst char *application_class,
+                     XrmOptionDescList options,
+                     Cardinal num_options,
+                     int *argc_in_out,
+                     _XtString *argv_in_out,
+                     String *fallback_resources,
+                     WidgetClass widget_class,
+                     va_list var_args)
 {
     XtAppContext app_con;
-    Display * dpy;
+    Display *dpy;
     register int saved_argc = *argc_in_out;
     Widget root;
     String attr;
     int count = 0;
     XtTypedArgList typed_args;
 
-    XtToolkitInitialize(); /* cannot be moved into _XtAppInit */
+    XtToolkitInitialize();      /* cannot be moved into _XtAppInit */
 
-    dpy = _XtAppInit(&app_con, (String)application_class, options, num_options,
-		     argc_in_out, &argv_in_out, fallback_resources);
+    dpy = _XtAppInit(&app_con, (String) application_class, options, num_options,
+                     argc_in_out, &argv_in_out, fallback_resources);
 
     typed_args = (XtTypedArgList) __XtMalloc((unsigned) sizeof(XtTypedArg));
-    attr = va_arg (var_args, String);
-    for(; attr != NULL; attr = va_arg (var_args, String)) {
+    attr = va_arg(var_args, String);
+    for (; attr != NULL; attr = va_arg(var_args, String)) {
         if (strcmp(attr, XtVaTypedArg) == 0) {
             typed_args[count].name = va_arg(var_args, String);
             typed_args[count].type = va_arg(var_args, String);
             typed_args[count].value = va_arg(var_args, XtArgVal);
             typed_args[count].size = va_arg(var_args, int);
-        } else {
-	    typed_args[count].name = attr;
-	    typed_args[count].type = NULL;
-	    typed_args[count].value = va_arg(var_args, XtArgVal);
-	    typed_args[count].size = 0;
         }
-	count++;
-	typed_args = (XtTypedArgList)
-	    XtRealloc((char *) typed_args,
-		       (Cardinal) ((size_t)(count + 1) * sizeof(XtTypedArg)));
+        else {
+            typed_args[count].name = attr;
+            typed_args[count].type = NULL;
+            typed_args[count].value = va_arg(var_args, XtArgVal);
+            typed_args[count].size = 0;
+        }
+        count++;
+        typed_args = (XtTypedArgList)
+            XtRealloc((char *) typed_args,
+                      (Cardinal) ((size_t) (count + 1) * sizeof(XtTypedArg)));
     }
     typed_args[count].name = NULL;
 
-    va_end (var_args);
+    va_end(var_args);
 
     root =
-	XtVaAppCreateShell( NULL, application_class,
-			    widget_class, dpy,
-			    XtNscreen, (XtArgVal)DefaultScreenOfDisplay(dpy),
-			    XtNargc, (XtArgVal)saved_argc,
-			    XtNargv, (XtArgVal)argv_in_out,
-			    XtVaNestedList, (XtVarArgsList)typed_args,
-			    NULL );
+        XtVaAppCreateShell(NULL, application_class,
+                           widget_class, dpy,
+                           XtNscreen, (XtArgVal) DefaultScreenOfDisplay(dpy),
+                           XtNargc, (XtArgVal) saved_argc,
+                           XtNargv, (XtArgVal) argv_in_out,
+                           XtVaNestedList, (XtVarArgsList) typed_args, NULL);
 
     if (app_context_return != NULL)
-	*app_context_return = app_con;
+        *app_context_return = app_con;
 
-    XtFree((XtPointer)typed_args);
-    XtFree((XtPointer)argv_in_out);
-    return(root);
+    XtFree((XtPointer) typed_args);
+    XtFree((XtPointer) argv_in_out);
+    return (root);
 }
 
 Widget
-_XtVaAppInitialize(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    _XtString *argv_in_out,
-    String *fallback_resources,
-    va_list var_args)
+_XtVaAppInitialize(XtAppContext *app_context_return,
+                   _Xconst char *application_class,
+                   XrmOptionDescList options,
+                   Cardinal num_options,
+                   int *argc_in_out,
+                   _XtString *argv_in_out,
+                   String *fallback_resources,
+                   va_list var_args)
 {
     return _XtVaOpenApplication(app_context_return, application_class,
-				options, num_options,
-				argc_in_out, argv_in_out, fallback_resources,
-				applicationShellWidgetClass, var_args);
+                                options, num_options,
+                                argc_in_out, argv_in_out, fallback_resources,
+                                applicationShellWidgetClass, var_args);
 }
 
 #if !((defined(SUNSHLIB) || defined(AIXSHLIB)) && defined(SHAREDCODE))
@@ -346,50 +343,47 @@ _XtVaAppInitialize(
  */
 
 Widget
-XtVaOpenApplication(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    _XtString *argv_in_out,
-    String *fallback_resources,
-    WidgetClass widget_class,
-    ...)
+XtVaOpenApplication(XtAppContext *app_context_return,
+                    _Xconst char *application_class,
+                    XrmOptionDescList options,
+                    Cardinal num_options,
+                    int *argc_in_out,
+                    _XtString *argv_in_out,
+                    String *fallback_resources,
+                    WidgetClass widget_class,
+                    ...)
 {
-    Widget      code;
-    va_list	var;
+    Widget code;
+    va_list var;
 
     va_start(var, widget_class);
-    code = _XtVaOpenApplication(app_context_return, (String)application_class,
-				options, num_options, argc_in_out, argv_in_out,
-				fallback_resources, widget_class, var);
+    code = _XtVaOpenApplication(app_context_return, (String) application_class,
+                                options, num_options, argc_in_out, argv_in_out,
+                                fallback_resources, widget_class, var);
     va_end(var);
     return code;
 }
 
 Widget
-XtVaAppInitialize(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    _XtString *argv_in_out,
-    String *fallback_resources,
-    ...)
+XtVaAppInitialize(XtAppContext *app_context_return,
+                  _Xconst char *application_class,
+                  XrmOptionDescList options,
+                  Cardinal num_options,
+                  int *argc_in_out,
+                  _XtString *argv_in_out,
+                  String *fallback_resources,
+                  ...)
 {
-    Widget      code;
-    va_list	var;
+    Widget code;
+    va_list var;
 
     va_start(var, fallback_resources);
-    code = _XtVaOpenApplication(app_context_return, (String)application_class,
-				options, num_options, argc_in_out, argv_in_out,
-				fallback_resources,
-				applicationShellWidgetClass, var);
+    code = _XtVaOpenApplication(app_context_return, (String) application_class,
+                                options, num_options, argc_in_out, argv_in_out,
+                                fallback_resources,
+                                applicationShellWidgetClass, var);
     va_end(var);
     return code;
 }
 
-#endif /* !((SUNSHLIB || AIXSHLIB) && SHAREDCODE) */
-
+#endif                          /* !((SUNSHLIB || AIXSHLIB) && SHAREDCODE) */
diff --git a/src/VarGet.c b/src/VarGet.c
index 2736899..2a805d2 100644
--- a/src/VarGet.c
+++ b/src/VarGet.c
@@ -59,19 +59,19 @@ in this Software without prior written authorization from The Open Group.
 static String XtNxtGetTypedArg = "xtGetTypedArg";
 
 void
-XtVaGetSubresources(
-    Widget widget,
-    XtPointer base,
-    _Xconst char* name,
-    _Xconst char* class,
-    XtResourceList resources,
-    Cardinal num_resources,
-    ...)
+XtVaGetSubresources(Widget widget,
+                    XtPointer base,
+                    _Xconst char *name,
+                    _Xconst char *class,
+                    XtResourceList resources,
+                    Cardinal num_resources,
+                    ...)
 {
-    va_list                 var;
-    XtTypedArgList          args;
-    Cardinal                num_args;
-    int			    total_count, typed_count;
+    va_list var;
+    XtTypedArgList args;
+    Cardinal num_args;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
@@ -84,224 +84,244 @@ XtVaGetSubresources(
     _XtVaToTypedArgList(var, total_count, &args, &num_args);
 
     _XtGetSubresources(widget, base, name, class, resources, num_resources,
-	NULL, 0, args, num_args);
+                       NULL, 0, args, num_args);
 
-    XtFree((XtPointer)args);
+    XtFree((XtPointer) args);
 
     va_end(var);
     UNLOCK_APP(app);
 }
 
-
 void
-XtVaGetApplicationResources(Widget widget, XtPointer base, XtResourceList resources, Cardinal num_resources, ...)
+XtVaGetApplicationResources(Widget widget,
+                            XtPointer base,
+                            XtResourceList resources,
+                            Cardinal num_resources,
+                            ...)
 {
-    va_list                 var;
-    XtTypedArgList          args;
-    Cardinal                num_args;
-    int			    total_count, typed_count;
+    va_list var;
+    XtTypedArgList args;
+    Cardinal num_args;
+    int total_count, typed_count;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    va_start(var,num_resources);
+    va_start(var, num_resources);
     _XtCountVaList(var, &total_count, &typed_count);
     va_end(var);
 
-    va_start(var,num_resources);
+    va_start(var, num_resources);
 
     _XtVaToTypedArgList(var, total_count, &args, &num_args);
 
     _XtGetApplicationResources(widget, base, resources, num_resources,
-	NULL, 0, args, num_args);
+                               NULL, 0, args, num_args);
 
-    XtFree((XtPointer)args);
+    XtFree((XtPointer) args);
 
     va_end(var);
     UNLOCK_APP(app);
 }
 
-
 static void
-GetTypedArg(
-    Widget              widget,
-    XtTypedArgList	typed_arg,
-    XtResourceList      resources,
-    Cardinal            num_resources)
+GetTypedArg(Widget widget,
+            XtTypedArgList typed_arg,
+            XtResourceList resources,
+            Cardinal num_resources)
 {
-    String              from_type = NULL;
-    Cardinal		from_size = 0;
-    XrmValue            from_val, to_val;
-    register Cardinal   i;
-    Arg			arg;
-    XtPointer		value;
+    String from_type = NULL;
+    Cardinal from_size = 0;
+    XrmValue from_val, to_val;
+    register Cardinal i;
+    Arg arg;
+    XtPointer value;
 
     /* note we presume that the XtResourceList to be un-compiled */
 
     for (i = 0; i < num_resources; i++) {
-        if (StringToName(typed_arg->name) == StringToName(resources[i].resource_name)) {
+        if (StringToName(typed_arg->name) ==
+            StringToName(resources[i].resource_name)) {
             from_type = resources[i].resource_type;
-	    from_size = resources[i].resource_size;
+            from_size = resources[i].resource_size;
             break;
         }
     }
 
     if (i == num_resources) {
-	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-            "unknownType", XtNxtGetTypedArg, XtCXtToolkitError,
-            "Unable to find type of resource for conversion",
-            NULL, NULL);
- 	return;
+        XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                        "unknownType", XtNxtGetTypedArg, XtCXtToolkitError,
+                        "Unable to find type of resource for conversion",
+                        NULL, NULL);
+        return;
     }
 
     value = ALLOCATE_LOCAL(from_size);
-    if (value == NULL) _XtAllocError(NULL);
+    if (value == NULL)
+        _XtAllocError(NULL);
     XtSetArg(arg, typed_arg->name, value);
     XtGetValues(widget, &arg, 1);
 
     from_val.size = from_size;
-    from_val.addr = (XPointer)value;
-    to_val.addr = (XPointer)typed_arg->value;
+    from_val.addr = (XPointer) value;
+    to_val.addr = (XPointer) typed_arg->value;
     to_val.size = (unsigned) typed_arg->size;
 
     if (!XtConvertAndStore(widget, from_type, &from_val,
-			   typed_arg->type, &to_val)) {
-	if (to_val.size > (unsigned) typed_arg->size) {
-	    String params[2];
-	    Cardinal num_params = 2;
-	    params[0] = typed_arg->type;
-	    params[1] = XtName(widget);
-	    XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"insufficientSpace", XtNxtGetTypedArg, XtCXtToolkitError,
-		"Insufficient space for converted type '%s' in widget '%s'",
-		params, &num_params);
-	}
-	else {
-	    String params[3];
-	    Cardinal num_params = 3;
-	    params[0] = from_type;
-	    params[1] = typed_arg->type;
-	    params[2] = XtName(widget);
-	    XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-		"conversionFailed", XtNxtGetTypedArg, XtCXtToolkitError,
-		"Type conversion (%s to %s) failed for widget '%s'",
-		params, &num_params);
-	}
+                           typed_arg->type, &to_val)) {
+        if (to_val.size > (unsigned) typed_arg->size) {
+            String params[2];
+            Cardinal num_params = 2;
+
+            params[0] = typed_arg->type;
+            params[1] = XtName(widget);
+            XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                            "insufficientSpace", XtNxtGetTypedArg,
+                            XtCXtToolkitError,
+                            "Insufficient space for converted type '%s' in widget '%s'",
+                            params, &num_params);
+        }
+        else {
+            String params[3];
+            Cardinal num_params = 3;
+
+            params[0] = from_type;
+            params[1] = typed_arg->type;
+            params[2] = XtName(widget);
+            XtAppWarningMsg(XtWidgetToApplicationContext(widget),
+                            "conversionFailed", XtNxtGetTypedArg,
+                            XtCXtToolkitError,
+                            "Type conversion (%s to %s) failed for widget '%s'",
+                            params, &num_params);
+        }
     }
     DEALLOCATE_LOCAL(value);
 }
 
 static int
-GetNestedArg(
-    Widget              widget,
-    XtTypedArgList	avlist,
-    ArgList             args,
-    XtResourceList      resources,
-    Cardinal            num_resources)
+GetNestedArg(Widget widget,
+             XtTypedArgList avlist,
+             ArgList args,
+             XtResourceList resources,
+             Cardinal num_resources)
 {
-    int         count = 0;
+    int count = 0;
 
     for (; avlist->name != NULL; avlist++) {
         if (avlist->type != NULL) {
-	    GetTypedArg(widget, avlist, resources, num_resources);
-        } else if(strcmp(avlist->name, XtVaNestedList) == 0) {
-            count += GetNestedArg(widget, (XtTypedArgList)avlist->value,
-				     args, resources, num_resources);
-        } else {
-            (args+count)->name = avlist->name;
-            (args+count)->value = avlist->value;
+            GetTypedArg(widget, avlist, resources, num_resources);
+        }
+        else if (strcmp(avlist->name, XtVaNestedList) == 0) {
+            count += GetNestedArg(widget, (XtTypedArgList) avlist->value,
+                                  args, resources, num_resources);
+        }
+        else {
+            (args + count)->name = avlist->name;
+            (args + count)->value = avlist->value;
             ++count;
         }
     }
 
-    return(count);
+    return (count);
 }
 
 void
 XtVaGetValues(Widget widget, ...)
 {
-    va_list		var;
-    String      	attr;
-    ArgList    		args;
-    XtTypedArg		typed_arg;
-    XtResourceList      resources = (XtResourceList)NULL;
-    Cardinal            num_resources;
-    int			count, total_count, typed_count;
+    va_list var;
+    String attr;
+    ArgList args;
+    XtTypedArg typed_arg;
+    XtResourceList resources = (XtResourceList) NULL;
+    Cardinal num_resources;
+    int count, total_count, typed_count;
+
     WIDGET_TO_APPCON(widget);
 
     LOCK_APP(app);
-    va_start(var,widget);
+    va_start(var, widget);
 
     _XtCountVaList(var, &total_count, &typed_count);
 
     if (total_count != typed_count) {
-	size_t limit = (size_t)(total_count - typed_count);
-        args = (ArgList)__XtMalloc((unsigned)(limit * sizeof(Arg)));
+        size_t limit = (size_t) (total_count - typed_count);
+
+        args = (ArgList) __XtMalloc((unsigned) (limit * sizeof(Arg)));
     }
-    else args = NULL;		/* for lint; really unused */
+    else
+        args = NULL;            /* for lint; really unused */
     va_end(var);
 
     if (args != NULL) {
-	va_start(var,widget);
-	for(attr = va_arg(var, String), count = 0 ; attr != NULL;
-			    attr = va_arg(var, String)) {
-	    if (strcmp(attr, XtVaTypedArg) == 0) {
-		typed_arg.name = va_arg(var, String);
-		typed_arg.type = va_arg(var, String);
-		typed_arg.value = va_arg(var, XtArgVal);
-		typed_arg.size = va_arg(var, int);
-
-		if (resources == NULL) {
-		    XtGetResourceList(XtClass(widget), &resources,&num_resources);
-		}
-
-		GetTypedArg(widget, &typed_arg, resources, num_resources);
-	    } else if (strcmp(attr, XtVaNestedList) == 0) {
-		if (resources == NULL) {
-		    XtGetResourceList(XtClass(widget),&resources, &num_resources);
-		}
-
-		count += GetNestedArg(widget, va_arg(var, XtTypedArgList),
-					 (args+count), resources, num_resources);
-	    } else {
-		args[count].name = attr;
-		args[count].value = va_arg(var, XtArgVal);
-		count ++;
-	    }
-	}
-	va_end(var);
+        va_start(var, widget);
+        for (attr = va_arg(var, String), count = 0; attr != NULL;
+             attr = va_arg(var, String)) {
+            if (strcmp(attr, XtVaTypedArg) == 0) {
+                typed_arg.name = va_arg(var, String);
+                typed_arg.type = va_arg(var, String);
+                typed_arg.value = va_arg(var, XtArgVal);
+                typed_arg.size = va_arg(var, int);
+
+                if (resources == NULL) {
+                    XtGetResourceList(XtClass(widget), &resources,
+                                      &num_resources);
+                }
+
+                GetTypedArg(widget, &typed_arg, resources, num_resources);
+            }
+            else if (strcmp(attr, XtVaNestedList) == 0) {
+                if (resources == NULL) {
+                    XtGetResourceList(XtClass(widget), &resources,
+                                      &num_resources);
+                }
+
+                count += GetNestedArg(widget, va_arg(var, XtTypedArgList),
+                                      (args + count), resources, num_resources);
+            }
+            else {
+                args[count].name = attr;
+                args[count].value = va_arg(var, XtArgVal);
+                count++;
+            }
+        }
+        va_end(var);
     }
 
-    XtFree((XtPointer)resources);
+    XtFree((XtPointer) resources);
 
     if (args != NULL) {
-	XtGetValues(widget, args, (Cardinal) count);
-	XtFree((XtPointer)args);
+        XtGetValues(widget, args, (Cardinal) count);
+        XtFree((XtPointer) args);
     }
     UNLOCK_APP(app);
 }
 
 void
-XtVaGetSubvalues(XtPointer base,XtResourceList  resources, Cardinal num_resources, ...)
+XtVaGetSubvalues(XtPointer base,
+                 XtResourceList resources,
+                 Cardinal num_resources,
+                 ...)
 {
-    va_list	var;
-    ArgList    	args;
-    Cardinal   	num_args;
-    int		total_count, typed_count;
+    va_list var;
+    ArgList args;
+    Cardinal num_args;
+    int total_count, typed_count;
 
-    va_start(var,num_resources);
+    va_start(var, num_resources);
 
     _XtCountVaList(var, &total_count, &typed_count);
 
     if (typed_count != 0) {
-	XtWarning("XtVaTypedArg is an invalid argument to XtVaGetSubvalues()\n");
+        XtWarning
+            ("XtVaTypedArg is an invalid argument to XtVaGetSubvalues()\n");
     }
     va_end(var);
 
-    va_start(var,num_resources);
-    _XtVaToArgList((Widget)NULL, var, total_count, &args, &num_args);
+    va_start(var, num_resources);
+    _XtVaToArgList((Widget) NULL, var, total_count, &args, &num_args);
     va_end(var);
 
     XtGetSubvalues(base, resources, num_resources, args, num_args);
 
-    XtFree((XtPointer)args);
+    XtFree((XtPointer) args);
 }
diff --git a/src/Varargs.c b/src/Varargs.c
index 7920e09..4e1f647 100644
--- a/src/Varargs.c
+++ b/src/Varargs.c
@@ -38,17 +38,15 @@ static String XtNxtConvertVarToArgList = "xtConvertVarToArgList";
  *    total number of attribute-value pairs and the count of those
  *    attributes that are typed. The list is counted recursively.
  */
-static  void
-_XtCountNestedList(
-    XtTypedArgList  avlist,
-    int             *total_count,
-    int             *typed_count)
+static void
+_XtCountNestedList(XtTypedArgList avlist, int *total_count, int *typed_count)
 {
     for (; avlist->name != NULL; avlist++) {
         if (strcmp(avlist->name, XtVaNestedList) == 0) {
-            _XtCountNestedList((XtTypedArgList)avlist->value, total_count,
-                	       typed_count);
-        } else {
+            _XtCountNestedList((XtTypedArgList) avlist->value, total_count,
+                               typed_count);
+        }
+        else {
             if (avlist->type != NULL) {
                 ++(*typed_count);
             }
@@ -57,7 +55,6 @@ _XtCountNestedList(
     }
 }
 
-
 /*
  *    Given a variable length attribute-value list, _XtCountVaList()
  *    returns counts of the total number of attribute-value pairs,
@@ -65,33 +62,34 @@ _XtCountNestedList(
  *    The list is counted recursively.
  */
 void
-_XtCountVaList(va_list var, int* total_count, int* typed_count)
+_XtCountVaList(va_list var, int *total_count, int *typed_count)
 {
-    String          attr;
+    String attr;
 
     *total_count = 0;
     *typed_count = 0;
 
-    for(attr = va_arg(var, String) ; attr != NULL;
-                        attr = va_arg(var, String)) {
+    for (attr = va_arg(var, String); attr != NULL; attr = va_arg(var, String)) {
         if (strcmp(attr, XtVaTypedArg) == 0) {
-            (void)va_arg(var, String);
-            (void)va_arg(var, String);
-            (void)va_arg(var, XtArgVal);
-            (void)va_arg(var, int);
+            (void) va_arg(var, String);
+            (void) va_arg(var, String);
+            (void) va_arg(var, XtArgVal);
+            (void) va_arg(var, int);
+
             ++(*total_count);
             ++(*typed_count);
-        } else if (strcmp(attr, XtVaNestedList) == 0) {
+        }
+        else if (strcmp(attr, XtVaNestedList) == 0) {
             _XtCountNestedList(va_arg(var, XtTypedArgList), total_count,
-                typed_count);
-        } else {
-            (void)va_arg(var, XtArgVal);
+                               typed_count);
+        }
+        else {
+            (void) va_arg(var, XtArgVal);
             ++(*total_count);
-	}
+        }
     }
 }
 
-
 /*
  *   Given a variable length attribute-value list, XtVaCreateArgsList()
  *   constructs an attribute-value list of type XtTypedArgList and
@@ -101,65 +99,65 @@ XtVarArgsList
 XtVaCreateArgsList(XtPointer unused, ...)
 {
     va_list var;
-    XtTypedArgList  avlist;
-    int		    count = 0;
-    String	    attr;
+    XtTypedArgList avlist;
+    int count = 0;
+    String attr;
 
     /*
      * Count the number of attribute-value pairs in the list.
      * Note: The count is required only to allocate enough space to store
      * the list. Therefore nested lists are not counted recursively.
      */
-    va_start(var,unused);
-    for(attr = va_arg(var, String) ; attr != NULL;
-                        attr = va_arg(var, String)) {
+    va_start(var, unused);
+    for (attr = va_arg(var, String); attr != NULL; attr = va_arg(var, String)) {
         ++count;
         if (strcmp(attr, XtVaTypedArg) == 0) {
-            (void)va_arg(var, String);
-            (void)va_arg(var, String);
-            (void)va_arg(var, XtArgVal);
-            (void)va_arg(var, int);
-        } else {
-            (void)va_arg(var, XtArgVal);
+            (void) va_arg(var, String);
+            (void) va_arg(var, String);
+            (void) va_arg(var, XtArgVal);
+            (void) va_arg(var, int);
+        }
+        else {
+            (void) va_arg(var, XtArgVal);
         }
     }
     va_end(var);
 
-    va_start(var,unused);
+    va_start(var, unused);
     avlist = _XtVaCreateTypedArgList(var, count);
     va_end(var);
-    return (XtVarArgsList)avlist;
+    return (XtVarArgsList) avlist;
 }
 
-
-XtTypedArgList _XtVaCreateTypedArgList(va_list var, register int count)
+XtTypedArgList
+_XtVaCreateTypedArgList(va_list var, register int count)
 {
-    String	    attr;
-    XtTypedArgList  avlist;
+    String attr;
+    XtTypedArgList avlist;
 
     avlist = (XtTypedArgList)
-		__XtCalloc((Cardinal)count + 1, (unsigned)sizeof(XtTypedArg));
-
-    for(attr = va_arg(var, String), count = 0; attr != NULL;
-		attr = va_arg(var, String)) {
-	if (strcmp(attr, XtVaTypedArg) == 0) {
-	    avlist[count].name = va_arg(var, String);
-	    avlist[count].type = va_arg(var, String);
-	    avlist[count].value = va_arg(var, XtArgVal);
-	    avlist[count].size = va_arg(var, int);
-	} else {
-	    avlist[count].name = attr;
-	    avlist[count].type = NULL;
-	    avlist[count].value = va_arg(var, XtArgVal);
-	}
-	++count;
+        __XtCalloc((Cardinal) count + 1, (unsigned) sizeof(XtTypedArg));
+
+    for (attr = va_arg(var, String), count = 0; attr != NULL;
+         attr = va_arg(var, String)) {
+        if (strcmp(attr, XtVaTypedArg) == 0) {
+            avlist[count].name = va_arg(var, String);
+            avlist[count].type = va_arg(var, String);
+            avlist[count].value = va_arg(var, XtArgVal);
+            avlist[count].size = va_arg(var, int);
+        }
+        else {
+            avlist[count].name = attr;
+            avlist[count].type = NULL;
+            avlist[count].value = va_arg(var, XtArgVal);
+        }
+        ++count;
     }
     avlist[count].name = NULL;
 
     return avlist;
 }
 
-
 /*
  *    TypedArgToArg() invokes a resource converter to convert the
  *    passed typed arg into a name/value pair and stores the name/value
@@ -169,127 +167,129 @@ XtTypedArgList _XtVaCreateTypedArgList(va_list var, register int count)
  *    1 if the conversion succeeded and 0 if the conversion failed.
  */
 static int
-TypedArgToArg(
-    Widget              widget,
-    XtTypedArgList      typed_arg,
-    ArgList             arg_return,
-    XtResourceList      resources,
-    Cardinal            num_resources,
-    ArgList		memory_return)
+TypedArgToArg(Widget widget,
+              XtTypedArgList typed_arg,
+              ArgList arg_return,
+              XtResourceList resources,
+              Cardinal num_resources,
+              ArgList memory_return)
 {
-    String              to_type = NULL;
-    XrmValue            from_val, to_val;
-
+    String to_type = NULL;
+    XrmValue from_val, to_val;
 
     if (widget == NULL) {
         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-            "nullWidget", XtNxtConvertVarToArgList, XtCXtToolkitError,
-	    "XtVaTypedArg conversion needs non-NULL widget handle",
-            NULL, NULL);
-        return(0);
+                        "nullWidget", XtNxtConvertVarToArgList,
+                        XtCXtToolkitError,
+                        "XtVaTypedArg conversion needs non-NULL widget handle",
+                        NULL, NULL);
+        return (0);
     }
 
     /* again we assume that the XtResourceList is un-compiled */
 
     for (; num_resources--; resources++)
-	if (strcmp(typed_arg->name, resources->resource_name) == 0) {
-	    to_type = resources->resource_type;
-	    break;
-	}
+        if (strcmp(typed_arg->name, resources->resource_name) == 0) {
+            to_type = resources->resource_type;
+            break;
+        }
 
     if (to_type == NULL) {
         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-            "unknownType", XtNxtConvertVarToArgList, XtCXtToolkitError,
-            "Unable to find type of resource for conversion",
-            NULL, NULL);
-        return(0);
+                        "unknownType", XtNxtConvertVarToArgList,
+                        XtCXtToolkitError,
+                        "Unable to find type of resource for conversion", NULL,
+                        NULL);
+        return (0);
     }
 
     to_val.addr = NULL;
     from_val.size = (Cardinal) typed_arg->size;
     if ((strcmp(typed_arg->type, XtRString) == 0) ||
-            ((unsigned) typed_arg->size > sizeof(XtArgVal))) {
-        from_val.addr = (XPointer)typed_arg->value;
-    } else {
-            from_val.addr = (XPointer)&typed_arg->value;
+        ((unsigned) typed_arg->size > sizeof(XtArgVal))) {
+        from_val.addr = (XPointer) typed_arg->value;
+    }
+    else {
+        from_val.addr = (XPointer) &typed_arg->value;
     }
 
     LOCK_PROCESS;
     XtConvertAndStore(widget, typed_arg->type, &from_val, to_type, &to_val);
 
     if (to_val.addr == NULL) {
-	UNLOCK_PROCESS;
+        UNLOCK_PROCESS;
         XtAppWarningMsg(XtWidgetToApplicationContext(widget),
-            "conversionFailed", XtNxtConvertVarToArgList, XtCXtToolkitError,
-            "Type conversion failed", NULL, NULL);
-        return(0);
+                        "conversionFailed", XtNxtConvertVarToArgList,
+                        XtCXtToolkitError, "Type conversion failed", NULL,
+                        NULL);
+        return (0);
     }
 
     arg_return->name = typed_arg->name;
     memory_return->value = (XtArgVal) NULL;
 
     if (strcmp(to_type, XtRString) == 0) {
-	arg_return->value = (XtArgVal) to_val.addr;
+        arg_return->value = (XtArgVal) to_val.addr;
     }
     else {
-	if (to_val.size == sizeof(long))
-	    arg_return->value = (XtArgVal) *(long *)to_val.addr;
-	else if (to_val.size == sizeof(int))
-	    arg_return->value = (XtArgVal) *(int *)to_val.addr;
-	else if (to_val.size == sizeof(short))
-	    arg_return->value = (XtArgVal) *(short *)to_val.addr;
-	else if (to_val.size == sizeof(char))
-	    arg_return->value = (XtArgVal) *(char *)to_val.addr;
-	else if (to_val.size == sizeof(XtArgVal))
-	    arg_return->value = *(XtArgVal *)to_val.addr;
-	else if (to_val.size > sizeof(XtArgVal)) {
-	    arg_return->value = (XtArgVal) (void *) __XtMalloc(to_val.size);
-	    if ((memory_return->value = arg_return->value) != 0)
-		memcpy((void *)arg_return->value, to_val.addr, to_val.size);
-	}
+        if (to_val.size == sizeof(long))
+            arg_return->value = (XtArgVal) * (long *) to_val.addr;
+        else if (to_val.size == sizeof(int))
+            arg_return->value = (XtArgVal) * (int *) to_val.addr;
+        else if (to_val.size == sizeof(short))
+            arg_return->value = (XtArgVal) * (short *) to_val.addr;
+        else if (to_val.size == sizeof(char))
+            arg_return->value = (XtArgVal) * (char *) to_val.addr;
+        else if (to_val.size == sizeof(XtArgVal))
+            arg_return->value = *(XtArgVal *) to_val.addr;
+        else if (to_val.size > sizeof(XtArgVal)) {
+            arg_return->value = (XtArgVal) (void *) __XtMalloc(to_val.size);
+            if ((memory_return->value = arg_return->value) != 0)
+                memcpy((void *) arg_return->value, to_val.addr, to_val.size);
+        }
     }
     UNLOCK_PROCESS;
 
-    return(1);
+    return (1);
 }
 
-
 /*
  *    NestedArgtoArg() converts the passed nested list into
  *    an ArgList/count.
  */
 static int
-NestedArgtoArg(
-    Widget              widget,
-    XtTypedArgList      avlist,
-    ArgList             args,
-    XtResourceList      resources,
-    Cardinal            num_resources,
-    ArgList		memory_return)
+NestedArgtoArg(Widget widget,
+               XtTypedArgList avlist,
+               ArgList args,
+               XtResourceList resources,
+               Cardinal num_resources,
+               ArgList memory_return)
 {
-    int         count = 0;
+    int count = 0;
 
     for (; avlist->name != NULL; avlist++) {
         if (avlist->type != NULL) {
             /* If widget is NULL, the typed arg is ignored */
             if (widget != NULL) {
                 /* this is a typed arg */
-                count += TypedArgToArg(widget, avlist, (args+count),
-					  resources, num_resources,
-					  (memory_return+count));
+                count += TypedArgToArg(widget, avlist, (args + count),
+                                       resources, num_resources,
+                                       (memory_return + count));
             }
-        } else if (strcmp(avlist->name, XtVaNestedList) == 0) {
-            count += NestedArgtoArg(widget, (XtTypedArgList)avlist->value,
-				       (args+count), resources, num_resources,
-				       (memory_return+count));
-        } else {
-            (args+count)->name = avlist->name;
-            (args+count)->value = avlist->value;
+        }
+        else if (strcmp(avlist->name, XtVaNestedList) == 0) {
+            count += NestedArgtoArg(widget, (XtTypedArgList) avlist->value,
+                                    (args + count), resources, num_resources,
+                                    (memory_return + count));
+        }
+        else {
+            (args + count)->name = avlist->name;
+            (args + count)->value = avlist->value;
             ++count;
         }
     }
 
-    return(count);
+    return (count);
 }
 
 /*
@@ -310,26 +310,24 @@ NestedArgtoArg(
  * the release of memory around the existing signature of _XtVaToArgList.
  */
 void
-_XtFreeArgList(
-    ArgList	args,	     /* as returned by _XtVaToArgList */
-    int		total_count, /*	 argument count returned by _XtCountVaList */
-    int 	typed_count) /* typed arg count returned by _XtCountVaList */
+_XtFreeArgList(ArgList args,    /* as returned by _XtVaToArgList */
+               int total_count, /* argument count returned by _XtCountVaList */
+               int typed_count) /* typed arg count returned by _XtCountVaList */
 {
     if (args) {
-	if (typed_count) {
-	    ArgList p;
-	    for (p = args + total_count; total_count--; ++p) {
-		XtFree((char *)p->value);
-	    }
-	}
-	XtFree((char *)args);
+        if (typed_count) {
+            ArgList p;
+
+            for (p = args + total_count; total_count--; ++p) {
+                XtFree((char *) p->value);
+            }
+        }
+        XtFree((char *) args);
     }
 }
 
-
 static void GetResources(Widget widget, XtResourceList *res_list,
-			 Cardinal *number);
-
+                         Cardinal *number);
 
 /*
  *    Given a variable argument list, _XtVaToArgList() returns the
@@ -338,12 +336,11 @@ static void GetResources(Widget widget, XtResourceList *res_list,
  *    ArgList should be freed with _XtFreeArgList.
  */
 void
-_XtVaToArgList(
-    Widget		widget,
-    va_list     	var,
-    int			max_count,
-    ArgList		*args_return,
-    Cardinal		*num_args_return)
+_XtVaToArgList(Widget widget,
+               va_list var,
+               int max_count,
+               ArgList *args_return,
+               Cardinal *num_args_return)
 {
     String		attr;
     int			count;
@@ -401,27 +398,23 @@ _XtVaToArgList(
 		count ++;
 	    }
     }
+    XtFree((XtPointer) resources);
 
-    XtFree((XtPointer)resources);
-
-    *num_args_return = (Cardinal)count;
-    *args_return = (ArgList)args;
+    *num_args_return = (Cardinal) count;
+    *args_return = (ArgList) args;
 }
 
-/*	Function Name: GetResources
- *	Description: Retrieves the normal and constraint resources
+/*      Function Name: GetResources
+ *      Description: Retrieves the normal and constraint resources
  *                   for this widget.
- *	Arguments: widget - the widget.
+ *      Arguments: widget - the widget.
  * RETURNED        res_list - the list of resource for this widget
  * RETURNED        number - the number of resources in the above list.
- *	Returns: none
+ *      Returns: none
  */
 
 static void
-GetResources(
-    Widget widget,
-    XtResourceList * res_list,
-    Cardinal * number)
+GetResources(Widget widget, XtResourceList *res_list, Cardinal *number)
 {
     Widget parent = XtParent(widget);
 
@@ -429,52 +422,54 @@ GetResources(
     XtGetResourceList(XtClass(widget), res_list, number);
 
     if (!XtIsShell(widget) && parent && XtIsConstraint(parent)) {
-	XtResourceList res, constraint, cons_top;
-	Cardinal num_constraint, temp;
+        XtResourceList res, constraint, cons_top;
+        Cardinal num_constraint, temp;
 
-	XtGetConstraintResourceList(XtClass(parent), &constraint,
-				    &num_constraint);
+        XtGetConstraintResourceList(XtClass(parent), &constraint,
+                                    &num_constraint);
 
-	cons_top = constraint;
-	*res_list = (XtResourceList) XtRealloc((char*)*res_list,
-					       (Cardinal)((*number + num_constraint) *
-						sizeof(XtResource)));
+        cons_top = constraint;
+        *res_list = (XtResourceList) XtRealloc((char *) *res_list,
+                                               (Cardinal) ((*number +
+                                                            num_constraint) *
+                                                           sizeof(XtResource)));
 
-	for (temp= num_constraint, res= *res_list + *number; temp != 0; temp--)
-	    *res++ = *constraint++;
+        for (temp = num_constraint, res = *res_list + *number; temp != 0;
+             temp--)
+            *res++ = *constraint++;
 
-	*number += num_constraint;
-	XtFree( (XtPointer) cons_top);
+        *number += num_constraint;
+        XtFree((XtPointer) cons_top);
     }
 }
 
-static int NestedArgtoTypedArg(
-    XtTypedArgList      args,
-    XtTypedArgList      avlist)
+static int
+NestedArgtoTypedArg(XtTypedArgList args, XtTypedArgList avlist)
 {
-    int         count = 0;
+    int count = 0;
 
     for (; avlist->name != NULL; avlist++) {
         if (avlist->type != NULL) {
-            (args+count)->name = avlist->name;
-            (args+count)->type = avlist->type;
-            (args+count)->size = avlist->size;
-            (args+count)->value = avlist->value;
+            (args + count)->name = avlist->name;
+            (args + count)->type = avlist->type;
+            (args + count)->size = avlist->size;
+            (args + count)->value = avlist->value;
             ++count;
-        } else if(strcmp(avlist->name, XtVaNestedList) == 0) {
-            count += NestedArgtoTypedArg((args+count),
-                            (XtTypedArgList)avlist->value);
-        } else {
-            (args+count)->name = avlist->name;
-	    (args+count)->type = NULL;
-            (args+count)->value = avlist->value;
+        }
+        else if (strcmp(avlist->name, XtVaNestedList) == 0) {
+            count += NestedArgtoTypedArg((args + count),
+                                         (XtTypedArgList) avlist->value);
+        }
+        else {
+            (args + count)->name = avlist->name;
+            (args + count)->type = NULL;
+            (args + count)->value = avlist->value;
             ++count;
         }
     }
-    return(count);
+    return (count);
 }
 
-
 /*
  *    Given a variable argument list, _XtVaToTypedArgList() returns
  *    the equivalent TypedArgList. _XtVaToTypedArgList() handles nested
@@ -482,36 +477,38 @@ static int NestedArgtoTypedArg(
  *    Note: _XtVaToTypedArgList() does not do type conversions.
  */
 void
-_XtVaToTypedArgList(
-    va_list             var,
-    int			max_count,
-    XtTypedArgList   	*args_return,
-    Cardinal            *num_args_return)
+_XtVaToTypedArgList(va_list var,
+                    int max_count,
+                    XtTypedArgList *args_return,
+                    Cardinal *num_args_return)
 {
-    XtTypedArgList	args = NULL;
-    String              attr;
-    int			count;
+    XtTypedArgList args = NULL;
+    String attr;
+    int count;
 
     args = (XtTypedArgList)
-	__XtMalloc((Cardinal)((size_t) max_count * sizeof(XtTypedArg)));
+        __XtMalloc((Cardinal) ((size_t) max_count * sizeof(XtTypedArg)));
 
-    for(attr = va_arg(var, String), count = 0 ; attr != NULL;
-		    attr = va_arg(var, String)) {
+    for (attr = va_arg(var, String), count = 0; attr != NULL;
+         attr = va_arg(var, String)) {
         if (strcmp(attr, XtVaTypedArg) == 0) {
-	    args[count].name = va_arg(var, String);
-	    args[count].type = va_arg(var, String);
-	    args[count].value = va_arg(var, XtArgVal);
-	    args[count].size = va_arg(var, int);
-	    ++count;
-	} else if (strcmp(attr, XtVaNestedList) == 0) {
-	    count += NestedArgtoTypedArg(&args[count],
-			va_arg(var, XtTypedArgList));
-	} else {
-	    args[count].name = attr;
-	    args[count].type = NULL;
-	    args[count].value = va_arg(var, XtArgVal);
-	    ++count;
-	}
+            args[count].name = va_arg(var, String);
+            args[count].type = va_arg(var, String);
+            args[count].value = va_arg(var, XtArgVal);
+            args[count].size = va_arg(var, int);
+
+            ++count;
+        }
+        else if (strcmp(attr, XtVaNestedList) == 0) {
+            count += NestedArgtoTypedArg(&args[count],
+                                         va_arg(var, XtTypedArgList));
+        }
+        else {
+            args[count].name = attr;
+            args[count].type = NULL;
+            args[count].value = va_arg(var, XtArgVal);
+            ++count;
+        }
     }
 
     *args_return = args;
diff --git a/src/Vendor.c b/src/Vendor.c
index da40e07..2a211b2 100644
--- a/src/Vendor.c
+++ b/src/Vendor.c
@@ -22,7 +22,6 @@ Except as contained in this notice, the name of The Open Group shall not be
 used in advertising or otherwise to promote the sale, use or other dealings
 in this Software without prior written authorization from The Open Group.
 
-
 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
 
                         All Rights Reserved
@@ -71,68 +70,74 @@ extern WidgetClass vendorShellWidgetClass;
 int __stdcall
 DllMain(unsigned long mod_handle, unsigned long flag, void *routine)
 {
-  switch (flag)
-    {
-    case 1: /* DLL_PROCESS_ATTACH - process attach */
-      vendorShellWidgetClass = (WidgetClass)(&vendorShellClassRec);
-      break;
-    case 0: /* DLL_PROCESS_DETACH - process detach */
-      break;
+    switch (flag) {
+    case 1:                    /* DLL_PROCESS_ATTACH - process attach */
+        vendorShellWidgetClass = (WidgetClass) (&vendorShellClassRec);
+        break;
+    case 0:                    /* DLL_PROCESS_DETACH - process detach */
+        break;
     }
-  return 1;
+    return 1;
 }
 #endif
 
-externaldef(vendorshellclassrec) VendorShellClassRec vendorShellClassRec = {
-  {
-    /* superclass         */    (WidgetClass) &wmShellClassRec,
-    /* class_name         */    "VendorShell",
-    /* size               */    sizeof(VendorShellRec),
-    /* Class Initializer  */	NULL,
-    /* class_part_initialize*/	NULL,
-    /* Class init'ed ?    */	FALSE,
-    /* initialize         */    NULL,
-    /* initialize_notify    */	NULL,
-    /* realize            */    XtInheritRealize,
-    /* actions            */    NULL,
-    /* num_actions        */    0,
-    /* resources          */    NULL,
-    /* resource_count     */	0,
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion    */    FALSE,
-    /* compress_exposure  */    TRUE,
-    /* compress_enterleave*/	FALSE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    NULL,
-    /* resize             */    XtInheritResize,
-    /* expose             */    NULL,
-    /* set_values         */    NULL,
-    /* set_values_hook      */	NULL,
-    /* set_values_almost    */	XtInheritSetValuesAlmost,
-    /* get_values_hook      */	NULL,
-    /* accept_focus       */    NULL,
-    /* intrinsics version */	XtVersion,
-    /* callback offsets   */    NULL,
-    /* tm_table		  */	NULL,
-    /* query_geometry	    */  NULL,
-    /* display_accelerator  */  NULL,
-    /* extension	    */  NULL
-  },{
-    /* geometry_manager   */    XtInheritGeometryManager,
-    /* change_managed     */    XtInheritChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension	    */  NULL
-  },{
-    /* extension	    */  NULL
-  },{
-    /* extension	    */  NULL
-  },{
-    /* extension	    */  NULL
-  }
+/* *INDENT-OFF* */
+externaldef(vendorshellclassrec)
+VendorShellClassRec vendorShellClassRec = {
+    {
+     /* superclass            */ (WidgetClass) &wmShellClassRec,
+     /* class_name            */ "VendorShell",
+     /* size                  */ sizeof(VendorShellRec),
+     /* Class Initializer     */ NULL,
+     /* class_part_initialize */ NULL,
+     /* Class init'ed ?       */ FALSE,
+     /* initialize            */ NULL,
+     /* initialize_notify     */ NULL,
+     /* realize               */ XtInheritRealize,
+     /* actions               */ NULL,
+     /* num_actions           */ 0,
+     /* resources             */ NULL,
+     /* resource_count        */ 0,
+     /* xrm_class             */ NULLQUARK,
+     /* compress_motion       */ FALSE,
+     /* compress_exposure     */ TRUE,
+     /* compress_enterleave   */ FALSE,
+     /* visible_interest      */ FALSE,
+     /* destroy               */ NULL,
+     /* resize                */ XtInheritResize,
+     /* expose                */ NULL,
+     /* set_values            */ NULL,
+     /* set_values_hook       */ NULL,
+     /* set_values_almost     */ XtInheritSetValuesAlmost,
+     /* get_values_hook       */ NULL,
+     /* accept_focus          */ NULL,
+     /* intrinsics version    */ XtVersion,
+     /* callback offsets      */ NULL,
+     /* tm_table              */ NULL,
+     /* query_geometry        */ NULL,
+     /* display_accelerator   */ NULL,
+     /* extension             */ NULL
+     },
+     {
+       /* geometry_manager    */ XtInheritGeometryManager,
+       /* change_managed      */ XtInheritChangeManaged,
+       /* insert_child        */ XtInheritInsertChild,
+       /* delete_child        */ XtInheritDeleteChild,
+       /* extension           */ NULL
+     },
+     {
+       /* extension           */ NULL
+     },
+     {
+       /* extension           */ NULL
+     },
+     {
+       /* extension           */ NULL
+     }
 };
+/* *INDENT-ON* */
 
 #if !defined(AIXSHLIB) || !defined(SHAREDCODE)
-externaldef(vendorshellwidgetclass) WidgetClass vendorShellWidgetClass =
-	(WidgetClass) (&vendorShellClassRec);
+externaldef(vendorshellwidgetclass)
+WidgetClass vendorShellWidgetClass = (WidgetClass) (&vendorShellClassRec);
 #endif
diff --git a/src/sharedlib.c b/src/sharedlib.c
index 52138e8..8ddb05f 100644
--- a/src/sharedlib.c
+++ b/src/sharedlib.c
@@ -34,23 +34,23 @@ in this Software without prior written authorization from The Open Group.
 #include "VendorP.h"
 #include "CreateI.h"
 
-
 #if defined(AIXSHLIB)
 WidgetClass vendorShellWidgetClass = (WidgetClass) &vendorShellClassRec;
 
-static void _XtVendorInitialize()
+static void
+_XtVendorInitialize()
 {
     transientShellWidgetClass->core_class.superclass =
-	(WidgetClass) &vendorShellClassRec;
+        (WidgetClass) &vendorShellClassRec;
     topLevelShellWidgetClass->core_class.superclass =
-	(WidgetClass) &vendorShellClassRec;
+        (WidgetClass) &vendorShellClassRec;
 }
 
 #define VENDORINIT _XtVendorInitialize();
 
 #else
 
-#define VENDORINIT /* as nothing */
+#define VENDORINIT              /* as nothing */
 
 #endif
 
@@ -59,9 +59,11 @@ static void _XtVendorInitialize()
  * _XtInherit needs to be statically linked since it is compared against as
  * well as called.
  */
-void _XtInherit()
+void
+_XtInherit()
 {
     extern void __XtInherit();
+
     __XtInherit();
 }
 #endif
@@ -74,117 +76,108 @@ void _XtInherit()
  *       call XtToolkitInitialize.
  */
 
-void XtToolkitInitialize()
+void
+XtToolkitInitialize()
 {
     extern void _XtToolkitInitialize();
-    VENDORINIT
-    _XtToolkitInitialize();
+
+    VENDORINIT _XtToolkitInitialize();
 }
 
 Widget
-XtInitialize(
-    _Xconst char* name,
-    _Xconst char* classname,
-    XrmOptionDescRec *options,
-    Cardinal num_options,
-    int *argc,
-    String *argv)
+XtInitialize(_Xconst char *name,
+             _Xconst char *classname,
+             XrmOptionDescRec *options,
+             Cardinal num_options, int *argc, String *argv)
 {
     extern Widget _XtInitialize();
+
     VENDORINIT
-    return _XtInitialize (name, classname, options, num_options, argc, argv);
+        return _XtInitialize(name, classname, options, num_options, argc, argv);
 }
 
 Widget
-XtAppInitialize(
-    XtAppContext * app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescRec *options,
-    Cardinal num_options,
-    int *argc_in_out,
-    String *argv_in_out,
-    String *fallback_resources,
-    ArgList args_in,
-    Cardinal num_args_in)
+XtAppInitialize(XtAppContext *app_context_return,
+                _Xconst char *application_class,
+                XrmOptionDescRec *options,
+                Cardinal num_options,
+                int *argc_in_out,
+                String *argv_in_out,
+                String *fallback_resources,
+                ArgList args_in, Cardinal num_args_in)
 {
     extern Widget _XtAppInitialize();
+
     VENDORINIT
-    return _XtAppInitialize (app_context_return, application_class, options,
-			     num_options, argc_in_out, argv_in_out,
-			     fallback_resources, args_in, num_args_in);
+        return _XtAppInitialize(app_context_return, application_class, options,
+                                num_options, argc_in_out, argv_in_out,
+                                fallback_resources, args_in, num_args_in);
 }
 
 Widget
-XtVaAppInitialize(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    String *argv_in_out,
-    String *fallback_resources,
-    ...)
+XtVaAppInitialize(XtAppContext *app_context_return,
+                  _Xconst char *application_class,
+                  XrmOptionDescList options,
+                  Cardinal num_options,
+                  int *argc_in_out,
+                  String *argv_in_out, String *fallback_resources, ...)
 {
-    va_list	var;
+    va_list var;
     extern Widget _XtVaAppInitialize();
 
-    VENDORINIT
-    va_start(var, fallback_resources);
+    VENDORINIT va_start(var, fallback_resources);
+
     return _XtVaAppInitialize(app_context_return, application_class, options,
-			      num_options, argc_in_out, argv_in_out,
-			      fallback_resources, var);
+                              num_options, argc_in_out, argv_in_out,
+                              fallback_resources, var);
 }
 
 Widget
-XtOpenApplication(
-    XtAppContext * app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescRec *options,
-    Cardinal num_options,
-    int *argc_in_out,
-    String *argv_in_out,
-    String *fallback_resources,
-    WidgetClass widget_class,
-    ArgList args_in,
-    Cardinal num_args_in)
+XtOpenApplication(XtAppContext *app_context_return,
+                  _Xconst char *application_class,
+                  XrmOptionDescRec *options,
+                  Cardinal num_options,
+                  int *argc_in_out,
+                  String *argv_in_out,
+                  String *fallback_resources,
+                  WidgetClass widget_class,
+                  ArgList args_in, Cardinal num_args_in)
 {
     extern Widget _XtOpenApplication();
+
     VENDORINIT
-    return _XtOpenApplication (app_context_return, application_class, options,
-			       num_options, argc_in_out, argv_in_out,
-			       fallback_resources, widget_class,
-			       args_in, num_args_in);
+        return _XtOpenApplication(app_context_return, application_class,
+                                  options, num_options, argc_in_out,
+                                  argv_in_out, fallback_resources, widget_class,
+                                  args_in, num_args_in);
 }
 
 Widget
-XtVaOpenApplication(
-    XtAppContext *app_context_return,
-    _Xconst char* application_class,
-    XrmOptionDescList options,
-    Cardinal num_options,
-    int *argc_in_out,
-    String *argv_in_out,
-    String *fallback_resources,
-    WidgetClass widget_class,
-    ...)
+XtVaOpenApplication(XtAppContext *app_context_return,
+                    _Xconst char *application_class,
+                    XrmOptionDescList options,
+                    Cardinal num_options,
+                    int *argc_in_out,
+                    String *argv_in_out,
+                    String *fallback_resources, WidgetClass widget_class, ...)
 {
-    va_list	var;
+    va_list var;
     extern Widget _XtVaOpenApplication();
 
-    VENDORINIT
-    va_start(var, widget_class);
+    VENDORINIT va_start(var, widget_class);
+
     return _XtVaOpenApplication(app_context_return, application_class, options,
-				num_options, argc_in_out, argv_in_out,
-				fallback_resources, widget_class, var);
+                                num_options, argc_in_out, argv_in_out,
+                                fallback_resources, widget_class, var);
 }
 
 #else
 
 #ifndef lint
-static int dummy;			/* avoid warning from ranlib */
+static int dummy;               /* avoid warning from ranlib */
 #endif
 
-#endif /* SUNSHLIB or AIXSHLIB */
+#endif                          /* SUNSHLIB or AIXSHLIB */
 
 #if defined(SUNSHLIB) && !defined(SHAREDCODE)
 
@@ -201,10 +194,10 @@ WidgetClass widgetClass = &widgetClassRec;
 WidgetClass coreWidgetClass = &widgetClassRec;
 
 extern ObjectClassRec objectClassRec;
-WidgetClass objectClass = (WidgetClass)&objectClassRec;
+WidgetClass objectClass = (WidgetClass) &objectClassRec;
 
 extern RectObjClassRec rectObjClassRec;
-WidgetClass rectObjClass = (WidgetClass)&rectObjClassRec;
+WidgetClass rectObjClass = (WidgetClass) &rectObjClassRec;
 
 extern ShellClassRec shellClassRec;
 WidgetClass shellWidgetClass = (WidgetClass) &shellClassRec;
@@ -222,7 +215,8 @@ extern TopLevelShellClassRec topLevelShellClassRec;
 WidgetClass topLevelShellWidgetClass = (WidgetClass) &topLevelShellClassRec;
 
 extern ApplicationShellClassRec applicationShellClassRec;
-WidgetClass applicationShellWidgetClass = (WidgetClass) &applicationShellClassRec;
+WidgetClass applicationShellWidgetClass =
+    (WidgetClass) &applicationShellClassRec;
 
 extern SessionShellClassRec sessionShellClassRec;
 WidgetClass sessionShellWidgetClass = (WidgetClass) &sessionShellClassRec;
@@ -230,4 +224,4 @@ WidgetClass sessionShellWidgetClass = (WidgetClass) &sessionShellClassRec;
 extern HookObjClassRec hookObjClassRec;
 WidgetClass hookObjectClass = (WidgetClass) &hookObjClassRec;
 
-#endif /* SUNSHLIB */
+#endif                          /* SUNSHLIB */
diff --git a/util/makestrs.c b/util/makestrs.c
index 774faa4..4d5c0a6 100644
--- a/util/makestrs.c
+++ b/util/makestrs.c
@@ -32,54 +32,54 @@ in this Software without prior written authorization from The Open Group.
 #include <unistd.h>
 
 typedef struct _TableEnt {
-    struct _TableEnt* next;
-    char* left;
-    char* right;
+    struct _TableEnt *next;
+    char *left;
+    char *right;
     size_t offset;
 } TableEnt;
 
 typedef struct _Table {
-    struct _Table* next;
-    TableEnt* tableent;
-    TableEnt* tableentcurrent;
-    TableEnt** tableenttail;
-    char* name;
+    struct _Table *next;
+    TableEnt *tableent;
+    TableEnt *tableentcurrent;
+    TableEnt **tableenttail;
+    char *name;
     size_t offset;
 } Table;
 
 typedef struct _File {
-    struct _File* next;
-    FILE* tmpl;
-    char* name;
-    Table* table;
-    Table* tablecurrent;
-    Table** tabletail;
+    struct _File *next;
+    FILE *tmpl;
+    char *name;
+    Table *table;
+    Table *tablecurrent;
+    Table **tabletail;
 } File;
 
-static File* file = NULL;
-static File* filecurrent = NULL;
-static File** filetail = &file;
-static char* conststr;
-static char* prefixstr = NULL;
-static char* featurestr = NULL;
-static char* ctmplstr = NULL;
-static char* fileprotstr;
-static char* externrefstr;
-static char* externdefstr;
+static File *file = NULL;
+static File *filecurrent = NULL;
+static File **filetail = &file;
+static char *conststr;
+static char *prefixstr = NULL;
+static char *featurestr = NULL;
+static char *ctmplstr = NULL;
+static char *fileprotstr;
+static char *externrefstr;
+static char *externdefstr;
 
 #ifndef FALSE
-# define FALSE 0
-# define TRUE  !(FALSE)
+#define FALSE 0
+#define TRUE  !(FALSE)
 #endif
 
-static int   solaris_abi_names = FALSE;
+static int solaris_abi_names = FALSE;
 
-#define X_DEFAULT_ABI	0
-#define X_ARRAYPER_ABI	1
-#define X_INTEL_ABI	2
-#define X_INTEL_ABI_BC	3
-#define X_SPARC_ABI	4
-#define X_FUNCTION_ABI	5
+#define X_DEFAULT_ABI   0
+#define X_ARRAYPER_ABI  1
+#define X_INTEL_ABI     2
+#define X_INTEL_ABI_BC  3
+#define X_SPARC_ABI     4
+#define X_FUNCTION_ABI  5
 
 #define X_MAGIC_STRING "<<<STRING_TABLE_GOES_HERE>>>"
 
@@ -87,8 +87,9 @@ static int   solaris_abi_names = FALSE;
  * Prepend filename with an includedir which can be specified on the
  * commandline. Needed to separate source and build directories.
  */
-static char* includedir = NULL;
-static FILE *ifopen(const char *myfile, const char *mode)
+static char *includedir = NULL;
+static FILE *
+ifopen(const char *myfile, const char *mode)
 {
 #ifndef HAVE_ASPRINTF
     size_t len;
@@ -104,7 +105,7 @@ static FILE *ifopen(const char *myfile, const char *mode)
         return NULL;
 #else
     len = strlen(myfile) + strlen(includedir) + 1;
-    buffer = (char*)malloc(len + 1);
+    buffer = (char *) malloc(len + 1);
     if (buffer == NULL)
         return NULL;
 
@@ -117,374 +118,411 @@ static FILE *ifopen(const char *myfile, const char *mode)
     return ret;
 }
 
-static void WriteHeaderProlog (FILE *f, File *phile)
+static void
+WriteHeaderProlog(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
-    (void) fprintf (f, "#ifdef %s\n", featurestr);
+    (void) fprintf(f, "#ifdef %s\n", featurestr);
     for (t = phile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    if (strcmp (te->left, "RAtom") == 0) {
-		(void) fprintf (f,
-			"#ifndef %s%s\n#define %s%s \"%s\"\n#endif\n",
-			prefixstr, te->left, prefixstr, te->left, te->right);
-	    } else {
-		(void) fprintf (f,
-			"#define %s%s \"%s\"\n",
-			prefixstr, te->left, te->right);
-	    }
-	}
+        for (te = t->tableent; te; te = te->next) {
+            if (strcmp(te->left, "RAtom") == 0) {
+                (void) fprintf(f,
+                               "#ifndef %s%s\n#define %s%s \"%s\"\n#endif\n",
+                               prefixstr, te->left, prefixstr, te->left,
+                               te->right);
+            }
+            else {
+                (void) fprintf(f,
+                               "#define %s%s \"%s\"\n",
+                               prefixstr, te->left, te->right);
+            }
+        }
     }
-    (void) fprintf (f, "%s", "#else\n");
+    (void) fprintf(f, "%s", "#else\n");
 }
 
-static void IntelABIWriteHeader (FILE *f, File *phile)
+static void
+IntelABIWriteHeader(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
-    WriteHeaderProlog (f, phile);
+    WriteHeaderProlog(f, phile);
 
     for (t = phile->table; t; t = t->next) {
-      (void) fprintf (f, "%s %sConst char %s[];\n",
-		      externrefstr, conststr ? conststr : fileprotstr, t->name);
-	for (te = t->tableent; te; te = te->next) {
-	    (void) fprintf (f,
-		"#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
-		prefixstr, te->left, prefixstr, te->left, t->name,
-		(unsigned long) te->offset);
-	}
+        (void) fprintf(f, "%s %sConst char %s[];\n",
+                       externrefstr, conststr ? conststr : fileprotstr,
+                       t->name);
+        for (te = t->tableent; te; te = te->next) {
+            (void) fprintf(f,
+                           "#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
+                           prefixstr, te->left, prefixstr, te->left, t->name,
+                           (unsigned long) te->offset);
+        }
     }
 
-    (void) fprintf (f, "#endif /* %s */\n", featurestr);
+    (void) fprintf(f, "#endif /* %s */\n", featurestr);
 }
 
-static void SPARCABIWriteHeader (FILE *f, File *phile)
+static void
+SPARCABIWriteHeader(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
     for (t = phile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    (void) fprintf (f, "#define %s%s \"%s\"\n",
-			    prefixstr, te->left, te->right);
-	}
+        for (te = t->tableent; te; te = te->next) {
+            (void) fprintf(f, "#define %s%s \"%s\"\n",
+                           prefixstr, te->left, te->right);
+        }
     }
 }
 
-static void FunctionWriteHeader (FILE *f, File *phile)
+static void
+FunctionWriteHeader(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
-    WriteHeaderProlog (f, phile);
+    WriteHeaderProlog(f, phile);
 
-    (void) fprintf (f, "%s %sConst char* %s();\n",
-		    externrefstr, conststr ? conststr : fileprotstr,
-		    phile->table->name);
+    (void) fprintf(f, "%s %sConst char* %s();\n",
+                   externrefstr, conststr ? conststr : fileprotstr,
+                   phile->table->name);
 
     for (t = phile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    (void) fprintf (f,
-		"#ifndef %s%s\n#define %s%s (%s(%lu))\n#endif\n",
-		prefixstr, te->left, prefixstr, te->left, phile->table->name,
-		(unsigned long) te->offset);
-	}
+        for (te = t->tableent; te; te = te->next) {
+            (void) fprintf(f,
+                           "#ifndef %s%s\n#define %s%s (%s(%lu))\n#endif\n",
+                           prefixstr, te->left, prefixstr, te->left,
+                           phile->table->name, (unsigned long) te->offset);
+        }
     }
 
-    (void) fprintf (f, "#endif /* %s */\n", featurestr);
+    (void) fprintf(f, "#endif /* %s */\n", featurestr);
 }
 
-static void ArrayperWriteHeader (FILE *f, File *phile)
+static void
+ArrayperWriteHeader(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
-    WriteHeaderProlog (f, phile);
+    WriteHeaderProlog(f, phile);
 
     for (t = phile->table; t; t = t->next) {
         for (te = t->tableent; te; te = te->next) {
-	    (void) fprintf (f,
-			    "#ifndef %s%s\n%s %sConst char %s%s[];\n#endif\n",
-			    prefixstr, te->left,
-			    externrefstr, conststr ? conststr : fileprotstr,
-			    prefixstr, te->left);
-	}
+            (void) fprintf(f,
+                           "#ifndef %s%s\n%s %sConst char %s%s[];\n#endif\n",
+                           prefixstr, te->left,
+                           externrefstr, conststr ? conststr : fileprotstr,
+                           prefixstr, te->left);
+        }
     }
 
-    (void) fprintf (f, "#endif /* %s */\n", featurestr);
+    (void) fprintf(f, "#endif /* %s */\n", featurestr);
 }
 
-static void DefaultWriteHeader (FILE *f, File *phile)
+static void
+DefaultWriteHeader(FILE * f, File * phile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
-    WriteHeaderProlog (f, phile);
+    WriteHeaderProlog(f, phile);
 
-    (void) fprintf (f, "%s %sConst char %s[];\n",
-		    externrefstr, conststr ? conststr : fileprotstr,
-		    phile->table->name);
+    (void) fprintf(f, "%s %sConst char %s[];\n",
+                   externrefstr, conststr ? conststr : fileprotstr,
+                   phile->table->name);
 
     for (t = phile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    (void) fprintf (f,
-		"#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
-		prefixstr, te->left, prefixstr, te->left, phile->table->name,
-		(unsigned long) te->offset);
-	}
+        for (te = t->tableent; te; te = te->next) {
+            (void) fprintf(f,
+                           "#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
+                           prefixstr, te->left, prefixstr, te->left,
+                           phile->table->name, (unsigned long) te->offset);
+        }
     }
 
-    (void) fprintf (f, "#endif /* %s */\n", featurestr);
+    (void) fprintf(f, "#endif /* %s */\n", featurestr);
 }
 
-static void CopyTmplProlog (FILE *tmpl, FILE *f)
+static void
+CopyTmplProlog(FILE * tmpl, FILE * f)
 {
     char buf[1024];
-    static const char* magic_string = X_MAGIC_STRING;
-    size_t magic_string_len = strlen (magic_string);
-
-    while (fgets (buf, sizeof buf, tmpl)) {
-	if (strncmp (buf, magic_string, magic_string_len) == 0) {
-	    return;
-	}
-	(void) fputs (buf, f);
+    static const char *magic_string = X_MAGIC_STRING;
+    size_t magic_string_len = strlen(magic_string);
+
+    while (fgets(buf, sizeof buf, tmpl)) {
+        if (strncmp(buf, magic_string, magic_string_len) == 0) {
+            return;
+        }
+        (void) fputs(buf, f);
     }
 }
 
-static void CopyTmplEpilog (FILE *tmpl, FILE *f)
+static void
+CopyTmplEpilog(FILE * tmpl, FILE * f)
 {
     char buf[1024];
 
-    while (fgets (buf, sizeof buf, tmpl))
-	(void) fputs (buf, f);
+    while (fgets(buf, sizeof buf, tmpl))
+        (void) fputs(buf, f);
 }
 
-static const char* abistring[] = {
-    "Default", "Array per string", "Intel", "Intel BC", "SPARC", "Function" };
+static const char *abistring[] = {
+    "Default", "Array per string", "Intel", "Intel BC", "SPARC", "Function"
+};
 
-static void WriteHeader (char *tagline, File *phile, int abi)
+static void
+WriteHeader(char *tagline, File * phile, int abi)
 {
-    FILE* f;
-    char* tmp;
-    static void (*headerproc[])(FILE *f, File *phile) = {
-	DefaultWriteHeader, ArrayperWriteHeader,
-	IntelABIWriteHeader, IntelABIWriteHeader,
-	SPARCABIWriteHeader, FunctionWriteHeader };
+    FILE *f;
+    char *tmp;
 
-    if ((f = fopen (phile->name, "w+")) == NULL) exit (1);
+    static void (*headerproc[]) (FILE * f, File * phile) = {
+    DefaultWriteHeader, ArrayperWriteHeader,
+            IntelABIWriteHeader, IntelABIWriteHeader,
+            SPARCABIWriteHeader, FunctionWriteHeader};
 
-    if (phile->tmpl) CopyTmplProlog (phile->tmpl, f);
+    if ((f = fopen(phile->name, "w+")) == NULL)
+        exit(1);
 
-    (void) fprintf (f,
-	"%s\n%s\n/* %s ABI version -- Do not edit */\n",
-	"/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
-	"/* This file is automatically generated. */",
-	abistring[abi]);
+    if (phile->tmpl)
+        CopyTmplProlog(phile->tmpl, f);
 
-    if (tagline) (void) fprintf (f, "/* %s */\n\n", tagline);
+    (void) fprintf(f,
+                   "%s\n%s\n/* %s ABI version -- Do not edit */\n",
+                   "/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
+                   "/* This file is automatically generated. */",
+                   abistring[abi]);
+
+    if (tagline)
+        (void) fprintf(f, "/* %s */\n\n", tagline);
 
     /* do the right thing for Motif, i.e. avoid _XmXmStrDefs_h_ */
-    if (strcmp (prefixstr, "Xm") == 0) {
+    if (strcmp(prefixstr, "Xm") == 0) {
 #ifdef HAVE_ASPRINTF
-	if (asprintf (&fileprotstr, "_%s_", phile->name) == -1)
-	    exit (1);
+        if (asprintf(&fileprotstr, "_%s_", phile->name) == -1)
+            exit(1);
 #else
-	if ((fileprotstr = malloc (strlen (phile->name) + 3)) == NULL)
-	   exit (1);
-	(void) sprintf (fileprotstr, "_%s_", phile->name);
+        if ((fileprotstr = malloc(strlen(phile->name) + 3)) == NULL)
+            exit(1);
+        (void) sprintf(fileprotstr, "_%s_", phile->name);
 #endif
-    } else {
+    }
+    else {
 #ifdef HAVE_ASPRINTF
-	if (asprintf (&fileprotstr, "_%s%s_", prefixstr, phile->name) == -1)
-	    exit (1);
+        if (asprintf(&fileprotstr, "_%s%s_", prefixstr, phile->name) == -1)
+            exit(1);
 #else
-	if ((fileprotstr = malloc (strlen (phile->name) + strlen (prefixstr) +  3)) == NULL)
-	   exit (1);
-	(void) sprintf (fileprotstr, "_%s%s_", prefixstr, phile->name);
+        if ((fileprotstr =
+             malloc(strlen(phile->name) + strlen(prefixstr) + 3)) == NULL)
+            exit(1);
+        (void) sprintf(fileprotstr, "_%s%s_", prefixstr, phile->name);
 #endif
     }
 
-    for (tmp = fileprotstr; *tmp; tmp++) if (*tmp == '.') *tmp = '_';
+    for (tmp = fileprotstr; *tmp; tmp++)
+        if (*tmp == '.')
+            *tmp = '_';
 
-    (*headerproc[abi])(f, phile);
+    (*headerproc[abi]) (f, phile);
 
-    if (phile->tmpl) CopyTmplEpilog (phile->tmpl, f);
+    if (phile->tmpl)
+        CopyTmplEpilog(phile->tmpl, f);
 
-    (void) free (fileprotstr);
-    (void) fclose (phile->tmpl);
-    (void) fclose (f);
+    (void) free(fileprotstr);
+    (void) fclose(phile->tmpl);
+    (void) fclose(f);
 }
 
-static void WriteSourceLine (TableEnt *te, int abi, int fudge)
+static void
+WriteSourceLine(TableEnt * te, int abi, int fudge)
 {
-    char* c;
-
-    for (c = te->right; *c; c++) (void) printf ("'%c',", *c);
-    (void) printf ("%c", '0');
-    if (te->next || fudge) (void) printf ("%c", ',');
-    (void) printf ("%s", "\n");
+    char *c;
+
+    for (c = te->right; *c; c++)
+        (void) printf("'%c',", *c);
+    (void) printf("%c", '0');
+    if (te->next || fudge)
+        (void) printf("%c", ',');
+    (void) printf("%s", "\n");
 }
 
 #define const_string "%s %sConst char %s[] = {\n"
 
-static void IntelABIWriteSource (int abi)
+static void
+IntelABIWriteSource(int abi)
 {
-    File* phile;
+    File *phile;
 
     for (phile = file; phile; phile = phile->next) {
-	Table* t;
-	TableEnt* te;
-
-	for (t = phile->table; t; t = t->next) {
-	    (void) printf (const_string, externdefstr,
-			   conststr ? conststr : "", t->name);
-	    for (te = t->tableent; te; te = te->next) {
-		WriteSourceLine (te, abi, 0);
-	    }
-	    (void) printf ("%s\n\n", "};");
-	}
+        Table *t;
+        TableEnt *te;
+
+        for (t = phile->table; t; t = t->next) {
+            (void) printf(const_string, externdefstr,
+                          conststr ? conststr : "", t->name);
+            for (te = t->tableent; te; te = te->next) {
+                WriteSourceLine(te, abi, 0);
+            }
+            (void) printf("%s\n\n", "};");
+        }
     }
 }
 
-static void IntelABIBCWriteSource (int abi)
+static void
+IntelABIBCWriteSource(int abi)
 {
-    File* phile;
+    File *phile;
 
     for (phile = file; phile; phile = phile->next) {
-	Table* t;
-	TableEnt* te;
-
-	(void) printf (const_string, externdefstr,
-		       conststr ? conststr : "", phile->table->name);
-
-	for (t = phile->table; t; t = t->next) {
-	    for (te = t->tableent; te; te = te->next) {
-		WriteSourceLine (te, abi, t->next ? 1 : 0);
-	    }
-	}
-	(void) printf ("%s\n\n", "};");
-
-	if (phile->table->next) {
-	    (void) printf (const_string, externdefstr,
-			   conststr ? conststr : "", phile->table->next->name);
-	    for (t = phile->table->next; t; t = t->next) {
-		for (te = t->tableent; te; te = te->next) {
-		    WriteSourceLine (te, abi, 0);
-		}
-	    }
-	    (void) printf ("%s\n\n", "};");
-	}
+        Table *t;
+        TableEnt *te;
+
+        (void) printf(const_string, externdefstr,
+                      conststr ? conststr : "", phile->table->name);
+
+        for (t = phile->table; t; t = t->next) {
+            for (te = t->tableent; te; te = te->next) {
+                WriteSourceLine(te, abi, t->next ? 1 : 0);
+            }
+        }
+        (void) printf("%s\n\n", "};");
+
+        if (phile->table->next) {
+            (void) printf(const_string, externdefstr,
+                          conststr ? conststr : "", phile->table->next->name);
+            for (t = phile->table->next; t; t = t->next) {
+                for (te = t->tableent; te; te = te->next) {
+                    WriteSourceLine(te, abi, 0);
+                }
+            }
+            (void) printf("%s\n\n", "};");
+        }
     }
 }
 
-static void FunctionWriteSource (int abi)
+static void
+FunctionWriteSource(int abi)
 {
-    File* phile;
+    File *phile;
 
     for (phile = file; phile; phile = phile->next) {
-	Table* t;
-	TableEnt* te;
-
-	(void) printf ("static %sConst char _%s[] = {\n",
-		       conststr ? conststr : "", phile->table->name);
-
-	for (t = phile->table; t; t = t->next) {
-	    for (te = t->tableent; te; te = te->next) {
-		WriteSourceLine (te, abi, t->next ? 1 : 0);
-	    }
-	}
-	(void) printf ("%s\n\n", "};");
-
-	(void) printf ("%sConst char* %s(index)\n    int index;\n{\n    return &_%s[index];\n}\n\n",
-		       conststr ? conststr : "",
-		       phile->table->name, phile->table->name);
+        Table *t;
+        TableEnt *te;
+
+        (void) printf("static %sConst char _%s[] = {\n",
+                      conststr ? conststr : "", phile->table->name);
+
+        for (t = phile->table; t; t = t->next) {
+            for (te = t->tableent; te; te = te->next) {
+                WriteSourceLine(te, abi, t->next ? 1 : 0);
+            }
+        }
+        (void) printf("%s\n\n", "};");
+
+        (void)
+            printf
+            ("%sConst char* %s(index)\n    int index;\n{\n    return &_%s[index];\n}\n\n",
+             conststr ? conststr : "", phile->table->name, phile->table->name);
     }
 }
 
-static void ArrayperWriteSource (int abi)
+static void
+ArrayperWriteSource(int abi)
 {
-    File* phile;
+    File *phile;
     static int done_atom;
 
     for (phile = file; phile; phile = phile->next) {
-	Table* t;
-	TableEnt* te;
-
-	for (t = phile->table; t; t = t->next) {
-	    for (te = t->tableent; te; te = te->next) {
-		if (strcmp (te->left, "RAtom") == 0) {
-		    if (done_atom) return;
-		    done_atom = 1;
-		}
-		(void) printf ("%s %sConst char %s%s[] = \"%s\";\n",
-			       externdefstr, conststr ? conststr : "",
-			       prefixstr,
-			       te->left, te->right);
-	    }
-	}
+        Table *t;
+        TableEnt *te;
+
+        for (t = phile->table; t; t = t->next) {
+            for (te = t->tableent; te; te = te->next) {
+                if (strcmp(te->left, "RAtom") == 0) {
+                    if (done_atom)
+                        return;
+                    done_atom = 1;
+                }
+                (void) printf("%s %sConst char %s%s[] = \"%s\";\n",
+                              externdefstr, conststr ? conststr : "",
+                              prefixstr, te->left, te->right);
+            }
+        }
     }
 }
 
-static void DefaultWriteSource (int abi)
+static void
+DefaultWriteSource(int abi)
 {
-    File* phile;
+    File *phile;
 
     for (phile = file; phile; phile = phile->next) {
-	Table* t;
-	TableEnt* te;
-
-	(void) printf (const_string, externdefstr, conststr ? conststr : "",
-		       phile->table->name);
-
-	for (t = phile->table; t; t = t->next) {
-	    for (te = t->tableent; te; te = te->next) {
-		WriteSourceLine (te, abi, t->next ? 1 : 0);
-	    }
-	}
-	(void) printf ("%s\n\n", "};");
+        Table *t;
+        TableEnt *te;
+
+        (void) printf(const_string, externdefstr, conststr ? conststr : "",
+                      phile->table->name);
+
+        for (t = phile->table; t; t = t->next) {
+            for (te = t->tableent; te; te = te->next) {
+                WriteSourceLine(te, abi, t->next ? 1 : 0);
+            }
+        }
+        (void) printf("%s\n\n", "};");
     }
 }
 
-static void WriteSource(char *tagline, int abi)
+static void
+WriteSource(char *tagline, int abi)
 {
-    static void (*sourceproc[])(int) = {
-	DefaultWriteSource, ArrayperWriteSource,
-	IntelABIWriteSource, IntelABIBCWriteSource,
-	DefaultWriteSource, FunctionWriteSource };
+    static void (*sourceproc[]) (int) = {
+    DefaultWriteSource, ArrayperWriteSource,
+            IntelABIWriteSource, IntelABIBCWriteSource,
+            DefaultWriteSource, FunctionWriteSource};
 
-    FILE* tmpl;
+    FILE *tmpl;
 
     if (ctmplstr) {
-	tmpl = ifopen (ctmplstr, "r");
-
-	if (tmpl) CopyTmplProlog (tmpl, stdout);
-	else {
-	    (void) fprintf (stderr, "Expected template %s, not found\n",
-			    ctmplstr);
-	    exit (1);
-	}
-    } else
-	tmpl = NULL;
-
+        tmpl = ifopen(ctmplstr, "r");
+
+        if (tmpl)
+            CopyTmplProlog(tmpl, stdout);
+        else {
+            (void) fprintf(stderr, "Expected template %s, not found\n",
+                           ctmplstr);
+            exit(1);
+        }
+    }
+    else
+        tmpl = NULL;
 
-    (void) printf ("%s\n%s\n/* %s ABI version -- Do not edit */\n",
-		   "/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
-		   "/* This file is automatically generated. */",
-		   abistring[abi]);
+    (void) printf("/* *%s* */\n", "INDENT-OFF");
+    (void) printf("%s\n%s\n/* %s ABI version -- Do not edit */\n",
+                  "/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
+                  "/* This file is automatically generated. */",
+                  abistring[abi]);
 
-    if (tagline) (void) printf ("/* %s */\n\n", tagline);
+    if (tagline)
+        (void) printf("/* %s */\n\n", tagline);
 
-    (*sourceproc[abi])(abi);
+    (*sourceproc[abi]) (abi);
 
     if (tmpl) {
-	CopyTmplEpilog (tmpl, stdout);
-	fclose(tmpl);
+        CopyTmplEpilog(tmpl, stdout);
+        fclose(tmpl);
     }
+    (void) printf("/* *%s* */\n", "INDENT-ON");
 }
 
-static void DoLine(char *buf)
+static void
+DoLine(char *buf)
 {
 #define X_NO_TOKEN 0
 #define X_FILE_TOKEN 1
@@ -499,284 +537,302 @@ static void DoLine(char *buf)
 
     int token;
     char lbuf[1024];
-    static const char* file_str = "#file";
-    static const char* table_str = "#table";
-    static const char* prefix_str = "#prefix";
-    static const char* feature_str = "#feature";
-    static const char* externref_str = "#externref";
-    static const char* externdef_str = "#externdef";
-    static const char* ctmpl_str = "#ctmpl";
-    static const char* htmpl_str = "#htmpl";
-    static const char* const_str = "#const";
-
-    if (strncmp (buf, file_str, strlen (file_str)) == 0)
-	token = X_FILE_TOKEN;
-    else if (strncmp (buf, table_str, strlen (table_str)) == 0)
-	token = X_TABLE_TOKEN;
-    else if (strncmp (buf, prefix_str, strlen (prefix_str)) == 0)
-	token = X_PREFIX_TOKEN;
-    else if (strncmp (buf, feature_str, strlen (feature_str)) == 0)
-	token = X_FEATURE_TOKEN;
-    else if (strncmp (buf, externref_str, strlen (externref_str)) == 0)
-	token = X_EXTERNREF_TOKEN;
-    else if (strncmp (buf, externdef_str, strlen (externdef_str)) == 0)
-	token = X_EXTERNDEF_TOKEN;
-    else if (strncmp (buf, ctmpl_str, strlen (ctmpl_str)) == 0)
-	token = X_CTMPL_TOKEN;
-    else if (strncmp (buf, htmpl_str, strlen (htmpl_str)) == 0)
-	token = X_HTMPL_TOKEN;
-    else if (strncmp (buf, const_str, strlen (const_str)) == 0)
-	token = X_CONST_TOKEN;
+    static const char *file_str = "#file";
+    static const char *table_str = "#table";
+    static const char *prefix_str = "#prefix";
+    static const char *feature_str = "#feature";
+    static const char *externref_str = "#externref";
+    static const char *externdef_str = "#externdef";
+    static const char *ctmpl_str = "#ctmpl";
+    static const char *htmpl_str = "#htmpl";
+    static const char *const_str = "#const";
+
+    if (strncmp(buf, file_str, strlen(file_str)) == 0)
+        token = X_FILE_TOKEN;
+    else if (strncmp(buf, table_str, strlen(table_str)) == 0)
+        token = X_TABLE_TOKEN;
+    else if (strncmp(buf, prefix_str, strlen(prefix_str)) == 0)
+        token = X_PREFIX_TOKEN;
+    else if (strncmp(buf, feature_str, strlen(feature_str)) == 0)
+        token = X_FEATURE_TOKEN;
+    else if (strncmp(buf, externref_str, strlen(externref_str)) == 0)
+        token = X_EXTERNREF_TOKEN;
+    else if (strncmp(buf, externdef_str, strlen(externdef_str)) == 0)
+        token = X_EXTERNDEF_TOKEN;
+    else if (strncmp(buf, ctmpl_str, strlen(ctmpl_str)) == 0)
+        token = X_CTMPL_TOKEN;
+    else if (strncmp(buf, htmpl_str, strlen(htmpl_str)) == 0)
+        token = X_HTMPL_TOKEN;
+    else if (strncmp(buf, const_str, strlen(const_str)) == 0)
+        token = X_CONST_TOKEN;
     else
         token = X_NO_TOKEN;
 
     switch (token) {
     case X_FILE_TOKEN:
-	{
-	    File* phile;
-
-	    if ((phile = (File*) malloc (sizeof(File))) == NULL)
-		exit(1);
-	    if ((phile->name = strdup (buf + strlen (file_str) + 1)) == NULL)
-		exit(1);
-	    phile->table = NULL;
-	    phile->tablecurrent = NULL;
-	    phile->tabletail = &phile->table;
-	    phile->next = NULL;
-	    phile->tmpl = NULL;
-
-	    *filetail = phile;
-	    filetail = &phile->next;
-	    filecurrent = phile;
-	}
-	break;
+    {
+        File *phile;
+
+        if ((phile = (File *) malloc(sizeof(File))) == NULL)
+            exit(1);
+        if ((phile->name = strdup(buf + strlen(file_str) + 1)) == NULL)
+            exit(1);
+        phile->table = NULL;
+        phile->tablecurrent = NULL;
+        phile->tabletail = &phile->table;
+        phile->next = NULL;
+        phile->tmpl = NULL;
+
+        *filetail = phile;
+        filetail = &phile->next;
+        filecurrent = phile;
+    }
+        break;
     case X_TABLE_TOKEN:
-	{
-	    Table* table;
-	    if ((table = (Table*) malloc (sizeof(Table))) == NULL)
-		exit(1);
-	    if ((table->name = strdup (buf + strlen (table_str) + 1)) == NULL)
-		exit(1);
-	    if (solaris_abi_names) {
-		if (strcmp(table->name, "XtStringsR6") == 0) {
-		    strcpy(table->name, "XtR6Strings");
-		} else if (strcmp(table->name, "XtShellStringsR6") == 0) {
-		    strcpy(table->name, "XtR6ShellStrings");
-		}
-	    }
-	    table->tableent = NULL;
-	    table->tableentcurrent = NULL;
-	    table->tableenttail = &table->tableent;
-	    table->next = NULL;
-	    table->offset = 0;
-
-	    *filecurrent->tabletail = table;
-	    filecurrent->tabletail = &table->next;
-	    filecurrent->tablecurrent = table;
-	}
-	break;
+    {
+        Table *table;
+
+        if ((table = (Table *) malloc(sizeof(Table))) == NULL)
+            exit(1);
+        if ((table->name = strdup(buf + strlen(table_str) + 1)) == NULL)
+            exit(1);
+        if (solaris_abi_names) {
+            if (strcmp(table->name, "XtStringsR6") == 0) {
+                strcpy(table->name, "XtR6Strings");
+            }
+            else if (strcmp(table->name, "XtShellStringsR6") == 0) {
+                strcpy(table->name, "XtR6ShellStrings");
+            }
+        }
+        table->tableent = NULL;
+        table->tableentcurrent = NULL;
+        table->tableenttail = &table->tableent;
+        table->next = NULL;
+        table->offset = 0;
+
+        *filecurrent->tabletail = table;
+        filecurrent->tabletail = &table->next;
+        filecurrent->tablecurrent = table;
+    }
+        break;
     case X_PREFIX_TOKEN:
-	if ((prefixstr = strdup (buf + strlen (prefix_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((prefixstr = strdup(buf + strlen(prefix_str) + 1)) == NULL)
+            exit(1);
+        break;
     case X_FEATURE_TOKEN:
-	if ((featurestr = strdup (buf + strlen (feature_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((featurestr = strdup(buf + strlen(feature_str) + 1)) == NULL)
+            exit(1);
+        break;
     case X_EXTERNREF_TOKEN:
-	if ((externrefstr = strdup (buf + strlen (externref_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((externrefstr = strdup(buf + strlen(externref_str) + 1)) == NULL)
+            exit(1);
+        break;
     case X_EXTERNDEF_TOKEN:
-	if ((externdefstr = strdup (buf + strlen (externdef_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((externdefstr = strdup(buf + strlen(externdef_str) + 1)) == NULL)
+            exit(1);
+        break;
     case X_CTMPL_TOKEN:
-	if ((ctmplstr = strdup (buf + strlen (ctmpl_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((ctmplstr = strdup(buf + strlen(ctmpl_str) + 1)) == NULL)
+            exit(1);
+        break;
     case X_HTMPL_TOKEN:
-	if ((filecurrent->tmpl = ifopen (buf + strlen (htmpl_str) + 1, "r")) == NULL) {
-	    (void) fprintf (stderr,
-			    "Expected template %s, not found\n", htmpl_str);
-	    exit (1);
-	}
-	break;
+        if ((filecurrent->tmpl =
+             ifopen(buf + strlen(htmpl_str) + 1, "r")) == NULL) {
+            (void) fprintf(stderr, "Expected template %s, not found\n",
+                           htmpl_str);
+            exit(1);
+        }
+        break;
     case X_CONST_TOKEN:
-	if ((conststr = strdup (buf + strlen (const_str) + 1)) == NULL)
-	    exit(1);
-	break;
+        if ((conststr = strdup(buf + strlen(const_str) + 1)) == NULL)
+            exit(1);
+        break;
     default:
-	{
-	    char* right;
-	    TableEnt* tableent;
-	    size_t llen;
-	    size_t rlen;
-	    size_t len;
-
-	    if ((right = strchr(buf, ' ')))
-		*right++ = 0;
-	    else
-		right = buf + 1;
-	    if (buf[0] == 'H') {
-		snprintf (lbuf, sizeof(lbuf), "%s%s", prefixstr, right);
-		right = lbuf;
-	    }
-
-	    llen = len = strlen(buf) + 1;
-	    rlen = strlen(right) + 1;
-	    if (right != buf + 1) len += rlen;
-	    tableent = (TableEnt*)calloc(sizeof(TableEnt) + len, 1);
-	    if (tableent == NULL)
-		exit(1);
-	    tableent->left = (char *)(tableent + 1);
-	    strcpy(tableent->left, buf);
-	    if (llen != len) {
-		tableent->right = tableent->left + llen;
-		strcpy(tableent->right, right);
-	    } else {
-		tableent->right = tableent->left + 1;
-	    }
-	    tableent->next = NULL;
-
-	    *filecurrent->tablecurrent->tableenttail = tableent;
-	    filecurrent->tablecurrent->tableenttail = &tableent->next;
-	    filecurrent->tablecurrent->tableentcurrent = tableent;
-	}
-	break;
+    {
+        char *right;
+        TableEnt *tableent;
+        size_t llen;
+        size_t rlen;
+        size_t len;
+
+        if ((right = strchr(buf, ' ')))
+            *right++ = 0;
+        else
+            right = buf + 1;
+        if (buf[0] == 'H') {
+            snprintf(lbuf, sizeof(lbuf), "%s%s", prefixstr, right);
+            right = lbuf;
+        }
+
+        llen = len = strlen(buf) + 1;
+        rlen = strlen(right) + 1;
+        if (right != buf + 1)
+            len += rlen;
+        tableent = (TableEnt *) calloc(sizeof(TableEnt) + len, 1);
+        if (tableent == NULL)
+            exit(1);
+        tableent->left = (char *) (tableent + 1);
+        strcpy(tableent->left, buf);
+        if (llen != len) {
+            tableent->right = tableent->left + llen;
+            strcpy(tableent->right, right);
+        }
+        else {
+            tableent->right = tableent->left + 1;
+        }
+        tableent->next = NULL;
+
+        *filecurrent->tablecurrent->tableenttail = tableent;
+        filecurrent->tablecurrent->tableenttail = &tableent->next;
+        filecurrent->tablecurrent->tableentcurrent = tableent;
+    }
+        break;
     }
 }
 
-static void IntelABIIndexEntries (File *myfile)
+static void
+IntelABIIndexEntries(File * myfile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
 
     for (t = myfile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    te->offset = t->offset;
-	    t->offset += strlen (te->right);
-	    t->offset++;
-	}
+        for (te = t->tableent; te; te = te->next) {
+            te->offset = t->offset;
+            t->offset += strlen(te->right);
+            t->offset++;
+        }
     }
 }
 
-static void DefaultIndexEntries (File *myfile)
+static void
+DefaultIndexEntries(File * myfile)
 {
-    Table* t;
-    TableEnt* te;
+    Table *t;
+    TableEnt *te;
     size_t offset = 0;
 
     for (t = myfile->table; t; t = t->next) {
-	for (te = t->tableent; te; te = te->next) {
-	    te->offset = offset;
-	    offset += strlen (te->right);
-	    offset++;
-	}
+        for (te = t->tableent; te; te = te->next) {
+            te->offset = offset;
+            offset += strlen(te->right);
+            offset++;
+        }
     }
 }
 
-static void IndexEntries (File *myfile, int abi)
+static void
+IndexEntries(File * myfile, int abi)
 {
     switch (abi) {
     case X_SPARC_ABI:
-	break;
+        break;
     case X_INTEL_ABI:
     case X_INTEL_ABI_BC:
-	IntelABIIndexEntries (myfile);
-	break;
+        IntelABIIndexEntries(myfile);
+        break;
     default:
-	DefaultIndexEntries (myfile);
-	break;
+        DefaultIndexEntries(myfile);
+        break;
     }
 }
 
-static char* DoComment (char *line)
+static char *
+DoComment(char *line)
 {
-    char* tag;
-    char* eol;
-    char* ret;
+    char *tag;
+    char *eol;
+    char *ret;
     size_t len;
 
     /* assume that the first line with two '$' in it is the RCS tag line */
-    if ((tag = strchr (line, '$')) == NULL) return NULL;
-    if ((eol = strchr (tag + 1, '$')) == NULL) return NULL;
-    len = (size_t)(eol - tag);
-    if ((ret = malloc (len)) == NULL)
-	exit (1);
-    (void) strncpy (ret, tag + 1, len - 1);
+    if ((tag = strchr(line, '$')) == NULL)
+        return NULL;
+    if ((eol = strchr(tag + 1, '$')) == NULL)
+        return NULL;
+    len = (size_t) (eol - tag);
+    if ((ret = malloc(len)) == NULL)
+        exit(1);
+    (void) strncpy(ret, tag + 1, len - 1);
     ret[len - 2] = 0;
     return ret;
 }
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
     size_t len;
-    char* tagline = NULL;
-    File* phile;
+    char *tagline = NULL;
+    File *phile;
     FILE *f;
     char buf[1024];
     int abi =
 #ifndef ARRAYPERSTR
-	X_DEFAULT_ABI;
+        X_DEFAULT_ABI;
 #else
-	X_ARRAYPER_ABI;
+        X_ARRAYPER_ABI;
 #endif
 
     f = stdin;
     if (argc > 1) {
-	int i;
-	for (i = 1; i < argc; i++) {
-	    if (strcmp (argv[i], "-f") == 0) {
-		if (++i < argc)
-		    f = fopen (argv[i], "r");
-		else
-		    return 1;
-	    }
-	    if (strcmp (argv[i], "-i") == 0) {
-		if (++i < argc) {
-		    includedir = argv[i];
-		} else {
-		    if (f != 0 && f != stdin) fclose(f);
-		    return 1;
-		}
-	    }
-	    if (strcmp (argv[i], "-sparcabi") == 0)
-		abi = X_SPARC_ABI;
-	    if (strcmp (argv[i], "-intelabi") == 0)
-		abi = X_INTEL_ABI;
-	    if (strcmp (argv[i], "-functionabi") == 0)
-		abi = X_FUNCTION_ABI;
-	    if (strcmp (argv[i], "-earlyR6bc") == 0 && abi == X_INTEL_ABI)
-		abi = X_INTEL_ABI_BC;
-	    if (strcmp (argv[i], "-arrayperabi") == 0)
-		abi = X_ARRAYPER_ABI;
+        int i;
+
+        for (i = 1; i < argc; i++) {
+            if (strcmp(argv[i], "-f") == 0) {
+                if (++i < argc)
+                    f = fopen(argv[i], "r");
+                else
+                    return 1;
+            }
+            if (strcmp(argv[i], "-i") == 0) {
+                if (++i < argc) {
+                    includedir = argv[i];
+                }
+                else {
+                    if (f != 0 && f != stdin)
+                        fclose(f);
+                    return 1;
+                }
+            }
+            if (strcmp(argv[i], "-sparcabi") == 0)
+                abi = X_SPARC_ABI;
+            if (strcmp(argv[i], "-intelabi") == 0)
+                abi = X_INTEL_ABI;
+            if (strcmp(argv[i], "-functionabi") == 0)
+                abi = X_FUNCTION_ABI;
+            if (strcmp(argv[i], "-earlyR6bc") == 0 && abi == X_INTEL_ABI)
+                abi = X_INTEL_ABI_BC;
+            if (strcmp(argv[i], "-arrayperabi") == 0)
+                abi = X_ARRAYPER_ABI;
 #ifdef ARRAYPERSTR
-	    if (strcmp (argv[i], "-defaultabi") == 0)
-		abi = X_DEFAULT_ABI;
+            if (strcmp(argv[i], "-defaultabi") == 0)
+                abi = X_DEFAULT_ABI;
 #endif
-	    if (strcmp (argv[i], "-solarisabinames") == 0)
-		solaris_abi_names = TRUE;
-	}
+            if (strcmp(argv[i], "-solarisabinames") == 0)
+                solaris_abi_names = TRUE;
+        }
     }
 
-    if (f == NULL) return 1;
+    if (f == NULL)
+        return 1;
     while (fgets(buf, sizeof buf, f)) {
-	if (!buf[0] || buf[0] == '\n')
-	    continue;
-	if (buf[0] == '!') {
-	    if (tagline) continue;
-	    tagline = DoComment (buf);
-	    continue;
-	}
-	if (buf[(len = strlen (buf) - 1)] == '\n') buf[len] = '\0';
-	DoLine(buf);
+        if (!buf[0] || buf[0] == '\n')
+            continue;
+        if (buf[0] == '!') {
+            if (tagline)
+                continue;
+            tagline = DoComment(buf);
+            continue;
+        }
+        if (buf[(len = strlen(buf) - 1)] == '\n')
+            buf[len] = '\0';
+        DoLine(buf);
     }
     for (phile = file; phile; phile = phile->next) {
-	if (abi != X_ARRAYPER_ABI) IndexEntries (phile, abi);
-	WriteHeader (tagline, phile, abi);
+        if (abi != X_ARRAYPER_ABI)
+            IndexEntries(phile, abi);
+        WriteHeader(tagline, phile, abi);
     }
     WriteSource(tagline, abi);
     return 0;
 }
-