indent'd like "x-indent.sh", but with a more complete set of typedefs - see

https://github.com/ThomasDickey/cindent-snapshots/blob/master/scripts/xxx-profile

Signed-off-by: Thomas E. Dickey <dickey@invisible-island.net>

1 files changed, 1601 insertions, 1522 deletions

diff --git a/src/Selection.c b/src/Selection.c
index 83b0bb5..b89654b 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,193 @@ 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 _X_UNUSED,
- XtPointer closure,
- XtPointer callData _X_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 +349,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 _X_UNUSED)
+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 +385,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 +429,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 +457,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 +471,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 +519,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 _X_UNUSED)
+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 _X_UNUSED,
-    XtPointer closure,
-    XEvent *ev,
-    Boolean *cont _X_UNUSED)
+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 _X_UNUSED,
-    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 +736,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 _X_UNUSED)
+static void
+HandleSelectionEvents(Widget widget,
+                      XtPointer closure,
+                      XEvent *event,
+                      Boolean * cont _X_UNUSED)
 {
     Select ctx;
     XSelectionEvent ev;
@@ -807,158 +822,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 +1000,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 +1075,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 _X_UNUSED)
+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 _X_UNUSED)
+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 _X_UNUSED)
+static void
+HandleGetIncrement(Widget widget,
+                   XtPointer closure,
+                   XEvent *ev,
+                   Boolean * cont _X_UNUSED)
 {
     XPropertyEvent *event = (XPropertyEvent *) ev;
     CallBackInfo info = (CallBackInfo) closure;
@@ -1183,109 +1207,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 +1325,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 _X_UNUSED)
+static void
+HandleSelectionReplies(Widget widget,
+                       XtPointer closure,
+                       XEvent *ev,
+                       Boolean * cont _X_UNUSED)
 {
     XSelectionEvent *event = (XSelectionEvent *) ev;
     Display *dpy = event->display;
@@ -1387,63 +1421,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 +1491,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 +1608,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 +1650,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 +1678,252 @@ 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 +1932,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 +2228,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 +2275,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 +2303,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;