Merge remote-tracking branch 'origin/released'

1 files changed, 480 insertions, 346 deletions

diff --git a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c b/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
index 6e2a8e9b2..68c4b583f 100644
--- a/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
+++ b/xorg-server/hw/xfree86/dixmods/extmod/xf86vmode.c
@@ -75,8 +75,7 @@ static unsigned char XF86VidModeReqCode = 0;
 #ifdef XF86VIDMODE_EVENTS
 static int XF86VidModeEventBase = 0;
 
-static void SXF86VidModeNotifyEvent();
-xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent *        /* to */
+static void SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent *    /* to */
     );
 
 static RESTYPE EventType;       /* resource type for event masks */
@@ -117,20 +116,22 @@ static DevPrivateKeyRec ScreenPrivateKeyRec;
 #define DEBUG_P(x) /**/
 #endif
     static int
- ClientMajorVersion(ClientPtr client) {
+ClientMajorVersion(ClientPtr client)
+{
     VidModePrivPtr pPriv;
 
-     pPriv = VM_GETPRIV(client);
+    pPriv = VM_GETPRIV(client);
     if (!pPriv)
-         return 0;
+        return 0;
     else
-         return pPriv->major;
+        return pPriv->major;
 }
+
 #ifdef XF86VIDMODE_EVENTS
 static void
- CheckScreenPrivate(pScreen)
+CheckScreenPrivate(pScreen)
 ScreenPtr
-    pScreen;
+ pScreen;
 {
     SetupScreen(pScreen);
 
@@ -142,9 +143,10 @@ ScreenPtr
     }
 }
 
-static XF86VidModeScreenPrivatePtr MakeScreenPrivate(pScreen)
+static XF86VidModeScreenPrivatePtr
+MakeScreenPrivate(pScreen)
 ScreenPtr
-    pScreen;
+ pScreen;
 {
     SetupScreen(pScreen);
 
@@ -160,18 +162,22 @@ ScreenPtr
 }
 
 static unsigned long
- getEventMask(ScreenPtr pScreen, ClientPtr client) {
+getEventMask(ScreenPtr pScreen, ClientPtr client)
+{
     SetupScreen(pScreen);
     XF86VidModeEventPtr pEv;
 
     if (!pPriv)
-         return 0;
+        return 0;
     for (pEv = pPriv->events; pEv; pEv = pEv->next)
         if (pEv->client == client)
             return pEv->mask;
-     return 0;
-} static Bool
- setEventMask(ScreenPtr pScreen, ClientPtr client, unsigned long mask) {
+    return 0;
+}
+
+static Bool
+setEventMask(ScreenPtr pScreen, ClientPtr client, unsigned long mask)
+{
     SetupScreen(pScreen);
     XF86VidModeEventPtr pEv, *pPrev;
 
@@ -181,7 +187,8 @@ static unsigned long
         pPriv = MakeScreenPrivate(pScreen);
         if (!pPriv)
             return FALSE;
-    } for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
+    }
+    for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
         if (pEv->client == client)
             break;
     if (mask == 0) {
@@ -208,38 +215,43 @@ static unsigned long
 }
 
 static int
- XF86VidModeFreeEvents(pointer value, XID id) {
+XF86VidModeFreeEvents(pointer value, XID id)
+{
     XF86VidModeEventPtr pOld = (XF86VidModeEventPtr) value;
     ScreenPtr pScreen = pOld->screen;
-     SetupScreen(pScreen);
+
+    SetupScreen(pScreen);
     XF86VidModeEventPtr pEv, *pPrev;
 
     if (!pPriv)
-         return TRUE;
+        return TRUE;
     for (pPrev = &pPriv->events; pEv = *pPrev; pPrev = &pEv->next)
         if (pEv == pOld)
             break;
     if (!pEv)
-         return TRUE;
+        return TRUE;
     *pPrev = pEv->next;
-     free(pEv);
-     CheckScreenPrivate(pScreen);
-     return TRUE;
-} static void
- SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced) {
+    free(pEv);
+    CheckScreenPrivate(pScreen);
+    return TRUE;
+}
+
+static void
+SendXF86VidModeNotify(ScreenPtr pScreen, int state, Bool forced)
+{
     XF86VidModeScreenPrivatePtr pPriv;
     XF86VidModeEventPtr pEv;
     unsigned long mask;
     xXF86VidModeNotifyEvent ev;
     int kind;
 
-     UpdateCurrentTimeIf();
-     mask = XF86VidModeNotifyMask;
-     pScreen = screenInfo.screens[pScreen->myNum];
-     pPriv = GetScreenPrivate(pScreen);
+    UpdateCurrentTimeIf();
+    mask = XF86VidModeNotifyMask;
+    pScreen = screenInfo.screens[pScreen->myNum];
+    pPriv = GetScreenPrivate(pScreen);
     if (!pPriv)
-         return;
-     kind = XF86VidModeModeChange;
+        return;
+    kind = XF86VidModeModeChange;
     for (pEv = pPriv->events; pEv; pEv = pEv->next) {
         if (!(pEv->mask & mask))
             continue;
@@ -251,8 +263,10 @@ static int
         ev.forced = forced;
         WriteEventsToClient(pEv->client, 1, (xEvent *) &ev);
 }} static void
- SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from,
-                         xXF86VidModeNotifyEvent * to) {
+
+SXF86VidModeNotifyEvent(xXF86VidModeNotifyEvent * from,
+                        xXF86VidModeNotifyEvent * to)
+{
     to->type = from->type;
     to->state = from->state;
     cpswaps(from->sequenceNumber, to->sequenceNumber);
@@ -264,29 +278,31 @@ static int
 #endif
 
 static int
- ProcXF86VidModeQueryVersion(ClientPtr client) {
+ProcXF86VidModeQueryVersion(ClientPtr client)
+{
     xXF86VidModeQueryVersionReply rep;
 
-     DEBUG_P("XF86VidModeQueryVersion");
+    DEBUG_P("XF86VidModeQueryVersion");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
-     rep.type = X_Reply;
-     rep.length = 0;
-     rep.sequenceNumber = client->sequence;
-     rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION;
-     rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION;
+    REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION;
+    rep.minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION;
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swaps(&rep.majorVersion);
         swaps(&rep.minorVersion);
-    } WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply),
-                    (char *) &rep);
+    }
+    WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), (char *) &rep);
     return Success;
 }
 
 static int
- ProcXF86VidModeGetModeLine(ClientPtr client) {
+ProcXF86VidModeGetModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetModeLineReq);
     xXF86VidModeGetModeLineReply rep;
     xXF86OldVidModeGetModeLineReply oldrep;
@@ -294,11 +310,11 @@ static int
     int dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeGetModeline");
+    DEBUG_P("XF86VidModeGetModeline");
 
-     ver = ClientMajorVersion(client);
-     REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
-     rep.type = X_Reply;
+    ver = ClientMajorVersion(client);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
+    rep.type = X_Reply;
     if (ver < 2) {
         rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply) -
                                     SIZEOF(xGenericReply));
@@ -386,7 +402,8 @@ static int
 }
 
 static int
- ProcXF86VidModeGetAllModeLines(ClientPtr client) {
+ProcXF86VidModeGetAllModeLines(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetAllModeLinesReq);
     xXF86VidModeGetAllModeLinesReply rep;
     xXF86VidModeModeInfo mdinf;
@@ -395,38 +412,39 @@ static int
     int modecount, dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeGetAllModelines");
+    DEBUG_P("XF86VidModeGetAllModelines");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
 
-     modecount = VidModeGetNumOfModes(stuff->screen);
+    modecount = VidModeGetNumOfModes(stuff->screen);
     if (modecount < 1)
-         return VidModeErrorBase + XF86VidModeExtensionDisabled;
+        return VidModeErrorBase + XF86VidModeExtensionDisabled;
 
     if (!VidModeGetFirstModeline(stuff->screen, &mode, &dotClock))
-         return BadValue;
+        return BadValue;
 
-     rep.type = X_Reply;
-     rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
+    rep.type = X_Reply;
+    rep.length = SIZEOF(xXF86VidModeGetAllModeLinesReply) -
         SIZEOF(xGenericReply);
     if (ver < 2)
-         rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
+        rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
     else
-         rep.length += modecount * sizeof(xXF86VidModeModeInfo);
-     rep.length >>= 2;
-     rep.sequenceNumber = client->sequence;
-     rep.modecount = modecount;
+        rep.length += modecount * sizeof(xXF86VidModeModeInfo);
+    rep.length >>= 2;
+    rep.sequenceNumber = client->sequence;
+    rep.modecount = modecount;
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.modecount);
-    } WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply),
-                    (char *) &rep);
+    }
+    WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply),
+                  (char *) &rep);
 
     do {
         mdinf.dotclock = dotClock;
@@ -492,7 +510,8 @@ static int
      && VidModeGetModeValue(mode, VIDMODE_FLAGS)  == stuff->flags )
 
 static int
- ProcXF86VidModeAddModeLine(ClientPtr client) {
+ProcXF86VidModeAddModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeAddModeLineReq);
     xXF86OldVidModeAddModeLineReq *oldstuff =
         (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
@@ -502,9 +521,9 @@ static int
     int dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeAddModeline");
+    DEBUG_P("XF86VidModeAddModeline");
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         /* convert from old format */
         stuff = &newstuff;
@@ -533,7 +552,8 @@ static int
         stuff->after_vsyncend = oldstuff->after_vsyncend;
         stuff->after_vtotal = oldstuff->after_vtotal;
         stuff->after_flags = oldstuff->after_flags;
-    } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
+    }
+    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
         ErrorF("AddModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
         ErrorF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
@@ -654,7 +674,8 @@ static int
 }
 
 static int
- ProcXF86VidModeDeleteModeLine(ClientPtr client) {
+ProcXF86VidModeDeleteModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeDeleteModeLineReq);
     xXF86OldVidModeDeleteModeLineReq *oldstuff =
         (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
@@ -663,9 +684,9 @@ static int
     int len, dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeDeleteModeline");
+    DEBUG_P("XF86VidModeDeleteModeline");
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         /* convert from old format */
         stuff = &newstuff;
@@ -683,7 +704,8 @@ static int
         stuff->vtotal = oldstuff->vtotal;
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
-    } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
+    }
+    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
         ErrorF("DeleteModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
         ErrorF("                 hdsp: %d hbeg: %d hend: %d httl: %d\n",
@@ -777,7 +799,8 @@ static int
 }
 
 static int
- ProcXF86VidModeModModeLine(ClientPtr client) {
+ProcXF86VidModeModModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeModModeLineReq);
     xXF86OldVidModeModModeLineReq *oldstuff =
         (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
@@ -786,9 +809,9 @@ static int
     int len, dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeModModeline");
+    DEBUG_P("XF86VidModeModModeline");
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         /* convert from old format */
         stuff = &newstuff;
@@ -805,7 +828,8 @@ static int
         stuff->vtotal = oldstuff->vtotal;
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
-    } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
+    }
+    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
         ErrorF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
                (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart,
                stuff->hsyncend, stuff->htotal);
@@ -903,7 +927,8 @@ static int
 }
 
 static int
- ProcXF86VidModeValidateModeLine(ClientPtr client) {
+ProcXF86VidModeValidateModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeValidateModeLineReq);
     xXF86OldVidModeValidateModeLineReq *oldstuff =
         (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
@@ -913,9 +938,9 @@ static int
     int len, status, dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeValidateModeline");
+    DEBUG_P("XF86VidModeValidateModeline");
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         /* convert from old format */
         stuff = &newstuff;
@@ -933,7 +958,8 @@ static int
         stuff->vtotal = oldstuff->vtotal;
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
-    } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
+    }
+    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
         ErrorF("ValidateModeLine - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
         ErrorF("                   hdsp: %d hbeg: %d hend: %d httl: %d\n",
@@ -1022,7 +1048,8 @@ static int
 }
 
 static int
- ProcXF86VidModeSwitchMode(ClientPtr client) {
+ProcXF86VidModeSwitchMode(ClientPtr client)
+{
     REQUEST(xXF86VidModeSwitchModeReq);
 
     DEBUG_P("XF86VidModeSwitchMode");
@@ -1035,8 +1062,11 @@ static int
     VidModeZoomViewport(stuff->screen, (short) stuff->zoom);
 
     return Success;
-} static int
- ProcXF86VidModeSwitchToMode(ClientPtr client) {
+}
+
+static int
+ProcXF86VidModeSwitchToMode(ClientPtr client)
+{
     REQUEST(xXF86VidModeSwitchToModeReq);
     xXF86OldVidModeSwitchToModeReq *oldstuff =
         (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
@@ -1045,9 +1075,9 @@ static int
     int len, dotClock;
     int ver;
 
-     DEBUG_P("XF86VidModeSwitchToMode");
+    DEBUG_P("XF86VidModeSwitchToMode");
 
-     ver = ClientMajorVersion(client);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         /* convert from old format */
         stuff = &newstuff;
@@ -1065,7 +1095,8 @@ static int
         stuff->vtotal = oldstuff->vtotal;
         stuff->flags = oldstuff->flags;
         stuff->privsize = oldstuff->privsize;
-    } if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
+    }
+    if (xf86GetVerbosity() > DEFAULT_XF86VIDMODE_VERBOSITY) {
         ErrorF("SwitchToMode - scrn: %d clock: %ld\n",
                (int) stuff->screen, (unsigned long) stuff->dotclock);
         ErrorF("               hdsp: %d hbeg: %d hend: %d httl: %d\n",
@@ -1138,7 +1169,8 @@ static int
 }
 
 static int
- ProcXF86VidModeLockModeSwitch(ClientPtr client) {
+ProcXF86VidModeLockModeSwitch(ClientPtr client)
+{
     REQUEST(xXF86VidModeLockModeSwitchReq);
 
     REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
@@ -1152,53 +1184,57 @@ static int
         return VidModeErrorBase + XF86VidModeZoomLocked;
 
     return Success;
-} static int
- ProcXF86VidModeGetMonitor(ClientPtr client) {
+}
+
+static int
+ProcXF86VidModeGetMonitor(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetMonitorReq);
     xXF86VidModeGetMonitorReply rep;
     CARD32 *hsyncdata, *vsyncdata;
     int i, nHsync, nVrefresh;
     pointer monitor;
 
-     DEBUG_P("XF86VidModeGetMonitor");
+    DEBUG_P("XF86VidModeGetMonitor");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
     if (!VidModeGetMonitor(stuff->screen, &monitor))
-         return BadValue;
+        return BadValue;
 
-     nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
-     nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i;
+    nHsync = VidModeGetMonitorValue(monitor, VIDMODE_MON_NHSYNC, 0).i;
+    nVrefresh = VidModeGetMonitorValue(monitor, VIDMODE_MON_NVREFRESH, 0).i;
 
-     rep.type = X_Reply;
+    rep.type = X_Reply;
     if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VENDOR, 0)).ptr)
-         rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor,
-                                                                    VIDMODE_MON_VENDOR,
-                                                                    0)).ptr);
+        rep.vendorLength = strlen((char *) (VidModeGetMonitorValue(monitor,
+                                                                   VIDMODE_MON_VENDOR,
+                                                                   0)).ptr);
     else
-         rep.vendorLength = 0;
+        rep.vendorLength = 0;
     if ((char *) (VidModeGetMonitorValue(monitor, VIDMODE_MON_MODEL, 0)).ptr)
-         rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor,
-                                                                   VIDMODE_MON_MODEL,
-                                                                   0)).ptr);
+        rep.modelLength = strlen((char *) (VidModeGetMonitorValue(monitor,
+                                                                  VIDMODE_MON_MODEL,
+                                                                  0)).ptr);
     else
-         rep.modelLength = 0;
-     rep.length =
+        rep.modelLength = 0;
+    rep.length =
         bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply) -
                        SIZEOF(xGenericReply) + (nHsync +
                                                 nVrefresh) * sizeof(CARD32) +
                        pad_to_int32(rep.vendorLength) +
                        pad_to_int32(rep.modelLength));
-     rep.sequenceNumber = client->sequence;
-     rep.nhsync = nHsync;
-     rep.nvsync = nVrefresh;
-     hsyncdata = malloc(nHsync * sizeof(CARD32));
+    rep.sequenceNumber = client->sequence;
+    rep.nhsync = nHsync;
+    rep.nvsync = nVrefresh;
+    hsyncdata = malloc(nHsync * sizeof(CARD32));
     if (!hsyncdata) {
         return BadAlloc;
-    } vsyncdata = malloc(nVrefresh * sizeof(CARD32));
+    }
+    vsyncdata = malloc(nVrefresh * sizeof(CARD32));
 
     if (!vsyncdata) {
         free(hsyncdata);
@@ -1208,19 +1244,18 @@ static int
     for (i = 0; i < nHsync; i++) {
         hsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
                                                                 VIDMODE_MON_HSYNC_LO,
-                                                                i)).
-            f | (unsigned
-                 short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI,
-                                                i)).f << 16;
+                                                                i)).f |
+            (unsigned
+             short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_HSYNC_HI,
+                                            i)).f << 16;
     }
     for (i = 0; i < nVrefresh; i++) {
         vsyncdata[i] = (unsigned short) (VidModeGetMonitorValue(monitor,
                                                                 VIDMODE_MON_VREFRESH_LO,
-                                                                i)).
-            f | (unsigned
-                 short) (VidModeGetMonitorValue(monitor,
-                                                VIDMODE_MON_VREFRESH_HI,
-                                                i)).f << 16;
+                                                                i)).f |
+            (unsigned
+             short) (VidModeGetMonitorValue(monitor, VIDMODE_MON_VREFRESH_HI,
+                                            i)).f << 16;
     }
 
     if (client->swapped) {
@@ -1249,38 +1284,40 @@ static int
 }
 
 static int
- ProcXF86VidModeGetViewPort(ClientPtr client) {
+ProcXF86VidModeGetViewPort(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetViewPortReq);
     xXF86VidModeGetViewPortReply rep;
     int x, y;
 
-     DEBUG_P("XF86VidModeGetViewPort");
+    DEBUG_P("XF86VidModeGetViewPort");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     rep.type = X_Reply;
-     rep.length = 0;
-     rep.sequenceNumber = client->sequence;
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
 
-     VidModeGetViewPort(stuff->screen, &x, &y);
-     rep.x = x;
-     rep.y = y;
+    VidModeGetViewPort(stuff->screen, &x, &y);
+    rep.x = x;
+    rep.y = y;
 
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.x);
         swapl(&rep.y);
-    } WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply),
-                    (char *) &rep);
+    }
+    WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply), (char *) &rep);
     return Success;
 }
 
 static int
- ProcXF86VidModeSetViewPort(ClientPtr client) {
+ProcXF86VidModeSetViewPort(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetViewPortReq);
 
     DEBUG_P("XF86VidModeSetViewPort");
@@ -1294,8 +1331,11 @@ static int
         return BadValue;
 
     return Success;
-} static int
- ProcXF86VidModeGetDotClocks(ClientPtr client) {
+}
+
+static int
+ProcXF86VidModeGetDotClocks(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetDotClocksReq);
     xXF86VidModeGetDotClocksReply rep;
     int n;
@@ -1304,31 +1344,33 @@ static int
     int *Clocks = NULL;
     Bool ClockProg;
 
-     DEBUG_P("XF86VidModeGetDotClocks");
+    DEBUG_P("XF86VidModeGetDotClocks");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg);
+    numClocks = VidModeGetNumOfClocks(stuff->screen, &ClockProg);
 
-     rep.type = X_Reply;
-     rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
-                                 - SIZEOF(xGenericReply) + numClocks);
-     rep.sequenceNumber = client->sequence;
-     rep.clocks = numClocks;
-     rep.maxclocks = MAXCLOCKS;
-     rep.flags = 0;
+    rep.type = X_Reply;
+    rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)
+                                - SIZEOF(xGenericReply) + numClocks);
+    rep.sequenceNumber = client->sequence;
+    rep.clocks = numClocks;
+    rep.maxclocks = MAXCLOCKS;
+    rep.flags = 0;
 
     if (!ClockProg) {
         Clocks = malloc(numClocks * sizeof(int));
         if (!Clocks)
-             return BadValue;
+            return BadValue;
         if (!VidModeGetClocks(stuff->screen, Clocks)) {
             free(Clocks);
             return BadValue;
-    }} if (ClockProg) {
+        }
+    }
+    if (ClockProg) {
         rep.flags |= CLKFLAG_PROGRAMABLE;
     }
     if (client->swapped) {
@@ -1356,7 +1398,8 @@ static int
 }
 
 static int
- ProcXF86VidModeSetGamma(ClientPtr client) {
+ProcXF86VidModeSetGamma(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetGammaReq);
 
     DEBUG_P("XF86VidModeSetGamma");
@@ -1372,79 +1415,89 @@ static int
         return BadValue;
 
     return Success;
-} static int
- ProcXF86VidModeGetGamma(ClientPtr client) {
+}
+
+static int
+ProcXF86VidModeGetGamma(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetGammaReq);
     xXF86VidModeGetGammaReply rep;
     float red, green, blue;
 
-     DEBUG_P("XF86VidModeGetGamma");
+    DEBUG_P("XF86VidModeGetGamma");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     rep.type = X_Reply;
-     rep.length = 0;
-     rep.sequenceNumber = client->sequence;
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
     if (!VidModeGetGamma(stuff->screen, &red, &green, &blue))
-         return BadValue;
-     rep.red = (CARD32) (red * 10000.);
-     rep.green = (CARD32) (green * 10000.);
-     rep.blue = (CARD32) (blue * 10000.);
+        return BadValue;
+    rep.red = (CARD32) (red * 10000.);
+    rep.green = (CARD32) (green * 10000.);
+    rep.blue = (CARD32) (blue * 10000.);
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.red);
         swapl(&rep.green);
         swapl(&rep.blue);
-    } WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep);
+    }
+    WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), (char *) &rep);
 
     return Success;
 }
 
 static int
- ProcXF86VidModeSetGammaRamp(ClientPtr client) {
+ProcXF86VidModeSetGammaRamp(ClientPtr client)
+{
     CARD16 *r, *g, *b;
     int length;
-     REQUEST(xXF86VidModeSetGammaRampReq);
+
+    REQUEST(xXF86VidModeSetGammaRampReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
     if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
-         return BadValue;
+        return BadValue;
 
-     length = (stuff->size + 1) & ~1;
+    length = (stuff->size + 1) & ~1;
 
-     REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6);
+    REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6);
 
-     r = (CARD16 *) &stuff[1];
-     g = r + length;
-     b = g + length;
+    r = (CARD16 *) &stuff[1];
+    g = r + length;
+    b = g + length;
 
     if (!VidModeSetGammaRamp(stuff->screen, stuff->size, r, g, b))
-         return BadValue;
+        return BadValue;
 
-     return Success;
-} static int
- ProcXF86VidModeGetGammaRamp(ClientPtr client) {
+    return Success;
+}
+
+static int
+ProcXF86VidModeGetGammaRamp(ClientPtr client)
+{
     CARD16 *ramp = NULL;
     int length;
     size_t ramplen = 0;
     xXF86VidModeGetGammaRampReply rep;
-     REQUEST(xXF86VidModeGetGammaRampReq);
+
+    REQUEST(xXF86VidModeGetGammaRampReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
     if (stuff->size != VidModeGetGammaRampSize(stuff->screen))
-         return BadValue;
+        return BadValue;
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
 
-     length = (stuff->size + 1) & ~1;
+    length = (stuff->size + 1) & ~1;
 
     if (stuff->size) {
         ramplen = length * 3 * sizeof(CARD16);
@@ -1455,7 +1508,9 @@ static int
                                  ramp, ramp + length, ramp + (length * 2))) {
             free(ramp);
             return BadValue;
-    }} rep.type = X_Reply;
+        }
+    }
+    rep.type = X_Reply;
     rep.length = (length >> 1) * 3;
     rep.sequenceNumber = client->sequence;
     rep.size = stuff->size;
@@ -1476,47 +1531,53 @@ static int
 }
 
 static int
- ProcXF86VidModeGetGammaRampSize(ClientPtr client) {
+ProcXF86VidModeGetGammaRampSize(ClientPtr client)
+{
     xXF86VidModeGetGammaRampSizeReply rep;
-     REQUEST(xXF86VidModeGetGammaRampSizeReq);
+
+    REQUEST(xXF86VidModeGetGammaRampSizeReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
 
-     rep.type = X_Reply;
-     rep.length = 0;
-     rep.sequenceNumber = client->sequence;
-     rep.size = VidModeGetGammaRampSize(stuff->screen);
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.size = VidModeGetGammaRampSize(stuff->screen);
     if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swaps(&rep.size);
-    } WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply),
-                    (char *) &rep);
+    }
+    WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply),
+                  (char *) &rep);
 
     return Success;
 }
 
 static int
- ProcXF86VidModeGetPermissions(ClientPtr client) {
+ProcXF86VidModeGetPermissions(ClientPtr client)
+{
     xXF86VidModeGetPermissionsReply rep;
-     REQUEST(xXF86VidModeGetPermissionsReq);
+
+    REQUEST(xXF86VidModeGetPermissionsReq);
 
     if (stuff->screen >= screenInfo.numScreens)
-         return BadValue;
+        return BadValue;
 
-     REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
 
-     rep.type = X_Reply;
-     rep.length = 0;
-     rep.sequenceNumber = client->sequence;
-     rep.permissions = XF86VM_READ_PERMISSION;
+    rep.type = X_Reply;
+    rep.length = 0;
+    rep.sequenceNumber = client->sequence;
+    rep.permissions = XF86VM_READ_PERMISSION;
     if (xf86GetVidModeEnabled() &&
         (xf86GetVidModeAllowNonLocal() || LocalClient(client))) {
         rep.permissions |= XF86VM_WRITE_PERMISSION;
-    } if (client->swapped) {
+    }
+    if (client->swapped) {
         swaps(&rep.sequenceNumber);
         swapl(&rep.length);
         swapl(&rep.permissions);
@@ -1528,21 +1589,23 @@ static int
 }
 
 static int
- ProcXF86VidModeSetClientVersion(ClientPtr client) {
+ProcXF86VidModeSetClientVersion(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetClientVersionReq);
 
     VidModePrivPtr pPriv;
 
-     DEBUG_P("XF86VidModeSetClientVersion");
+    DEBUG_P("XF86VidModeSetClientVersion");
 
-     REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
+    REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
 
     if ((pPriv = VM_GETPRIV(client)) == NULL) {
         pPriv = malloc(sizeof(VidModePrivRec));
         if (!pPriv)
             return BadAlloc;
         VM_SETPRIV(client, pPriv);
-    } pPriv->major = stuff->major;
+    }
+    pPriv->major = stuff->major;
 
     pPriv->minor = stuff->minor;
 
@@ -1550,85 +1613,103 @@ static int
 }
 
 static int
- ProcXF86VidModeDispatch(ClientPtr client) {
+ProcXF86VidModeDispatch(ClientPtr client)
+{
     REQUEST(xReq);
     switch (stuff->data) {
     case X_XF86VidModeQueryVersion:
         return ProcXF86VidModeQueryVersion(client);
-        case X_XF86VidModeGetModeLine:return ProcXF86VidModeGetModeLine(client);
-        case X_XF86VidModeGetMonitor:return ProcXF86VidModeGetMonitor(client);
-        case X_XF86VidModeGetAllModeLines:return
-            ProcXF86VidModeGetAllModeLines(client);
-        case X_XF86VidModeValidateModeLine:return
-            ProcXF86VidModeValidateModeLine(client);
-        case X_XF86VidModeGetViewPort:return ProcXF86VidModeGetViewPort(client);
-        case X_XF86VidModeGetDotClocks:return
-            ProcXF86VidModeGetDotClocks(client);
-        case X_XF86VidModeSetClientVersion:return
-            ProcXF86VidModeSetClientVersion(client);
-        case X_XF86VidModeGetGamma:return ProcXF86VidModeGetGamma(client);
-        case X_XF86VidModeGetGammaRamp:return
-            ProcXF86VidModeGetGammaRamp(client);
-        case X_XF86VidModeGetGammaRampSize:return
-            ProcXF86VidModeGetGammaRampSize(client);
-        case X_XF86VidModeGetPermissions:return
-            ProcXF86VidModeGetPermissions(client);
-        default:if (!xf86GetVidModeEnabled())
+    case X_XF86VidModeGetModeLine:
+        return ProcXF86VidModeGetModeLine(client);
+    case X_XF86VidModeGetMonitor:
+        return ProcXF86VidModeGetMonitor(client);
+    case X_XF86VidModeGetAllModeLines:
+        return ProcXF86VidModeGetAllModeLines(client);
+    case X_XF86VidModeValidateModeLine:
+        return ProcXF86VidModeValidateModeLine(client);
+    case X_XF86VidModeGetViewPort:
+        return ProcXF86VidModeGetViewPort(client);
+    case X_XF86VidModeGetDotClocks:
+        return ProcXF86VidModeGetDotClocks(client);
+    case X_XF86VidModeSetClientVersion:
+        return ProcXF86VidModeSetClientVersion(client);
+    case X_XF86VidModeGetGamma:
+        return ProcXF86VidModeGetGamma(client);
+    case X_XF86VidModeGetGammaRamp:
+        return ProcXF86VidModeGetGammaRamp(client);
+    case X_XF86VidModeGetGammaRampSize:
+        return ProcXF86VidModeGetGammaRampSize(client);
+    case X_XF86VidModeGetPermissions:
+        return ProcXF86VidModeGetPermissions(client);
+    default:
+        if (!xf86GetVidModeEnabled())
             return VidModeErrorBase + XF86VidModeExtensionDisabled;
         if (xf86GetVidModeAllowNonLocal() || LocalClient(client)) {
             switch (stuff->data) {
             case X_XF86VidModeAddModeLine:
                 return ProcXF86VidModeAddModeLine(client);
-                case X_XF86VidModeDeleteModeLine:return
-                    ProcXF86VidModeDeleteModeLine(client);
-                case X_XF86VidModeModModeLine:return
-                    ProcXF86VidModeModModeLine(client);
-                case X_XF86VidModeSwitchMode:return
-                    ProcXF86VidModeSwitchMode(client);
-                case X_XF86VidModeSwitchToMode:return
-                    ProcXF86VidModeSwitchToMode(client);
-                case X_XF86VidModeLockModeSwitch:return
-                    ProcXF86VidModeLockModeSwitch(client);
-                case X_XF86VidModeSetViewPort:return
-                    ProcXF86VidModeSetViewPort(client);
-                case X_XF86VidModeSetGamma:return
-                    ProcXF86VidModeSetGamma(client);
-                case X_XF86VidModeSetGammaRamp:return
-                    ProcXF86VidModeSetGammaRamp(client);
-                default:return BadRequest;
-        }}
+            case X_XF86VidModeDeleteModeLine:
+                return ProcXF86VidModeDeleteModeLine(client);
+            case X_XF86VidModeModModeLine:
+                return ProcXF86VidModeModModeLine(client);
+            case X_XF86VidModeSwitchMode:
+                return ProcXF86VidModeSwitchMode(client);
+            case X_XF86VidModeSwitchToMode:
+                return ProcXF86VidModeSwitchToMode(client);
+            case X_XF86VidModeLockModeSwitch:
+                return ProcXF86VidModeLockModeSwitch(client);
+            case X_XF86VidModeSetViewPort:
+                return ProcXF86VidModeSetViewPort(client);
+            case X_XF86VidModeSetGamma:
+                return ProcXF86VidModeSetGamma(client);
+            case X_XF86VidModeSetGammaRamp:
+                return ProcXF86VidModeSetGammaRamp(client);
+            default:
+                return BadRequest;
+            }
+        }
         else
-             return VidModeErrorBase + XF86VidModeClientNotLocal;
+            return VidModeErrorBase + XF86VidModeClientNotLocal;
     }
 }
 
 static int
- SProcXF86VidModeQueryVersion(ClientPtr client) {
+SProcXF86VidModeQueryVersion(ClientPtr client)
+{
     REQUEST(xXF86VidModeQueryVersionReq);
     swaps(&stuff->length);
     return ProcXF86VidModeQueryVersion(client);
-} static int
- SProcXF86VidModeGetModeLine(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetModeLine(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetModeLineReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetModeLine(client);
-} static int
- SProcXF86VidModeGetAllModeLines(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetAllModeLines(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetAllModeLinesReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetAllModeLines(client);
-} static int
- SProcXF86VidModeAddModeLine(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeAddModeLine(ClientPtr client)
+{
     xXF86OldVidModeAddModeLineReq *oldstuff =
         (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
     int ver;
 
-     REQUEST(xXF86VidModeAddModeLineReq);
-     ver = ClientMajorVersion(client);
+    REQUEST(xXF86VidModeAddModeLineReq);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         swaps(&oldstuff->length);
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq);
@@ -1666,13 +1747,14 @@ static int
 }
 
 static int
- SProcXF86VidModeDeleteModeLine(ClientPtr client) {
+SProcXF86VidModeDeleteModeLine(ClientPtr client)
+{
     xXF86OldVidModeDeleteModeLineReq *oldstuff =
         (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
     int ver;
 
-     REQUEST(xXF86VidModeDeleteModeLineReq);
-     ver = ClientMajorVersion(client);
+    REQUEST(xXF86VidModeDeleteModeLineReq);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         swaps(&oldstuff->length);
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq);
@@ -1710,13 +1792,14 @@ static int
 }
 
 static int
- SProcXF86VidModeModModeLine(ClientPtr client) {
+SProcXF86VidModeModModeLine(ClientPtr client)
+{
     xXF86OldVidModeModModeLineReq *oldstuff =
         (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
     int ver;
 
-     REQUEST(xXF86VidModeModModeLineReq);
-     ver = ClientMajorVersion(client);
+    REQUEST(xXF86VidModeModModeLineReq);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         swaps(&oldstuff->length);
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq);
@@ -1754,13 +1837,14 @@ static int
 }
 
 static int
- SProcXF86VidModeValidateModeLine(ClientPtr client) {
+SProcXF86VidModeValidateModeLine(ClientPtr client)
+{
     xXF86OldVidModeValidateModeLineReq *oldstuff =
         (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
     int ver;
 
-     REQUEST(xXF86VidModeValidateModeLineReq);
-     ver = ClientMajorVersion(client);
+    REQUEST(xXF86VidModeValidateModeLineReq);
+    ver = ClientMajorVersion(client);
     if (ver < 2) {
         swaps(&oldstuff->length);
         REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq);
@@ -1798,44 +1882,60 @@ static int
 }
 
 static int
- SProcXF86VidModeSwitchMode(ClientPtr client) {
+SProcXF86VidModeSwitchMode(ClientPtr client)
+{
     REQUEST(xXF86VidModeSwitchModeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq);
     swaps(&stuff->screen);
     swaps(&stuff->zoom);
     return ProcXF86VidModeSwitchMode(client);
-} static int
- SProcXF86VidModeSwitchToMode(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeSwitchToMode(ClientPtr client)
+{
     REQUEST(xXF86VidModeSwitchToModeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq);
     swapl(&stuff->screen);
     return ProcXF86VidModeSwitchToMode(client);
-} static int
- SProcXF86VidModeLockModeSwitch(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeLockModeSwitch(ClientPtr client)
+{
     REQUEST(xXF86VidModeLockModeSwitchReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq);
     swaps(&stuff->screen);
     swaps(&stuff->lock);
     return ProcXF86VidModeLockModeSwitch(client);
-} static int
- SProcXF86VidModeGetMonitor(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetMonitor(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetMonitorReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetMonitor(client);
-} static int
- SProcXF86VidModeGetViewPort(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetViewPort(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetViewPortReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetViewPort(client);
-} static int
- SProcXF86VidModeSetViewPort(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeSetViewPort(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetViewPortReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq);
@@ -1843,23 +1943,32 @@ static int
     swapl(&stuff->x);
     swapl(&stuff->y);
     return ProcXF86VidModeSetViewPort(client);
-} static int
- SProcXF86VidModeGetDotClocks(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetDotClocks(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetDotClocksReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetDotClocks(client);
-} static int
- SProcXF86VidModeSetClientVersion(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeSetClientVersion(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetClientVersionReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq);
     swaps(&stuff->major);
     swaps(&stuff->minor);
     return ProcXF86VidModeSetClientVersion(client);
-} static int
- SProcXF86VidModeSetGamma(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeSetGamma(ClientPtr client)
+{
     REQUEST(xXF86VidModeSetGammaReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq);
@@ -1868,120 +1977,145 @@ static int
     swapl(&stuff->green);
     swapl(&stuff->blue);
     return ProcXF86VidModeSetGamma(client);
-} static int
- SProcXF86VidModeGetGamma(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetGamma(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetGammaReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetGamma(client);
-} static int
- SProcXF86VidModeSetGammaRamp(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeSetGammaRamp(ClientPtr client)
+{
     int length;
-     REQUEST(xXF86VidModeSetGammaRampReq);
-     swaps(&stuff->length);
-     REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq);
-     swaps(&stuff->size);
-     swaps(&stuff->screen);
-     length = ((stuff->size + 1) & ~1) * 6;
-     REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length);
-     SwapRestS(stuff);
-     return ProcXF86VidModeSetGammaRamp(client);
-} static int
- SProcXF86VidModeGetGammaRamp(ClientPtr client) {
+
+    REQUEST(xXF86VidModeSetGammaRampReq);
+    swaps(&stuff->length);
+    REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq);
+    swaps(&stuff->size);
+    swaps(&stuff->screen);
+    length = ((stuff->size + 1) & ~1) * 6;
+    REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length);
+    SwapRestS(stuff);
+    return ProcXF86VidModeSetGammaRamp(client);
+}
+
+static int
+SProcXF86VidModeGetGammaRamp(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetGammaRampReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq);
     swaps(&stuff->size);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetGammaRamp(client);
-} static int
- SProcXF86VidModeGetGammaRampSize(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetGammaRampSize(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetGammaRampSizeReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetGammaRampSize(client);
-} static int
- SProcXF86VidModeGetPermissions(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeGetPermissions(ClientPtr client)
+{
     REQUEST(xXF86VidModeGetPermissionsReq);
     swaps(&stuff->length);
     REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq);
     swaps(&stuff->screen);
     return ProcXF86VidModeGetPermissions(client);
-} static int
- SProcXF86VidModeDispatch(ClientPtr client) {
+}
+
+static int
+SProcXF86VidModeDispatch(ClientPtr client)
+{
     REQUEST(xReq);
     switch (stuff->data) {
     case X_XF86VidModeQueryVersion:
         return SProcXF86VidModeQueryVersion(client);
-        case X_XF86VidModeGetModeLine:return
-            SProcXF86VidModeGetModeLine(client);
-        case X_XF86VidModeGetMonitor:return SProcXF86VidModeGetMonitor(client);
-        case X_XF86VidModeGetAllModeLines:return
-            SProcXF86VidModeGetAllModeLines(client);
-        case X_XF86VidModeGetViewPort:return
-            SProcXF86VidModeGetViewPort(client);
-        case X_XF86VidModeValidateModeLine:return
-            SProcXF86VidModeValidateModeLine(client);
-        case X_XF86VidModeGetDotClocks:return
-            SProcXF86VidModeGetDotClocks(client);
-        case X_XF86VidModeSetClientVersion:return
-            SProcXF86VidModeSetClientVersion(client);
-        case X_XF86VidModeGetGamma:return SProcXF86VidModeGetGamma(client);
-        case X_XF86VidModeGetGammaRamp:return
-            SProcXF86VidModeGetGammaRamp(client);
-        case X_XF86VidModeGetGammaRampSize:return
-            SProcXF86VidModeGetGammaRampSize(client);
-        case X_XF86VidModeGetPermissions:return
-            SProcXF86VidModeGetPermissions(client);
-        default:if (!xf86GetVidModeEnabled())
+    case X_XF86VidModeGetModeLine:
+        return SProcXF86VidModeGetModeLine(client);
+    case X_XF86VidModeGetMonitor:
+        return SProcXF86VidModeGetMonitor(client);
+    case X_XF86VidModeGetAllModeLines:
+        return SProcXF86VidModeGetAllModeLines(client);
+    case X_XF86VidModeGetViewPort:
+        return SProcXF86VidModeGetViewPort(client);
+    case X_XF86VidModeValidateModeLine:
+        return SProcXF86VidModeValidateModeLine(client);
+    case X_XF86VidModeGetDotClocks:
+        return SProcXF86VidModeGetDotClocks(client);
+    case X_XF86VidModeSetClientVersion:
+        return SProcXF86VidModeSetClientVersion(client);
+    case X_XF86VidModeGetGamma:
+        return SProcXF86VidModeGetGamma(client);
+    case X_XF86VidModeGetGammaRamp:
+        return SProcXF86VidModeGetGammaRamp(client);
+    case X_XF86VidModeGetGammaRampSize:
+        return SProcXF86VidModeGetGammaRampSize(client);
+    case X_XF86VidModeGetPermissions:
+        return SProcXF86VidModeGetPermissions(client);
+    default:
+        if (!xf86GetVidModeEnabled())
             return VidModeErrorBase + XF86VidModeExtensionDisabled;
         if (xf86GetVidModeAllowNonLocal() || LocalClient(client)) {
             switch (stuff->data) {
             case X_XF86VidModeAddModeLine:
                 return SProcXF86VidModeAddModeLine(client);
-                case X_XF86VidModeDeleteModeLine:return
-                    SProcXF86VidModeDeleteModeLine(client);
-                case X_XF86VidModeModModeLine:return
-                    SProcXF86VidModeModModeLine(client);
-                case X_XF86VidModeSwitchMode:return
-                    SProcXF86VidModeSwitchMode(client);
-                case X_XF86VidModeSwitchToMode:return
-                    SProcXF86VidModeSwitchToMode(client);
-                case X_XF86VidModeLockModeSwitch:return
-                    SProcXF86VidModeLockModeSwitch(client);
-                case X_XF86VidModeSetViewPort:return
-                    SProcXF86VidModeSetViewPort(client);
-                case X_XF86VidModeSetGamma:return
-                    SProcXF86VidModeSetGamma(client);
-                case X_XF86VidModeSetGammaRamp:return
-                    SProcXF86VidModeSetGammaRamp(client);
-                default:return BadRequest;
-        }}
+            case X_XF86VidModeDeleteModeLine:
+                return SProcXF86VidModeDeleteModeLine(client);
+            case X_XF86VidModeModModeLine:
+                return SProcXF86VidModeModModeLine(client);
+            case X_XF86VidModeSwitchMode:
+                return SProcXF86VidModeSwitchMode(client);
+            case X_XF86VidModeSwitchToMode:
+                return SProcXF86VidModeSwitchToMode(client);
+            case X_XF86VidModeLockModeSwitch:
+                return SProcXF86VidModeLockModeSwitch(client);
+            case X_XF86VidModeSetViewPort:
+                return SProcXF86VidModeSetViewPort(client);
+            case X_XF86VidModeSetGamma:
+                return SProcXF86VidModeSetGamma(client);
+            case X_XF86VidModeSetGammaRamp:
+                return SProcXF86VidModeSetGammaRamp(client);
+            default:
+                return BadRequest;
+            }
+        }
         else
-             return VidModeErrorBase + XF86VidModeClientNotLocal;
+            return VidModeErrorBase + XF86VidModeClientNotLocal;
     }
 }
 
 void
- XFree86VidModeExtensionInit(void) {
+XFree86VidModeExtensionInit(void)
+{
     ExtensionEntry *extEntry;
     ScreenPtr pScreen;
     int i;
     Bool enabled = FALSE;
 
-     DEBUG_P("XFree86VidModeExtensionInit");
+    DEBUG_P("XFree86VidModeExtensionInit");
 
     if (!dixRegisterPrivateKey(&VidModeClientPrivateKeyRec, PRIVATE_CLIENT, 0))
-         return;
+        return;
 #ifdef XF86VIDMODE_EVENTS
     if (!dixRegisterPrivateKey(&ScreenPrivateKeyRec, PRIVATE_SCREEN, 0))
-         return;
+        return;
 #endif
 
 #ifdef XF86VIDMODE_EVENTS
-     EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent");
+    EventType = CreateNewResourceType(XF86VidModeFreeEvents, "VidModeEvent");
 #endif
 
     for (i = 0; i < screenInfo.numScreens; i++) {
@@ -1990,8 +2124,8 @@ void
             enabled = TRUE;
     }
     /* This means that the DDX doesn't want the vidmode extension enabled */
-        if (!enabled)
-         return;
+    if (!enabled)
+        return;
 
     if (
 #ifdef XF86VIDMODE_EVENTS