svn merge file:///D:/svnrepos/vcxsrv/branches/released .

1 files changed, 327 insertions, 369 deletions

diff --git a/xorg-server/Xext/xtest.c b/xorg-server/Xext/xtest.c
index db6d54543..3ff02ed91 100644
--- a/xorg-server/Xext/xtest.c
+++ b/xorg-server/Xext/xtest.c
@@ -1,30 +1,30 @@
 /*
 
-Copyright 1992, 1998  The Open Group
+   Copyright 1992, 1998  The Open Group
 
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
+   Permission to use, copy, modify, distribute, and sell this software and its
+   documentation for any purpose is hereby granted without fee, provided that
+   the above copyright notice appear in all copies and that both that
+   copyright notice and this permission notice appear in supporting
+   documentation.
 
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
+   The above copyright notice and this permission notice shall be included
+   in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+   IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+   OTHER DEALINGS IN THE SOFTWARE.
 
-Except as contained in this notice, the name of The Open Group shall
-not be used in advertising or otherwise to promote the sale, use or
-other dealings in this Software without prior written authorization
-from The Open Group.
+   Except as contained in this notice, the name of The Open Group shall
+   not be used in advertising or otherwise to promote the sale, use or
+   other dealings in this Software without prior written authorization
+   from The Open Group.
 
-*/
+ */
 
 #ifdef HAVE_DIX_CONFIG_H
 #include <dix-config.h>
@@ -42,33 +42,27 @@ from The Open Group.
 #include "scrnintstr.h"
 #include "dixevents.h"
 #include "sleepuntil.h"
+#include "mi.h"
 #define _XTEST_SERVER_
 #include <X11/extensions/XTest.h>
 #include <X11/extensions/xteststr.h>
-#ifdef XINPUT
 #include <X11/extensions/XI.h>
 #include <X11/extensions/XIproto.h>
-#define EXTENSION_EVENT_BASE	64
-#endif /* XINPUT */
 
 #include "modinit.h"
 
-#ifdef XINPUT
 extern int DeviceValuator;
-#endif /* XINPUT */
+extern int DeviceMotionNotify;
 
 #ifdef PANORAMIX
 #include "panoramiX.h"
 #include "panoramiXsrv.h"
 #endif
 
-static void XTestResetProc(
-    ExtensionEntry * /* extEntry */
-);
 static int XTestSwapFakeInput(
-    ClientPtr /* client */,
-    xReq * /* req */
-);
+        ClientPtr /* client */,
+        xReq * /* req */
+        );
 
 static DISPATCH_PROC(ProcXTestCompareCursor);
 static DISPATCH_PROC(ProcXTestDispatch);
@@ -85,23 +79,16 @@ void
 XTestExtensionInit(INITARGS)
 {
     AddExtension(XTestExtensionName, 0, 0,
-		 ProcXTestDispatch, SProcXTestDispatch,
-		 XTestResetProc, StandardMinorOpcode);
-}
-
-/*ARGSUSED*/
-static void
-XTestResetProc (extEntry)
-ExtensionEntry	*extEntry;
-{
+            ProcXTestDispatch, SProcXTestDispatch,
+            NULL, StandardMinorOpcode);
 }
 
 static int
 ProcXTestGetVersion(client)
-    register ClientPtr client;
+    ClientPtr client;
 {
     xXTestGetVersionReply rep;
-    register int n;
+    int n;
 
     REQUEST_SIZE_MATCH(xXTestGetVersionReq);
     rep.type = X_Reply;
@@ -110,8 +97,8 @@ ProcXTestGetVersion(client)
     rep.majorVersion = XTestMajorVersion;
     rep.minorVersion = XTestMinorVersion;
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
-	swaps(&rep.minorVersion, n);
+        swaps(&rep.sequenceNumber, n);
+        swaps(&rep.minorVersion, n);
     }
     WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep);
     return(client->noClientException);
@@ -119,37 +106,38 @@ ProcXTestGetVersion(client)
 
 static int
 ProcXTestCompareCursor(client)
-    register ClientPtr client;
+    ClientPtr client;
 {
     REQUEST(xXTestCompareCursorReq);
     xXTestCompareCursorReply rep;
     WindowPtr pWin;
     CursorPtr pCursor;
-    register int n, rc;
+    int n, rc;
+    DeviceIntPtr ptr = PickPointer(client);
 
     REQUEST_SIZE_MATCH(xXTestCompareCursorReq);
     rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
     if (rc != Success)
         return rc;
     if (stuff->cursor == None)
-	pCursor = NullCursor;
+        pCursor = NullCursor;
     else if (stuff->cursor == XTestCurrentCursor)
-	pCursor = GetSpriteCursor();
+        pCursor = GetSpriteCursor(ptr);
     else {
-	rc = dixLookupResource((pointer *)&pCursor, stuff->cursor, RT_CURSOR,
-			       client, DixReadAccess);
-	if (rc != Success) 
-	{
-	    client->errorValue = stuff->cursor;
-	    return (rc == BadValue) ? BadCursor : rc;
-	}
+        rc = dixLookupResource((pointer *)&pCursor, stuff->cursor, RT_CURSOR,
+                client, DixReadAccess);
+        if (rc != Success)
+        {
+            client->errorValue = stuff->cursor;
+            return (rc == BadValue) ? BadCursor : rc;
+        }
     }
     rep.type = X_Reply;
     rep.length = 0;
     rep.sequenceNumber = client->sequence;
     rep.same = (wCursor(pWin) == pCursor);
     if (client->swapped) {
-    	swaps(&rep.sequenceNumber, n);
+        swaps(&rep.sequenceNumber, n);
     }
     WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep);
     return(client->noClientException);
@@ -157,345 +145,315 @@ ProcXTestCompareCursor(client)
 
 static int
 ProcXTestFakeInput(client)
-    register ClientPtr client;
+    ClientPtr client;
 {
     REQUEST(xXTestFakeInputReq);
     int nev, n, type, rc;
     xEvent *ev;
     DeviceIntPtr dev = NULL;
     WindowPtr root;
-#ifdef XINPUT
     Bool extension = FALSE;
     deviceValuator *dv = NULL;
-    int base;
-    int *values;
-#endif /* XINPUT */
+    int valuators[MAX_VALUATORS] = {0};
+    int numValuators = 0;
+    int firstValuator = 0;
+    EventListPtr events;
+    int nevents;
+    int i;
+    int base = 0;
+    int flags = 0;
 
     nev = (stuff->length << 2) - sizeof(xReq);
     if ((nev % sizeof(xEvent)) || !nev)
-	return BadLength;
+        return BadLength;
     nev /= sizeof(xEvent);
     UpdateCurrentTime();
     ev = (xEvent *)&((xReq *)stuff)[1];
     type = ev->u.u.type & 0177;
-#ifdef XINPUT
+
     if (type >= EXTENSION_EVENT_BASE)
     {
-	type -= DeviceValuator;
-	switch (type) {
-	case XI_DeviceKeyPress:
-	case XI_DeviceKeyRelease:
-	case XI_DeviceButtonPress:
-	case XI_DeviceButtonRelease:
-	case XI_DeviceMotionNotify:
-	case XI_ProximityIn:
-	case XI_ProximityOut:
-	    break;
-	default:
-	    client->errorValue = ev->u.u.type;
-	    return BadValue;
-	}
-	if (nev == 1 && type == XI_DeviceMotionNotify)
-	    return BadLength;
-	if (type == XI_DeviceMotionNotify)
-	    base = ((deviceValuator *)(ev+1))->first_valuator;
-	else
-	    base = 0;
-	for (n = 1; n < nev; n++)
-	{
-	    dv = (deviceValuator *)(ev + n);
-	    if (dv->type != DeviceValuator)
-	    {
-		client->errorValue = dv->type;
-		return BadValue;
-	    }
-	    if (dv->first_valuator != base)
-	    {
-		client->errorValue = dv->first_valuator;
-		return BadValue;
-	    }
-	    if (!dv->num_valuators || dv->num_valuators > 6)
-	    {
-		client->errorValue = dv->num_valuators;
-		return BadValue;
-	    }
-	    base += dv->num_valuators;
-	}
-	type = type - XI_DeviceKeyPress + KeyPress;
-	extension = TRUE;
-    }
-    else
-#endif /* XINPUT */
+        extension = TRUE;
+
+        /* check device */
+        rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client,
+                DixWriteAccess);
+        if (rc != Success)
+        {
+            client->errorValue = stuff->deviceid & 0177;
+            return rc;
+        }
+
+        /* check type */
+        type -= DeviceValuator;
+        switch (type) {
+            case XI_DeviceKeyPress:
+            case XI_DeviceKeyRelease:
+            case XI_DeviceButtonPress:
+            case XI_DeviceButtonRelease:
+            case XI_DeviceMotionNotify:
+            case XI_ProximityIn:
+            case XI_ProximityOut:
+                break;
+            default:
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+        }
+
+        /* check validity */
+        if (nev == 1 && type == XI_DeviceMotionNotify)
+            return BadLength; /* DevMotion must be followed by DevValuator */
+
+        if (type == XI_DeviceMotionNotify)
+        {
+            firstValuator = ((deviceValuator *)(ev+1))->first_valuator;
+            if (firstValuator > dev->valuator->numAxes)
+            {
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+            }
+
+            if (ev->u.u.detail == xFalse)
+                flags |= POINTER_ABSOLUTE;
+        } else
+        {
+            firstValuator = 0;
+            flags |= POINTER_ABSOLUTE;
+        }
+
+        if (nev == 1 && type == XI_DeviceMotionNotify && !dev->valuator)
+        {
+            client->errorValue = dv->first_valuator;
+            return BadValue;
+        }
+
+
+        /* check validity of valuator events */
+        base = firstValuator;
+        for (n = 1; n < nev; n++)
+        {
+            dv = (deviceValuator *)(ev + n);
+            if (dv->type != DeviceValuator)
+            {
+                client->errorValue = dv->type;
+                return BadValue;
+            }
+            if (dv->first_valuator != base)
+            {
+                client->errorValue = dv->first_valuator;
+                return BadValue;
+            }
+            switch(dv->num_valuators)
+            {
+                case 6: valuators[base + 5] = dv->valuator5;
+                case 5: valuators[base + 4] = dv->valuator4;
+                case 4: valuators[base + 3] = dv->valuator3;
+                case 3: valuators[base + 2] = dv->valuator2;
+                case 2: valuators[base + 1] = dv->valuator1;
+                case 1: valuators[base] = dv->valuator0;
+                        break;
+                default:
+                        client->errorValue = dv->num_valuators;
+                        return BadValue;
+            }
+
+            base += dv->num_valuators;
+            numValuators += dv->num_valuators;
+
+            if (firstValuator + numValuators > dev->valuator->numAxes)
+            {
+                client->errorValue = dv->num_valuators;
+                return BadValue;
+            }
+        }
+        type = type - XI_DeviceKeyPress + KeyPress;
+
+    } else
     {
-	if (nev != 1)
-	    return BadLength;
-	switch (type)
-	{
-	case KeyPress:
-	case KeyRelease:
-	case MotionNotify:
-	case ButtonPress:
-	case ButtonRelease:
-	    break;
-	default:
-	    client->errorValue = ev->u.u.type;
-	    return BadValue;
-	}
+        if (nev != 1)
+            return BadLength;
+        switch (type)
+        {
+            case KeyPress:
+            case KeyRelease:
+                dev = PickKeyboard(client);
+                break;
+            case ButtonPress:
+            case ButtonRelease:
+                dev = PickPointer(client);
+                break;
+            case MotionNotify:
+                dev = PickPointer(client);
+                valuators[0] = ev->u.keyButtonPointer.rootX;
+                valuators[1] = ev->u.keyButtonPointer.rootY;
+                numValuators = 2;
+                firstValuator = 0;
+                if (ev->u.u.detail == xFalse)
+                    flags = POINTER_ABSOLUTE | POINTER_SCREEN;
+                break;
+            default:
+                client->errorValue = ev->u.u.type;
+                return BadValue;
+        }
+
+        if (dev->u.lastSlave)
+            dev = dev->u.lastSlave;
     }
+
+    /* If the event has a time set, wait for it to pass */
     if (ev->u.keyButtonPointer.time)
     {
-	TimeStamp activateTime;
-	CARD32 ms;
-
-	activateTime = currentTime;
-	ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
-	if (ms < activateTime.milliseconds)
-	    activateTime.months++;
-	activateTime.milliseconds = ms;
-	ev->u.keyButtonPointer.time = 0;
-
-	/* see mbuf.c:QueueDisplayRequest for code similar to this */
-
-	if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
-	{
-	    return BadAlloc;
-	}
-	/* swap the request back so we can simply re-execute it */
-	if (client->swapped)
-	{
-    	    (void) XTestSwapFakeInput(client, (xReq *)stuff);
-	    swaps(&stuff->length, n);
-	}
-	ResetCurrentRequest (client);
-	client->sequence--;
-	return Success;
-    }
-#ifdef XINPUT
-    if (extension)
-    {
-	rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client,
-			     DixWriteAccess);
-	if (rc != Success)
-	{
-	    client->errorValue = stuff->deviceid & 0177;
-	    return rc;
-	}
-	if (nev > 1)
-	{
-	    dv = (deviceValuator *)(ev + 1);
-	    if (!dev->valuator || dv->first_valuator >= dev->valuator->numAxes)
-	    {
-		client->errorValue = dv->first_valuator;
-		return BadValue;
-	    }
-	    if (dv->first_valuator + dv->num_valuators >
-		dev->valuator->numAxes)
-	    {
-		client->errorValue = dv->num_valuators;
-		return BadValue;
-	    }
-	}
+        TimeStamp activateTime;
+        CARD32 ms;
+
+        activateTime = currentTime;
+        ms = activateTime.milliseconds + ev->u.keyButtonPointer.time;
+        if (ms < activateTime.milliseconds)
+            activateTime.months++;
+        activateTime.milliseconds = ms;
+        ev->u.keyButtonPointer.time = 0;
+
+        /* see mbuf.c:QueueDisplayRequest for code similar to this */
+
+        if (!ClientSleepUntil(client, &activateTime, NULL, NULL))
+        {
+            return BadAlloc;
+        }
+        /* swap the request back so we can simply re-execute it */
+        if (client->swapped)
+        {
+            (void) XTestSwapFakeInput(client, (xReq *)stuff);
+            swaps(&stuff->length, n);
+        }
+        ResetCurrentRequest (client);
+        client->sequence--;
+        return Success;
     }
-#endif /* XINPUT */
+
     switch (type)
     {
-    case KeyPress:
-    case KeyRelease:
-#ifdef XINPUT
-	if (!extension)
-#endif /* XINPUT */
-	    dev = inputInfo.keyboard;
-	if (ev->u.u.detail < dev->key->curKeySyms.minKeyCode ||
-	    ev->u.u.detail > dev->key->curKeySyms.maxKeyCode)
-	{
-	    client->errorValue = ev->u.u.detail;
-	    return BadValue;
-	}
-	break;
-    case MotionNotify:
-#ifdef XINPUT
-	if (extension)
-	{
-	    if (ev->u.u.detail != xFalse && ev->u.u.detail != xTrue)
-	    {
-		client->errorValue = ev->u.u.detail;
-		return BadValue;
-	    }
-	    if (ev->u.u.detail == xTrue && dev->valuator->mode == Absolute)
-	    {
-		values = dev->valuator->axisVal + dv->first_valuator;
-		for (n = 1; n < nev; n++)
-		{
-		    dv = (deviceValuator *)(ev + n);
-		    switch (dv->num_valuators)
-		    {
-		    case 6:
-			dv->valuator5 += values[5];
-		    case 5:
-			dv->valuator4 += values[4];
-		    case 4:
-			dv->valuator3 += values[3];
-		    case 3:
-			dv->valuator2 += values[2];
-		    case 2:
-			dv->valuator1 += values[1];
-		    case 1:
-			dv->valuator0 += values[0];
-		    }
-		    values += 6;
-		}
-	    }
-	    break;
-	}
-#endif /* XINPUT */
-	dev = inputInfo.pointer;
-	if (ev->u.keyButtonPointer.root == None)
-	    root = GetCurrentRootWindow();
-	else
-	{
-	    rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root, client,
-				 DixGetAttrAccess);
-	    if (rc != Success)
-		return rc;
-	    if (root->parent)
-	    {
-		client->errorValue = ev->u.keyButtonPointer.root;
-		return BadValue;
-	    }
-	}
-	if (ev->u.u.detail == xTrue)
-	{
-	    int x, y;
-	    GetSpritePosition(&x, &y);
-	    ev->u.keyButtonPointer.rootX += x;
-	    ev->u.keyButtonPointer.rootY += y;
-	}
-	else if (ev->u.u.detail != xFalse)
-	{
-	    client->errorValue = ev->u.u.detail;
-	    return BadValue;
-	}
-
-#ifdef PANORAMIX
-	if (!noPanoramiXExtension) {
-	    ScreenPtr pScreen = root->drawable.pScreen;
-	    BoxRec    box;
-	    int       i;
-	    int       x = ev->u.keyButtonPointer.rootX + panoramiXdataPtr[0].x;
-	    int       y = ev->u.keyButtonPointer.rootY + panoramiXdataPtr[0].y;
-	    if (!POINT_IN_REGION(pScreen, &XineramaScreenRegions[pScreen->myNum],
-				 x, y, &box)) {
-		FOR_NSCREENS(i) {
-		    if (i == pScreen->myNum) continue;
-		    if (POINT_IN_REGION(pScreen,
-					&XineramaScreenRegions[i],
-					x, y, &box)) {
-			root = WindowTable[i];
-			x   -= panoramiXdataPtr[i].x;
-			y   -= panoramiXdataPtr[i].y;
-			ev->u.keyButtonPointer.rootX = x;
-			ev->u.keyButtonPointer.rootY = y;
-			break;
-		    }
-		}
-	    }
-	}
-#endif
-
-	if (ev->u.keyButtonPointer.rootX < 0)
-	    ev->u.keyButtonPointer.rootX = 0;
-	else if (ev->u.keyButtonPointer.rootX >= root->drawable.width)
-	    ev->u.keyButtonPointer.rootX = root->drawable.width - 1;
-	if (ev->u.keyButtonPointer.rootY < 0)
-	    ev->u.keyButtonPointer.rootY = 0;
-	else if (ev->u.keyButtonPointer.rootY >= root->drawable.height)
-	    ev->u.keyButtonPointer.rootY = root->drawable.height - 1;
-
-#ifdef PANORAMIX
-	if ((!noPanoramiXExtension
-	     && root->drawable.pScreen->myNum != XineramaGetCursorScreen())
-	    || (noPanoramiXExtension && root != GetCurrentRootWindow()))
-
-#else
-	if (root != GetCurrentRootWindow())
-#endif
-	{
-	    NewCurrentScreen(root->drawable.pScreen,
-			     ev->u.keyButtonPointer.rootX,
-			     ev->u.keyButtonPointer.rootY);
-	    return client->noClientException;
-	}
-	(*root->drawable.pScreen->SetCursorPosition)
-	    (root->drawable.pScreen,
-	     ev->u.keyButtonPointer.rootX,
-	     ev->u.keyButtonPointer.rootY, FALSE);
-        dev->valuator->lastx = ev->u.keyButtonPointer.rootX;
-        dev->valuator->lasty = ev->u.keyButtonPointer.rootY;
-	break;
-    case ButtonPress:
-    case ButtonRelease:
-#ifdef XINPUT
-	if (!extension)
-#endif /* XINPUT */
-	    dev = inputInfo.pointer;
-	if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
-	{
-	    client->errorValue = ev->u.u.detail;
-	    return BadValue;
-	}
-	break;
+        case KeyPress:
+        case KeyRelease:
+            if (ev->u.u.detail < dev->key->curKeySyms.minKeyCode ||
+                    ev->u.u.detail > dev->key->curKeySyms.maxKeyCode)
+            {
+                client->errorValue = ev->u.u.detail;
+                return BadValue;
+            }
+            break;
+        case MotionNotify:
+            /* broken lib, XI events have root uninitialized */
+            if (extension || ev->u.keyButtonPointer.root == None)
+                root = GetCurrentRootWindow(dev);
+            else
+            {
+                rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root,
+                                     client, DixGetAttrAccess);
+                if (rc != Success)
+                    return rc;
+                if (root->parent)
+                {
+                    client->errorValue = ev->u.keyButtonPointer.root;
+                    return BadValue;
+                }
+            }
+            if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse)
+            {
+                client->errorValue = ev->u.u.detail;
+                return BadValue;
+            }
+
+            /* FIXME: Xinerama! */
+
+            break;
+        case ButtonPress:
+        case ButtonRelease:
+            if (!extension)
+            {
+                dev = PickPointer(client);
+                if (dev->u.lastSlave)
+                    dev = dev->u.lastSlave;
+            }
+            if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
+            {
+                client->errorValue = ev->u.u.detail;
+                return BadValue;
+            }
+            break;
     }
     if (screenIsSaved == SCREEN_SAVER_ON)
-	dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
-    ev->u.keyButtonPointer.time = currentTime.milliseconds;
-    (*dev->public.processInputProc)(ev, dev, nev);
+        dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
+
+    GetEventList(&events);
+    switch(type) {
+        case MotionNotify:
+            nevents = GetPointerEvents(events, dev, type, 0, flags,
+                            firstValuator, numValuators, valuators);
+            break;
+        case ButtonPress:
+        case ButtonRelease:
+            nevents = GetPointerEvents(events, dev, type, ev->u.u.detail,
+                                       flags, firstValuator,
+                                       numValuators, valuators);
+            break;
+        case KeyPress:
+        case KeyRelease:
+            nevents = GetKeyboardEvents(events, dev, type, ev->u.u.detail);
+            break;
+    }
+
+    OsBlockSignals();
+    for (i = 0; i < nevents; i++)
+        mieqEnqueue(dev, (events+i)->event);
+    OsReleaseSignals();
+
     return client->noClientException;
 }
 
 static int
 ProcXTestGrabControl(client)
-    register ClientPtr client;
+    ClientPtr client;
 {
     REQUEST(xXTestGrabControlReq);
 
     REQUEST_SIZE_MATCH(xXTestGrabControlReq);
     if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse))
     {
-	client->errorValue = stuff->impervious;
+        client->errorValue = stuff->impervious;
         return(BadValue);
     }
     if (stuff->impervious)
-	MakeClientGrabImpervious(client);
+        MakeClientGrabImpervious(client);
     else
-	MakeClientGrabPervious(client);
+        MakeClientGrabPervious(client);
     return(client->noClientException);
 }
 
 static int
 ProcXTestDispatch (client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
     REQUEST(xReq);
     switch (stuff->data)
     {
-    case X_XTestGetVersion:
-	return ProcXTestGetVersion(client);
-    case X_XTestCompareCursor:
-	return ProcXTestCompareCursor(client);
-    case X_XTestFakeInput:
-	return ProcXTestFakeInput(client);
-    case X_XTestGrabControl:
-	return ProcXTestGrabControl(client);
-    default:
-	return BadRequest;
+        case X_XTestGetVersion:
+            return ProcXTestGetVersion(client);
+        case X_XTestCompareCursor:
+            return ProcXTestCompareCursor(client);
+        case X_XTestFakeInput:
+            return ProcXTestFakeInput(client);
+        case X_XTestGrabControl:
+            return ProcXTestGrabControl(client);
+        default:
+            return BadRequest;
     }
 }
 
 static int
 SProcXTestGetVersion(client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
-    register int n;
+    int n;
     REQUEST(xXTestGetVersionReq);
 
     swaps(&stuff->length, n);
@@ -506,9 +464,9 @@ SProcXTestGetVersion(client)
 
 static int
 SProcXTestCompareCursor(client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
-    register int n;
+    int n;
     REQUEST(xXTestCompareCursorReq);
 
     swaps(&stuff->length, n);
@@ -520,49 +478,49 @@ SProcXTestCompareCursor(client)
 
 static int
 XTestSwapFakeInput(client, req)
-    register ClientPtr	client;
+    ClientPtr	client;
     xReq *req;
 {
-    register int nev;
-    register xEvent *ev;
+    int nev;
+    xEvent *ev;
     xEvent sev;
     EventSwapPtr proc;
 
     nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
     for (ev = (xEvent *)&req[1]; --nev >= 0; ev++)
     {
-    	/* Swap event */
-    	proc = EventSwapVector[ev->u.u.type & 0177];
-	/* no swapping proc; invalid event type? */
-    	if (!proc ||  proc ==  NotImplemented) {
-	    client->errorValue = ev->u.u.type;
-	    return BadValue;
-	}
-    	(*proc)(ev, &sev);
-	*ev = sev;
+        /* Swap event */
+        proc = EventSwapVector[ev->u.u.type & 0177];
+        /* no swapping proc; invalid event type? */
+        if (!proc ||  proc ==  NotImplemented) {
+            client->errorValue = ev->u.u.type;
+            return BadValue;
+        }
+        (*proc)(ev, &sev);
+        *ev = sev;
     }
     return Success;
 }
 
 static int
 SProcXTestFakeInput(client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
-    register int n;
+    int n;
     REQUEST(xReq);
 
     swaps(&stuff->length, n);
     n = XTestSwapFakeInput(client, stuff);
     if (n != Success)
-	return n;
+        return n;
     return ProcXTestFakeInput(client);
 }
 
 static int
 SProcXTestGrabControl(client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
-    register int n;
+    int n;
     REQUEST(xXTestGrabControlReq);
 
     swaps(&stuff->length, n);
@@ -572,20 +530,20 @@ SProcXTestGrabControl(client)
 
 static int
 SProcXTestDispatch (client)
-    register ClientPtr	client;
+    ClientPtr	client;
 {
     REQUEST(xReq);
     switch (stuff->data)
     {
-    case X_XTestGetVersion:
-	return SProcXTestGetVersion(client);
-    case X_XTestCompareCursor:
-	return SProcXTestCompareCursor(client);
-    case X_XTestFakeInput:
-	return SProcXTestFakeInput(client);
-    case X_XTestGrabControl:
-	return SProcXTestGrabControl(client);
-    default:
-	return BadRequest;
+        case X_XTestGetVersion:
+            return SProcXTestGetVersion(client);
+        case X_XTestCompareCursor:
+            return SProcXTestCompareCursor(client);
+        case X_XTestFakeInput:
+            return SProcXTestFakeInput(client);
+        case X_XTestGrabControl:
+            return SProcXTestGrabControl(client);
+        default:
+            return BadRequest;
     }
 }