Xorg update part1

8 files changed, 1920 insertions, 50 deletions

diff --git a/abs/core/xorg-server/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff b/abs/core/xorg-server/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff
new file mode 100644
index 0000000..12c1101
--- /dev/null
+++ b/abs/core/xorg-server/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff
@@ -0,0 +1,116 @@
+--- xorg-server-1.12.1/exa/exa_glyphs.c	2012-03-30 04:57:25.000000000 +0200
++++ xorg-server-1.12.1/exa_glyphs.c.new	2012-04-15 11:48:51.683214230 +0200
+@@ -686,6 +686,7 @@
+     PixmapPtr pMaskPixmap = 0;
+     PicturePtr pMask = NULL;
+     ScreenPtr pScreen = pDst->pDrawable->pScreen;
++    ExaScreenPriv(pScreen);
+     int width = 0, height = 0;
+     int x, y;
+     int first_xOff = list->xOff, first_yOff = list->yOff;
+@@ -697,7 +698,6 @@
+     ExaGlyphBuffer buffer;
+ 
+     if (maskFormat) {
+-        ExaScreenPriv(pScreen);
+         GCPtr pGC;
+         xRectangle rect;
+ 
+@@ -719,22 +719,20 @@
+                                                 maskFormat->depth,
+                                                 CREATE_PIXMAP_USAGE_SCRATCH);
+         if (!pMaskPixmap)
+-            return;
++	    goto fallback;
+         component_alpha = NeedsComponent(maskFormat->format);
+         pMask = CreatePicture(0, &pMaskPixmap->drawable,
+                               maskFormat, CPComponentAlpha, &component_alpha,
+                               serverClient, &error);
+-        if (!pMask ||
+-            (!component_alpha && pExaScr->info->CheckComposite &&
+-             !(*pExaScr->info->CheckComposite) (PictOpAdd, pSrc, NULL, pMask)))
++        (*pScreen->DestroyPixmap) (pMaskPixmap);
++	if (!pMask)
++	    goto fallback;
++
++	if (!component_alpha && pExaScr->info->CheckComposite &&
++	    !(*pExaScr->info->CheckComposite) (PictOpAdd, pSrc, NULL, pMask))
+         {
+             PictFormatPtr argbFormat;
+ 
+-            (*pScreen->DestroyPixmap) (pMaskPixmap);
+-
+-            if (!pMask)
+-                return;
+-
+             /* The driver can't seem to composite to a8, let's try argb (but
+              * without component-alpha) */
+             FreePicture((pointer) pMask, (XID) 0);
+@@ -748,15 +746,25 @@
+                                                     maskFormat->depth,
+                                                     CREATE_PIXMAP_USAGE_SCRATCH);
+             if (!pMaskPixmap)
+-                return;
++	    goto fallback;
+ 
+             pMask = CreatePicture(0, &pMaskPixmap->drawable, maskFormat, 0, 0,
+                                   serverClient, &error);
+-            if (!pMask) {
+-                (*pScreen->DestroyPixmap) (pMaskPixmap);
+-                return;
+-            }
++            (*pScreen->DestroyPixmap) (pMaskPixmap);
++	    if (!pMask)
++	    goto fallback;
+         }
++	  
++	if (pExaScr->info->CheckComposite &&
++	    (!(*pExaScr->info->CheckComposite) (PictOpAdd, pSrc, NULL, pMask) ||
++	     (!(*pExaScr->info->CheckComposite) (op, pSrc, pMask, pDst) &&
++	      (op != PictOpOver ||
++	       !(*pExaScr->info->CheckComposite) (PictOpOutReverse, pSrc, pMask, pDst) ||
++	       !(*pExaScr->info->CheckComposite) (PictOpOver, pSrc, pMask, pDst))))) {
++	    FreePicture ((pointer) pMask, (XID) 0);
++	    goto fallback;
++	}
++
+         pGC = GetScratchGC(pMaskPixmap->drawable.depth, pScreen);
+         ValidateGC(&pMaskPixmap->drawable, pGC);
+         rect.x = 0;
+@@ -769,6 +777,13 @@
+         y = -extents.y1;
+     }
+     else {
++    	if (pExaScr->info->CheckComposite &&
++	    !(*pExaScr->info->CheckComposite) (op, pSrc, NULL, pDst) &&
++	    (op != PictOpOver ||
++	     !(*pExaScr->info->CheckComposite) (PictOpOutReverse, pSrc, NULL, pDst) ||
++	     !(*pExaScr->info->CheckComposite) (PictOpOver, pSrc, NULL, pDst)))
++	    goto fallback;
++
+         x = 0;
+         y = 0;
+     }
+@@ -834,6 +849,10 @@
+                          xSrc + x - first_xOff,
+                          ySrc + y - first_yOff, 0, 0, x, y, width, height);
+         FreePicture((pointer) pMask, (XID) 0);
+-        (*pScreen->DestroyPixmap) (pMaskPixmap);
+     }
++    
++    return;
++
++fallback:
++    ExaCheckGlyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
+ }
+--- xorg-server-1.12.1/exa/exa_render.c	2012-03-30 04:57:25.000000000 +0200
++++ xorg-server-1.12.1/exa_render.c.new	2012-04-15 11:50:35.272482047 +0200
+@@ -878,7 +878,7 @@
+     Bool saveMaskRepeat = pMask ? pMask->repeat : 0;
+     RegionRec region;
+ 
+-    if (pExaScr->swappedOut)
++    if (pExaScr->fallback_counter || pExaScr->swappedOut)
+         goto fallback;
+ 
+     /* Remove repeat in source if useless */
diff --git a/abs/core/xorg-server/PKGBUILD b/abs/core/xorg-server/PKGBUILD
index 91144d8..747eeca 100644
--- a/abs/core/xorg-server/PKGBUILD
+++ b/abs/core/xorg-server/PKGBUILD
@@ -1,33 +1,51 @@
-# $Id: PKGBUILD 97822 2010-11-01 22:35:02Z jgc $
+# $Id: PKGBUILD 163203 2012-07-09 16:05:50Z andyrtr $
 # Maintainer: Jan de Groot <jgc@archlinux.org>
 
 pkgbase=xorg-server
 pkgname=('xorg-server' 'xorg-server-xephyr' 'xorg-server-xdmx' 'xorg-server-xvfb' 'xorg-server-xnest' 'xorg-server-common' 'xorg-server-devel')
-pkgver=1.9.2
+pkgver=1.12.3
 pkgrel=1
 arch=('i686' 'x86_64')
 license=('custom')
 url="http://xorg.freedesktop.org"
-makedepends=('pixman' 'libx11' 'mesa' 'libgl' 'xf86driproto' 'xcmiscproto' 'xtrans' 'bigreqsproto' 'randrproto' 'inputproto' 'fontsproto' 'videoproto' 'compositeproto' 'recordproto' 'scrnsaverproto' 'resourceproto' 'xineramaproto' 'libxkbfile' 'libxfont' 'renderproto' 'libpciaccess' 'libxv' 'xf86dgaproto' 'libxmu' 'libxrender' 'libxi' 'dmxproto' 'libxaw' 'libdmx' 'libxtst' 'libxres')
+makedepends=('pixman' 'libx11' 'mesa' 'libgl' 'xf86driproto' 'xcmiscproto' 'xtrans' 'bigreqsproto' 'randrproto' 'inputproto' 'fontsproto' 'videoproto'
+             'compositeproto' 'recordproto' 'scrnsaverproto' 'resourceproto' 'xineramaproto' 'libxkbfile' 'libxfont' 'renderproto' 'libpciaccess'
+             'libxv' 'xf86dgaproto' 'libxmu' 'libxrender' 'libxi' 'dmxproto' 'libxaw' 'libdmx' 'libxtst' 'libxres' 'xorg-xkbcomp' 'xorg-util-macros'
+             'xorg-font-util' 'glproto' 'dri2proto' 'udev>=183' 'libgcrypt')
 options=('!libtool')
 source=(${url}/releases/individual/xserver/${pkgbase}-${pkgver}.tar.bz2
-        xorg-redhat-die-ugly-pattern-die-die-die.patch
+        autoconfig-nvidia.patch
+        autoconfig-sis.patch
+        #EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff
+        #git-fixes.patch
         xvfb-run
         xvfb-run.1
-        10-quirks.conf crash.patch)
-md5sums=('5c8773499a6a8c1ddaedf33577ec9634'
-         '1a336eb22e27cbf443ec5a2ecddfa93c'
-         '52fd3effd80d7bc6c1660d4ecf23d31c'
-         '376c70308715cd2643f7bff936d9934b'
-         'd4f7dfc6be4ef4e2c6dd7632a9d88abe')
+        10-quirks.conf)
+sha256sums=('3654b613393734ce0c7c23e81ca4ceb6e8afefb5f0649233ffd105c1220544fe'
+            '66e25f76a7496c429e0aff4b0670f168719bb0ceaeb88c6f2272f2bf3ed21162'
+            'd027776fac1f7675b0a9ee817502290b1c45f9c09b0f0a6bb058c35f92361e84'
+            'ff0156309470fc1d378fd2e104338020a884295e285972cc88e250e031cc35b9'
+            '2460adccd3362fefd4cdc5f1c70f332d7b578091fb9167bf88b5f91265bbd776'
+            '94612f5c0d34a3b7152915c2e285c7b462e9d8e38d3539bd551a339498eac166')
 
 build() {
   cd "${srcdir}/${pkgbase}-${pkgver}"
 
-  # Get rid of the ugly pattern
-  patch -Np3 -i "${srcdir}/xorg-redhat-die-ugly-pattern-die-die-die.patch"
-  patch -Np1 -i "${srcdir}/crash.patch"
+  # Use nouveau/nv/nvidia drivers for nvidia devices
+  patch -Np1 -i "${srcdir}/autoconfig-nvidia.patch"
 
+  # Use unofficial imedia SiS driver for supported SiS devices
+  patch -Np0 -i "${srcdir}/autoconfig-sis.patch"
+
+  # fix glitches and crashes with EXA and cairo 1.12
+  # taken from https://bugs.freedesktop.org/show_bug.cgi?id=47266
+  # and reworked for 1.12.1 changes
+#  patch -Np1 -i ${srcdir}/EXA_Fall_back_earlier_and_more_thoroughly_from_exaGlyphsV2.diff
+
+  # Add post-release patches from 1.12 branch
+#  patch -Np1 -i ${srcdir}/git-fixes.patch
+
+  autoreconf -fi
   ./configure --prefix=/usr \
       --enable-ipv6 \
       --enable-dri \
@@ -40,6 +58,9 @@ build() {
       --enable-xephyr \
       --enable-glx-tls \
       --enable-kdrive \
+      --enable-kdrive-evdev \
+      --enable-kdrive-kbd \
+      --enable-kdrive-mouse \
       --enable-install-setuid \
       --enable-config-udev \
       --disable-config-dbus \
@@ -51,10 +72,10 @@ build() {
       --localstatedir=/var \
       --with-xkb-path=/usr/share/X11/xkb \
       --with-xkb-output=/var/lib/xkb \
-      --with-dri-driver-path=/usr/lib/xorg/modules/dri \
       --with-fontrootdir=/usr/share/fonts
   make
 
+  # Disable subdirs for make install rule to make splitting easier
   sed -e 's/^DMX_SUBDIRS =.*/DMX_SUBDIRS =/' \
       -e 's/^XVFB_SUBDIRS =.*/XVFB_SUBDIRS =/' \
       -e 's/^XNEST_SUBDIRS =.*/XNEST_SUBDIRS = /' \
@@ -64,7 +85,7 @@ build() {
 
 package_xorg-server-common() {
   pkgdesc="Xorg server common files"
-  depends=('xkeyboard-config' 'xorg-xkb-utils' 'xorg-fonts-misc')
+  depends=('xkeyboard-config' 'xorg-xkbcomp' 'xorg-setxkbmap' 'xorg-fonts-misc')
 
   cd "${srcdir}/${pkgbase}-${pkgver}"
   install -m755 -d "${pkgdir}/usr/share/licenses/xorg-server-common"
@@ -73,7 +94,7 @@ package_xorg-server-common() {
   make -C xkb DESTDIR="${pkgdir}" install-data
 
   install -m755 -d "${pkgdir}/usr/share/man/man1"
-  install -m644 doc/Xserver.1 "${pkgdir}/usr/share/man/man1/"
+  install -m644 man/Xserver.1 "${pkgdir}/usr/share/man/man1/"
 
   install -m755 -d "${pkgdir}/usr/lib/xorg"
   install -m644 dix/protocol.txt "${pkgdir}/usr/lib/xorg/"
@@ -85,6 +106,7 @@ package_xorg-server() {
   backup=('etc/X11/xorg.conf.d/10-evdev.conf' 'etc/X11/xorg.conf.d/10-quirks.conf')
   provides=('x-server')
   groups=('xorg')
+  conflicts=('nvidia-utils<=290.10')
 
   cd "${srcdir}/${pkgbase}-${pkgver}"
   make DESTDIR="${pkgdir}" install
@@ -176,9 +198,3 @@ package_xorg-server-devel() {
   install -m755 -d "${pkgdir}/usr/share/licenses/xorg-server-devel"
   ln -sf ../xorg-server-common/COPYING "${pkgdir}/usr/share/licenses/xorg-server-devel/COPYING"
 }
-md5sums=('5c8773499a6a8c1ddaedf33577ec9634'
-         '1a336eb22e27cbf443ec5a2ecddfa93c'
-         '52fd3effd80d7bc6c1660d4ecf23d31c'
-         '376c70308715cd2643f7bff936d9934b'
-         'd4f7dfc6be4ef4e2c6dd7632a9d88abe'
-         'f46bf7abb53b6d80b665c0c14c7346dd')
diff --git a/abs/core/xorg-server/__changelog b/abs/core/xorg-server/__changelog
deleted file mode 100644
index cd15789..0000000
--- a/abs/core/xorg-server/__changelog
+++ /dev/null
@@ -1 +0,0 @@
-add patch to stop xorg from crashing with qt
diff --git a/abs/core/xorg-server/autoconfig-nvidia.patch b/abs/core/xorg-server/autoconfig-nvidia.patch
new file mode 100644
index 0000000..6d5220a
--- /dev/null
+++ b/abs/core/xorg-server/autoconfig-nvidia.patch
@@ -0,0 +1,28 @@
+diff -Nur xorg-server-1.11.99.902.orig/hw/xfree86/common/xf86pciBus.c xorg-server-1.11.99.902/hw/xfree86/common/xf86pciBus.c
+--- xorg-server-1.11.99.902.orig/hw/xfree86/common/xf86pciBus.c	2012-02-10 10:10:37.583014924 +0000
++++ xorg-server-1.11.99.902/hw/xfree86/common/xf86pciBus.c	2012-02-10 11:16:07.148971317 +0000
+@@ -1144,7 +1144,23 @@
+         int idx = 0;
+ 
+ #ifdef __linux__
+-        driverList[idx++] = "nouveau";
++	    switch (dev->device_id)
++		{
++		/* NV1 */
++		case 0x0008:
++		case 0x0009:
++		    driverList[idx++] = "vesa";
++		    break;
++		/* NV3 */
++		case 0x0018:
++		case 0x0019:
++		    driverList[idx++] = "nouveau";
++		    break;
++		default:
++		    driverList[idx++] = "nouveau";
++		    driverList[idx++] = "nvidia";
++		    break;
++		}
+ #endif
+         driverList[idx++] = "nv";
+         break;
diff --git a/abs/core/xorg-server/autoconfig-sis.patch b/abs/core/xorg-server/autoconfig-sis.patch
new file mode 100644
index 0000000..0b50049
--- /dev/null
+++ b/abs/core/xorg-server/autoconfig-sis.patch
@@ -0,0 +1,21 @@
+--- hw/xfree86/common/xf86pciBus.c.orig	2011-09-24 10:53:45.421697668 +0000
++++ hw/xfree86/common/xf86pciBus.c	2011-09-24 10:55:56.416250708 +0000
+@@ -1200,9 +1200,15 @@
+             break;
+         }
+         break;
+-    case 0x1039:
+-        driverList[0] = "sis";
+-        break;
++	case 0x1039:
++	    switch (dev->device_id)
++	    {
++		case 0x6350: case 0x6351:
++		    driverList[0] = "sisimedia"; driverList[1] = "sis"; break;
++		default:
++		    driverList[0] = "sis"; break;
++	    }
++	    break;
+     case 0x126f:
+         driverList[0] = "siliconmotion";
+         break;
diff --git a/abs/core/xorg-server/crash.patch b/abs/core/xorg-server/crash.patch
deleted file mode 100644
index 1e10d1a..0000000
--- a/abs/core/xorg-server/crash.patch
+++ /dev/null
@@ -1,11 +0,0 @@
---- a/Xext/panoramiXprocs.c
-+++ b/Xext/panoramiXprocs.c
-@@ -634,7 +634,7 @@ int PanoramiXTranslateCoords(ClientPtr client)
-     rep.dstX = x - pDst->drawable.x;
-     rep.dstY = y - pDst->drawable.y;
-     if((pDst == screenInfo.screens[0]->root) ||
--       (pWin->drawable.id == screenInfo.screens[0]->screensaver.wid))
-+       (pDst->drawable.id == screenInfo.screens[0]->screensaver.wid))
-     {
- 	rep.dstX += screenInfo.screens[0]->x;
- 	rep.dstY += screenInfo.screens[0]->y;
diff --git a/abs/core/xorg-server/git-fixes.patch b/abs/core/xorg-server/git-fixes.patch
new file mode 100644
index 0000000..f6ca242
--- /dev/null
+++ b/abs/core/xorg-server/git-fixes.patch
@@ -0,0 +1,1717 @@
+From b5bf0ac5405eab77f26bb2f8726644232af17178 Mon Sep 17 00:00:00 2001
+From: Keith Packard <keithp@keithp.com>
+Date: Wed, 11 Apr 2012 16:28:21 +0000
+Subject: hw/xfree86: Spurious ');' in xf86vmode.c messed up indentation badly
+
+Inside the unfinished XF86VIDMODE_EVENTS #ifdef block the
+function definition for xf86VidModeNotifyEvent had an extra ');'
+before the prototype argument declarations. This was harmless for the
+compiler as the code never gets used, but completely messed up the
+file re-indentation. This patch removes the spurious characters in
+preparation for re-indenting the file.
+
+Signed-off-by: Keith Packard <keithp@keithp.com>
+(cherry picked from commit 592bd0ae2b60cd6f6afd3efc40f5f659b12900b4)
+---
+diff --git a/hw/xfree86/dixmods/extmod/xf86vmode.c b/hw/xfree86/dixmods/extmod/xf86vmode.c
+index 6e2a8e9..9f64f8e 100644
+--- a/hw/xfree86/dixmods/extmod/xf86vmode.c
++++ b/hw/xfree86/dixmods/extmod/xf86vmode.c
+@@ -75,7 +75,7 @@ static unsigned char XF86VidModeReqCode = 0;
+ #ifdef XF86VIDMODE_EVENTS
+ static int XF86VidModeEventBase = 0;
+ 
+-static void SXF86VidModeNotifyEvent();
++static void SXF86VidModeNotifyEvent(
+ xXF86VidModeNotifyEvent * /* from */ , xXF86VidModeNotifyEvent *        /* to */
+     );
+ 
+--
+cgit v0.9.0.2-2-gbebe
+From 3ad72a80088fe3236f38bd0696b04f399e24fe3d Mon Sep 17 00:00:00 2001
+From: Keith Packard <keithp@keithp.com>
+Date: Wed, 11 Apr 2012 16:33:54 +0000
+Subject: hw/xfree86: Re-indent xf86vmode.c
+
+This is the result of re-running the 'x-indent.sh' script over
+xf86vmode.c to clean up the disaster caused by broken syntax in the
+file.
+
+Signed-off-by: Keith Packard <keithp@keithp.com>
+(cherry picked from commit 9779b904c7c0b49c74054c22c420012c40595cdc)
+---
+diff --git a/hw/xfree86/dixmods/extmod/xf86vmode.c b/hw/xfree86/dixmods/extmod/xf86vmode.c
+index 9f64f8e..68c4b58 100644
+--- a/hw/xfree86/dixmods/extmod/xf86vmode.c
++++ b/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
+--
+cgit v0.9.0.2-2-gbebe
+From 15607cf2dc87405606b20113011f1ebd97637d32 Mon Sep 17 00:00:00 2001
+From: Daniel Kurtz <djkurtz@chromium.org>
+Date: Thu, 12 Apr 2012 00:11:10 +0000
+Subject: dix: don't BUG_WARN for button events from button-only device
+
+Events from button-only devices still need coordinates, and they get them
+from scale_to_desktop().  Therefore, a dev without valuators is not a bug.
+However, a dev with valuators, but less than two of them still is a bug.
+
+This was noticed when unplugging a "Creative Technology SB Arena Headset",
+which has some BTNs and some KEYs, but no REL or ABS valuators.
+It emits [BTN_3] = 0 on unplug, which would trigger the BUG_WARN.
+
+Signed-off-by: Daniel Kurtz <djkurtz@chromium.org>
+Reviewed-by: Chase Douglas <chase.douglas@canonical.com>
+Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
+(cherry picked from commit c5a45b0f7658c77725adce2b64a0fbd62f208328)
+---
+diff --git a/dix/getevents.c b/dix/getevents.c
+index 4e0af45..9dc9617 100644
+--- a/dix/getevents.c
++++ b/dix/getevents.c
+@@ -842,7 +842,7 @@ scale_to_desktop(DeviceIntPtr dev, ValuatorMask *mask,
+     ScreenPtr scr = miPointerGetScreen(dev);
+     double x, y;
+ 
+-    BUG_WARN(!dev->valuator || dev->valuator->numAxes < 2);
++    BUG_WARN(dev->valuator && dev->valuator->numAxes < 2);
+     if (!dev->valuator || dev->valuator->numAxes < 2) {
+         /* if we have no axes, last.valuators must be in screen coords
+          * anyway */
+--
+cgit v0.9.0.2-2-gbebe
+From f8d2ca759ad37d5e99d462f21a2259ce17bb1a00 Mon Sep 17 00:00:00 2001
+From: Peter Hutterer <peter.hutterer@who-t.net>
+Date: Wed, 18 Apr 2012 05:56:37 +0000
+Subject: dix: indentation fix
+
+Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
+(cherry picked from commit ebf214876a4885a98ded4f5525925b69005fae05)
+---
+diff --git a/dix/dispatch.c b/dix/dispatch.c
+index 9a2e22f..d971805 100644
+--- a/dix/dispatch.c
++++ b/dix/dispatch.c
+@@ -416,8 +416,8 @@ Dispatch(void)
+                 if (XSERVER_REQUEST_START_ENABLED())
+                     XSERVER_REQUEST_START(LookupMajorName(client->majorOp),
+                                           client->majorOp,
+-                                          ((xReq *) client->requestBuffer)->
+-                                          length, client->index,
++                                          ((xReq *) client->requestBuffer)->length,
++                                          client->index,
+                                           client->requestBuffer);
+ #endif
+                 if (result > (maxBigRequestSize << 2))
+--
+cgit v0.9.0.2-2-gbebe
+From f012f0c48dedba4df69cc1a1ecdf8ee5d37daca9 Mon Sep 17 00:00:00 2001
+From: Michal Suchanek <hramrach@gmail.com>
+Date: Thu, 26 Apr 2012 13:11:20 +0000
+Subject: dmx: Annotate dmxlog.c with _X_ATTRIBUTE_PRINTF and _X_NORETURN
+
+and fix resulting printf warning in dmxLogVisual
+
+Signed-off-by: Michal Suchanek <hramrach@gmail.com>
+Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
+Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
+(cherry picked from commit d662fa2450856777b59c4b62b912395a8bfd52fd)
+---
+diff --git a/hw/dmx/dmxlog.c b/hw/dmx/dmxlog.c
+index b56bb93..151f672 100644
+--- a/hw/dmx/dmxlog.c
++++ b/hw/dmx/dmxlog.c
+@@ -86,6 +86,8 @@ ErrorF(const char *format, ...)
+ 
+ /** Provide an VFatalError function when used stand-alone. */
+ static void
++VFatalError(const char *format, va_list args) _X_ATTRIBUTE_PRINTF(1, 0) _X_NORETURN;
++static void
+ VFatalError(const char *format, va_list args)
+ {
+     vfprintf(stderr, format, args);     /* RATS: We assume the format string
+@@ -104,7 +106,9 @@ VErrorF(const char *format, va_list args)
+ }
+ #else
+ /** This function was removed between XFree86 4.3.0 and XFree86 4.4.0. */
+-extern void AbortServer(void);
++extern void AbortServer(void) _X_NORETURN;
++static void
++VFatalError(const char *format, va_list args) _X_ATTRIBUTE_PRINTF(1, 0) _X_NORETURN;
+ static void
+ VFatalError(const char *format, va_list args)
+ {
+@@ -166,6 +170,8 @@ dmxHeader(dmxLogLevel logLevel, DMXInputInfo * dmxInput,
+ /* Prints the error message with the appropriate low-level X output
+  * routine. */
+ static void
++dmxMessage(dmxLogLevel logLevel, const char *format, va_list args) _X_ATTRIBUTE_PRINTF(2, 0);
++static void
+ dmxMessage(dmxLogLevel logLevel, const char *format, va_list args)
+ {
+     if (logLevel == dmxFatal || logLevel >= dmxCurrentLogLevel) {
+@@ -303,10 +309,11 @@ dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi, int defaultVisual)
+         class = "DirectColor";
+         break;
+     }
++#define VisualLogFormat "0x%02lx %s %2db %db/rgb %3d 0x%04lx 0x%04lx 0x%04lx%s\n"
+ 
+     if (dmxScreen) {
+         dmxLogOutput(dmxScreen,
+-                     "0x%02x %s %2db %db/rgb %3d 0x%04x 0x%04x 0x%04x%s\n",
++                     VisualLogFormat,
+                      vi->visualid, class, vi->depth, vi->bits_per_rgb,
+                      vi->colormap_size,
+                      vi->red_mask, vi->green_mask, vi->blue_mask,
+@@ -314,7 +321,7 @@ dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi, int defaultVisual)
+     }
+     else {
+         dmxLog(dmxInfo,
+-               "  0x%02x %s %2db %db/rgb %3d 0x%04x 0x%04x 0x%04x%s\n",
++               "  " VisualLogFormat,
+                vi->visualid, class, vi->depth, vi->bits_per_rgb,
+                vi->colormap_size,
+                vi->red_mask, vi->green_mask, vi->blue_mask,
+diff --git a/hw/dmx/dmxlog.h b/hw/dmx/dmxlog.h
+index 4d4cd26..162484b 100644
+--- a/hw/dmx/dmxlog.h
++++ b/hw/dmx/dmxlog.h
+@@ -55,18 +55,23 @@ typedef enum {
+ /* Logging functions used by Xserver/hw/dmx routines. */
+ extern dmxLogLevel dmxSetLogLevel(dmxLogLevel newLevel);
+ extern dmxLogLevel dmxGetLogLevel(void);
+-extern void dmxLog(dmxLogLevel logLevel, const char *format, ...);
+-extern void dmxLogCont(dmxLogLevel logLevel, const char *format, ...);
++extern void dmxLog(dmxLogLevel logLevel, const char *format,
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
++extern void dmxLogCont(dmxLogLevel logLevel, const char *format,
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
+ extern const char *dmxEventName(int type);
+ 
+ #ifndef DMX_LOG_STANDALONE
+-extern void dmxLogOutput(DMXScreenInfo * dmxScreen, const char *format, ...);
++extern void dmxLogOutput(DMXScreenInfo * dmxScreen, const char *format,
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
+ extern void dmxLogOutputCont(DMXScreenInfo * dmxScreen, const char *format,
+-                             ...);
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
+ extern void dmxLogOutputWarning(DMXScreenInfo * dmxScreen, const char *format,
+-                                ...);
+-extern void dmxLogInput(DMXInputInfo * dmxInput, const char *format, ...);
+-extern void dmxLogInputCont(DMXInputInfo * dmxInput, const char *format, ...);
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
++extern void dmxLogInput(DMXInputInfo * dmxInput, const char *format,
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
++extern void dmxLogInputCont(DMXInputInfo * dmxInput, const char *format,
++                             ...) _X_ATTRIBUTE_PRINTF(2, 3);
+ extern void dmxLogArgs(dmxLogLevel logLevel, int argc, char **argv);
+ extern void dmxLogVisual(DMXScreenInfo * dmxScreen, XVisualInfo * vi,
+                          int defaultVisual);
+--
+cgit v0.9.0.2-2-gbebe
+From 58dfb13953af71021317b9d85230b1163198f031 Mon Sep 17 00:00:00 2001
+From: Jeremy Huddleston <jeremyhu@apple.com>
+Date: Thu, 10 May 2012 07:53:20 +0000
+Subject: Revert "dix: when disabling a device, release all buttons and keys"
+
+This reverts commit 90299556db24543bb7365e8c2897deca3aa219e7.
+
+The commit being reverted triggered a segfault on server shutdown when a
+device posts raw events after the root windows are forced to NULL.
+
+https://lists.debian.org/debian-x/2012/05/msg00240.html
+
+Signed-off-by: Jeremy Huddleston <jeremyhu@apple.com>
+---
+diff --git a/dix/devices.c b/dix/devices.c
+index d0e99bd..0125504 100644
+--- a/dix/devices.c
++++ b/dix/devices.c
+@@ -432,8 +432,6 @@ DisableDevice(DeviceIntPtr dev, BOOL sendevent)
+     if (*prev != dev)
+         return FALSE;
+ 
+-    ReleaseButtonsAndKeys(dev);
+-
+     /* float attached devices */
+     if (IsMaster(dev)) {
+         for (other = inputInfo.devices; other; other = other->next) {
+--
+cgit v0.9.0.2-2-gbebe
diff --git a/abs/core/xorg-server/xorg-redhat-die-ugly-pattern-die-die-die.patch b/abs/core/xorg-server/xorg-redhat-die-ugly-pattern-die-die-die.patch
deleted file mode 100644
index 4e782f1..0000000
--- a/abs/core/xorg-server/xorg-redhat-die-ugly-pattern-die-die-die.patch
+++ /dev/null
@@ -1,16 +0,0 @@
-Remove the default root window grey stipple pattern, replacing it with
-blackness.
-
---- xc/programs/Xserver/dix/window.c.die-ugly-pattern-die-die-die	Tue Feb 12 16:33:04 2002
-+++ xc/programs/Xserver/dix/window.c	Tue Feb 12 16:45:32 2002
-@@ -119,8 +119,8 @@
-  *
-  ******/
- 
--static unsigned char _back_lsb[4] = {0x88, 0x22, 0x44, 0x11};
--static unsigned char _back_msb[4] = {0x11, 0x44, 0x22, 0x88};
-+static unsigned char _back_lsb[4] = {0x00, 0x00, 0x00, 0x00};
-+static unsigned char _back_msb[4] = {0x00, 0x00, 0x00, 0x00};
- 
- int screenIsSaved = SCREEN_SAVER_OFF;
-