133 files changed, 8196 insertions, 8733 deletions
diff --git a/xorg-server/Xext/panoramiX.c b/xorg-server/Xext/panoramiX.c
index be7e03100..4b82200ec 100644
--- a/xorg-server/Xext/panoramiX.c
+++ b/xorg-server/Xext/panoramiX.c
@@ -54,6 +54,7 @@ Equipment Corporation.
 #include "resource.h"
 #include "picturestr.h"
 #include "xfixesint.h"
+#include "damageextint.h"
 #ifdef COMPOSITE
 #include "compint.h"
 #endif
@@ -73,7 +74,7 @@ int PanoramiXPixWidth = 0;
 int PanoramiXPixHeight = 0;
 int PanoramiXNumScreens = 0;
 
-static RegionRec PanoramiXScreenRegion = { {0, 0, 0, 0}, NULL };
+_X_EXPORT RegionRec PanoramiXScreenRegion = { {0, 0, 0, 0}, NULL };
 
 static int PanoramiXNumDepths;
 static DepthPtr PanoramiXDepths;
@@ -582,6 +583,7 @@ PanoramiXExtensionInit(void)
 
     PanoramiXRenderInit();
     PanoramiXFixesInit();
+    PanoramiXDamageInit();
 #ifdef COMPOSITE
     PanoramiXCompositeInit();
 #endif
@@ -887,6 +889,7 @@ PanoramiXResetProc(ExtensionEntry * extEntry)
 
     PanoramiXRenderReset();
     PanoramiXFixesReset();
+    PanoramiXDamageReset();
 #ifdef COMPOSITE
     PanoramiXCompositeReset ();
 #endif
diff --git a/xorg-server/Xext/panoramiXsrv.h b/xorg-server/Xext/panoramiXsrv.h
index 7c605fe66..0fcde4fd5 100644
--- a/xorg-server/Xext/panoramiXsrv.h
+++ b/xorg-server/Xext/panoramiXsrv.h
@@ -11,6 +11,7 @@
 extern _X_EXPORT int PanoramiXNumScreens;
 extern _X_EXPORT int PanoramiXPixWidth;
 extern _X_EXPORT int PanoramiXPixHeight;
+extern _X_EXPORT RegionRec PanoramiXScreenRegion;
 
 extern _X_EXPORT VisualID PanoramiXTranslateVisualID(int screen, VisualID orig);
 extern _X_EXPORT void PanoramiXConsolidate(void);
diff --git a/xorg-server/Xext/shm.c b/xorg-server/Xext/shm.c
index 227fe8c4f..2cf720ed7 100644
--- a/xorg-server/Xext/shm.c
+++ b/xorg-server/Xext/shm.c
@@ -39,6 +39,7 @@ in this Software without prior written authorization from The Open Group.
 #endif
 #include <unistd.h>
 #include <sys/stat.h>
+#include <fcntl.h>
 #include <X11/X.h>
 #include <X11/Xproto.h>
 #include "misc.h"
@@ -1196,6 +1197,35 @@ ProcShmAttachFd(ClientPtr client)
 }
 
 static int
+shm_tmpfile(void)
+{
+#ifdef SHMDIR
+	int	fd;
+	int	flags;
+	char	template[] = SHMDIR "/shmfd-XXXXXX";
+#ifdef O_TMPFILE
+	fd = open(SHMDIR, O_TMPFILE|O_RDWR|O_CLOEXEC|O_EXCL, 0666);
+	if (fd >= 0) {
+		ErrorF ("Using O_TMPFILE\n");
+		return fd;
+	}
+	ErrorF ("Not using O_TMPFILE\n");
+#endif
+	fd = mkstemp(template);
+	if (fd < 0)
+		return -1;
+	unlink(template);
+	if (fcntl(fd, F_GETFD, &flags) >= 0) {
+		flags |= FD_CLOEXEC;
+		(void) fcntl(fd, F_SETFD, &flags);
+	}
+	return fd;
+#else
+        return -1;
+#endif
+}
+
+static int
 ProcShmCreateSegment(ClientPtr client)
 {
     int fd;
@@ -1207,17 +1237,15 @@ ProcShmCreateSegment(ClientPtr client)
         .sequenceNumber = client->sequence,
         .length = 0,
     };
-    char template[] = "/tmp/shm-XXXXXX";
 
     REQUEST_SIZE_MATCH(xShmCreateSegmentReq);
     if ((stuff->readOnly != xTrue) && (stuff->readOnly != xFalse)) {
         client->errorValue = stuff->readOnly;
         return BadValue;
     }
-    fd = mkstemp(template);
+    fd = shm_tmpfile();
     if (fd < 0)
         return BadAlloc;
-    unlink(template);
     if (ftruncate(fd, stuff->size) < 0) {
         close(fd);
         return BadAlloc;
diff --git a/xorg-server/Xi/exevents.c b/xorg-server/Xi/exevents.c
index d3c7fc54d..4e180d755 100644
--- a/xorg-server/Xi/exevents.c
+++ b/xorg-server/Xi/exevents.c
@@ -1415,7 +1415,8 @@ DeliverTouchEmulatedEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
                 !(ev->device_event.flags & TOUCH_CLIENT_ID))
                 TouchListenerAcceptReject(dev, ti, 0, XIAcceptTouch);
 
-            if (deliveries && ev->any.type == ET_TouchEnd &&
+            if (ev->any.type == ET_TouchEnd &&
+                ti->num_listeners == 1 &&
                 !dev->button->buttonsDown &&
                 dev->deviceGrab.fromPassiveGrab && GrabIsPointerGrab(grab)) {
                 (*dev->deviceGrab.DeactivateGrab) (dev);
@@ -1849,7 +1850,8 @@ DeliverTouchBeginEvent(DeviceIntPtr dev, TouchPointInfoPtr ti,
         if (rc == Success) {
             listener->state = LISTENER_IS_OWNER;
             /* async grabs cannot replay, so automatically accept this touch */
-            if (dev->deviceGrab.grab &&
+            if (listener->type == LISTENER_POINTER_GRAB &&
+                dev->deviceGrab.grab &&
                 dev->deviceGrab.fromPassiveGrab &&
                 dev->deviceGrab.grab->pointerMode == GrabModeAsync)
                 ActivateEarlyAccept(dev, ti);
diff --git a/xorg-server/composite/compinit.c b/xorg-server/composite/compinit.c
index bc1130e78..3c910914e 100644
--- a/xorg-server/composite/compinit.c
+++ b/xorg-server/composite/compinit.c
@@ -117,11 +117,11 @@ compChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
 
     if (ret && (mask & CWBackingStore) &&
         pScreen->backingStoreSupport != NotUseful) {
-        if (pWin->backingStore != NotUseful) {
+        if (pWin->backingStore != NotUseful && !pWin->backStorage) {
             compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic);
             pWin->backStorage = (pointer) (intptr_t) 1;
         }
-        else {
+        else if (pWin->backingStore == NotUseful && pWin->backStorage) {
             compUnredirectWindow(serverClient, pWin,
                                  CompositeRedirectAutomatic);
             pWin->backStorage = NULL;
@@ -355,6 +355,9 @@ compScreenInit(ScreenPtr pScreen)
         return FALSE;
     }
 
+    if (!disableBackingStore)
+        pScreen->backingStoreSupport = WhenMapped;
+
     cs->PositionWindow = pScreen->PositionWindow;
     pScreen->PositionWindow = compPositionWindow;
 
diff --git a/xorg-server/composite/compoverlay.c b/xorg-server/composite/compoverlay.c
index 3eafc2031..ae3dcb61d 100644
--- a/xorg-server/composite/compoverlay.c
+++ b/xorg-server/composite/compoverlay.c
@@ -137,16 +137,19 @@ compCreateOverlayWindow(ScreenPtr pScreen)
     int result;
     int w = pScreen->width;
     int h = pScreen->height;
+    int x = 0, y = 0;
 
 #ifdef PANORAMIX
     if (!noPanoramiXExtension) {
+        x = -pScreen->x;
+        y = -pScreen->y;
         w = PanoramiXPixWidth;
         h = PanoramiXPixHeight;
     }
 #endif
 
     pWin = cs->pOverlayWin =
-        CreateWindow(cs->overlayWid, pRoot, 0, 0, w, h, 0,
+        CreateWindow(cs->overlayWid, pRoot, x, y, w, h, 0,
                      InputOutput, CWBackPixmap | CWOverrideRedirect, &attrs[0],
                      pRoot->drawable.depth,
                      serverClient, pScreen->rootVisual, &result);
diff --git a/xorg-server/configure.ac b/xorg-server/configure.ac
index 6197e9bed..7ec19976b 100644
--- a/xorg-server/configure.ac
+++ b/xorg-server/configure.ac
@@ -26,9 +26,9 @@ dnl
 dnl Process this file with autoconf to create configure.
 
 AC_PREREQ(2.60)
-AC_INIT([xorg-server], 1.14.99.903, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
-RELEASE_DATE="2013-11-23"
-RELEASE_NAME="Apple Pie"
+AC_INIT([xorg-server], 1.14.99.905, [https://bugs.freedesktop.org/enter_bug.cgi?product=xorg], xorg-server)
+RELEASE_DATE="2013-12-19"
+RELEASE_NAME="Kraken"
 AC_CONFIG_SRCDIR([Makefile.am])
 AM_INIT_AUTOMAKE([foreign dist-bzip2])
 AC_USE_SYSTEM_EXTENSIONS
@@ -782,12 +782,12 @@ DRI3PROTO="dri3proto >= 1.0"
 XINERAMAPROTO="xineramaproto"
 BIGFONTPROTO="xf86bigfontproto >= 1.2.0"
 DGAPROTO="xf86dgaproto >= 2.0.99.1"
-GLPROTO="glproto >= 1.4.16"
+GLPROTO="glproto >= 1.4.17"
 DMXPROTO="dmxproto >= 2.2.99.1"
 VIDMODEPROTO="xf86vidmodeproto >= 2.2.99.1"
 WINDOWSWMPROTO="windowswmproto"
 APPLEWMPROTO="applewmproto >= 1.4"
-XSHMFENCE="xshmfence"
+XSHMFENCE="xshmfence >= 1.1"
 
 dnl Required modules
 XPROTO="xproto >= 7.0.22"
@@ -1086,6 +1086,49 @@ case "$DRI2,$HAVE_DRI2PROTO" in
 esac
 AM_CONDITIONAL(DRI2, test "x$DRI2" = xyes)
 
+dnl
+dnl Locate a suitable tmp file system for creating shared memeory files
+dnl
+
+AC_ARG_WITH(shared-memory-dir, AS_HELP_STRING([--with-shared-memory-dir=PATH], [Path to directory in a world-writable temporary directory for anonymous shared memory (default: auto)]),
+[],
+[with_shared_memory_dir=yes])
+
+shmdirs="/run/shm /var/tmp /tmp"
+
+case x"$with_shared_memory_dir" in
+xyes)
+	for dir in $shmdirs; do
+		case x"$with_shared_memory_dir" in
+		xyes)
+			echo Checking temp dir "$dir"
+			if test -d "$dir"; then
+				with_shared_memory_dir="$dir"
+			fi
+			;;
+		esac
+	done
+	;;
+x/*)
+	;;
+xno)
+	;;
+*)
+	AC_MSG_ERROR([Invalid directory specified for --with-shared-memory-dir: $with_shared_memory_dir])
+	;;
+esac
+
+case x"$with_shared_memory_dir" in
+xyes)
+	AC_MSG_ERROR([No directory found for shared memory temp files.])
+	;;
+xno)
+	;;
+*)
+	AC_DEFINE_UNQUOTED(SHMDIR, ["$with_shared_memory_dir"], [Directory for shared memory temp files])
+	;;
+esac
+
 AC_ARG_ENABLE(xtrans-send-fds,	AS_HELP_STRING([--disable-xtrans-send-fds], [Use Xtrans support for fd passing (default: auto)]), [XTRANS_SEND_FDS=$enableval], [XTRANS_SEND_FDS=auto])
 
 case "x$XTRANS_SEND_FDS" in
@@ -1175,7 +1218,7 @@ case "$DRI3,$HAVE_XSHMFENCE" in
 	yes,yes | auto,yes)
 		;;
 	yes,no)
-		AC_MSG_ERROR("DRI3 requested, but xshmfence not found.])
+		AC_MSG_ERROR([DRI3 requested, but xshmfence not found.])
 		DRI3=no
 		;;
 	no,*)
@@ -1830,7 +1873,7 @@ if test "x$XORG" = xyes; then
 		if test "x$CONFIG_UDEV_KMS" = xyes; then
 			AC_MSG_ERROR([Platform device enumeration requires libpciaccess])
 		fi
-		if test "x$INT10" != xstub; then
+		if test "x$INT10MODULE" = xyes && test "x$INT10" != xstub; then
 			AC_MSG_ERROR([Cannot build int10 without libpciaccess])
 		fi
 	fi
@@ -2065,8 +2108,8 @@ if test "x$XWIN" = xyes; then
 			;;
 	esac
 
-	XWIN_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $RANDR_LIB $RENDER_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $DAMAGE_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $OS_LIB"
-	XWIN_SYS_LIBS="$XWIN_SYS_LIBS $XWINMODULES_LIBS $GLX_SYS_LIBS"
+	XWIN_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $RANDR_LIB $RENDER_LIB $DBE_LIB $RECORD_LIB $GLX_LIBS $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $DAMAGE_LIB $PRESENT_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $OS_LIB"
+	XWIN_SYS_LIBS="$XWIN_SYS_LIBS $XWINMODULES_LIBS"
 	AC_SUBST(XWIN_LIBS)
 	AC_SUBST(XWIN_SERVER_NAME)
 	AC_SUBST(XWIN_SYS_LIBS)
@@ -2082,10 +2125,16 @@ if test "x$XWIN" = xyes; then
 
 dnl XWin with AIGLX requires OpenGL spec files in order to generate wrapper code for native GL functions
 	if [test "x$XWIN" = xyes && test "x$AIGLX" = xyes] ; then
-           AC_CHECK_PROG(PYTHON, python, python)
-           if test -z "$PYTHON"; then
-                AC_MSG_ERROR([python not found])
+           AC_CHECK_PROG(PYTHON3, python3, python3)
+           if test -z "$PYTHON3"; then
+                AC_MSG_ERROR([python3 not found])
+           fi
+           AC_MSG_CHECKING(for python module lxml)
+           $PYTHON3 -c "import lxml;"
+           if test $? -ne 0 ; then
+                AC_MSG_ERROR([not found])
            fi
+           AC_MSG_RESULT(yes)
            if test "x$KHRONOS_SPEC_DIR" = "xauto" ; then
 		PKG_CHECK_MODULES([KHRONOS_OPENGL_REGISTRY], [khronos-opengl-registry])
 		KHRONOS_SPEC_DIR=`pkg-config khronos-opengl-registry --variable=specdir`
@@ -2109,7 +2158,7 @@ if test "x$XQUARTZ" = xyes; then
 	AC_DEFINE(XQUARTZ,1,[Have Quartz])
 	AC_DEFINE(ROOTLESS,1,[Build Rootless code])
 
-	XQUARTZ_LIBS="$FB_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $XPSTUBS_LIB"
+	XQUARTZ_LIBS="$FB_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $RECORD_LIB $RANDR_LIB $RENDER_LIB $DAMAGE_LIB $MIEXT_SYNC_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $XPSTUBS_LIB $PRESENT_LIB"
 	AC_SUBST([XQUARTZ_LIBS])
 
 	AC_CHECK_LIB([Xplugin],[xp_init],[:])
diff --git a/xorg-server/damageext/damageext.c b/xorg-server/damageext/damageext.c
index 481f778bb..8e6d97b9e 100644
--- a/xorg-server/damageext/damageext.c
+++ b/xorg-server/damageext/damageext.c
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2002 Keith Packard
+ * Copyright 2013 Red Hat, Inc.
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
@@ -25,9 +26,24 @@
 #endif
 
 #include "damageextint.h"
+#include "damagestr.h"
 #include "protocol-versions.h"
 #include "extinit.h"
 
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+
+typedef struct {
+    DamageExtPtr ext;
+    DamagePtr damage[MAXSCREENS];
+} PanoramiXDamageRes;
+
+static RESTYPE XRT_DAMAGE;
+static int (*PanoramiXSaveDamageCreate) (ClientPtr);
+
+#endif
+
 static unsigned char DamageReqCode;
 static int DamageEventBase;
 static RESTYPE DamageExtType;
@@ -37,24 +53,62 @@ static DevPrivateKeyRec DamageClientPrivateKeyRec;
 #define DamageClientPrivateKey (&DamageClientPrivateKeyRec)
 
 static void
+DamageNoteCritical(ClientPtr pClient)
+{
+    DamageClientPtr pDamageClient = GetDamageClient(pClient);
+
+    /* Composite extension marks clients with manual Subwindows as critical */
+    if (pDamageClient->critical > 0) {
+        SetCriticalOutputPending();
+        pClient->smart_priority = SMART_MAX_PRIORITY;
+    }
+}
+
+static void
+damageGetGeometry(DrawablePtr draw, int *x, int *y, int *w, int *h)
+{
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension && draw->type == DRAWABLE_WINDOW) {
+        WindowPtr win = (WindowPtr)draw;
+
+        if (!win->parent) {
+            *x = screenInfo.x;
+            *y = screenInfo.y;
+            *w = screenInfo.width;
+            *h = screenInfo.height;
+            return;
+        }
+    }
+#endif
+
+    *x = draw->x;
+    *y = draw->y;
+    *w = draw->width;
+    *h = draw->height;
+}
+
+static void
 DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
 {
     ClientPtr pClient = pDamageExt->pClient;
-    DamageClientPtr pDamageClient = GetDamageClient(pClient);
     DrawablePtr pDrawable = pDamageExt->pDrawable;
     xDamageNotifyEvent ev;
-    int i;
+    int i, x, y, w, h;
+
+    damageGetGeometry(pDrawable, &x, &y, &w, &h);
 
     UpdateCurrentTimeIf();
+
     ev.type = DamageEventBase + XDamageNotify;
     ev.level = pDamageExt->level;
     ev.drawable = pDamageExt->drawable;
     ev.damage = pDamageExt->id;
     ev.timestamp = currentTime.milliseconds;
-    ev.geometry.x = pDrawable->x;
-    ev.geometry.y = pDrawable->y;
-    ev.geometry.width = pDrawable->width;
-    ev.geometry.height = pDrawable->height;
+    ev.geometry.x = x;
+    ev.geometry.y = y;
+    ev.geometry.width = w;
+    ev.geometry.height = h;
+
     if (pBoxes) {
         for (i = 0; i < nBoxes; i++) {
             ev.level = pDamageExt->level;
@@ -70,15 +124,12 @@ DamageExtNotify(DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
     else {
         ev.area.x = 0;
         ev.area.y = 0;
-        ev.area.width = pDrawable->width;
-        ev.area.height = pDrawable->height;
+        ev.area.width = w;
+        ev.area.height = h;
         WriteEventsToClient(pClient, 1, (xEvent *) &ev);
     }
-    /* Composite extension marks clients with manual Subwindows as critical */
-    if (pDamageClient->critical > 0) {
-        SetCriticalOutputPending();
-        pClient->smart_priority = SMART_MAX_PRIORITY;
-    }
+
+    DamageNoteCritical(pClient);
 }
 
 static void
@@ -158,23 +209,62 @@ ProcDamageQueryVersion(ClientPtr client)
     return Success;
 }
 
-static int
-ProcDamageCreate(ClientPtr client)
+static void
+DamageExtRegister(DrawablePtr pDrawable, DamagePtr pDamage, Bool report)
+{
+    DamageSetReportAfterOp(pDamage, TRUE);
+    DamageRegister(pDrawable, pDamage);
+
+    if (report) {
+        RegionPtr pRegion = &((WindowPtr) pDrawable)->borderClip;
+        RegionTranslate(pRegion, -pDrawable->x, -pDrawable->y);
+        DamageReportDamage(pDamage, pRegion);
+        RegionTranslate(pRegion, pDrawable->x, pDrawable->y);
+    }
+}
+
+static DamageExtPtr
+DamageExtCreate(DrawablePtr pDrawable, DamageReportLevel level,
+                ClientPtr client, XID id, XID drawable)
+{
+    DamageExtPtr pDamageExt = malloc(sizeof(DamageExtRec));
+    if (!pDamageExt)
+        return NULL;
+
+    pDamageExt->id = id;
+    pDamageExt->drawable = drawable;
+    pDamageExt->pDrawable = pDrawable;
+    pDamageExt->level = level;
+    pDamageExt->pClient = client;
+    pDamageExt->pDamage = DamageCreate(DamageExtReport, DamageExtDestroy, level,
+                                       FALSE, pDrawable->pScreen, pDamageExt);
+    if (!pDamageExt->pDamage) {
+        free(pDamageExt);
+        return NULL;
+    }
+
+    if (!AddResource(id, DamageExtType, (pointer) pDamageExt))
+        return NULL;
+
+    DamageExtRegister(pDrawable, pDamageExt->pDamage,
+                      pDrawable->type == DRAWABLE_WINDOW);
+
+    return pDamageExt;
+}
+
+static DamageExtPtr
+doDamageCreate(ClientPtr client, int *rc)
 {
     DrawablePtr pDrawable;
     DamageExtPtr pDamageExt;
     DamageReportLevel level;
-    RegionPtr pRegion;
-    int rc;
 
     REQUEST(xDamageCreateReq);
 
-    REQUEST_SIZE_MATCH(xDamageCreateReq);
-    LEGAL_NEW_RESOURCE(stuff->damage, client);
-    rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
-                           DixGetAttrAccess | DixReadAccess);
-    if (rc != Success)
-        return rc;
+    *rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
+                            DixGetAttrAccess | DixReadAccess);
+    if (*rc != Success)
+        return NULL;
 
     switch (stuff->level) {
     case XDamageReportRawRectangles:
@@ -191,39 +281,27 @@ ProcDamageCreate(ClientPtr client)
         break;
     default:
         client->errorValue = stuff->level;
-        return BadValue;
+        *rc = BadValue;
+        return NULL;
     }
 
-    pDamageExt = malloc(sizeof(DamageExtRec));
+    pDamageExt = DamageExtCreate(pDrawable, level, client, stuff->damage,
+                                 stuff->drawable);
     if (!pDamageExt)
-        return BadAlloc;
-    pDamageExt->id = stuff->damage;
-    pDamageExt->drawable = stuff->drawable;
-    pDamageExt->pDrawable = pDrawable;
-    pDamageExt->level = level;
-    pDamageExt->pClient = client;
-    pDamageExt->pDamage = DamageCreate(DamageExtReport,
-                                       DamageExtDestroy,
-                                       level,
-                                       FALSE, pDrawable->pScreen, pDamageExt);
-    if (!pDamageExt->pDamage) {
-        free(pDamageExt);
-        return BadAlloc;
-    }
-    if (!AddResource(stuff->damage, DamageExtType, (pointer) pDamageExt))
-        return BadAlloc;
+        *rc = BadAlloc;
 
-    DamageSetReportAfterOp(pDamageExt->pDamage, TRUE);
-    DamageRegister(pDamageExt->pDrawable, pDamageExt->pDamage);
-
-    if (pDrawable->type == DRAWABLE_WINDOW) {
-        pRegion = &((WindowPtr) pDrawable)->borderClip;
-        RegionTranslate(pRegion, -pDrawable->x, -pDrawable->y);
-        DamageReportDamage(pDamageExt->pDamage, pRegion);
-        RegionTranslate(pRegion, pDrawable->x, pDrawable->y);
-    }
+    return pDamageExt;
+}
 
-    return Success;
+static int
+ProcDamageCreate(ClientPtr client)
+{
+    int rc;
+    REQUEST(xDamageCreateReq);
+    REQUEST_SIZE_MATCH(xDamageCreateReq);
+    LEGAL_NEW_RESOURCE(stuff->damage, client);
+    doDamageCreate(client, &rc);
+    return rc;
 }
 
 static int
@@ -238,6 +316,88 @@ ProcDamageDestroy(ClientPtr client)
     return Success;
 }
 
+#ifdef PANORAMIX
+static RegionPtr
+DamageExtSubtractWindowClip(DamageExtPtr pDamageExt)
+{
+    WindowPtr win = (WindowPtr)pDamageExt->pDrawable;
+    PanoramiXRes *res = NULL;
+    RegionPtr ret;
+    int i;
+
+    if (!win->parent)
+        return &PanoramiXScreenRegion;
+
+    dixLookupResourceByType((void **)&res, win->drawable.id, XRT_WINDOW,
+                            serverClient, DixReadAccess);
+    if (!res)
+        return NULL;
+
+    ret = RegionCreate(NULL, 0);
+    if (!ret)
+        return NULL;
+
+    FOR_NSCREENS_FORWARD(i) {
+        ScreenPtr screen;
+        if (Success != dixLookupWindow(&win, res->info[i].id, serverClient,
+                                       DixReadAccess))
+            goto out;
+
+        screen = win->drawable.pScreen;
+
+        RegionTranslate(ret, -screen->x, -screen->y);
+        if (!RegionUnion(ret, ret, &win->borderClip))
+            goto out;
+        RegionTranslate(ret, screen->x, screen->y);
+    }
+
+    return ret;
+
+out:
+    RegionDestroy(ret);
+    return NULL;
+}
+
+static void
+DamageExtFreeWindowClip(RegionPtr reg)
+{
+    if (reg != &PanoramiXScreenRegion)
+        RegionDestroy(reg);
+}
+#endif
+
+/*
+ * DamageSubtract intersects with borderClip, so we must reconstruct the
+ * protocol's perspective of same...
+ */
+static Bool
+DamageExtSubtract(DamageExtPtr pDamageExt, const RegionPtr pRegion)
+{
+    DamagePtr pDamage = pDamageExt->pDamage;
+
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension) {
+        RegionPtr damage = DamageRegion(pDamage);
+        RegionSubtract(damage, damage, pRegion);
+
+        if (pDamageExt->pDrawable->type == DRAWABLE_WINDOW) {
+            DrawablePtr pDraw = pDamageExt->pDrawable;
+            RegionPtr clip = DamageExtSubtractWindowClip(pDamageExt);
+            if (clip) {
+                RegionTranslate(clip, -pDraw->x, -pDraw->y);
+                RegionIntersect(damage, damage, clip);
+                RegionTranslate(clip, pDraw->x, pDraw->y);
+                DamageExtFreeWindowClip(clip);
+            }
+        }
+
+        return RegionNotEmpty(damage);
+    }
+#endif
+
+    return DamageSubtract(pDamage, pRegion);
+}
+
 static int
 ProcDamageSubtract(ClientPtr client)
 {
@@ -257,7 +417,7 @@ ProcDamageSubtract(ClientPtr client)
         if (pRepair) {
             if (pParts)
                 RegionIntersect(pParts, DamageRegion(pDamage), pRepair);
-            if (DamageSubtract(pDamage, pRepair))
+            if (DamageExtSubtract(pDamageExt, pRepair))
                 DamageExtReport(pDamage, DamageRegion(pDamage),
                                 (void *) pDamageExt);
         }
@@ -267,6 +427,7 @@ ProcDamageSubtract(ClientPtr client)
             DamageEmpty(pDamage);
         }
     }
+
     return Success;
 }
 
@@ -456,6 +617,127 @@ SDamageNotifyEvent(xDamageNotifyEvent * from, xDamageNotifyEvent * to)
     cpswaps(from->geometry.height, to->geometry.height);
 }
 
+#ifdef PANORAMIX
+
+static void
+PanoramiXDamageReport(DamagePtr pDamage, RegionPtr pRegion, void *closure)
+{
+    PanoramiXDamageRes *res = closure;
+    DamageExtPtr pDamageExt = res->ext;
+    WindowPtr pWin = (WindowPtr)pDamage->pDrawable;
+    ScreenPtr pScreen = pDamage->pScreen;
+
+    /* happens on unmap? sigh xinerama */
+    if (RegionNil(pRegion))
+        return;
+
+    /* translate root windows if necessary */
+    if (!pWin->parent)
+        RegionTranslate(pRegion, pScreen->x, pScreen->y);
+
+    /* add our damage to the protocol view */
+    DamageReportDamage(pDamageExt->pDamage, pRegion);
+
+    /* empty our view */
+    DamageEmpty(pDamage);
+}
+
+static void
+PanoramiXDamageExtDestroy(DamagePtr pDamage, void *closure)
+{
+    PanoramiXDamageRes *damage = closure;
+    damage->damage[pDamage->pScreen->myNum] = NULL;
+}
+
+static int
+PanoramiXDamageCreate(ClientPtr client)
+{
+    PanoramiXDamageRes *damage;
+    PanoramiXRes *draw;
+    int i, rc;
+
+    REQUEST(xDamageCreateReq);
+
+    REQUEST_SIZE_MATCH(xDamageCreateReq);
+    LEGAL_NEW_RESOURCE(stuff->damage, client);
+    rc = dixLookupResourceByClass((void **)&draw, stuff->drawable, XRC_DRAWABLE,
+                                  client, DixGetAttrAccess | DixReadAccess);
+    if (rc != Success)
+        return rc;
+
+    if (!(damage = calloc(1, sizeof(PanoramiXDamageRes))))
+        return BadAlloc;
+
+    if (!AddResource(stuff->damage, XRT_DAMAGE, damage))
+        return BadAlloc;
+
+    damage->ext = doDamageCreate(client, &rc);
+    if (rc == Success && draw->type == XRT_WINDOW) {
+        FOR_NSCREENS_FORWARD(i) {
+            DrawablePtr pDrawable;
+            DamagePtr pDamage = DamageCreate(PanoramiXDamageReport,
+                                             PanoramiXDamageExtDestroy,
+                                             DamageReportRawRegion,
+                                             FALSE,
+                                             screenInfo.screens[i],
+                                             damage);
+            if (!pDamage) {
+                rc = BadAlloc;
+            } else {
+                damage->damage[i] = pDamage;
+                rc = dixLookupDrawable(&pDrawable, draw->info[i].id, client,
+                                       M_WINDOW,
+                                       DixGetAttrAccess | DixReadAccess);
+            }
+            if (rc != Success)
+                break;
+
+            DamageExtRegister(pDrawable, pDamage, i != 0);
+        }
+    }
+
+    if (rc != Success)
+        FreeResource(stuff->damage, RT_NONE);
+
+    return rc;
+}
+
+static int
+PanoramiXDamageDelete(void *res, XID id)
+{
+    int i;
+    PanoramiXDamageRes *damage = res;
+
+    FOR_NSCREENS_BACKWARD(i) {
+        if (damage->damage[i]) {
+            DamageDestroy(damage->damage[i]);
+            damage->damage[i] = NULL;
+        }
+    }
+
+    free(damage);
+    return 1;
+}
+
+void
+PanoramiXDamageInit(void)
+{
+    XRT_DAMAGE = CreateNewResourceType(PanoramiXDamageDelete, "XineramaDamage");
+    if (!XRT_DAMAGE)
+        FatalError("Couldn't Xineramify Damage extension\n");
+
+    PanoramiXSaveDamageCreate = ProcDamageVector[X_DamageCreate];
+    ProcDamageVector[X_DamageCreate] = PanoramiXDamageCreate;
+}
+
+void
+PanoramiXDamageReset(void)
+{
+    ProcDamageVector[X_DamageCreate] = PanoramiXSaveDamageCreate;
+}
+
+#endif /* PANORAMIX */
+
 void
 DamageExtensionInit(void)
 {
@@ -486,5 +768,10 @@ DamageExtensionInit(void)
             (EventSwapPtr) SDamageNotifyEvent;
         SetResourceTypeErrorValue(DamageExtType,
                                   extEntry->errorBase + BadDamage);
+#ifdef PANORAMIX
+        if (XRT_DAMAGE)
+            SetResourceTypeErrorValue(XRT_DAMAGE,
+                                      extEntry->errorBase + BadDamage);
+#endif
     }
 }
diff --git a/xorg-server/damageext/damageextint.h b/xorg-server/damageext/damageextint.h
index 272337922..e50149501 100644
--- a/xorg-server/damageext/damageextint.h
+++ b/xorg-server/damageext/damageextint.h
@@ -67,4 +67,7 @@ typedef struct _DamageExt {
 void
  DamageExtSetCritical(ClientPtr pClient, Bool critical);
 
+void PanoramiXDamageInit(void);
+void PanoramiXDamageReset(void);
+
 #endif                          /* _DAMAGEEXTINT_H_ */
diff --git a/xorg-server/dix/dispatch.c b/xorg-server/dix/dispatch.c
index b2ca29f10..a034a7bc5 100644
--- a/xorg-server/dix/dispatch.c
+++ b/xorg-server/dix/dispatch.c
@@ -224,8 +224,9 @@ UpdateCurrentTimeIf(void)
 
 #undef SMART_DEBUG
 
-#define SMART_SCHEDULE_DEFAULT_INTERVAL	20      /* ms */
-#define SMART_SCHEDULE_MAX_SLICE	200     /* ms */
+/* in milliseconds */
+#define SMART_SCHEDULE_DEFAULT_INTERVAL	5
+#define SMART_SCHEDULE_MAX_SLICE	15
 
 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(_MSC_VER)
 Bool SmartScheduleDisable = TRUE;
diff --git a/xorg-server/dix/events.c b/xorg-server/dix/events.c
index f61c7c7eb..291eec5ed 100644
--- a/xorg-server/dix/events.c
+++ b/xorg-server/dix/events.c
@@ -4702,7 +4702,7 @@ DeviceEnterLeaveEvent(DeviceIntPtr mouse,
 
     filter = GetEventFilter(mouse, (xEvent *) event);
 
-    if (grab && grab->type == XI2) {
+    if (grab && grab->grabtype == XI2) {
         Mask mask;
 
         mask = xi2mask_isset(grab->xi2mask, mouse, type);
diff --git a/xorg-server/dix/window.c b/xorg-server/dix/window.c
index 112417ebf..4a455c9c7 100644
--- a/xorg-server/dix/window.c
+++ b/xorg-server/dix/window.c
@@ -530,7 +530,11 @@ CreateRootWindow(ScreenPtr pScreen)
     if (disableBackingStore)
         pScreen->backingStoreSupport = NotUseful;
     if (enableBackingStore)
-        pScreen->backingStoreSupport = Always;
+        pScreen->backingStoreSupport = WhenMapped;
+#ifdef COMPOSITE
+    if (noCompositeExtension)
+        pScreen->backingStoreSupport = NotUseful;
+#endif
 
     pScreen->saveUnderSupport = NotUseful;
 
diff --git a/xorg-server/dri3/dri3.c b/xorg-server/dri3/dri3.c
index 2bca7ae9b..76e07b40e 100644
--- a/xorg-server/dri3/dri3.c
+++ b/xorg-server/dri3/dri3.c
@@ -68,6 +68,11 @@ dri3_extension_init(void)
     ExtensionEntry *extension;
     int i;
 
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension)
+        return;
+#endif
+
     extension = AddExtension(DRI3_NAME, DRI3NumberEvents, DRI3NumberErrors,
                              proc_dri3_dispatch, sproc_dri3_dispatch,
                              NULL, StandardMinorOpcode);
diff --git a/xorg-server/dri3/dri3_request.c b/xorg-server/dri3/dri3_request.c
index 3ebb9d509..4e1408fb5 100644
--- a/xorg-server/dri3/dri3_request.c
+++ b/xorg-server/dri3/dri3_request.c
@@ -29,6 +29,7 @@
 #include <unistd.h>
 #include <xace.h>
 #include "../Xext/syncsdk.h"
+#include <protocol-versions.h>
 
 static int
 proc_dri3_query_version(ClientPtr client)
@@ -38,8 +39,8 @@ proc_dri3_query_version(ClientPtr client)
         .type = X_Reply,
         .sequenceNumber = client->sequence,
         .length = 0,
-        .majorVersion = DRI3_MAJOR,
-        .minorVersion = DRI3_MINOR
+        .majorVersion = SERVER_DRI3_MAJOR_VERSION,
+        .minorVersion = SERVER_DRI3_MINOR_VERSION
     };
 
     REQUEST_SIZE_MATCH(xDRI3QueryVersionReq);
diff --git a/xorg-server/dri3/dri3_screen.c b/xorg-server/dri3/dri3_screen.c
index cf2735b8d..c88029612 100644
--- a/xorg-server/dri3/dri3_screen.c
+++ b/xorg-server/dri3/dri3_screen.c
@@ -55,6 +55,9 @@ dri3_pixmap_from_fd(PixmapPtr *ppixmap, ScreenPtr screen, int fd,
     dri3_screen_info_ptr        info = ds->info;
     PixmapPtr                   pixmap;
 
+    if (!info || !info->pixmap_from_fd)
+        return BadImplementation;
+
     pixmap = (*info->pixmap_from_fd) (screen, fd, width, height, stride, depth, bpp);
     if (!pixmap)
         return BadAlloc;
@@ -71,6 +74,9 @@ dri3_fd_from_pixmap(int *pfd, PixmapPtr pixmap, CARD16 *stride, CARD32 *size)
     dri3_screen_info_ptr        info = ds->info;
     int                         fd;
 
+    if (!info || !info->fd_from_pixmap)
+        return BadImplementation;
+
     fd = (*info->fd_from_pixmap)(screen, pixmap, stride, size);
     if (fd < 0)
         return BadAlloc;
diff --git a/xorg-server/glx/Makefile.am b/xorg-server/glx/Makefile.am
index 5f28e87da..54e81406d 100644
--- a/xorg-server/glx/Makefile.am
+++ b/xorg-server/glx/Makefile.am
@@ -20,7 +20,8 @@ AM_CPPFLAGS = \
 	-I$(top_srcdir)/hw/xfree86/os-support/bus \
 	-I$(top_srcdir)/hw/xfree86/common \
 	-I$(top_srcdir)/hw/xfree86/dri \
-	-I$(top_srcdir)/mi
+	-I$(top_srcdir)/mi \
+	-I$(top_srcdir)/present
 
 if DRI2_AIGLX
 AM_CPPFLAGS += -I$(top_srcdir)/hw/xfree86/dri2
@@ -69,7 +70,6 @@ libglx_la_SOURCES = \
         glxscreens.c \
         glxscreens.h \
         glxserver.h \
-        glxstubs.c \
         glxutil.h \
         render2.c \
         render2swap.c \
diff --git a/xorg-server/glx/glxcmds.c b/xorg-server/glx/glxcmds.c
index fc2bb35bd..34343bde6 100644
--- a/xorg-server/glx/glxcmds.c
+++ b/xorg-server/glx/glxcmds.c
@@ -2471,3 +2471,64 @@ __glXDisp_ClientInfo(__GLXclientState * cl, GLbyte * pc)
 
     return Success;
 }
+
+#include <GL/glxtokens.h>
+
+void
+__glXsendSwapEvent(__GLXdrawable *drawable, int type, CARD64 ust,
+                   CARD64 msc, CARD32 sbc)
+{
+    ClientPtr client = clients[CLIENT_ID(drawable->drawId)];
+
+    xGLXBufferSwapComplete2 wire =  {
+        .type = __glXEventBase + GLX_BufferSwapComplete
+    };
+
+    if (!client)
+        return;
+
+    if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
+        return;
+
+    wire.event_type = type;
+    wire.drawable = drawable->drawId;
+    wire.ust_hi = ust >> 32;
+    wire.ust_lo = ust & 0xffffffff;
+    wire.msc_hi = msc >> 32;
+    wire.msc_lo = msc & 0xffffffff;
+    wire.sbc = sbc;
+
+    WriteEventsToClient(client, 1, (xEvent *) &wire);
+}
+
+#if PRESENT
+static void
+__glXpresentCompleteNotify(WindowPtr window, CARD8 present_mode, CARD32 serial,
+                           uint64_t ust, uint64_t msc)
+{
+    __GLXdrawable *drawable;
+    int glx_type;
+    int rc;
+
+    rc = dixLookupResourceByType((pointer *) &drawable, window->drawable.id,
+                                 __glXDrawableRes, serverClient, DixGetAttrAccess);
+
+    if (rc != Success)
+        return;
+
+    if (present_mode == PresentCompleteModeFlip)
+        glx_type = GLX_FLIP_COMPLETE_INTEL;
+    else
+        glx_type = GLX_BLIT_COMPLETE_INTEL;
+        
+    __glXsendSwapEvent(drawable, glx_type, ust, msc, serial);
+}
+
+#include <present.h>
+
+void
+__glXregisterPresentCompleteNotify(void)
+{
+    present_register_complete_notify(__glXpresentCompleteNotify);
+}
+#endif
diff --git a/xorg-server/glx/glxdri2.c b/xorg-server/glx/glxdri2.c
index fbbd1fd95..b2f3d6ee8 100644
--- a/xorg-server/glx/glxdri2.c
+++ b/xorg-server/glx/glxdri2.c
@@ -55,7 +55,6 @@ typedef struct __GLXDRIscreen __GLXDRIscreen;
 typedef struct __GLXDRIcontext __GLXDRIcontext;
 typedef struct __GLXDRIdrawable __GLXDRIdrawable;
 
-
 #ifdef __DRI2_ROBUSTNESS
 #define ALL_DRI_CTX_FLAGS (__DRI_CTX_FLAG_DEBUG                         \
                            | __DRI_CTX_FLAG_FORWARD_COMPATIBLE          \
@@ -177,36 +176,25 @@ __glXdriSwapEvent(ClientPtr client, void *data, int type, CARD64 ust,
                   CARD64 msc, CARD32 sbc)
 {
     __GLXdrawable *drawable = data;
-    xGLXBufferSwapComplete2 wire =  {
-        .type = __glXEventBase + GLX_BufferSwapComplete
-    };
-
-    if (!(drawable->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
-        return;
-
+    int glx_type;
     switch (type) {
     case DRI2_EXCHANGE_COMPLETE:
-        wire.event_type = GLX_EXCHANGE_COMPLETE_INTEL;
+        glx_type = GLX_EXCHANGE_COMPLETE_INTEL;
         break;
+    default:
+        /* unknown swap completion type,
+         * BLIT is a reasonable default, so
+         * fall through ...
+         */
     case DRI2_BLIT_COMPLETE:
-        wire.event_type = GLX_BLIT_COMPLETE_INTEL;
+        glx_type = GLX_BLIT_COMPLETE_INTEL;
         break;
     case DRI2_FLIP_COMPLETE:
-        wire.event_type = GLX_FLIP_COMPLETE_INTEL;
-        break;
-    default:
-        /* unknown swap completion type */
-        wire.event_type = 0;
+        glx_type = GLX_FLIP_COMPLETE_INTEL;
         break;
     }
-    wire.drawable = drawable->drawId;
-    wire.ust_hi = ust >> 32;
-    wire.ust_lo = ust & 0xffffffff;
-    wire.msc_hi = msc >> 32;
-    wire.msc_lo = msc & 0xffffffff;
-    wire.sbc = sbc;
-
-    WriteEventsToClient(client, 1, (xEvent *) &wire);
+    
+    __glXsendSwapEvent(drawable, glx_type, ust, msc, sbc);
 }
 
 /*
@@ -784,7 +772,7 @@ dri2FlushFrontBuffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 }
 
 static const __DRIdri2LoaderExtension loaderExtension = {
-    {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
+    {__DRI_DRI2_LOADER, 3},
     dri2GetBuffers,
     dri2FlushFrontBuffer,
     dri2GetBuffersWithFormat,
@@ -792,7 +780,7 @@ static const __DRIdri2LoaderExtension loaderExtension = {
 
 #ifdef __DRI_USE_INVALIDATE
 static const __DRIuseInvalidateExtension dri2UseInvalidate = {
-    {__DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION}
+    {__DRI_USE_INVALIDATE, 1}
 };
 #endif
 
@@ -940,6 +928,9 @@ initializeExtensions(__GLXDRIscreen * screen)
     }
 }
 
+/* white lie */
+extern glx_func_ptr glXGetProcAddressARB(const char *);
+
 static __GLXscreen *
 __glXDRIscreenProbe(ScreenPtr pScreen)
 {
@@ -1024,6 +1015,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     screen->leaveVT = pScrn->LeaveVT;
     pScrn->LeaveVT = glxDRILeaveVT;
 
+    __glXsetGetProcAddress(glXGetProcAddressARB);
+
     LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;
diff --git a/xorg-server/glx/glxdricommon.c b/xorg-server/glx/glxdricommon.c
index 426ea6acc..d83ebb445 100644
--- a/xorg-server/glx/glxdricommon.c
+++ b/xorg-server/glx/glxdricommon.c
@@ -72,7 +72,7 @@ getUST(int64_t * ust)
 }
 
 const __DRIsystemTimeExtension systemTimeExtension = {
-    {__DRI_SYSTEM_TIME, __DRI_SYSTEM_TIME_VERSION},
+    {__DRI_SYSTEM_TIME, 1},
     getUST,
     NULL,
 };
diff --git a/xorg-server/glx/glxdriswrast.c b/xorg-server/glx/glxdriswrast.c
index 0523710fb..23989be89 100644
--- a/xorg-server/glx/glxdriswrast.c
+++ b/xorg-server/glx/glxdriswrast.c
@@ -391,7 +391,7 @@ swrastGetImage(__DRIdrawable * draw,
 }
 
 static const __DRIswrastLoaderExtension swrastLoaderExtension = {
-    {__DRI_SWRAST_LOADER, __DRI_SWRAST_LOADER_VERSION},
+    {__DRI_SWRAST_LOADER, 1},
     swrastGetDrawableInfo,
     swrastPutImage,
     swrastGetImage
@@ -432,6 +432,9 @@ initializeExtensions(__GLXDRIscreen * screen)
 
 extern Bool g_fswrastwgl;
 
+/* white lie */
+extern glx_func_ptr glXGetProcAddressARB(const char *);
+
 static __GLXscreen *
 __glXDRIscreenProbe(ScreenPtr pScreen)
 {
@@ -455,9 +458,9 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
 
     screen->driver = glxProbeDriver(driverName,
                                     (void **) &screen->core,
-                                    __DRI_CORE, __DRI_CORE_VERSION,
+                                    __DRI_CORE, 1,
                                     (void **) &screen->swrast,
-                                    __DRI_SWRAST, __DRI_SWRAST_VERSION);
+                                    __DRI_SWRAST, 1);
     if (screen->driver == NULL) {
         goto handle_error;
     }
@@ -484,6 +487,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
     screen->base.GLXmajor = 1;
     screen->base.GLXminor = 4;
 
+    __glXsetGetProcAddress(glXGetProcAddressARB);
+
     LogMessage(X_INFO, "AIGLX: Loaded and initialized %s\n", driverName);
 
     return &screen->base;
diff --git a/xorg-server/glx/glxext.c b/xorg-server/glx/glxext.c
index ee0487e92..d6ca8f886 100644
--- a/xorg-server/glx/glxext.c
+++ b/xorg-server/glx/glxext.c
@@ -404,6 +404,9 @@ GlxExtensionInit(void)
 
     __glXErrorBase = extEntry->errorBase;
     __glXEventBase = extEntry->eventBase;
+#if PRESENT
+    __glXregisterPresentCompleteNotify();
+#endif
 }
 
 /************************************************************************/
@@ -546,17 +549,19 @@ __glXleaveServer(GLboolean rendering)
     glxServerLeaveCount++;
 }
 
-static void (*(*_get_proc_address)(const char *))(void);
+static glx_gpa_proc _get_proc_address;
 
 void
-__glXsetGetProcAddress(void (*(*get_proc_address) (const char *))(void))
+__glXsetGetProcAddress(glx_gpa_proc get_proc_address)
 {
     _get_proc_address = get_proc_address;
 }
 
 void *__glGetProcAddress(const char *proc)
 {
-    return _get_proc_address(proc);
+    void *ret = _get_proc_address(proc);
+
+    return ret ? ret : NoopDDA;
 }
 
 /*
diff --git a/xorg-server/glx/glxserver.h b/xorg-server/glx/glxserver.h
index 5e29abb28..7f36e5f5e 100644
--- a/xorg-server/glx/glxserver.h
+++ b/xorg-server/glx/glxserver.h
@@ -117,9 +117,20 @@ void __glXleaveServer(GLboolean rendering);
 void glxSuspendClients(void);
 void glxResumeClients(void);
 
-void __glXsetGetProcAddress(void (*(*get_proc_address) (const char *)) (void));
+typedef void (*glx_func_ptr)(void);
+typedef glx_func_ptr (*glx_gpa_proc)(const char *);
+void __glXsetGetProcAddress(glx_gpa_proc get_proc_address);
 void *__glGetProcAddress(const char *);
 
+void
+__glXsendSwapEvent(__GLXdrawable *drawable, int type, CARD64 ust,
+                   CARD64 msc, CARD32 sbc);
+
+#if PRESENT
+void
+__glXregisterPresentCompleteNotify(void);
+#endif
+
 /*
 ** State kept per client.
 */
diff --git a/xorg-server/glx/glxstubs.c b/xorg-server/glx/glxstubs.c
deleted file mode 100644
index 69bc00480..000000000
--- a/xorg-server/glx/glxstubs.c
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright © 2013 Red Hat, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *	Adam Jackson <ajax@redhat.com>
- */
-
-/*
- * Redirection stubs for things that we call by name but that aren't exported
- * from libGL by name.  Strictly speaking this list should be a lot longer,
- * but this is enough to get us linking against contemporary Mesa.
- */
-
-#include <inttypes.h>
-#include "glxserver.h"
-
-#define thunk(name, type, call_args, ...) \
-    _X_HIDDEN void name(__VA_ARGS__) { \
-	static type proc; \
-	if (!proc) proc = __glGetProcAddress(#name); \
-	proc call_args; \
-    }
-
-thunk(glSampleMaskSGIS, PFNGLSAMPLEMASKSGISPROC,
-      (value, invert), GLclampf value, GLboolean invert)
-
-thunk(glSamplePatternSGIS, PFNGLSAMPLEPATTERNSGISPROC,
-      (pattern), GLenum pattern)
-
-thunk(glActiveStencilFaceEXT, PFNGLACTIVESTENCILFACEEXTPROC,
-      (face), GLenum face)
diff --git a/xorg-server/glx/indirect_dispatch.c b/xorg-server/glx/indirect_dispatch.c
index 921c68c9c..f81477458 100644
--- a/xorg-server/glx/indirect_dispatch.c
+++ b/xorg-server/glx/indirect_dispatch.c
@@ -52,94 +52,89 @@ typedef struct {
     __GLX_PIXEL_3D_HDR;
 } __GLXpixel3DHeader;
 
-extern GLboolean __glXErrorOccured( void );
-extern void __glXClearErrorOccured( void );
+extern GLboolean __glXErrorOccured(void);
+extern void __glXClearErrorOccured(void);
 
-static const unsigned dummy_answer[2] = {0, 0};
+static const unsigned dummy_answer[2] = { 0, 0 };
 
-int __glXDisp_NewList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_NewList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_NewList( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            *(GLenum   *)(pc +  4)
-        ) );
+    if (cx != NULL) {
+        glNewList(*(GLuint *) (pc + 0), *(GLenum *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_EndList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_EndList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_EndList( GET_DISPATCH(), () );
+    if (cx != NULL) {
+        glEndList();
         error = Success;
     }
 
     return error;
 }
 
-void __glXDisp_CallList(GLbyte * pc)
+void
+__glXDisp_CallList(GLbyte * pc)
 {
-    CALL_CallList( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glCallList(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_CallLists(GLbyte * pc)
+void
+__glXDisp_CallLists(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  0);
-    const GLenum type = *(GLenum   *)(pc +  4);
-    const GLvoid * lists =  (const GLvoid *)(pc +  8);
+    const GLsizei n = *(GLsizei *) (pc + 0);
+    const GLenum type = *(GLenum *) (pc + 4);
+    const GLvoid *lists = (const GLvoid *) (pc + 8);
 
-    CALL_CallLists( GET_DISPATCH(), (
-        n,
-        type,
-        lists
-    ) );
+    lists = (const GLvoid *) (pc + 8);
+
+    glCallLists(n, type, lists);
 }
 
-int __glXDisp_DeleteLists(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_DeleteLists(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_DeleteLists( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            *(GLsizei  *)(pc +  4)
-        ) );
+    if (cx != NULL) {
+        glDeleteLists(*(GLuint *) (pc + 0), *(GLsizei *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenLists(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLuint retval;
-        retval = CALL_GenLists( GET_DISPATCH(), (
-            *(GLsizei  *)(pc +  0)
-        ) );
+
+        retval = glGenLists(*(GLsizei *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -147,1648 +142,1399 @@ int __glXDisp_GenLists(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_ListBase(GLbyte * pc)
+void
+__glXDisp_ListBase(GLbyte * pc)
 {
-    CALL_ListBase( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glListBase(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_Begin(GLbyte * pc)
+void
+__glXDisp_Begin(GLbyte * pc)
 {
-    CALL_Begin( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glBegin(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_Bitmap(GLbyte * pc)
+void
+__glXDisp_Bitmap(GLbyte * pc)
 {
-    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_Bitmap( GET_DISPATCH(), (
-        *(GLsizei  *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLfloat  *)(pc + 28),
-        *(GLfloat  *)(pc + 32),
-        *(GLfloat  *)(pc + 36),
-        *(GLfloat  *)(pc + 40),
-        bitmap
-    ) );
+    glBitmap(*(GLsizei *) (pc + 20),
+             *(GLsizei *) (pc + 24),
+             *(GLfloat *) (pc + 28),
+             *(GLfloat *) (pc + 32),
+             *(GLfloat *) (pc + 36), *(GLfloat *) (pc + 40), bitmap);
 }
 
-void __glXDisp_Color3bv(GLbyte * pc)
+void
+__glXDisp_Color3bv(GLbyte * pc)
 {
-    CALL_Color3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glColor3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDisp_Color3dv(GLbyte * pc)
+void
+__glXDisp_Color3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Color3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glColor3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Color3fv(GLbyte * pc)
+void
+__glXDisp_Color3fv(GLbyte * pc)
 {
-    CALL_Color3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glColor3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Color3iv(GLbyte * pc)
+void
+__glXDisp_Color3iv(GLbyte * pc)
 {
-    CALL_Color3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glColor3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Color3sv(GLbyte * pc)
+void
+__glXDisp_Color3sv(GLbyte * pc)
 {
-    CALL_Color3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glColor3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Color3ubv(GLbyte * pc)
+void
+__glXDisp_Color3ubv(GLbyte * pc)
 {
-    CALL_Color3ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glColor3ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDisp_Color3uiv(GLbyte * pc)
+void
+__glXDisp_Color3uiv(GLbyte * pc)
 {
-    CALL_Color3uiv( GET_DISPATCH(), (
-         (const GLuint *)(pc +  0)
-    ) );
+    glColor3uiv((const GLuint *) (pc + 0));
 }
 
-void __glXDisp_Color3usv(GLbyte * pc)
+void
+__glXDisp_Color3usv(GLbyte * pc)
 {
-    CALL_Color3usv( GET_DISPATCH(), (
-         (const GLushort *)(pc +  0)
-    ) );
+    glColor3usv((const GLushort *) (pc + 0));
 }
 
-void __glXDisp_Color4bv(GLbyte * pc)
+void
+__glXDisp_Color4bv(GLbyte * pc)
 {
-    CALL_Color4bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glColor4bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDisp_Color4dv(GLbyte * pc)
+void
+__glXDisp_Color4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Color4dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glColor4dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Color4fv(GLbyte * pc)
+void
+__glXDisp_Color4fv(GLbyte * pc)
 {
-    CALL_Color4fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glColor4fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Color4iv(GLbyte * pc)
+void
+__glXDisp_Color4iv(GLbyte * pc)
 {
-    CALL_Color4iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glColor4iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Color4sv(GLbyte * pc)
+void
+__glXDisp_Color4sv(GLbyte * pc)
 {
-    CALL_Color4sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glColor4sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Color4ubv(GLbyte * pc)
+void
+__glXDisp_Color4ubv(GLbyte * pc)
 {
-    CALL_Color4ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glColor4ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDisp_Color4uiv(GLbyte * pc)
+void
+__glXDisp_Color4uiv(GLbyte * pc)
 {
-    CALL_Color4uiv( GET_DISPATCH(), (
-         (const GLuint *)(pc +  0)
-    ) );
+    glColor4uiv((const GLuint *) (pc + 0));
 }
 
-void __glXDisp_Color4usv(GLbyte * pc)
+void
+__glXDisp_Color4usv(GLbyte * pc)
 {
-    CALL_Color4usv( GET_DISPATCH(), (
-         (const GLushort *)(pc +  0)
-    ) );
+    glColor4usv((const GLushort *) (pc + 0));
 }
 
-void __glXDisp_EdgeFlagv(GLbyte * pc)
+void
+__glXDisp_EdgeFlagv(GLbyte * pc)
 {
-    CALL_EdgeFlagv( GET_DISPATCH(), (
-         (const GLboolean *)(pc +  0)
-    ) );
+    glEdgeFlagv((const GLboolean *) (pc + 0));
 }
 
-void __glXDisp_End(GLbyte * pc)
+void
+__glXDisp_End(GLbyte * pc)
 {
-    CALL_End( GET_DISPATCH(), () );
+    glEnd();
 }
 
-void __glXDisp_Indexdv(GLbyte * pc)
+void
+__glXDisp_Indexdv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_Indexdv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glIndexdv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Indexfv(GLbyte * pc)
+void
+__glXDisp_Indexfv(GLbyte * pc)
 {
-    CALL_Indexfv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glIndexfv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Indexiv(GLbyte * pc)
+void
+__glXDisp_Indexiv(GLbyte * pc)
 {
-    CALL_Indexiv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glIndexiv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Indexsv(GLbyte * pc)
+void
+__glXDisp_Indexsv(GLbyte * pc)
 {
-    CALL_Indexsv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glIndexsv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Normal3bv(GLbyte * pc)
+void
+__glXDisp_Normal3bv(GLbyte * pc)
 {
-    CALL_Normal3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glNormal3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDisp_Normal3dv(GLbyte * pc)
+void
+__glXDisp_Normal3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Normal3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glNormal3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Normal3fv(GLbyte * pc)
+void
+__glXDisp_Normal3fv(GLbyte * pc)
 {
-    CALL_Normal3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glNormal3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Normal3iv(GLbyte * pc)
+void
+__glXDisp_Normal3iv(GLbyte * pc)
 {
-    CALL_Normal3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glNormal3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Normal3sv(GLbyte * pc)
+void
+__glXDisp_Normal3sv(GLbyte * pc)
 {
-    CALL_Normal3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glNormal3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_RasterPos2dv(GLbyte * pc)
+void
+__glXDisp_RasterPos2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos2dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glRasterPos2dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_RasterPos2fv(GLbyte * pc)
+void
+__glXDisp_RasterPos2fv(GLbyte * pc)
 {
-    CALL_RasterPos2fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glRasterPos2fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_RasterPos2iv(GLbyte * pc)
+void
+__glXDisp_RasterPos2iv(GLbyte * pc)
 {
-    CALL_RasterPos2iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glRasterPos2iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_RasterPos2sv(GLbyte * pc)
+void
+__glXDisp_RasterPos2sv(GLbyte * pc)
 {
-    CALL_RasterPos2sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glRasterPos2sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_RasterPos3dv(GLbyte * pc)
+void
+__glXDisp_RasterPos3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glRasterPos3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_RasterPos3fv(GLbyte * pc)
+void
+__glXDisp_RasterPos3fv(GLbyte * pc)
 {
-    CALL_RasterPos3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glRasterPos3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_RasterPos3iv(GLbyte * pc)
+void
+__glXDisp_RasterPos3iv(GLbyte * pc)
 {
-    CALL_RasterPos3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glRasterPos3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_RasterPos3sv(GLbyte * pc)
+void
+__glXDisp_RasterPos3sv(GLbyte * pc)
 {
-    CALL_RasterPos3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glRasterPos3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_RasterPos4dv(GLbyte * pc)
+void
+__glXDisp_RasterPos4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos4dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glRasterPos4dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_RasterPos4fv(GLbyte * pc)
+void
+__glXDisp_RasterPos4fv(GLbyte * pc)
 {
-    CALL_RasterPos4fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glRasterPos4fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_RasterPos4iv(GLbyte * pc)
+void
+__glXDisp_RasterPos4iv(GLbyte * pc)
 {
-    CALL_RasterPos4iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glRasterPos4iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_RasterPos4sv(GLbyte * pc)
+void
+__glXDisp_RasterPos4sv(GLbyte * pc)
 {
-    CALL_RasterPos4sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glRasterPos4sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Rectdv(GLbyte * pc)
+void
+__glXDisp_Rectdv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Rectdv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0),
-         (const GLdouble *)(pc + 16)
-    ) );
+    glRectdv((const GLdouble *) (pc + 0), (const GLdouble *) (pc + 16));
 }
 
-void __glXDisp_Rectfv(GLbyte * pc)
+void
+__glXDisp_Rectfv(GLbyte * pc)
 {
-    CALL_Rectfv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0),
-         (const GLfloat *)(pc +  8)
-    ) );
+    glRectfv((const GLfloat *) (pc + 0), (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_Rectiv(GLbyte * pc)
+void
+__glXDisp_Rectiv(GLbyte * pc)
 {
-    CALL_Rectiv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0),
-         (const GLint *)(pc +  8)
-    ) );
+    glRectiv((const GLint *) (pc + 0), (const GLint *) (pc + 8));
 }
 
-void __glXDisp_Rectsv(GLbyte * pc)
+void
+__glXDisp_Rectsv(GLbyte * pc)
 {
-    CALL_Rectsv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    glRectsv((const GLshort *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_TexCoord1dv(GLbyte * pc)
+void
+__glXDisp_TexCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord1dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glTexCoord1dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_TexCoord1fv(GLbyte * pc)
+void
+__glXDisp_TexCoord1fv(GLbyte * pc)
 {
-    CALL_TexCoord1fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glTexCoord1fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_TexCoord1iv(GLbyte * pc)
+void
+__glXDisp_TexCoord1iv(GLbyte * pc)
 {
-    CALL_TexCoord1iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glTexCoord1iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_TexCoord1sv(GLbyte * pc)
+void
+__glXDisp_TexCoord1sv(GLbyte * pc)
 {
-    CALL_TexCoord1sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glTexCoord1sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_TexCoord2dv(GLbyte * pc)
+void
+__glXDisp_TexCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord2dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glTexCoord2dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_TexCoord2fv(GLbyte * pc)
+void
+__glXDisp_TexCoord2fv(GLbyte * pc)
 {
-    CALL_TexCoord2fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glTexCoord2fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_TexCoord2iv(GLbyte * pc)
+void
+__glXDisp_TexCoord2iv(GLbyte * pc)
 {
-    CALL_TexCoord2iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glTexCoord2iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_TexCoord2sv(GLbyte * pc)
+void
+__glXDisp_TexCoord2sv(GLbyte * pc)
 {
-    CALL_TexCoord2sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glTexCoord2sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_TexCoord3dv(GLbyte * pc)
+void
+__glXDisp_TexCoord3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glTexCoord3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_TexCoord3fv(GLbyte * pc)
+void
+__glXDisp_TexCoord3fv(GLbyte * pc)
 {
-    CALL_TexCoord3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glTexCoord3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_TexCoord3iv(GLbyte * pc)
+void
+__glXDisp_TexCoord3iv(GLbyte * pc)
 {
-    CALL_TexCoord3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glTexCoord3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_TexCoord3sv(GLbyte * pc)
+void
+__glXDisp_TexCoord3sv(GLbyte * pc)
 {
-    CALL_TexCoord3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glTexCoord3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_TexCoord4dv(GLbyte * pc)
+void
+__glXDisp_TexCoord4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord4dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glTexCoord4dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_TexCoord4fv(GLbyte * pc)
+void
+__glXDisp_TexCoord4fv(GLbyte * pc)
 {
-    CALL_TexCoord4fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glTexCoord4fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_TexCoord4iv(GLbyte * pc)
+void
+__glXDisp_TexCoord4iv(GLbyte * pc)
 {
-    CALL_TexCoord4iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glTexCoord4iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_TexCoord4sv(GLbyte * pc)
+void
+__glXDisp_TexCoord4sv(GLbyte * pc)
 {
-    CALL_TexCoord4sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glTexCoord4sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Vertex2dv(GLbyte * pc)
+void
+__glXDisp_Vertex2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex2dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glVertex2dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Vertex2fv(GLbyte * pc)
+void
+__glXDisp_Vertex2fv(GLbyte * pc)
 {
-    CALL_Vertex2fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glVertex2fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Vertex2iv(GLbyte * pc)
+void
+__glXDisp_Vertex2iv(GLbyte * pc)
 {
-    CALL_Vertex2iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glVertex2iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Vertex2sv(GLbyte * pc)
+void
+__glXDisp_Vertex2sv(GLbyte * pc)
 {
-    CALL_Vertex2sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glVertex2sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Vertex3dv(GLbyte * pc)
+void
+__glXDisp_Vertex3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glVertex3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Vertex3fv(GLbyte * pc)
+void
+__glXDisp_Vertex3fv(GLbyte * pc)
 {
-    CALL_Vertex3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glVertex3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Vertex3iv(GLbyte * pc)
+void
+__glXDisp_Vertex3iv(GLbyte * pc)
 {
-    CALL_Vertex3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glVertex3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Vertex3sv(GLbyte * pc)
+void
+__glXDisp_Vertex3sv(GLbyte * pc)
 {
-    CALL_Vertex3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glVertex3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_Vertex4dv(GLbyte * pc)
+void
+__glXDisp_Vertex4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex4dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glVertex4dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Vertex4fv(GLbyte * pc)
+void
+__glXDisp_Vertex4fv(GLbyte * pc)
 {
-    CALL_Vertex4fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glVertex4fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Vertex4iv(GLbyte * pc)
+void
+__glXDisp_Vertex4iv(GLbyte * pc)
 {
-    CALL_Vertex4iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    glVertex4iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_Vertex4sv(GLbyte * pc)
+void
+__glXDisp_Vertex4sv(GLbyte * pc)
 {
-    CALL_Vertex4sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    glVertex4sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_ClipPlane(GLbyte * pc)
+void
+__glXDisp_ClipPlane(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_ClipPlane( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 32),
-         (const GLdouble *)(pc +  0)
-    ) );
+    glClipPlane(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_ColorMaterial(GLbyte * pc)
+void
+__glXDisp_ColorMaterial(GLbyte * pc)
 {
-    CALL_ColorMaterial( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
+    glColorMaterial(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-void __glXDisp_CullFace(GLbyte * pc)
+void
+__glXDisp_CullFace(GLbyte * pc)
 {
-    CALL_CullFace( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glCullFace(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_Fogf(GLbyte * pc)
+void
+__glXDisp_Fogf(GLbyte * pc)
 {
-    CALL_Fogf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glFogf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_Fogfv(GLbyte * pc)
+void
+__glXDisp_Fogfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 4);
 
-    CALL_Fogfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glFogfv(pname, params);
 }
 
-void __glXDisp_Fogi(GLbyte * pc)
+void
+__glXDisp_Fogi(GLbyte * pc)
 {
-    CALL_Fogi( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4)
-    ) );
+    glFogi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
 }
 
-void __glXDisp_Fogiv(GLbyte * pc)
+void
+__glXDisp_Fogiv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLint *params;
 
     params = (const GLint *) (pc + 4);
 
-    CALL_Fogiv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glFogiv(pname, params);
 }
 
-void __glXDisp_FrontFace(GLbyte * pc)
+void
+__glXDisp_FrontFace(GLbyte * pc)
 {
-    CALL_FrontFace( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glFrontFace(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_Hint(GLbyte * pc)
+void
+__glXDisp_Hint(GLbyte * pc)
 {
-    CALL_Hint( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
+    glHint(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-void __glXDisp_Lightf(GLbyte * pc)
+void
+__glXDisp_Lightf(GLbyte * pc)
 {
-    CALL_Lightf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glLightf(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_Lightfv(GLbyte * pc)
+void
+__glXDisp_Lightfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_Lightfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glLightfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_Lighti(GLbyte * pc)
+void
+__glXDisp_Lighti(GLbyte * pc)
 {
-    CALL_Lighti( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glLighti(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_Lightiv(GLbyte * pc)
+void
+__glXDisp_Lightiv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_Lightiv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glLightiv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_LightModelf(GLbyte * pc)
+void
+__glXDisp_LightModelf(GLbyte * pc)
 {
-    CALL_LightModelf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glLightModelf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_LightModelfv(GLbyte * pc)
+void
+__glXDisp_LightModelfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 4);
 
-    CALL_LightModelfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glLightModelfv(pname, params);
 }
 
-void __glXDisp_LightModeli(GLbyte * pc)
+void
+__glXDisp_LightModeli(GLbyte * pc)
 {
-    CALL_LightModeli( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4)
-    ) );
+    glLightModeli(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
 }
 
-void __glXDisp_LightModeliv(GLbyte * pc)
+void
+__glXDisp_LightModeliv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLint *params;
 
     params = (const GLint *) (pc + 4);
 
-    CALL_LightModeliv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glLightModeliv(pname, params);
 }
 
-void __glXDisp_LineStipple(GLbyte * pc)
+void
+__glXDisp_LineStipple(GLbyte * pc)
 {
-    CALL_LineStipple( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLushort *)(pc +  4)
-    ) );
+    glLineStipple(*(GLint *) (pc + 0), *(GLushort *) (pc + 4));
 }
 
-void __glXDisp_LineWidth(GLbyte * pc)
+void
+__glXDisp_LineWidth(GLbyte * pc)
 {
-    CALL_LineWidth( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0)
-    ) );
+    glLineWidth(*(GLfloat *) (pc + 0));
 }
 
-void __glXDisp_Materialf(GLbyte * pc)
+void
+__glXDisp_Materialf(GLbyte * pc)
 {
-    CALL_Materialf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glMaterialf(*(GLenum *) (pc + 0),
+                *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_Materialfv(GLbyte * pc)
+void
+__glXDisp_Materialfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_Materialfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glMaterialfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_Materiali(GLbyte * pc)
+void
+__glXDisp_Materiali(GLbyte * pc)
 {
-    CALL_Materiali( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glMateriali(*(GLenum *) (pc + 0),
+                *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_Materialiv(GLbyte * pc)
+void
+__glXDisp_Materialiv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_Materialiv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glMaterialiv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_PointSize(GLbyte * pc)
+void
+__glXDisp_PointSize(GLbyte * pc)
 {
-    CALL_PointSize( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0)
-    ) );
+    glPointSize(*(GLfloat *) (pc + 0));
 }
 
-void __glXDisp_PolygonMode(GLbyte * pc)
+void
+__glXDisp_PolygonMode(GLbyte * pc)
 {
-    CALL_PolygonMode( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
+    glPolygonMode(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-void __glXDisp_PolygonStipple(GLbyte * pc)
+void
+__glXDisp_PolygonStipple(GLbyte * pc)
 {
-    const GLubyte * const mask = (const GLubyte *) (pc + 20);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLubyte *const mask = (const GLubyte *) ((pc + 20));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_PolygonStipple( GET_DISPATCH(), (
-        mask
-    ) );
+    glPolygonStipple(mask);
 }
 
-void __glXDisp_Scissor(GLbyte * pc)
+void
+__glXDisp_Scissor(GLbyte * pc)
 {
-    CALL_Scissor( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLsizei  *)(pc +  8),
-        *(GLsizei  *)(pc + 12)
-    ) );
+    glScissor(*(GLint *) (pc + 0),
+              *(GLint *) (pc + 4),
+              *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
 }
 
-void __glXDisp_ShadeModel(GLbyte * pc)
+void
+__glXDisp_ShadeModel(GLbyte * pc)
 {
-    CALL_ShadeModel( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glShadeModel(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_TexParameterf(GLbyte * pc)
+void
+__glXDisp_TexParameterf(GLbyte * pc)
 {
-    CALL_TexParameterf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glTexParameterf(*(GLenum *) (pc + 0),
+                    *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_TexParameterfv(GLbyte * pc)
+void
+__glXDisp_TexParameterfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_TexParameterfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexParameterfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexParameteri(GLbyte * pc)
+void
+__glXDisp_TexParameteri(GLbyte * pc)
 {
-    CALL_TexParameteri( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glTexParameteri(*(GLenum *) (pc + 0),
+                    *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_TexParameteriv(GLbyte * pc)
+void
+__glXDisp_TexParameteriv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_TexParameteriv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexParameteriv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexImage1D(GLbyte * pc)
+void
+__glXDisp_TexImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLint    *)(pc + 28),
-        *(GLsizei  *)(pc + 32),
-        *(GLint    *)(pc + 40),
-        *(GLenum   *)(pc + 44),
-        *(GLenum   *)(pc + 48),
-        pixels
-    ) );
+    glTexImage1D(*(GLenum *) (pc + 20),
+                 *(GLint *) (pc + 24),
+                 *(GLint *) (pc + 28),
+                 *(GLsizei *) (pc + 32),
+                 *(GLint *) (pc + 40),
+                 *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
 }
 
-void __glXDisp_TexImage2D(GLbyte * pc)
+void
+__glXDisp_TexImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLint    *)(pc + 28),
-        *(GLsizei  *)(pc + 32),
-        *(GLsizei  *)(pc + 36),
-        *(GLint    *)(pc + 40),
-        *(GLenum   *)(pc + 44),
-        *(GLenum   *)(pc + 48),
-        pixels
-    ) );
+    glTexImage2D(*(GLenum *) (pc + 20),
+                 *(GLint *) (pc + 24),
+                 *(GLint *) (pc + 28),
+                 *(GLsizei *) (pc + 32),
+                 *(GLsizei *) (pc + 36),
+                 *(GLint *) (pc + 40),
+                 *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
 }
 
-void __glXDisp_TexEnvf(GLbyte * pc)
+void
+__glXDisp_TexEnvf(GLbyte * pc)
 {
-    CALL_TexEnvf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glTexEnvf(*(GLenum *) (pc + 0),
+              *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_TexEnvfv(GLbyte * pc)
+void
+__glXDisp_TexEnvfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_TexEnvfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexEnvfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexEnvi(GLbyte * pc)
+void
+__glXDisp_TexEnvi(GLbyte * pc)
 {
-    CALL_TexEnvi( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glTexEnvi(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_TexEnviv(GLbyte * pc)
+void
+__glXDisp_TexEnviv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_TexEnviv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexEnviv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexGend(GLbyte * pc)
+void
+__glXDisp_TexGend(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_TexGend( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  8),
-        *(GLenum   *)(pc + 12),
-        *(GLdouble *)(pc +  0)
-    ) );
+    glTexGend(*(GLenum *) (pc + 8),
+              *(GLenum *) (pc + 12), *(GLdouble *) (pc + 0));
 }
 
-void __glXDisp_TexGendv(GLbyte * pc)
+void
+__glXDisp_TexGendv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLdouble * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLdouble *params;
 
 #ifdef __GLX_ALIGN64
     const GLuint compsize = __glTexGendv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
     params = (const GLdouble *) (pc + 8);
 
-    CALL_TexGendv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexGendv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexGenf(GLbyte * pc)
+void
+__glXDisp_TexGenf(GLbyte * pc)
 {
-    CALL_TexGenf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glTexGenf(*(GLenum *) (pc + 0),
+              *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_TexGenfv(GLbyte * pc)
+void
+__glXDisp_TexGenfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_TexGenfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexGenfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_TexGeni(GLbyte * pc)
+void
+__glXDisp_TexGeni(GLbyte * pc)
 {
-    CALL_TexGeni( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glTexGeni(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_TexGeniv(GLbyte * pc)
+void
+__glXDisp_TexGeniv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_TexGeniv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glTexGeniv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_InitNames(GLbyte * pc)
+void
+__glXDisp_InitNames(GLbyte * pc)
 {
-    CALL_InitNames( GET_DISPATCH(), () );
+    glInitNames();
 }
 
-void __glXDisp_LoadName(GLbyte * pc)
+void
+__glXDisp_LoadName(GLbyte * pc)
 {
-    CALL_LoadName( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glLoadName(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_PassThrough(GLbyte * pc)
+void
+__glXDisp_PassThrough(GLbyte * pc)
 {
-    CALL_PassThrough( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0)
-    ) );
+    glPassThrough(*(GLfloat *) (pc + 0));
 }
 
-void __glXDisp_PopName(GLbyte * pc)
+void
+__glXDisp_PopName(GLbyte * pc)
 {
-    CALL_PopName( GET_DISPATCH(), () );
+    glPopName();
 }
 
-void __glXDisp_PushName(GLbyte * pc)
+void
+__glXDisp_PushName(GLbyte * pc)
 {
-    CALL_PushName( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glPushName(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_DrawBuffer(GLbyte * pc)
+void
+__glXDisp_DrawBuffer(GLbyte * pc)
 {
-    CALL_DrawBuffer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glDrawBuffer(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_Clear(GLbyte * pc)
+void
+__glXDisp_Clear(GLbyte * pc)
 {
-    CALL_Clear( GET_DISPATCH(), (
-        *(GLbitfield *)(pc +  0)
-    ) );
+    glClear(*(GLbitfield *) (pc + 0));
 }
 
-void __glXDisp_ClearAccum(GLbyte * pc)
+void
+__glXDisp_ClearAccum(GLbyte * pc)
 {
-    CALL_ClearAccum( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8),
-        *(GLfloat  *)(pc + 12)
-    ) );
+    glClearAccum(*(GLfloat *) (pc + 0),
+                 *(GLfloat *) (pc + 4),
+                 *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12));
 }
 
-void __glXDisp_ClearIndex(GLbyte * pc)
+void
+__glXDisp_ClearIndex(GLbyte * pc)
 {
-    CALL_ClearIndex( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0)
-    ) );
+    glClearIndex(*(GLfloat *) (pc + 0));
 }
 
-void __glXDisp_ClearColor(GLbyte * pc)
+void
+__glXDisp_ClearColor(GLbyte * pc)
 {
-    CALL_ClearColor( GET_DISPATCH(), (
-        *(GLclampf *)(pc +  0),
-        *(GLclampf *)(pc +  4),
-        *(GLclampf *)(pc +  8),
-        *(GLclampf *)(pc + 12)
-    ) );
+    glClearColor(*(GLclampf *) (pc + 0),
+                 *(GLclampf *) (pc + 4),
+                 *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12));
 }
 
-void __glXDisp_ClearStencil(GLbyte * pc)
+void
+__glXDisp_ClearStencil(GLbyte * pc)
 {
-    CALL_ClearStencil( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0)
-    ) );
+    glClearStencil(*(GLint *) (pc + 0));
 }
 
-void __glXDisp_ClearDepth(GLbyte * pc)
+void
+__glXDisp_ClearDepth(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_ClearDepth( GET_DISPATCH(), (
-        *(GLclampd *)(pc +  0)
-    ) );
+    glClearDepth(*(GLclampd *) (pc + 0));
 }
 
-void __glXDisp_StencilMask(GLbyte * pc)
+void
+__glXDisp_StencilMask(GLbyte * pc)
 {
-    CALL_StencilMask( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glStencilMask(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_ColorMask(GLbyte * pc)
+void
+__glXDisp_ColorMask(GLbyte * pc)
 {
-    CALL_ColorMask( GET_DISPATCH(), (
-        *(GLboolean *)(pc +  0),
-        *(GLboolean *)(pc +  1),
-        *(GLboolean *)(pc +  2),
-        *(GLboolean *)(pc +  3)
-    ) );
+    glColorMask(*(GLboolean *) (pc + 0),
+                *(GLboolean *) (pc + 1),
+                *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3));
 }
 
-void __glXDisp_DepthMask(GLbyte * pc)
+void
+__glXDisp_DepthMask(GLbyte * pc)
 {
-    CALL_DepthMask( GET_DISPATCH(), (
-        *(GLboolean *)(pc +  0)
-    ) );
+    glDepthMask(*(GLboolean *) (pc + 0));
 }
 
-void __glXDisp_IndexMask(GLbyte * pc)
+void
+__glXDisp_IndexMask(GLbyte * pc)
 {
-    CALL_IndexMask( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0)
-    ) );
+    glIndexMask(*(GLuint *) (pc + 0));
 }
 
-void __glXDisp_Accum(GLbyte * pc)
+void
+__glXDisp_Accum(GLbyte * pc)
 {
-    CALL_Accum( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glAccum(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_Disable(GLbyte * pc)
+void
+__glXDisp_Disable(GLbyte * pc)
 {
-    CALL_Disable( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glDisable(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_Enable(GLbyte * pc)
+void
+__glXDisp_Enable(GLbyte * pc)
 {
-    CALL_Enable( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glEnable(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_PopAttrib(GLbyte * pc)
+void
+__glXDisp_PopAttrib(GLbyte * pc)
 {
-    CALL_PopAttrib( GET_DISPATCH(), () );
+    glPopAttrib();
 }
 
-void __glXDisp_PushAttrib(GLbyte * pc)
+void
+__glXDisp_PushAttrib(GLbyte * pc)
 {
-    CALL_PushAttrib( GET_DISPATCH(), (
-        *(GLbitfield *)(pc +  0)
-    ) );
+    glPushAttrib(*(GLbitfield *) (pc + 0));
 }
 
-void __glXDisp_MapGrid1d(GLbyte * pc)
+void
+__glXDisp_MapGrid1d(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_MapGrid1d( GET_DISPATCH(), (
-        *(GLint    *)(pc + 16),
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8)
-    ) );
+    glMapGrid1d(*(GLint *) (pc + 16),
+                *(GLdouble *) (pc + 0), *(GLdouble *) (pc + 8));
 }
 
-void __glXDisp_MapGrid1f(GLbyte * pc)
+void
+__glXDisp_MapGrid1f(GLbyte * pc)
 {
-    CALL_MapGrid1f( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glMapGrid1f(*(GLint *) (pc + 0),
+                *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_MapGrid2d(GLbyte * pc)
+void
+__glXDisp_MapGrid2d(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_MapGrid2d( GET_DISPATCH(), (
-        *(GLint    *)(pc + 32),
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLint    *)(pc + 36),
-        *(GLdouble *)(pc + 16),
-        *(GLdouble *)(pc + 24)
-    ) );
+    glMapGrid2d(*(GLint *) (pc + 32),
+                *(GLdouble *) (pc + 0),
+                *(GLdouble *) (pc + 8),
+                *(GLint *) (pc + 36),
+                *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24));
 }
 
-void __glXDisp_MapGrid2f(GLbyte * pc)
+void
+__glXDisp_MapGrid2f(GLbyte * pc)
 {
-    CALL_MapGrid2f( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLfloat  *)(pc + 16),
-        *(GLfloat  *)(pc + 20)
-    ) );
+    glMapGrid2f(*(GLint *) (pc + 0),
+                *(GLfloat *) (pc + 4),
+                *(GLfloat *) (pc + 8),
+                *(GLint *) (pc + 12),
+                *(GLfloat *) (pc + 16), *(GLfloat *) (pc + 20));
 }
 
-void __glXDisp_EvalCoord1dv(GLbyte * pc)
+void
+__glXDisp_EvalCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_EvalCoord1dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glEvalCoord1dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_EvalCoord1fv(GLbyte * pc)
+void
+__glXDisp_EvalCoord1fv(GLbyte * pc)
 {
-    CALL_EvalCoord1fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glEvalCoord1fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_EvalCoord2dv(GLbyte * pc)
+void
+__glXDisp_EvalCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_EvalCoord2dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glEvalCoord2dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_EvalCoord2fv(GLbyte * pc)
+void
+__glXDisp_EvalCoord2fv(GLbyte * pc)
 {
-    CALL_EvalCoord2fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glEvalCoord2fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_EvalMesh1(GLbyte * pc)
+void
+__glXDisp_EvalMesh1(GLbyte * pc)
 {
-    CALL_EvalMesh1( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glEvalMesh1(*(GLenum *) (pc + 0), *(GLint *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_EvalPoint1(GLbyte * pc)
+void
+__glXDisp_EvalPoint1(GLbyte * pc)
 {
-    CALL_EvalPoint1( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0)
-    ) );
+    glEvalPoint1(*(GLint *) (pc + 0));
 }
 
-void __glXDisp_EvalMesh2(GLbyte * pc)
+void
+__glXDisp_EvalMesh2(GLbyte * pc)
 {
-    CALL_EvalMesh2( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16)
-    ) );
+    glEvalMesh2(*(GLenum *) (pc + 0),
+                *(GLint *) (pc + 4),
+                *(GLint *) (pc + 8),
+                *(GLint *) (pc + 12), *(GLint *) (pc + 16));
 }
 
-void __glXDisp_EvalPoint2(GLbyte * pc)
+void
+__glXDisp_EvalPoint2(GLbyte * pc)
 {
-    CALL_EvalPoint2( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLint    *)(pc +  4)
-    ) );
+    glEvalPoint2(*(GLint *) (pc + 0), *(GLint *) (pc + 4));
 }
 
-void __glXDisp_AlphaFunc(GLbyte * pc)
+void
+__glXDisp_AlphaFunc(GLbyte * pc)
 {
-    CALL_AlphaFunc( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLclampf *)(pc +  4)
-    ) );
+    glAlphaFunc(*(GLenum *) (pc + 0), *(GLclampf *) (pc + 4));
 }
 
-void __glXDisp_BlendFunc(GLbyte * pc)
+void
+__glXDisp_BlendFunc(GLbyte * pc)
 {
-    CALL_BlendFunc( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
+    glBlendFunc(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-void __glXDisp_LogicOp(GLbyte * pc)
+void
+__glXDisp_LogicOp(GLbyte * pc)
 {
-    CALL_LogicOp( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glLogicOp(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_StencilFunc(GLbyte * pc)
+void
+__glXDisp_StencilFunc(GLbyte * pc)
 {
-    CALL_StencilFunc( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLuint   *)(pc +  8)
-    ) );
+    glStencilFunc(*(GLenum *) (pc + 0),
+                  *(GLint *) (pc + 4), *(GLuint *) (pc + 8));
 }
 
-void __glXDisp_StencilOp(GLbyte * pc)
+void
+__glXDisp_StencilOp(GLbyte * pc)
 {
-    CALL_StencilOp( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8)
-    ) );
+    glStencilOp(*(GLenum *) (pc + 0),
+                *(GLenum *) (pc + 4), *(GLenum *) (pc + 8));
 }
 
-void __glXDisp_DepthFunc(GLbyte * pc)
+void
+__glXDisp_DepthFunc(GLbyte * pc)
 {
-    CALL_DepthFunc( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glDepthFunc(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_PixelZoom(GLbyte * pc)
+void
+__glXDisp_PixelZoom(GLbyte * pc)
 {
-    CALL_PixelZoom( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glPixelZoom(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_PixelTransferf(GLbyte * pc)
+void
+__glXDisp_PixelTransferf(GLbyte * pc)
 {
-    CALL_PixelTransferf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glPixelTransferf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_PixelTransferi(GLbyte * pc)
+void
+__glXDisp_PixelTransferi(GLbyte * pc)
 {
-    CALL_PixelTransferi( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4)
-    ) );
+    glPixelTransferi(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
 }
 
-int __glXDisp_PixelStoref(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_PixelStoref(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_PixelStoref( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLfloat  *)(pc +  4)
-        ) );
+    if (cx != NULL) {
+        glPixelStoref(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_PixelStorei(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_PixelStorei(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_PixelStorei( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLint    *)(pc +  4)
-        ) );
+    if (cx != NULL) {
+        glPixelStorei(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-void __glXDisp_PixelMapfv(GLbyte * pc)
+void
+__glXDisp_PixelMapfv(GLbyte * pc)
 {
-    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
+    const GLsizei mapsize = *(GLsizei *) (pc + 4);
 
-    CALL_PixelMapfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        mapsize,
-         (const GLfloat *)(pc +  8)
-    ) );
+    glPixelMapfv(*(GLenum *) (pc + 0), mapsize, (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_PixelMapuiv(GLbyte * pc)
+void
+__glXDisp_PixelMapuiv(GLbyte * pc)
 {
-    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
+    const GLsizei mapsize = *(GLsizei *) (pc + 4);
 
-    CALL_PixelMapuiv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        mapsize,
-         (const GLuint *)(pc +  8)
-    ) );
+    glPixelMapuiv(*(GLenum *) (pc + 0), mapsize, (const GLuint *) (pc + 8));
 }
 
-void __glXDisp_PixelMapusv(GLbyte * pc)
+void
+__glXDisp_PixelMapusv(GLbyte * pc)
 {
-    const GLsizei mapsize = *(GLsizei  *)(pc +  4);
+    const GLsizei mapsize = *(GLsizei *) (pc + 4);
 
-    CALL_PixelMapusv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        mapsize,
-         (const GLushort *)(pc +  8)
-    ) );
+    glPixelMapusv(*(GLenum *) (pc + 0), mapsize, (const GLushort *) (pc + 8));
 }
 
-void __glXDisp_ReadBuffer(GLbyte * pc)
+void
+__glXDisp_ReadBuffer(GLbyte * pc)
 {
-    CALL_ReadBuffer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glReadBuffer(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_CopyPixels(GLbyte * pc)
+void
+__glXDisp_CopyPixels(GLbyte * pc)
 {
-    CALL_CopyPixels( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLsizei  *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLenum   *)(pc + 16)
-    ) );
+    glCopyPixels(*(GLint *) (pc + 0),
+                 *(GLint *) (pc + 4),
+                 *(GLsizei *) (pc + 8),
+                 *(GLsizei *) (pc + 12), *(GLenum *) (pc + 16));
 }
 
-void __glXDisp_DrawPixels(GLbyte * pc)
+void
+__glXDisp_DrawPixels(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_DrawPixels( GET_DISPATCH(), (
-        *(GLsizei  *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLenum   *)(pc + 28),
-        *(GLenum   *)(pc + 32),
-        pixels
-    ) );
+    glDrawPixels(*(GLsizei *) (pc + 20),
+                 *(GLsizei *) (pc + 24),
+                 *(GLenum *) (pc + 28), *(GLenum *) (pc + 32), pixels);
 }
 
-int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetBooleanv_size(pname);
         GLboolean answerBuffer[200];
-        GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1);
+        GLboolean *params =
+            __glXGetAnswerBuffer(cl, compsize, answerBuffer,
+                                 sizeof(answerBuffer), 1);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetBooleanv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
+        glGetBooleanv(pname, params);
         __glXSendReply(cl->client, params, compsize, 1, GL_FALSE, 0);
         error = Success;
     }
@@ -1796,19 +1542,18 @@ int __glXDisp_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble equation[4];
-        CALL_GetClipPlane( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            equation
-        ) );
+
+        glGetClipPlane(*(GLenum *) (pc + 0), equation);
         __glXSendReply(cl->client, equation, 4, 8, GL_TRUE, 0);
         error = Success;
     }
@@ -1816,27 +1561,28 @@ int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetDoublev(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetDoublev_size(pname);
         GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *params =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetDoublev( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
+        glGetDoublev(pname, params);
         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -1844,16 +1590,18 @@ int __glXDisp_GetDoublev(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetError(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLenum retval;
-        retval = CALL_GetError( GET_DISPATCH(), () );
+
+        retval = glGetError();
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -1861,27 +1609,28 @@ int __glXDisp_GetError(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetFloatv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetFloatv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetFloatv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
+        glGetFloatv(pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -1889,27 +1638,28 @@ int __glXDisp_GetFloatv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetIntegerv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetIntegerv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
+        glGetIntegerv(pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -1917,28 +1667,28 @@ int __glXDisp_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetLightfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetLightfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetLightfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetLightfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -1946,28 +1696,28 @@ int __glXDisp_GetLightfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetLightiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetLightiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetLightiv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetLightiv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -1975,29 +1725,29 @@ int __glXDisp_GetLightiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMapdv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target = *(GLenum   *)(pc +  0);
-        const GLenum query = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum target = *(GLenum *) (pc + 0);
+        const GLenum query = *(GLenum *) (pc + 4);
 
-        const GLuint compsize = __glGetMapdv_size(target,query);
+        const GLuint compsize = __glGetMapdv_size(target, query);
         GLdouble answerBuffer[200];
-        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *v =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapdv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
+        glGetMapdv(target, query, v);
         __glXSendReply(cl->client, v, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -2005,29 +1755,29 @@ int __glXDisp_GetMapdv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMapfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target = *(GLenum   *)(pc +  0);
-        const GLenum query = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum target = *(GLenum *) (pc + 0);
+        const GLenum query = *(GLenum *) (pc + 4);
 
-        const GLuint compsize = __glGetMapfv_size(target,query);
+        const GLuint compsize = __glGetMapfv_size(target, query);
         GLfloat answerBuffer[200];
-        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *v =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapfv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
+        glGetMapfv(target, query, v);
         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2035,29 +1785,29 @@ int __glXDisp_GetMapfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMapiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target = *(GLenum   *)(pc +  0);
-        const GLenum query = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum target = *(GLenum *) (pc + 0);
+        const GLenum query = *(GLenum *) (pc + 4);
 
-        const GLuint compsize = __glGetMapiv_size(target,query);
+        const GLuint compsize = __glGetMapiv_size(target, query);
         GLint answerBuffer[200];
-        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *v =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapiv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
+        glGetMapiv(target, query, v);
         __glXSendReply(cl->client, v, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2065,28 +1815,28 @@ int __glXDisp_GetMapiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMaterialfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMaterialfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMaterialfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2094,28 +1844,28 @@ int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMaterialiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMaterialiv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMaterialiv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2123,27 +1873,28 @@ int __glXDisp_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum map = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetPixelMapfv_size(map);
         GLfloat answerBuffer[200];
-        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *values =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapfv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
+        glGetPixelMapfv(map, values);
         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2151,27 +1902,28 @@ int __glXDisp_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum map = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetPixelMapuiv_size(map);
         GLuint answerBuffer[200];
-        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLuint *values =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapuiv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
+        glGetPixelMapuiv(map, values);
         __glXSendReply(cl->client, values, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2179,27 +1931,28 @@ int __glXDisp_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map = *(GLenum   *)(pc +  0);
+    if (cx != NULL) {
+        const GLenum map = *(GLenum *) (pc + 0);
 
         const GLuint compsize = __glGetPixelMapusv_size(map);
         GLushort answerBuffer[200];
-        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
+        GLushort *values =
+            __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
+                                 sizeof(answerBuffer), 2);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapusv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
+        glGetPixelMapusv(map, values);
         __glXSendReply(cl->client, values, compsize, 2, GL_FALSE, 0);
         error = Success;
     }
@@ -2207,28 +1960,28 @@ int __glXDisp_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexEnvfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexEnvfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexEnvfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2236,28 +1989,28 @@ int __glXDisp_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexEnviv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexEnviv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexEnviv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2265,28 +2018,28 @@ int __glXDisp_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexGendv_size(pname);
         GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *params =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGendv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexGendv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -2294,28 +2047,28 @@ int __glXDisp_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexGenfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGenfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexGenfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2323,28 +2076,28 @@ int __glXDisp_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexGeniv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGeniv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexGeniv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2352,28 +2105,28 @@ int __glXDisp_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2381,28 +2134,28 @@ int __glXDisp_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetTexParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetTexParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2410,29 +2163,29 @@ int __glXDisp_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  8);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 8);
 
         const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexLevelParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLint    *)(pc +  4),
-            pname,
-            params
-        ) );
+        glGetTexLevelParameterfv(*(GLenum *) (pc + 0),
+                                 *(GLint *) (pc + 4), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2440,29 +2193,29 @@ int __glXDisp_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  8);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 8);
 
         const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexLevelParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLint    *)(pc +  4),
-            pname,
-            params
-        ) );
+        glGetTexLevelParameteriv(*(GLenum *) (pc + 0),
+                                 *(GLint *) (pc + 4), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2470,18 +2223,18 @@ int __glXDisp_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsEnabled(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsEnabled( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0)
-        ) );
+
+        retval = glIsEnabled(*(GLenum *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2489,18 +2242,18 @@ int __glXDisp_IsEnabled(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsList( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
+
+        retval = glIsList(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2508,251 +2261,223 @@ int __glXDisp_IsList(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_DepthRange(GLbyte * pc)
+void
+__glXDisp_DepthRange(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_DepthRange( GET_DISPATCH(), (
-        *(GLclampd *)(pc +  0),
-        *(GLclampd *)(pc +  8)
-    ) );
+    glDepthRange(*(GLclampd *) (pc + 0), *(GLclampd *) (pc + 8));
 }
 
-void __glXDisp_Frustum(GLbyte * pc)
+void
+__glXDisp_Frustum(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 48);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 48);
         pc -= 4;
     }
 #endif
 
-    CALL_Frustum( GET_DISPATCH(), (
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLdouble *)(pc + 16),
-        *(GLdouble *)(pc + 24),
-        *(GLdouble *)(pc + 32),
-        *(GLdouble *)(pc + 40)
-    ) );
+    glFrustum(*(GLdouble *) (pc + 0),
+              *(GLdouble *) (pc + 8),
+              *(GLdouble *) (pc + 16),
+              *(GLdouble *) (pc + 24),
+              *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40));
 }
 
-void __glXDisp_LoadIdentity(GLbyte * pc)
+void
+__glXDisp_LoadIdentity(GLbyte * pc)
 {
-    CALL_LoadIdentity( GET_DISPATCH(), () );
+    glLoadIdentity();
 }
 
-void __glXDisp_LoadMatrixf(GLbyte * pc)
+void
+__glXDisp_LoadMatrixf(GLbyte * pc)
 {
-    CALL_LoadMatrixf( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glLoadMatrixf((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_LoadMatrixd(GLbyte * pc)
+void
+__glXDisp_LoadMatrixd(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 128);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 128);
         pc -= 4;
     }
 #endif
 
-    CALL_LoadMatrixd( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glLoadMatrixd((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_MatrixMode(GLbyte * pc)
+void
+__glXDisp_MatrixMode(GLbyte * pc)
 {
-    CALL_MatrixMode( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glMatrixMode(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_MultMatrixf(GLbyte * pc)
+void
+__glXDisp_MultMatrixf(GLbyte * pc)
 {
-    CALL_MultMatrixf( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    glMultMatrixf((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_MultMatrixd(GLbyte * pc)
+void
+__glXDisp_MultMatrixd(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 128);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 128);
         pc -= 4;
     }
 #endif
 
-    CALL_MultMatrixd( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    glMultMatrixd((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_Ortho(GLbyte * pc)
+void
+__glXDisp_Ortho(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 48);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 48);
         pc -= 4;
     }
 #endif
 
-    CALL_Ortho( GET_DISPATCH(), (
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLdouble *)(pc + 16),
-        *(GLdouble *)(pc + 24),
-        *(GLdouble *)(pc + 32),
-        *(GLdouble *)(pc + 40)
-    ) );
+    glOrtho(*(GLdouble *) (pc + 0),
+            *(GLdouble *) (pc + 8),
+            *(GLdouble *) (pc + 16),
+            *(GLdouble *) (pc + 24),
+            *(GLdouble *) (pc + 32), *(GLdouble *) (pc + 40));
 }
 
-void __glXDisp_PopMatrix(GLbyte * pc)
+void
+__glXDisp_PopMatrix(GLbyte * pc)
 {
-    CALL_PopMatrix( GET_DISPATCH(), () );
+    glPopMatrix();
 }
 
-void __glXDisp_PushMatrix(GLbyte * pc)
+void
+__glXDisp_PushMatrix(GLbyte * pc)
 {
-    CALL_PushMatrix( GET_DISPATCH(), () );
+    glPushMatrix();
 }
 
-void __glXDisp_Rotated(GLbyte * pc)
+void
+__glXDisp_Rotated(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Rotated( GET_DISPATCH(), (
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLdouble *)(pc + 16),
-        *(GLdouble *)(pc + 24)
-    ) );
+    glRotated(*(GLdouble *) (pc + 0),
+              *(GLdouble *) (pc + 8),
+              *(GLdouble *) (pc + 16), *(GLdouble *) (pc + 24));
 }
 
-void __glXDisp_Rotatef(GLbyte * pc)
+void
+__glXDisp_Rotatef(GLbyte * pc)
 {
-    CALL_Rotatef( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8),
-        *(GLfloat  *)(pc + 12)
-    ) );
+    glRotatef(*(GLfloat *) (pc + 0),
+              *(GLfloat *) (pc + 4),
+              *(GLfloat *) (pc + 8), *(GLfloat *) (pc + 12));
 }
 
-void __glXDisp_Scaled(GLbyte * pc)
+void
+__glXDisp_Scaled(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Scaled( GET_DISPATCH(), (
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLdouble *)(pc + 16)
-    ) );
+    glScaled(*(GLdouble *) (pc + 0),
+             *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16));
 }
 
-void __glXDisp_Scalef(GLbyte * pc)
+void
+__glXDisp_Scalef(GLbyte * pc)
 {
-    CALL_Scalef( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glScalef(*(GLfloat *) (pc + 0),
+             *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_Translated(GLbyte * pc)
+void
+__glXDisp_Translated(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Translated( GET_DISPATCH(), (
-        *(GLdouble *)(pc +  0),
-        *(GLdouble *)(pc +  8),
-        *(GLdouble *)(pc + 16)
-    ) );
+    glTranslated(*(GLdouble *) (pc + 0),
+                 *(GLdouble *) (pc + 8), *(GLdouble *) (pc + 16));
 }
 
-void __glXDisp_Translatef(GLbyte * pc)
+void
+__glXDisp_Translatef(GLbyte * pc)
 {
-    CALL_Translatef( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glTranslatef(*(GLfloat *) (pc + 0),
+                 *(GLfloat *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_Viewport(GLbyte * pc)
+void
+__glXDisp_Viewport(GLbyte * pc)
 {
-    CALL_Viewport( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLsizei  *)(pc +  8),
-        *(GLsizei  *)(pc + 12)
-    ) );
+    glViewport(*(GLint *) (pc + 0),
+               *(GLint *) (pc + 4),
+               *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
 }
 
-void __glXDisp_BindTexture(GLbyte * pc)
+void
+__glXDisp_BindTexture(GLbyte * pc)
 {
-    CALL_BindTexture( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    glBindTexture(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
-void __glXDisp_Indexubv(GLbyte * pc)
+void
+__glXDisp_Indexubv(GLbyte * pc)
 {
-    CALL_Indexubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glIndexubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDisp_PolygonOffset(GLbyte * pc)
+void
+__glXDisp_PolygonOffset(GLbyte * pc)
 {
-    CALL_PolygonOffset( GET_DISPATCH(), (
-        *(GLfloat  *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    glPolygonOffset(*(GLfloat *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLboolean retval;
         GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4),
-            residences
-        ) );
+        GLboolean *residences =
+            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        retval =
+            glAreTexturesResident(n, (const GLuint *) (pc + 4), residences);
         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
         error = Success;
     }
@@ -2760,24 +2485,23 @@ int __glXDisp_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLboolean retval;
         GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4),
-            residences
-        ) );
+        GLboolean *residences =
+            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        retval =
+            glAreTexturesResident(n, (const GLuint *) (pc + 4), residences);
         __glXSendReply(cl->client, residences, n, 1, GL_TRUE, retval);
         error = Success;
     }
@@ -2785,115 +2509,103 @@ int __glXDisp_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_CopyTexImage1D(GLbyte * pc)
+void
+__glXDisp_CopyTexImage1D(GLbyte * pc)
 {
-    CALL_CopyTexImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLsizei  *)(pc + 20),
-        *(GLint    *)(pc + 24)
-    ) );
+    glCopyTexImage1D(*(GLenum *) (pc + 0),
+                     *(GLint *) (pc + 4),
+                     *(GLenum *) (pc + 8),
+                     *(GLint *) (pc + 12),
+                     *(GLint *) (pc + 16),
+                     *(GLsizei *) (pc + 20), *(GLint *) (pc + 24));
 }
 
-void __glXDisp_CopyTexImage2D(GLbyte * pc)
+void
+__glXDisp_CopyTexImage2D(GLbyte * pc)
 {
-    CALL_CopyTexImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLsizei  *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLint    *)(pc + 28)
-    ) );
+    glCopyTexImage2D(*(GLenum *) (pc + 0),
+                     *(GLint *) (pc + 4),
+                     *(GLenum *) (pc + 8),
+                     *(GLint *) (pc + 12),
+                     *(GLint *) (pc + 16),
+                     *(GLsizei *) (pc + 20),
+                     *(GLsizei *) (pc + 24), *(GLint *) (pc + 28));
 }
 
-void __glXDisp_CopyTexSubImage1D(GLbyte * pc)
+void
+__glXDisp_CopyTexSubImage1D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLsizei  *)(pc + 20)
-    ) );
+    glCopyTexSubImage1D(*(GLenum *) (pc + 0),
+                        *(GLint *) (pc + 4),
+                        *(GLint *) (pc + 8),
+                        *(GLint *) (pc + 12),
+                        *(GLint *) (pc + 16), *(GLsizei *) (pc + 20));
 }
 
-void __glXDisp_CopyTexSubImage2D(GLbyte * pc)
+void
+__glXDisp_CopyTexSubImage2D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLint    *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLsizei  *)(pc + 28)
-    ) );
+    glCopyTexSubImage2D(*(GLenum *) (pc + 0),
+                        *(GLint *) (pc + 4),
+                        *(GLint *) (pc + 8),
+                        *(GLint *) (pc + 12),
+                        *(GLint *) (pc + 16),
+                        *(GLint *) (pc + 20),
+                        *(GLsizei *) (pc + 24), *(GLsizei *) (pc + 28));
 }
 
-int __glXDisp_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
-        CALL_DeleteTextures( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4)
-        ) );
+        glDeleteTextures(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
-        CALL_DeleteTextures( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4)
-        ) );
+        glDeleteTextures(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenTextures(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenTextures( GET_DISPATCH(), (
-            n,
-            textures
-        ) );
+        GLuint *textures =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        glGenTextures(n, textures);
         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -2901,22 +2613,22 @@ int __glXDisp_GenTextures(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenTextures( GET_DISPATCH(), (
-            n,
-            textures
-        ) );
+        GLuint *textures =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        glGenTextures(n, textures);
         __glXSendReply(cl->client, textures, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -2924,18 +2636,18 @@ int __glXDisp_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsTexture(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsTexture( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
+
+        retval = glIsTexture(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2943,18 +2655,18 @@ int __glXDisp_IsTexture(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsTexture( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
+
+        retval = glIsTexture(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2962,165 +2674,144 @@ int __glXDisp_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_PrioritizeTextures(GLbyte * pc)
+void
+__glXDisp_PrioritizeTextures(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  0);
+    const GLsizei n = *(GLsizei *) (pc + 0);
 
-    CALL_PrioritizeTextures( GET_DISPATCH(), (
-        n,
-         (const GLuint *)(pc +  4),
-         (const GLclampf *)(pc +  4)
-    ) );
+    glPrioritizeTextures(n,
+                         (const GLuint *) (pc + 4),
+                         (const GLclampf *) (pc + 4));
 }
 
-void __glXDisp_TexSubImage1D(GLbyte * pc)
+void
+__glXDisp_TexSubImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexSubImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLint    *)(pc + 28),
-        *(GLsizei  *)(pc + 36),
-        *(GLenum   *)(pc + 44),
-        *(GLenum   *)(pc + 48),
-        pixels
-    ) );
+    glTexSubImage1D(*(GLenum *) (pc + 20),
+                    *(GLint *) (pc + 24),
+                    *(GLint *) (pc + 28),
+                    *(GLsizei *) (pc + 36),
+                    *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
 }
 
-void __glXDisp_TexSubImage2D(GLbyte * pc)
+void
+__glXDisp_TexSubImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexSubImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLint    *)(pc + 28),
-        *(GLint    *)(pc + 32),
-        *(GLsizei  *)(pc + 36),
-        *(GLsizei  *)(pc + 40),
-        *(GLenum   *)(pc + 44),
-        *(GLenum   *)(pc + 48),
-        pixels
-    ) );
+    glTexSubImage2D(*(GLenum *) (pc + 20),
+                    *(GLint *) (pc + 24),
+                    *(GLint *) (pc + 28),
+                    *(GLint *) (pc + 32),
+                    *(GLsizei *) (pc + 36),
+                    *(GLsizei *) (pc + 40),
+                    *(GLenum *) (pc + 44), *(GLenum *) (pc + 48), pixels);
 }
 
-void __glXDisp_BlendColor(GLbyte * pc)
+void
+__glXDisp_BlendColor(GLbyte * pc)
 {
-    CALL_BlendColor( GET_DISPATCH(), (
-        *(GLclampf *)(pc +  0),
-        *(GLclampf *)(pc +  4),
-        *(GLclampf *)(pc +  8),
-        *(GLclampf *)(pc + 12)
-    ) );
+    glBlendColor(*(GLclampf *) (pc + 0),
+                 *(GLclampf *) (pc + 4),
+                 *(GLclampf *) (pc + 8), *(GLclampf *) (pc + 12));
 }
 
-void __glXDisp_BlendEquation(GLbyte * pc)
+void
+__glXDisp_BlendEquation(GLbyte * pc)
 {
-    CALL_BlendEquation( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glBlendEquation(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_ColorTable(GLbyte * pc)
+void
+__glXDisp_ColorTable(GLbyte * pc)
 {
-    const GLvoid * const table = (const GLvoid *) (pc + 40);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const table = (const GLvoid *) ((pc + 40));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_ColorTable( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLenum   *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLenum   *)(pc + 32),
-        *(GLenum   *)(pc + 36),
-        table
-    ) );
+    glColorTable(*(GLenum *) (pc + 20),
+                 *(GLenum *) (pc + 24),
+                 *(GLsizei *) (pc + 28),
+                 *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), table);
 }
 
-void __glXDisp_ColorTableParameterfv(GLbyte * pc)
+void
+__glXDisp_ColorTableParameterfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_ColorTableParameterfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_ColorTableParameteriv(GLbyte * pc)
+void
+__glXDisp_ColorTableParameteriv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_ColorTableParameteriv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_CopyColorTable(GLbyte * pc)
+void
+__glXDisp_CopyColorTable(GLbyte * pc)
 {
-    CALL_CopyColorTable( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLsizei  *)(pc + 16)
-    ) );
+    glCopyColorTable(*(GLenum *) (pc + 0),
+                     *(GLenum *) (pc + 4),
+                     *(GLint *) (pc + 8),
+                     *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
 }
 
-int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3128,28 +2819,28 @@ int __glXDisp_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetColorTableParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3157,28 +2848,28 @@ int __glXDisp_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3186,28 +2877,28 @@ int __glXDisp_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetColorTableParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3215,175 +2906,150 @@ int __glXDisp_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_ColorSubTable(GLbyte * pc)
+void
+__glXDisp_ColorSubTable(GLbyte * pc)
 {
-    const GLvoid * const data = (const GLvoid *) (pc + 40);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const data = (const GLvoid *) ((pc + 40));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_ColorSubTable( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLenum   *)(pc + 32),
-        *(GLenum   *)(pc + 36),
-        data
-    ) );
+    glColorSubTable(*(GLenum *) (pc + 20),
+                    *(GLsizei *) (pc + 24),
+                    *(GLsizei *) (pc + 28),
+                    *(GLenum *) (pc + 32), *(GLenum *) (pc + 36), data);
 }
 
-void __glXDisp_CopyColorSubTable(GLbyte * pc)
+void
+__glXDisp_CopyColorSubTable(GLbyte * pc)
 {
-    CALL_CopyColorSubTable( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLsizei  *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLsizei  *)(pc + 16)
-    ) );
+    glCopyColorSubTable(*(GLenum *) (pc + 0),
+                        *(GLsizei *) (pc + 4),
+                        *(GLint *) (pc + 8),
+                        *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
 }
 
-void __glXDisp_ConvolutionFilter1D(GLbyte * pc)
+void
+__glXDisp_ConvolutionFilter1D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const image = (const GLvoid *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_ConvolutionFilter1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLenum   *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLenum   *)(pc + 36),
-        *(GLenum   *)(pc + 40),
-        image
-    ) );
+    glConvolutionFilter1D(*(GLenum *) (pc + 20),
+                          *(GLenum *) (pc + 24),
+                          *(GLsizei *) (pc + 28),
+                          *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image);
 }
 
-void __glXDisp_ConvolutionFilter2D(GLbyte * pc)
+void
+__glXDisp_ConvolutionFilter2D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const image = (const GLvoid *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_ConvolutionFilter2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 20),
-        *(GLenum   *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLsizei  *)(pc + 32),
-        *(GLenum   *)(pc + 36),
-        *(GLenum   *)(pc + 40),
-        image
-    ) );
+    glConvolutionFilter2D(*(GLenum *) (pc + 20),
+                          *(GLenum *) (pc + 24),
+                          *(GLsizei *) (pc + 28),
+                          *(GLsizei *) (pc + 32),
+                          *(GLenum *) (pc + 36), *(GLenum *) (pc + 40), image);
 }
 
-void __glXDisp_ConvolutionParameterf(GLbyte * pc)
+void
+__glXDisp_ConvolutionParameterf(GLbyte * pc)
 {
-    CALL_ConvolutionParameterf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLfloat  *)(pc +  8)
-    ) );
+    glConvolutionParameterf(*(GLenum *) (pc + 0),
+                            *(GLenum *) (pc + 4), *(GLfloat *) (pc + 8));
 }
 
-void __glXDisp_ConvolutionParameterfv(GLbyte * pc)
+void
+__glXDisp_ConvolutionParameterfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLfloat * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 8);
 
-    CALL_ConvolutionParameterfv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_ConvolutionParameteri(GLbyte * pc)
+void
+__glXDisp_ConvolutionParameteri(GLbyte * pc)
 {
-    CALL_ConvolutionParameteri( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8)
-    ) );
+    glConvolutionParameteri(*(GLenum *) (pc + 0),
+                            *(GLenum *) (pc + 4), *(GLint *) (pc + 8));
 }
 
-void __glXDisp_ConvolutionParameteriv(GLbyte * pc)
+void
+__glXDisp_ConvolutionParameteriv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  4);
-    const GLint * params;
+    const GLenum pname = *(GLenum *) (pc + 4);
+    const GLint *params;
 
     params = (const GLint *) (pc + 8);
 
-    CALL_ConvolutionParameteriv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        pname,
-        params
-    ) );
+    glConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
 }
 
-void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
+void
+__glXDisp_CopyConvolutionFilter1D(GLbyte * pc)
 {
-    CALL_CopyConvolutionFilter1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLsizei  *)(pc + 16)
-    ) );
+    glCopyConvolutionFilter1D(*(GLenum *) (pc + 0),
+                              *(GLenum *) (pc + 4),
+                              *(GLint *) (pc + 8),
+                              *(GLint *) (pc + 12), *(GLsizei *) (pc + 16));
 }
 
-void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
+void
+__glXDisp_CopyConvolutionFilter2D(GLbyte * pc)
 {
-    CALL_CopyConvolutionFilter2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLsizei  *)(pc + 16),
-        *(GLsizei  *)(pc + 20)
-    ) );
+    glCopyConvolutionFilter2D(*(GLenum *) (pc + 0),
+                              *(GLenum *) (pc + 4),
+                              *(GLint *) (pc + 8),
+                              *(GLint *) (pc + 12),
+                              *(GLsizei *) (pc + 16), *(GLsizei *) (pc + 20));
 }
 
-int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3391,28 +3057,28 @@ int __glXDisp_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetConvolutionParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3420,28 +3086,28 @@ int __glXDisp_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3449,28 +3115,28 @@ int __glXDisp_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetConvolutionParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3478,28 +3144,28 @@ int __glXDisp_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3507,28 +3173,28 @@ int __glXDisp_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetHistogramParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3536,28 +3202,28 @@ int __glXDisp_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3565,28 +3231,28 @@ int __glXDisp_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetHistogramParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3594,28 +3260,28 @@ int __glXDisp_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3623,28 +3289,28 @@ int __glXDisp_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMinmaxParameterfv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3652,28 +3318,28 @@ int __glXDisp_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3681,28 +3347,28 @@ int __glXDisp_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        glGetMinmaxParameteriv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3710,562 +3376,526 @@ int __glXDisp_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_Histogram(GLbyte * pc)
-{
-    CALL_Histogram( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLsizei  *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLboolean *)(pc + 12)
-    ) );
+void
+__glXDisp_Histogram(GLbyte * pc)
+{
+    glHistogram(*(GLenum *) (pc + 0),
+                *(GLsizei *) (pc + 4),
+                *(GLenum *) (pc + 8), *(GLboolean *) (pc + 12));
 }
 
-void __glXDisp_Minmax(GLbyte * pc)
+void
+__glXDisp_Minmax(GLbyte * pc)
 {
-    CALL_Minmax( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLboolean *)(pc +  8)
-    ) );
+    glMinmax(*(GLenum *) (pc + 0),
+             *(GLenum *) (pc + 4), *(GLboolean *) (pc + 8));
 }
 
-void __glXDisp_ResetHistogram(GLbyte * pc)
+void
+__glXDisp_ResetHistogram(GLbyte * pc)
 {
-    CALL_ResetHistogram( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glResetHistogram(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_ResetMinmax(GLbyte * pc)
+void
+__glXDisp_ResetMinmax(GLbyte * pc)
 {
-    CALL_ResetMinmax( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glResetMinmax(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_TexImage3D(GLbyte * pc)
+void
+__glXDisp_TexImage3D(GLbyte * pc)
 {
-    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
-    const GLvoid * const pixels = (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
-    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
+    const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
+    const GLvoid *const pixels =
+        (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
+    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexImage3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 36),
-        *(GLint    *)(pc + 40),
-        *(GLint    *)(pc + 44),
-        *(GLsizei  *)(pc + 48),
-        *(GLsizei  *)(pc + 52),
-        *(GLsizei  *)(pc + 56),
-        *(GLint    *)(pc + 64),
-        *(GLenum   *)(pc + 68),
-        *(GLenum   *)(pc + 72),
-        pixels
-    ) );
+    glTexImage3D(*(GLenum *) (pc + 36),
+                 *(GLint *) (pc + 40),
+                 *(GLint *) (pc + 44),
+                 *(GLsizei *) (pc + 48),
+                 *(GLsizei *) (pc + 52),
+                 *(GLsizei *) (pc + 56),
+                 *(GLint *) (pc + 64),
+                 *(GLenum *) (pc + 68), *(GLenum *) (pc + 72), pixels);
 }
 
-void __glXDisp_TexSubImage3D(GLbyte * pc)
+void
+__glXDisp_TexSubImage3D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 88);
-    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
+    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) hdr->rowLength) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) hdr->skipRows) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) hdr->skipImages) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) hdr->skipPixels) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) hdr->alignment) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
+    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, (GLint) hdr->imageHeight);
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
+    glPixelStorei(GL_UNPACK_SKIP_IMAGES, (GLint) hdr->skipImages);
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
 
-    CALL_TexSubImage3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 36),
-        *(GLint    *)(pc + 40),
-        *(GLint    *)(pc + 44),
-        *(GLint    *)(pc + 48),
-        *(GLint    *)(pc + 52),
-        *(GLsizei  *)(pc + 60),
-        *(GLsizei  *)(pc + 64),
-        *(GLsizei  *)(pc + 68),
-        *(GLenum   *)(pc + 76),
-        *(GLenum   *)(pc + 80),
-        pixels
-    ) );
+    glTexSubImage3D(*(GLenum *) (pc + 36),
+                    *(GLint *) (pc + 40),
+                    *(GLint *) (pc + 44),
+                    *(GLint *) (pc + 48),
+                    *(GLint *) (pc + 52),
+                    *(GLsizei *) (pc + 60),
+                    *(GLsizei *) (pc + 64),
+                    *(GLsizei *) (pc + 68),
+                    *(GLenum *) (pc + 76), *(GLenum *) (pc + 80), pixels);
 }
 
-void __glXDisp_CopyTexSubImage3D(GLbyte * pc)
+void
+__glXDisp_CopyTexSubImage3D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLint    *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLsizei  *)(pc + 32)
-    ) );
+    glCopyTexSubImage3D(*(GLenum *) (pc + 0),
+                        *(GLint *) (pc + 4),
+                        *(GLint *) (pc + 8),
+                        *(GLint *) (pc + 12),
+                        *(GLint *) (pc + 16),
+                        *(GLint *) (pc + 20),
+                        *(GLint *) (pc + 24),
+                        *(GLsizei *) (pc + 28), *(GLsizei *) (pc + 32));
 }
 
-void __glXDisp_ActiveTexture(GLbyte * pc)
+void
+__glXDisp_ActiveTexture(GLbyte * pc)
 {
-    CALL_ActiveTexture( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    glActiveTextureARB(*(GLenum *) (pc + 0));
 }
 
-void __glXDisp_MultiTexCoord1dv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord1dv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  8),
-         (const GLdouble *)(pc +  0)
-    ) );
+    glMultiTexCoord1dvARB(*(GLenum *) (pc + 8), (const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord1fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord1fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    glMultiTexCoord1fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord1iv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord1iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord1iv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    glMultiTexCoord1ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord1sv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord1sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord1sv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    glMultiTexCoord1svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord2dv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord2dv( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 16),
-         (const GLdouble *)(pc +  0)
-    ) );
+    glMultiTexCoord2dvARB(*(GLenum *) (pc + 16), (const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord2fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord2fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    glMultiTexCoord2fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord2iv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord2iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord2iv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    glMultiTexCoord2ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord2sv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord2sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord2sv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    glMultiTexCoord2svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord3dv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord3dv( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 24),
-         (const GLdouble *)(pc +  0)
-    ) );
+    glMultiTexCoord3dvARB(*(GLenum *) (pc + 24), (const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord3fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord3fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    glMultiTexCoord3fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord3iv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord3iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord3iv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    glMultiTexCoord3ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord3sv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord3sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord3sv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    glMultiTexCoord3svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord4dv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord4dv( GET_DISPATCH(), (
-        *(GLenum   *)(pc + 32),
-         (const GLdouble *)(pc +  0)
-    ) );
+    glMultiTexCoord4dvARB(*(GLenum *) (pc + 32), (const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord4fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord4fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    glMultiTexCoord4fvARB(*(GLenum *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord4iv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord4iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord4iv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    glMultiTexCoord4ivARB(*(GLenum *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_MultiTexCoord4sv(GLbyte * pc)
+void
+__glXDisp_MultiTexCoord4sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord4sv( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    glMultiTexCoord4svARB(*(GLenum *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_CompressedTexImage1D(GLbyte * pc)
+void
+__glXDisp_CompressedTexImage1D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
+    PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
+        __glGetProcAddress("glCompressedTexImage1D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 20);
 
-    CALL_CompressedTexImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        imageSize,
-         (const GLvoid *)(pc + 24)
-    ) );
+    CompressedTexImage1D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLint *) (pc + 16),
+                         imageSize, (const GLvoid *) (pc + 24));
 }
 
-void __glXDisp_CompressedTexImage2D(GLbyte * pc)
+void
+__glXDisp_CompressedTexImage2D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 24);
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
+        __glGetProcAddress("glCompressedTexImage2D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 24);
 
-    CALL_CompressedTexImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLsizei  *)(pc + 16),
-        *(GLint    *)(pc + 20),
-        imageSize,
-         (const GLvoid *)(pc + 28)
-    ) );
+    CompressedTexImage2D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLsizei *) (pc + 16),
+                         *(GLint *) (pc + 20),
+                         imageSize, (const GLvoid *) (pc + 28));
 }
 
-void __glXDisp_CompressedTexImage3D(GLbyte * pc)
+void
+__glXDisp_CompressedTexImage3D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
+    PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
+        __glGetProcAddress("glCompressedTexImage3D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 28);
 
-    CALL_CompressedTexImage3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLsizei  *)(pc + 16),
-        *(GLsizei  *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        imageSize,
-         (const GLvoid *)(pc + 32)
-    ) );
+    CompressedTexImage3D(*(GLenum *) (pc + 0),
+                         *(GLint *) (pc + 4),
+                         *(GLenum *) (pc + 8),
+                         *(GLsizei *) (pc + 12),
+                         *(GLsizei *) (pc + 16),
+                         *(GLsizei *) (pc + 20),
+                         *(GLint *) (pc + 24),
+                         imageSize, (const GLvoid *) (pc + 32));
 }
 
-void __glXDisp_CompressedTexSubImage1D(GLbyte * pc)
+void
+__glXDisp_CompressedTexSubImage1D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 20);
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
+        __glGetProcAddress("glCompressedTexSubImage1D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 20);
 
-    CALL_CompressedTexSubImage1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLenum   *)(pc + 16),
-        imageSize,
-         (const GLvoid *)(pc + 24)
-    ) );
+    CompressedTexSubImage1D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLsizei *) (pc + 12),
+                            *(GLenum *) (pc + 16),
+                            imageSize, (const GLvoid *) (pc + 24));
 }
 
-void __glXDisp_CompressedTexSubImage2D(GLbyte * pc)
+void
+__glXDisp_CompressedTexSubImage2D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 28);
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
+        __glGetProcAddress("glCompressedTexSubImage2D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 28);
 
-    CALL_CompressedTexSubImage2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLsizei  *)(pc + 16),
-        *(GLsizei  *)(pc + 20),
-        *(GLenum   *)(pc + 24),
-        imageSize,
-         (const GLvoid *)(pc + 32)
-    ) );
+    CompressedTexSubImage2D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLint *) (pc + 12),
+                            *(GLsizei *) (pc + 16),
+                            *(GLsizei *) (pc + 20),
+                            *(GLenum *) (pc + 24),
+                            imageSize, (const GLvoid *) (pc + 32));
 }
 
-void __glXDisp_CompressedTexSubImage3D(GLbyte * pc)
+void
+__glXDisp_CompressedTexSubImage3D(GLbyte * pc)
 {
-    const GLsizei imageSize = *(GLsizei  *)(pc + 36);
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
+        __glGetProcAddress("glCompressedTexSubImage3D");
+    const GLsizei imageSize = *(GLsizei *) (pc + 36);
 
-    CALL_CompressedTexSubImage3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLsizei  *)(pc + 20),
-        *(GLsizei  *)(pc + 24),
-        *(GLsizei  *)(pc + 28),
-        *(GLenum   *)(pc + 32),
-        imageSize,
-         (const GLvoid *)(pc + 40)
-    ) );
+    CompressedTexSubImage3D(*(GLenum *) (pc + 0),
+                            *(GLint *) (pc + 4),
+                            *(GLint *) (pc + 8),
+                            *(GLint *) (pc + 12),
+                            *(GLint *) (pc + 16),
+                            *(GLsizei *) (pc + 20),
+                            *(GLsizei *) (pc + 24),
+                            *(GLsizei *) (pc + 28),
+                            *(GLenum *) (pc + 32),
+                            imageSize, (const GLvoid *) (pc + 40));
 }
 
-void __glXDisp_SampleCoverage(GLbyte * pc)
+void
+__glXDisp_SampleCoverage(GLbyte * pc)
 {
-    CALL_SampleCoverage( GET_DISPATCH(), (
-        *(GLclampf *)(pc +  0),
-        *(GLboolean *)(pc +  4)
-    ) );
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage =
+        __glGetProcAddress("glSampleCoverage");
+    SampleCoverage(*(GLclampf *) (pc + 0), *(GLboolean *) (pc + 4));
 }
 
-void __glXDisp_BlendFuncSeparate(GLbyte * pc)
+void
+__glXDisp_BlendFuncSeparate(GLbyte * pc)
 {
-    CALL_BlendFuncSeparate( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLenum   *)(pc + 12)
-    ) );
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
+        __glGetProcAddress("glBlendFuncSeparate");
+    BlendFuncSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                      *(GLenum *) (pc + 8), *(GLenum *) (pc + 12));
 }
 
-void __glXDisp_FogCoorddv(GLbyte * pc)
+void
+__glXDisp_FogCoorddv(GLbyte * pc)
 {
+    PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
+
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_FogCoorddv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    FogCoorddv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_PointParameterf(GLbyte * pc)
+void
+__glXDisp_PointParameterf(GLbyte * pc)
 {
-    CALL_PointParameterf( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLfloat  *)(pc +  4)
-    ) );
+    PFNGLPOINTPARAMETERFPROC PointParameterf =
+        __glGetProcAddress("glPointParameterf");
+    PointParameterf(*(GLenum *) (pc + 0), *(GLfloat *) (pc + 4));
 }
 
-void __glXDisp_PointParameterfv(GLbyte * pc)
+void
+__glXDisp_PointParameterfv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLfloat * params;
+    PFNGLPOINTPARAMETERFVPROC PointParameterfv =
+        __glGetProcAddress("glPointParameterfv");
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLfloat *params;
 
     params = (const GLfloat *) (pc + 4);
 
-    CALL_PointParameterfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    PointParameterfv(pname, params);
 }
 
-void __glXDisp_PointParameteri(GLbyte * pc)
+void
+__glXDisp_PointParameteri(GLbyte * pc)
 {
-    CALL_PointParameteri( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLint    *)(pc +  4)
-    ) );
+    PFNGLPOINTPARAMETERIPROC PointParameteri =
+        __glGetProcAddress("glPointParameteri");
+    PointParameteri(*(GLenum *) (pc + 0), *(GLint *) (pc + 4));
 }
 
-void __glXDisp_PointParameteriv(GLbyte * pc)
+void
+__glXDisp_PointParameteriv(GLbyte * pc)
 {
-    const GLenum pname = *(GLenum   *)(pc +  0);
-    const GLint * params;
+    PFNGLPOINTPARAMETERIVPROC PointParameteriv =
+        __glGetProcAddress("glPointParameteriv");
+    const GLenum pname = *(GLenum *) (pc + 0);
+    const GLint *params;
 
     params = (const GLint *) (pc + 4);
 
-    CALL_PointParameteriv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    PointParameteriv(pname, params);
 }
 
-void __glXDisp_SecondaryColor3bv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3bv(GLbyte * pc)
 {
-    CALL_SecondaryColor3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
+        __glGetProcAddress("glSecondaryColor3bv");
+    SecondaryColor3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3dv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3dv(GLbyte * pc)
 {
+    PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
+        __glGetProcAddress("glSecondaryColor3dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_SecondaryColor3dv( GET_DISPATCH(), (
-         (const GLdouble *)(pc +  0)
-    ) );
+    SecondaryColor3dv((const GLdouble *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3iv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3iv(GLbyte * pc)
 {
-    CALL_SecondaryColor3iv( GET_DISPATCH(), (
-         (const GLint *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
+        __glGetProcAddress("glSecondaryColor3iv");
+    SecondaryColor3iv((const GLint *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3sv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3sv(GLbyte * pc)
 {
-    CALL_SecondaryColor3sv( GET_DISPATCH(), (
-         (const GLshort *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
+        __glGetProcAddress("glSecondaryColor3sv");
+    SecondaryColor3sv((const GLshort *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3ubv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3ubv(GLbyte * pc)
 {
-    CALL_SecondaryColor3ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
+        __glGetProcAddress("glSecondaryColor3ubv");
+    SecondaryColor3ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3uiv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3uiv(GLbyte * pc)
 {
-    CALL_SecondaryColor3uiv( GET_DISPATCH(), (
-         (const GLuint *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
+        __glGetProcAddress("glSecondaryColor3uiv");
+    SecondaryColor3uiv((const GLuint *) (pc + 0));
 }
 
-void __glXDisp_SecondaryColor3usv(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3usv(GLbyte * pc)
 {
-    CALL_SecondaryColor3usv( GET_DISPATCH(), (
-         (const GLushort *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
+        __glGetProcAddress("glSecondaryColor3usv");
+    SecondaryColor3usv((const GLushort *) (pc + 0));
 }
 
-void __glXDisp_WindowPos3fv(GLbyte * pc)
+void
+__glXDisp_WindowPos3fv(GLbyte * pc)
 {
-    CALL_WindowPos3fv( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
+    PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
+
+    WindowPos3fv((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_BeginQuery(GLbyte * pc)
+void
+__glXDisp_BeginQuery(GLbyte * pc)
 {
-    CALL_BeginQuery( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
+
+    BeginQuery(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
-int __glXDisp_DeleteQueries(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLDELETEQUERIESPROC DeleteQueries =
+        __glGetProcAddress("glDeleteQueries");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
-        CALL_DeleteQueries( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4)
-        ) );
+        DeleteQueries(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-void __glXDisp_EndQuery(GLbyte * pc)
+void
+__glXDisp_EndQuery(GLbyte * pc)
 {
-    CALL_EndQuery( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
+
+    EndQuery(*(GLenum *) (pc + 0));
 }
 
-int __glXDisp_GenQueries(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenQueries(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenQueries( GET_DISPATCH(), (
-            n,
-            ids
-        ) );
+        GLuint *ids =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenQueries(n, ids);
         __glXSendReply(cl->client, ids, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4273,28 +3903,30 @@ int __glXDisp_GenQueries(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetQueryObjectiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
+        __glGetProcAddress("glGetQueryObjectiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetQueryObjectiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryObjectiv( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
+        GetQueryObjectiv(*(GLuint *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4302,28 +3934,30 @@ int __glXDisp_GetQueryObjectiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetQueryObjectuiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
+        __glGetProcAddress("glGetQueryObjectuiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetQueryObjectuiv_size(pname);
         GLuint answerBuffer[200];
-        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLuint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryObjectuiv( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
+        GetQueryObjectuiv(*(GLuint *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4331,28 +3965,29 @@ int __glXDisp_GetQueryObjectuiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetQueryiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetQueryiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryiv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        GetQueryiv(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4360,362 +3995,277 @@ int __glXDisp_GetQueryiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsQuery(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsQuery(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsQuery( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
-        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
-        error = Success;
-    }
-
-    return error;
-}
-
-void __glXDisp_BlendEquationSeparate(GLbyte * pc)
-{
-    CALL_BlendEquationSeparate( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
-}
-
-void __glXDisp_DrawBuffers(GLbyte * pc)
-{
-    const GLsizei n = *(GLsizei  *)(pc +  0);
-
-    CALL_DrawBuffers( GET_DISPATCH(), (
-        n,
-         (const GLenum *)(pc +  4)
-    ) );
-}
-
-int __glXDisp_GetVertexAttribdv(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetVertexAttribdv_size(pname);
-        GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
 
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribdv( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
+        retval = IsQuery(*(GLuint *) (pc + 0));
+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_GetVertexAttribfv(__GLXclientState *cl, GLbyte *pc)
+void
+__glXDisp_BlendEquationSeparate(GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetVertexAttribfv_size(pname);
-        GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribfv( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
+        __glGetProcAddress("glBlendEquationSeparate");
+    BlendEquationSeparate(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-int __glXDisp_GetVertexAttribiv(__GLXclientState *cl, GLbyte *pc)
+void
+__glXDisp_DrawBuffers(GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetVertexAttribiv_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribiv( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
+    PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
+    const GLsizei n = *(GLsizei *) (pc + 0);
 
-    return error;
+    DrawBuffers(n, (const GLenum *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib1dv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
+        __glGetProcAddress("glVertexAttrib1dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib1dv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib1dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib1sv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1sv(GLbyte * pc)
 {
-    CALL_VertexAttrib1sv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
+        __glGetProcAddress("glVertexAttrib1sv");
+    VertexAttrib1sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2dv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
+        __glGetProcAddress("glVertexAttrib2dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib2dv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib2dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2sv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2sv(GLbyte * pc)
 {
-    CALL_VertexAttrib2sv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
+        __glGetProcAddress("glVertexAttrib2sv");
+    VertexAttrib2sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3dv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
+        __glGetProcAddress("glVertexAttrib3dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib3dv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib3dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3sv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3sv(GLbyte * pc)
 {
-    CALL_VertexAttrib3sv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
+        __glGetProcAddress("glVertexAttrib3sv");
+    VertexAttrib3sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Nbv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Nbv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nbv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLbyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
+        __glGetProcAddress("glVertexAttrib4Nbv");
+    VertexAttrib4Nbv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Niv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Niv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Niv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
+        __glGetProcAddress("glVertexAttrib4Niv");
+    VertexAttrib4Niv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Nsv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Nsv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nsv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
+        __glGetProcAddress("glVertexAttrib4Nsv");
+    VertexAttrib4Nsv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Nubv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Nubv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nubv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
+        __glGetProcAddress("glVertexAttrib4Nubv");
+    VertexAttrib4Nubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Nuiv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Nuiv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nuiv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLuint *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
+        __glGetProcAddress("glVertexAttrib4Nuiv");
+    VertexAttrib4Nuiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4Nusv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4Nusv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nusv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLushort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
+        __glGetProcAddress("glVertexAttrib4Nusv");
+    VertexAttrib4Nusv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4bv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4bv(GLbyte * pc)
 {
-    CALL_VertexAttrib4bv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLbyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
+        __glGetProcAddress("glVertexAttrib4bv");
+    VertexAttrib4bv(*(GLuint *) (pc + 0), (const GLbyte *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4dv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
+        __glGetProcAddress("glVertexAttrib4dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib4dv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib4dv(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4iv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4iv(GLbyte * pc)
 {
-    CALL_VertexAttrib4iv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLint *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
+        __glGetProcAddress("glVertexAttrib4iv");
+    VertexAttrib4iv(*(GLuint *) (pc + 0), (const GLint *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4sv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4sv(GLbyte * pc)
 {
-    CALL_VertexAttrib4sv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
+        __glGetProcAddress("glVertexAttrib4sv");
+    VertexAttrib4sv(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4ubv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4ubv(GLbyte * pc)
 {
-    CALL_VertexAttrib4ubv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
+        __glGetProcAddress("glVertexAttrib4ubv");
+    VertexAttrib4ubv(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4uiv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4uiv(GLbyte * pc)
 {
-    CALL_VertexAttrib4uiv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLuint *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
+        __glGetProcAddress("glVertexAttrib4uiv");
+    VertexAttrib4uiv(*(GLuint *) (pc + 0), (const GLuint *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4usv(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4usv(GLbyte * pc)
 {
-    CALL_VertexAttrib4usv( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLushort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
+        __glGetProcAddress("glVertexAttrib4usv");
+    VertexAttrib4usv(*(GLuint *) (pc + 0), (const GLushort *) (pc + 4));
 }
 
-void __glXDisp_ClampColor(GLbyte * pc)
+void
+__glXDisp_ClampColor(GLbyte * pc)
 {
-    CALL_ClampColor( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4)
-    ) );
+    PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
+
+    ClampColor(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4));
 }
 
-void __glXDisp_BindProgramARB(GLbyte * pc)
+void
+__glXDisp_BindProgramARB(GLbyte * pc)
 {
-    CALL_BindProgramARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    PFNGLBINDPROGRAMARBPROC BindProgramARB =
+        __glGetProcAddress("glBindProgramARB");
+    BindProgramARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
-int __glXDisp_DeleteProgramsARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
+        __glGetProcAddress("glDeleteProgramsARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
-        CALL_DeleteProgramsARB( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4)
-        ) );
+        DeleteProgramsARB(n, (const GLuint *) (pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDisp_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENPROGRAMSARBPROC GenProgramsARB =
+        __glGetProcAddress("glGenProgramsARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenProgramsARB( GET_DISPATCH(), (
-            n,
-            programs
-        ) );
+        GLuint *programs =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenProgramsARB(n, programs);
         __glXSendReply(cl->client, programs, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4723,20 +4273,21 @@ int __glXDisp_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
+        __glGetProcAddress("glGetProgramEnvParameterdvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble params[4];
-        CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            params
-        ) );
+
+        GetProgramEnvParameterdvARB(*(GLenum *) (pc + 0),
+                                    *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4744,20 +4295,21 @@ int __glXDisp_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
+        __glGetProcAddress("glGetProgramEnvParameterfvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLfloat params[4];
-        CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            params
-        ) );
+
+        GetProgramEnvParameterfvARB(*(GLenum *) (pc + 0),
+                                    *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4765,20 +4317,21 @@ int __glXDisp_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
+        __glGetProcAddress("glGetProgramLocalParameterdvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble params[4];
-        CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            params
-        ) );
+
+        GetProgramLocalParameterdvARB(*(GLenum *) (pc + 0),
+                                      *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4786,20 +4339,21 @@ int __glXDisp_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
+        __glGetProcAddress("glGetProgramLocalParameterfvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLfloat params[4];
-        CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            params
-        ) );
+
+        GetProgramLocalParameterfvARB(*(GLenum *) (pc + 0),
+                                      *(GLuint *) (pc + 4), params);
         __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4807,28 +4361,30 @@ int __glXDisp_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
+        __glGetProcAddress("glGetProgramivARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
+    if (cx != NULL) {
+        const GLenum pname = *(GLenum *) (pc + 4);
 
         const GLuint compsize = __glGetProgramivARB_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetProgramivARB( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            pname,
-            params
-        ) );
+        GetProgramivARB(*(GLenum *) (pc + 0), pname, params);
         __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4836,18 +4392,19 @@ int __glXDisp_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsProgramARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsProgramARB( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
+
+        retval = IsProgramARB(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4855,144 +4412,143 @@ int __glXDisp_IsProgramARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
+void
+__glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
+        __glGetProcAddress("glProgramEnvParameter4dvARB");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-         (const GLdouble *)(pc +  8)
-    ) );
+    ProgramEnvParameter4dvARB(*(GLenum *) (pc + 0),
+                              *(GLuint *) (pc + 4),
+                              (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
+void
+__glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc)
 {
-    CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-         (const GLfloat *)(pc +  8)
-    ) );
+    PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
+        __glGetProcAddress("glProgramEnvParameter4fvARB");
+    ProgramEnvParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
+                              (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
+void
+__glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
+        __glGetProcAddress("glProgramLocalParameter4dvARB");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-         (const GLdouble *)(pc +  8)
-    ) );
+    ProgramLocalParameter4dvARB(*(GLenum *) (pc + 0),
+                                *(GLuint *) (pc + 4),
+                                (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
+void
+__glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc)
 {
-    CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-         (const GLfloat *)(pc +  8)
-    ) );
+    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
+        __glGetProcAddress("glProgramLocalParameter4fvARB");
+    ProgramLocalParameter4fvARB(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4),
+                                (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_ProgramStringARB(GLbyte * pc)
+void
+__glXDisp_ProgramStringARB(GLbyte * pc)
 {
-    const GLsizei len = *(GLsizei  *)(pc +  8);
+    PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
+        __glGetProcAddress("glProgramStringARB");
+    const GLsizei len = *(GLsizei *) (pc + 8);
 
-    CALL_ProgramStringARB( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        len,
-         (const GLvoid *)(pc + 12)
-    ) );
+    ProgramStringARB(*(GLenum *) (pc + 0),
+                     *(GLenum *) (pc + 4), len, (const GLvoid *) (pc + 12));
 }
 
-void __glXDisp_VertexAttrib1fvARB(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib1fvARB( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
+        __glGetProcAddress("glVertexAttrib1fvARB");
+    VertexAttrib1fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2fvARB(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib2fvARB( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
+        __glGetProcAddress("glVertexAttrib2fvARB");
+    VertexAttrib2fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3fvARB(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib3fvARB( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
+        __glGetProcAddress("glVertexAttrib3fvARB");
+    VertexAttrib3fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4fvARB(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
+        __glGetProcAddress("glVertexAttrib4fvARB");
+    VertexAttrib4fvARB(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_BindFramebuffer(GLbyte * pc)
+void
+__glXDisp_BindFramebuffer(GLbyte * pc)
 {
-    CALL_BindFramebuffer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
+        __glGetProcAddress("glBindFramebuffer");
+    BindFramebuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
-void __glXDisp_BindRenderbuffer(GLbyte * pc)
+void
+__glXDisp_BindRenderbuffer(GLbyte * pc)
 {
-    CALL_BindRenderbuffer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
+        __glGetProcAddress("glBindRenderbuffer");
+    BindRenderbuffer(*(GLenum *) (pc + 0), *(GLuint *) (pc + 4));
 }
 
-void __glXDisp_BlitFramebuffer(GLbyte * pc)
+void
+__glXDisp_BlitFramebuffer(GLbyte * pc)
 {
-    CALL_BlitFramebuffer( GET_DISPATCH(), (
-        *(GLint    *)(pc +  0),
-        *(GLint    *)(pc +  4),
-        *(GLint    *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLint    *)(pc + 20),
-        *(GLint    *)(pc + 24),
-        *(GLint    *)(pc + 28),
-        *(GLbitfield *)(pc + 32),
-        *(GLenum   *)(pc + 36)
-    ) );
+    PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
+        __glGetProcAddress("glBlitFramebuffer");
+    BlitFramebuffer(*(GLint *) (pc + 0), *(GLint *) (pc + 4),
+                    *(GLint *) (pc + 8), *(GLint *) (pc + 12),
+                    *(GLint *) (pc + 16), *(GLint *) (pc + 20),
+                    *(GLint *) (pc + 24), *(GLint *) (pc + 28),
+                    *(GLbitfield *) (pc + 32), *(GLenum *) (pc + 36));
 }
 
-int __glXDisp_CheckFramebufferStatus(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
+        __glGetProcAddress("glCheckFramebufferStatus");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLenum retval;
-        retval = CALL_CheckFramebufferStatus( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0)
-        ) );
+
+        retval = CheckFramebufferStatus(*(GLenum *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5000,97 +4556,93 @@ int __glXDisp_CheckFramebufferStatus(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_DeleteFramebuffers(GLbyte * pc)
+void
+__glXDisp_DeleteFramebuffers(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  0);
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
+        __glGetProcAddress("glDeleteFramebuffers");
+    const GLsizei n = *(GLsizei *) (pc + 0);
 
-    CALL_DeleteFramebuffers( GET_DISPATCH(), (
-        n,
-         (const GLuint *)(pc +  4)
-    ) );
+    DeleteFramebuffers(n, (const GLuint *) (pc + 4));
 }
 
-void __glXDisp_DeleteRenderbuffers(GLbyte * pc)
+void
+__glXDisp_DeleteRenderbuffers(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  0);
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
+        __glGetProcAddress("glDeleteRenderbuffers");
+    const GLsizei n = *(GLsizei *) (pc + 0);
 
-    CALL_DeleteRenderbuffers( GET_DISPATCH(), (
-        n,
-         (const GLuint *)(pc +  4)
-    ) );
+    DeleteRenderbuffers(n, (const GLuint *) (pc + 4));
 }
 
-void __glXDisp_FramebufferRenderbuffer(GLbyte * pc)
+void
+__glXDisp_FramebufferRenderbuffer(GLbyte * pc)
 {
-    CALL_FramebufferRenderbuffer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLuint   *)(pc + 12)
-    ) );
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
+        __glGetProcAddress("glFramebufferRenderbuffer");
+    FramebufferRenderbuffer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                            *(GLenum *) (pc + 8), *(GLuint *) (pc + 12));
 }
 
-void __glXDisp_FramebufferTexture1D(GLbyte * pc)
+void
+__glXDisp_FramebufferTexture1D(GLbyte * pc)
 {
-    CALL_FramebufferTexture1D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLuint   *)(pc + 12),
-        *(GLint    *)(pc + 16)
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
+        __glGetProcAddress("glFramebufferTexture1D");
+    FramebufferTexture1D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16));
 }
 
-void __glXDisp_FramebufferTexture2D(GLbyte * pc)
+void
+__glXDisp_FramebufferTexture2D(GLbyte * pc)
 {
-    CALL_FramebufferTexture2D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLuint   *)(pc + 12),
-        *(GLint    *)(pc + 16)
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
+        __glGetProcAddress("glFramebufferTexture2D");
+    FramebufferTexture2D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16));
 }
 
-void __glXDisp_FramebufferTexture3D(GLbyte * pc)
+void
+__glXDisp_FramebufferTexture3D(GLbyte * pc)
 {
-    CALL_FramebufferTexture3D( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLuint   *)(pc + 12),
-        *(GLint    *)(pc + 16),
-        *(GLint    *)(pc + 20)
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
+        __glGetProcAddress("glFramebufferTexture3D");
+    FramebufferTexture3D(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                         *(GLenum *) (pc + 8), *(GLuint *) (pc + 12),
+                         *(GLint *) (pc + 16), *(GLint *) (pc + 20));
 }
 
-void __glXDisp_FramebufferTextureLayer(GLbyte * pc)
+void
+__glXDisp_FramebufferTextureLayer(GLbyte * pc)
 {
-    CALL_FramebufferTextureLayer( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLuint   *)(pc +  8),
-        *(GLint    *)(pc + 12),
-        *(GLint    *)(pc + 16)
-    ) );
+    PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
+        __glGetProcAddress("glFramebufferTextureLayer");
+    FramebufferTextureLayer(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                            *(GLuint *) (pc + 8), *(GLint *) (pc + 12),
+                            *(GLint *) (pc + 16));
 }
 
-int __glXDisp_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
+        __glGetProcAddress("glGenFramebuffers");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenFramebuffers( GET_DISPATCH(), (
-            n,
-            framebuffers
-        ) );
+        GLuint *framebuffers =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenFramebuffers(n, framebuffers);
         __glXSendReply(cl->client, framebuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -5098,22 +4650,24 @@ int __glXDisp_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
+        __glGetProcAddress("glGenRenderbuffers");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
+    if (cx != NULL) {
+        const GLsizei n = *(GLsizei *) (pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenRenderbuffers( GET_DISPATCH(), (
-            n,
-            renderbuffers
-        ) );
+        GLuint *renderbuffers =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenRenderbuffers(n, renderbuffers);
         __glXSendReply(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -5121,28 +4675,32 @@ int __glXDisp_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_GenerateMipmap(GLbyte * pc)
+void
+__glXDisp_GenerateMipmap(GLbyte * pc)
 {
-    CALL_GenerateMipmap( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap =
+        __glGetProcAddress("glGenerateMipmap");
+    GenerateMipmap(*(GLenum *) (pc + 0));
 }
 
-int __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
+                                              GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
+        GetFramebufferAttachmentParameteriv =
+        __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLint params[1];
-        CALL_GetFramebufferAttachmentParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLenum   *)(pc +  4),
-            *(GLenum   *)(pc +  8),
-            params
-        ) );
+
+        GetFramebufferAttachmentParameteriv(*(GLenum *) (pc + 0),
+                                            *(GLenum *) (pc + 4),
+                                            *(GLenum *) (pc + 8), params);
         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -5150,20 +4708,21 @@ int __glXDisp_GetFramebufferAttachmentParameteriv(__GLXclientState *cl, GLbyte *
     return error;
 }
 
-int __glXDisp_GetRenderbufferParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
+        __glGetProcAddress("glGetRenderbufferParameteriv");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLint params[1];
-        CALL_GetRenderbufferParameteriv( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLenum   *)(pc +  4),
-            params
-        ) );
+
+        GetRenderbufferParameteriv(*(GLenum *) (pc + 0),
+                                   *(GLenum *) (pc + 4), params);
         __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -5171,37 +4730,20 @@ int __glXDisp_GetRenderbufferParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDisp_IsFramebuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer =
+        __glGetProcAddress("glIsFramebuffer");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsFramebuffer( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
-        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
-        error = Success;
-    }
 
-    return error;
-}
-
-int __glXDisp_IsRenderbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLboolean retval;
-        retval = CALL_IsRenderbuffer( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0)
-        ) );
+        retval = IsFramebuffer(*(GLuint *) (pc + 0));
         __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5209,743 +4751,364 @@ int __glXDisp_IsRenderbuffer(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDisp_RenderbufferStorage(GLbyte * pc)
-{
-    CALL_RenderbufferStorage( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLenum   *)(pc +  4),
-        *(GLsizei  *)(pc +  8),
-        *(GLsizei  *)(pc + 12)
-    ) );
-}
-
-void __glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
-{
-    CALL_RenderbufferStorageMultisample( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLsizei  *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLsizei  *)(pc + 12),
-        *(GLsizei  *)(pc + 16)
-    ) );
-}
-
-void __glXDisp_SampleMaskSGIS(GLbyte * pc)
-{
-    CALL_SampleMaskSGIS( GET_DISPATCH(), (
-        *(GLclampf *)(pc +  0),
-        *(GLboolean *)(pc +  4)
-    ) );
-}
-
-void __glXDisp_SamplePatternSGIS(GLbyte * pc)
-{
-    CALL_SamplePatternSGIS( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
-}
-
-void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
-{
-    CALL_SecondaryColor3fvEXT( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
-}
-
-void __glXDisp_FogCoordfvEXT(GLbyte * pc)
-{
-    CALL_FogCoordfvEXT( GET_DISPATCH(), (
-         (const GLfloat *)(pc +  0)
-    ) );
-}
-
-int __glXDisp_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDisp_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer =
+        __glGetProcAddress("glIsRenderbuffer");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    __GLXcontext *const cx = __glXForceCurrent(cl, req->contextTag, &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n = *(GLsizei  *)(pc +  0);
-
+    if (cx != NULL) {
         GLboolean retval;
-        GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
-            n,
-             (const GLuint *)(pc +  4),
-            residences
-        ) );
-        __glXSendReply(cl->client, residences, n, 1, GL_FALSE, retval);
-        error = Success;
-    }
-
-    return error;
-}
-
-void __glXDisp_ExecuteProgramNV(GLbyte * pc)
-{
-    CALL_ExecuteProgramNV( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-         (const GLfloat *)(pc +  8)
-    ) );
-}
-
-int __glXDisp_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLdouble params[4];
-        CALL_GetProgramParameterdvNV( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            *(GLenum   *)(pc +  8),
-            params
-        ) );
-        __glXSendReply(cl->client, params, 4, 8, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLfloat params[4];
-        CALL_GetProgramParameterfvNV( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            *(GLenum   *)(pc +  8),
-            params
-        ) );
-        __glXSendReply(cl->client, params, 4, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetProgramivNV_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetProgramivNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLint params[1];
-        CALL_GetTrackMatrixivNV( GET_DISPATCH(), (
-            *(GLenum   *)(pc +  0),
-            *(GLuint   *)(pc +  4),
-            *(GLenum   *)(pc +  8),
-            params
-        ) );
-        __glXSendReply(cl->client, params, 1, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
-        GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribdvNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 8, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
-
-        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
-        GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribfvNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDisp_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname = *(GLenum   *)(pc +  4);
 
-        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribivNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            pname,
-            params
-        ) );
-        __glXSendReply(cl->client, params, compsize, 4, GL_FALSE, 0);
+        retval = IsRenderbuffer(*(GLuint *) (pc + 0));
+        __glXSendReply(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
 
     return error;
 }
 
-void __glXDisp_LoadProgramNV(GLbyte * pc)
+void
+__glXDisp_RenderbufferStorage(GLbyte * pc)
 {
-    const GLsizei len = *(GLsizei  *)(pc +  8);
-
-    CALL_LoadProgramNV( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-        len,
-         (const GLubyte *)(pc + 12)
-    ) );
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
+        __glGetProcAddress("glRenderbufferStorage");
+    RenderbufferStorage(*(GLenum *) (pc + 0), *(GLenum *) (pc + 4),
+                        *(GLsizei *) (pc + 8), *(GLsizei *) (pc + 12));
 }
 
-void __glXDisp_ProgramParameters4dvNV(GLbyte * pc)
+void
+__glXDisp_RenderbufferStorageMultisample(GLbyte * pc)
 {
-    const GLsizei num = *(GLsizei  *)(pc +  8);
-
-#ifdef __GLX_ALIGN64
-    const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
-        pc -= 4;
-    }
-#endif
-
-    CALL_ProgramParameters4dvNV( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-        num,
-         (const GLdouble *)(pc + 12)
-    ) );
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
+        __glGetProcAddress("glRenderbufferStorageMultisample");
+    RenderbufferStorageMultisample(*(GLenum *) (pc + 0), *(GLsizei *) (pc + 4),
+                                   *(GLenum *) (pc + 8), *(GLsizei *) (pc + 12),
+                                   *(GLsizei *) (pc + 16));
 }
 
-void __glXDisp_ProgramParameters4fvNV(GLbyte * pc)
+void
+__glXDisp_SecondaryColor3fvEXT(GLbyte * pc)
 {
-    const GLsizei num = *(GLsizei  *)(pc +  8);
-
-    CALL_ProgramParameters4fvNV( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-        num,
-         (const GLfloat *)(pc + 12)
-    ) );
+    PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
+        __glGetProcAddress("glSecondaryColor3fvEXT");
+    SecondaryColor3fvEXT((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_RequestResidentProgramsNV(GLbyte * pc)
+void
+__glXDisp_FogCoordfvEXT(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  0);
-
-    CALL_RequestResidentProgramsNV( GET_DISPATCH(), (
-        n,
-         (const GLuint *)(pc +  4)
-    ) );
+    PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
+        __glGetProcAddress("glFogCoordfvEXT");
+    FogCoordfvEXT((const GLfloat *) (pc + 0));
 }
 
-void __glXDisp_TrackMatrixNV(GLbyte * pc)
-{
-    CALL_TrackMatrixNV( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4),
-        *(GLenum   *)(pc +  8),
-        *(GLenum   *)(pc + 12)
-    ) );
-}
-
-void __glXDisp_VertexAttrib1dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
+        __glGetProcAddress("glVertexAttrib1dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib1dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib1dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib1fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib1fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
+        __glGetProcAddress("glVertexAttrib1fvNV");
+    VertexAttrib1fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib1svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib1svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib1svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
+        __glGetProcAddress("glVertexAttrib1svNV");
+    VertexAttrib1svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
+        __glGetProcAddress("glVertexAttrib2dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib2dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib2dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib2fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
+        __glGetProcAddress("glVertexAttrib2fvNV");
+    VertexAttrib2fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib2svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib2svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib2svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
+        __glGetProcAddress("glVertexAttrib2svNV");
+    VertexAttrib2svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
+        __glGetProcAddress("glVertexAttrib3dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib3dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib3dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib3fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
+        __glGetProcAddress("glVertexAttrib3fvNV");
+    VertexAttrib3fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib3svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib3svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib3svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
+        __glGetProcAddress("glVertexAttrib3svNV");
+    VertexAttrib3svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
+        __glGetProcAddress("glVertexAttrib4dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib4dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLdouble *)(pc +  4)
-    ) );
+    VertexAttrib4dvNV(*(GLuint *) (pc + 0), (const GLdouble *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLfloat *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
+        __glGetProcAddress("glVertexAttrib4fvNV");
+    VertexAttrib4fvNV(*(GLuint *) (pc + 0), (const GLfloat *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLshort *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
+        __glGetProcAddress("glVertexAttrib4svNV");
+    VertexAttrib4svNV(*(GLuint *) (pc + 0), (const GLshort *) (pc + 4));
 }
 
-void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttrib4ubvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4ubvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
+        __glGetProcAddress("glVertexAttrib4ubvNV");
+    VertexAttrib4ubvNV(*(GLuint *) (pc + 0), (const GLubyte *) (pc + 4));
 }
 
-void __glXDisp_VertexAttribs1dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs1dvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
+        __glGetProcAddress("glVertexAttribs1dvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs1dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLdouble *)(pc +  8)
-    ) );
+    VertexAttribs1dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs1fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs1fvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
+        __glGetProcAddress("glVertexAttribs1fvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs1fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLfloat *)(pc +  8)
-    ) );
+    VertexAttribs1fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs1svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs1svNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
+        __glGetProcAddress("glVertexAttribs1svNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs1svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLshort *)(pc +  8)
-    ) );
+    VertexAttribs1svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs2dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs2dvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
+        __glGetProcAddress("glVertexAttribs2dvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs2dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLdouble *)(pc +  8)
-    ) );
+    VertexAttribs2dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs2fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs2fvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
+        __glGetProcAddress("glVertexAttribs2fvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs2fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLfloat *)(pc +  8)
-    ) );
+    VertexAttribs2fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs2svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs2svNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
+        __glGetProcAddress("glVertexAttribs2svNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs2svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLshort *)(pc +  8)
-    ) );
+    VertexAttribs2svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs3dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs3dvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
+        __glGetProcAddress("glVertexAttribs3dvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs3dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLdouble *)(pc +  8)
-    ) );
+    VertexAttribs3dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs3fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs3fvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
+        __glGetProcAddress("glVertexAttribs3fvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs3fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLfloat *)(pc +  8)
-    ) );
+    VertexAttribs3fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs3svNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs3svNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
+        __glGetProcAddress("glVertexAttribs3svNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_VertexAttribs3svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLshort *)(pc +  8)
-    ) );
+    VertexAttribs3svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
-void __glXDisp_VertexAttribs4dvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs4dvNV(GLbyte * pc)
 {
-    const GLsizei n = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
+        __glGetProcAddress("glVertexAttribs4dvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs4dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLdouble *)(pc +  8)
-    ) );
-}
-
-void __glXDisp_VertexAttribs4fvNV(GLbyte * pc)
-{
-    const GLsizei n = *(GLsizei  *)(pc +  4);
-
-    CALL_VertexAttribs4fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLfloat *)(pc +  8)
-    ) );
-}
-
-void __glXDisp_VertexAttribs4svNV(GLbyte * pc)
-{
-    const GLsizei n = *(GLsizei  *)(pc +  4);
-
-    CALL_VertexAttribs4svNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLshort *)(pc +  8)
-    ) );
-}
-
-void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
-{
-    const GLsizei n = *(GLsizei  *)(pc +  4);
-
-    CALL_VertexAttribs4ubvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        n,
-         (const GLubyte *)(pc +  8)
-    ) );
+    VertexAttribs4dvNV(*(GLuint *) (pc + 0), n, (const GLdouble *) (pc + 8));
 }
 
-void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
+void
+__glXDisp_VertexAttribs4fvNV(GLbyte * pc)
 {
-    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0)
-    ) );
-}
-
-int __glXDisp_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
+        __glGetProcAddress("glVertexAttribs4fvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei len = *(GLsizei  *)(pc +  4);
-
-        GLdouble params[4];
-        CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            len,
-             (const GLubyte *)(pc +  8),
-            params
-        ) );
-        __glXSendReply(cl->client, params, 4, 8, GL_TRUE, 0);
-        error = Success;
-    }
-
-    return error;
+    VertexAttribs4fvNV(*(GLuint *) (pc + 0), n, (const GLfloat *) (pc + 8));
 }
 
-int __glXDisp_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
+void
+__glXDisp_VertexAttribs4svNV(GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);
+    PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
+        __glGetProcAddress("glVertexAttribs4svNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei len = *(GLsizei  *)(pc +  4);
-
-        GLfloat params[4];
-        CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), (
-            *(GLuint   *)(pc +  0),
-            len,
-             (const GLubyte *)(pc +  8),
-            params
-        ) );
-        __glXSendReply(cl->client, params, 4, 4, GL_TRUE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc)
-{
-    const GLsizei len = *(GLsizei  *)(pc + 36);
-
-#ifdef __GLX_ALIGN64
-    const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
-        pc -= 4;
-    }
-#endif
-
-    CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc + 32),
-        len,
-         (const GLubyte *)(pc + 40),
-         (const GLdouble *)(pc +  0)
-    ) );
+    VertexAttribs4svNV(*(GLuint *) (pc + 0), n, (const GLshort *) (pc + 8));
 }
 
-void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc)
+void
+__glXDisp_VertexAttribs4ubvNV(GLbyte * pc)
 {
-    const GLsizei len = *(GLsizei  *)(pc +  4);
+    PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
+        __glGetProcAddress("glVertexAttribs4ubvNV");
+    const GLsizei n = *(GLsizei *) (pc + 4);
 
-    CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), (
-        *(GLuint   *)(pc +  0),
-        len,
-         (const GLubyte *)(pc + 24),
-         (const GLfloat *)(pc +  8)
-    ) );
+    VertexAttribs4ubvNV(*(GLuint *) (pc + 0), n, (const GLubyte *) (pc + 8));
 }
 
-void __glXDisp_BindFramebufferEXT(GLbyte * pc)
+void
+__glXDisp_ActiveStencilFaceEXT(GLbyte * pc)
 {
-    CALL_BindFramebufferEXT( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
+    PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
+        __glGetProcAddress("glActiveStencilFaceEXT");
+    ActiveStencilFaceEXT(*(GLenum *) (pc + 0));
 }
-
-void __glXDisp_BindRenderbufferEXT(GLbyte * pc)
-{
-    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
-        *(GLenum   *)(pc +  0),
-        *(GLuint   *)(pc +  4)
-    ) );
-}
-
diff --git a/xorg-server/glx/indirect_dispatch_swap.c b/xorg-server/glx/indirect_dispatch_swap.c
index ee53910bf..d48fb131a 100644
--- a/xorg-server/glx/indirect_dispatch_swap.c
+++ b/xorg-server/glx/indirect_dispatch_swap.c
@@ -52,66 +52,91 @@ typedef struct {
     __GLX_PIXEL_3D_HDR;
 } __GLXpixel3DHeader;
 
-extern GLboolean __glXErrorOccured( void );
-extern void __glXClearErrorOccured( void );
+extern GLboolean __glXErrorOccured(void);
+extern void __glXClearErrorOccured(void);
 
-static const unsigned dummy_answer[2] = {0, 0};
+static const unsigned dummy_answer[2] = { 0, 0 };
 
 static GLsizei
-bswap_CARD32( const void * src )
+bswap_CARD32(const void *src)
 {
-    union { uint32_t dst; GLsizei ret; } x;
-    x.dst = bswap_32( *(uint32_t *) src );
+    union {
+        uint32_t dst;
+        GLsizei ret;
+    } x;
+
+    x.dst = bswap_32(*(uint32_t *) src);
     return x.ret;
 }
 
 static GLshort
-bswap_CARD16( const void * src )
+bswap_CARD16(const void *src)
 {
-    union { uint16_t dst; GLshort ret; } x;
-    x.dst = bswap_16( *(uint16_t *) src );
+    union {
+        uint16_t dst;
+        GLshort ret;
+    } x;
+
+    x.dst = bswap_16(*(uint16_t *) src);
     return x.ret;
 }
 
 static GLenum
-bswap_ENUM( const void * src )
+bswap_ENUM(const void *src)
 {
-    union { uint32_t dst; GLenum ret; } x;
-    x.dst = bswap_32( *(uint32_t *) src );
+    union {
+        uint32_t dst;
+        GLenum ret;
+    } x;
+
+    x.dst = bswap_32(*(uint32_t *) src);
     return x.ret;
 }
 
 static GLsync
-bswap_CARD64( const void * src )
+bswap_CARD64(const void *src)
 {
-    union { uint64_t dst; GLsync ret; } x;
-    x.dst = bswap_64( *(uint64_t *) src );
+    union {
+        uint64_t dst;
+        GLsync ret;
+    } x;
+
+    x.dst = bswap_64(*(uint64_t *) src);
     return x.ret;
 }
 
 static GLdouble
-bswap_FLOAT64( const void * src )
+bswap_FLOAT64(const void *src)
 {
-    union { uint64_t dst; GLdouble ret; } x;
-    x.dst = bswap_64( *(uint64_t *) src );
+    union {
+        uint64_t dst;
+        GLdouble ret;
+    } x;
+
+    x.dst = bswap_64(*(uint64_t *) src);
     return x.ret;
 }
 
 static GLfloat
-bswap_FLOAT32( const void * src )
+bswap_FLOAT32(const void *src)
 {
-    union { uint32_t dst; GLfloat ret; } x;
-    x.dst = bswap_32( *(uint32_t *) src );
+    union {
+        uint32_t dst;
+        GLfloat ret;
+    } x;
+
+    x.dst = bswap_32(*(uint32_t *) src);
     return x.ret;
 }
 
 static void *
-bswap_16_array( uint16_t * src, unsigned count )
+bswap_16_array(uint16_t * src, unsigned count)
 {
-    unsigned  i;
+    unsigned i;
+
+    for (i = 0; i < count; i++) {
+        uint16_t temp = bswap_16(src[i]);
 
-    for ( i = 0 ; i < count ; i++ ) {
-        uint16_t temp = bswap_16( src[i] );
         src[i] = temp;
     }
 
@@ -119,12 +144,13 @@ bswap_16_array( uint16_t * src, unsigned count )
 }
 
 static void *
-bswap_32_array( uint32_t * src, unsigned count )
+bswap_32_array(uint32_t * src, unsigned count)
 {
-    unsigned  i;
+    unsigned i;
+
+    for (i = 0; i < count; i++) {
+        uint32_t temp = bswap_32(src[i]);
 
-    for ( i = 0 ; i < count ; i++ ) {
-        uint32_t temp = bswap_32( src[i] );
         src[i] = temp;
     }
 
@@ -132,119 +158,121 @@ bswap_32_array( uint32_t * src, unsigned count )
 }
 
 static void *
-bswap_64_array( uint64_t * src, unsigned count )
+bswap_64_array(uint64_t * src, unsigned count)
 {
-    unsigned  i;
+    unsigned i;
+
+    for (i = 0; i < count; i++) {
+        uint64_t temp = bswap_64(src[i]);
 
-    for ( i = 0 ; i < count ; i++ ) {
-        uint64_t temp = bswap_64( src[i] );
         src[i] = temp;
     }
 
     return src;
 }
 
-int __glXDispSwap_NewList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_NewList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_NewList( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-             (GLenum  )bswap_ENUM   ( pc +  4 )
-        ) );
+    if (cx != NULL) {
+        glNewList((GLuint) bswap_CARD32(pc + 0), (GLenum) bswap_ENUM(pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_EndList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_EndList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_EndList( GET_DISPATCH(), () );
+    if (cx != NULL) {
+        glEndList();
         error = Success;
     }
 
     return error;
 }
 
-void __glXDispSwap_CallList(GLbyte * pc)
+void
+__glXDispSwap_CallList(GLbyte * pc)
 {
-    CALL_CallList( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glCallList((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_CallLists(GLbyte * pc)
+void
+__glXDispSwap_CallLists(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
-    const GLenum type =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLvoid * lists;
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
+    const GLenum type = (GLenum) bswap_ENUM(pc + 4);
+    const GLvoid *lists;
 
-    switch(type) {
+    switch (type) {
     case GL_BYTE:
     case GL_UNSIGNED_BYTE:
     case GL_2_BYTES:
     case GL_3_BYTES:
     case GL_4_BYTES:
-        lists = (const GLvoid *) (pc + 8); break;
+        lists = (const GLvoid *) (pc + 8);
+        break;
     case GL_SHORT:
     case GL_UNSIGNED_SHORT:
-        lists = (const GLvoid *) bswap_16_array( (uint16_t *) (pc + 8), n ); break;
+        lists = (const GLvoid *) bswap_16_array((uint16_t *) (pc + 8), n);
+        break;
     case GL_INT:
     case GL_UNSIGNED_INT:
     case GL_FLOAT:
-        lists = (const GLvoid *) bswap_32_array( (uint32_t *) (pc + 8), n ); break;
+        lists = (const GLvoid *) bswap_32_array((uint32_t *) (pc + 8), n);
+        break;
     default:
         return;
     }
 
-    CALL_CallLists( GET_DISPATCH(), (
-        n,
-        type,
-        lists
-    ) );
+    glCallLists(n, type, lists);
 }
 
-int __glXDispSwap_DeleteLists(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_DeleteLists(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_DeleteLists( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-             (GLsizei )bswap_CARD32 ( pc +  4 )
-        ) );
+    if (cx != NULL) {
+        glDeleteLists((GLuint) bswap_CARD32(pc + 0),
+                      (GLsizei) bswap_CARD32(pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenLists(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLuint retval;
-        retval = CALL_GenLists( GET_DISPATCH(), (
-             (GLsizei )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = glGenLists((GLsizei) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -252,1648 +280,1469 @@ int __glXDispSwap_GenLists(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_ListBase(GLbyte * pc)
+void
+__glXDispSwap_ListBase(GLbyte * pc)
 {
-    CALL_ListBase( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glListBase((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_Begin(GLbyte * pc)
+void
+__glXDispSwap_Begin(GLbyte * pc)
 {
-    CALL_Begin( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glBegin((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_Bitmap(GLbyte * pc)
+void
+__glXDispSwap_Bitmap(GLbyte * pc)
 {
-    const GLubyte * const bitmap = (const GLubyte *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLubyte *const bitmap = (const GLubyte *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_Bitmap( GET_DISPATCH(), (
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLfloat )bswap_FLOAT32( pc + 28 ),
-         (GLfloat )bswap_FLOAT32( pc + 32 ),
-         (GLfloat )bswap_FLOAT32( pc + 36 ),
-         (GLfloat )bswap_FLOAT32( pc + 40 ),
-        bitmap
-    ) );
+    glBitmap((GLsizei) bswap_CARD32(pc + 20),
+             (GLsizei) bswap_CARD32(pc + 24),
+             (GLfloat) bswap_FLOAT32(pc + 28),
+             (GLfloat) bswap_FLOAT32(pc + 32),
+             (GLfloat) bswap_FLOAT32(pc + 36),
+             (GLfloat) bswap_FLOAT32(pc + 40), bitmap);
 }
 
-void __glXDispSwap_Color3bv(GLbyte * pc)
+void
+__glXDispSwap_Color3bv(GLbyte * pc)
 {
-    CALL_Color3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glColor3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDispSwap_Color3dv(GLbyte * pc)
+void
+__glXDispSwap_Color3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Color3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glColor3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color3fv(GLbyte * pc)
+void
+__glXDispSwap_Color3fv(GLbyte * pc)
 {
-    CALL_Color3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glColor3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color3iv(GLbyte * pc)
+void
+__glXDispSwap_Color3iv(GLbyte * pc)
 {
-    CALL_Color3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color3sv(GLbyte * pc)
+void
+__glXDispSwap_Color3sv(GLbyte * pc)
 {
-    CALL_Color3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glColor3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color3ubv(GLbyte * pc)
+void
+__glXDispSwap_Color3ubv(GLbyte * pc)
 {
-    CALL_Color3ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glColor3ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDispSwap_Color3uiv(GLbyte * pc)
+void
+__glXDispSwap_Color3uiv(GLbyte * pc)
 {
-    CALL_Color3uiv( GET_DISPATCH(), (
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glColor3uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color3usv(GLbyte * pc)
+void
+__glXDispSwap_Color3usv(GLbyte * pc)
 {
-    CALL_Color3usv( GET_DISPATCH(), (
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glColor3usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Color4bv(GLbyte * pc)
+void
+__glXDispSwap_Color4bv(GLbyte * pc)
 {
-    CALL_Color4bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glColor4bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDispSwap_Color4dv(GLbyte * pc)
+void
+__glXDispSwap_Color4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Color4dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glColor4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Color4fv(GLbyte * pc)
+void
+__glXDispSwap_Color4fv(GLbyte * pc)
 {
-    CALL_Color4fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glColor4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Color4iv(GLbyte * pc)
+void
+__glXDispSwap_Color4iv(GLbyte * pc)
 {
-    CALL_Color4iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glColor4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Color4sv(GLbyte * pc)
+void
+__glXDispSwap_Color4sv(GLbyte * pc)
 {
-    CALL_Color4sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
-    ) );
+    glColor4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Color4ubv(GLbyte * pc)
+void
+__glXDispSwap_Color4ubv(GLbyte * pc)
 {
-    CALL_Color4ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glColor4ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDispSwap_Color4uiv(GLbyte * pc)
+void
+__glXDispSwap_Color4uiv(GLbyte * pc)
 {
-    CALL_Color4uiv( GET_DISPATCH(), (
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glColor4uiv((const GLuint *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Color4usv(GLbyte * pc)
+void
+__glXDispSwap_Color4usv(GLbyte * pc)
 {
-    CALL_Color4usv( GET_DISPATCH(), (
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
-    ) );
+    glColor4usv((const GLushort *) bswap_16_array((uint16_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_EdgeFlagv(GLbyte * pc)
+void
+__glXDispSwap_EdgeFlagv(GLbyte * pc)
 {
-    CALL_EdgeFlagv( GET_DISPATCH(), (
-         (const GLboolean *)(pc +  0)
-    ) );
+    glEdgeFlagv((const GLboolean *) (pc + 0));
 }
 
-void __glXDispSwap_End(GLbyte * pc)
+void
+__glXDispSwap_End(GLbyte * pc)
 {
-    CALL_End( GET_DISPATCH(), () );
+    glEnd();
 }
 
-void __glXDispSwap_Indexdv(GLbyte * pc)
+void
+__glXDispSwap_Indexdv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_Indexdv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
-    ) );
+    glIndexdv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_Indexfv(GLbyte * pc)
+void
+__glXDispSwap_Indexfv(GLbyte * pc)
 {
-    CALL_Indexfv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
+    glIndexfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_Indexiv(GLbyte * pc)
+void
+__glXDispSwap_Indexiv(GLbyte * pc)
 {
-    CALL_Indexiv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
+    glIndexiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_Indexsv(GLbyte * pc)
+void
+__glXDispSwap_Indexsv(GLbyte * pc)
 {
-    CALL_Indexsv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
-    ) );
+    glIndexsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_Normal3bv(GLbyte * pc)
+void
+__glXDispSwap_Normal3bv(GLbyte * pc)
 {
-    CALL_Normal3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    glNormal3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDispSwap_Normal3dv(GLbyte * pc)
+void
+__glXDispSwap_Normal3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Normal3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glNormal3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Normal3fv(GLbyte * pc)
+void
+__glXDispSwap_Normal3fv(GLbyte * pc)
 {
-    CALL_Normal3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glNormal3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Normal3iv(GLbyte * pc)
+void
+__glXDispSwap_Normal3iv(GLbyte * pc)
 {
-    CALL_Normal3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glNormal3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Normal3sv(GLbyte * pc)
+void
+__glXDispSwap_Normal3sv(GLbyte * pc)
 {
-    CALL_Normal3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glNormal3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_RasterPos2dv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos2dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
-    ) );
+    glRasterPos2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_RasterPos2fv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos2fv(GLbyte * pc)
 {
-    CALL_RasterPos2fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glRasterPos2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_RasterPos2iv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos2iv(GLbyte * pc)
 {
-    CALL_RasterPos2iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glRasterPos2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_RasterPos2sv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos2sv(GLbyte * pc)
 {
-    CALL_RasterPos2sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
-    ) );
+    glRasterPos2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_RasterPos3dv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glRasterPos3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_RasterPos3fv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos3fv(GLbyte * pc)
 {
-    CALL_RasterPos3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glRasterPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_RasterPos3iv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos3iv(GLbyte * pc)
 {
-    CALL_RasterPos3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glRasterPos3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_RasterPos3sv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos3sv(GLbyte * pc)
 {
-    CALL_RasterPos3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glRasterPos3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_RasterPos4dv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_RasterPos4dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glRasterPos4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_RasterPos4fv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos4fv(GLbyte * pc)
 {
-    CALL_RasterPos4fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glRasterPos4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_RasterPos4iv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos4iv(GLbyte * pc)
 {
-    CALL_RasterPos4iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glRasterPos4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_RasterPos4sv(GLbyte * pc)
+void
+__glXDispSwap_RasterPos4sv(GLbyte * pc)
 {
-    CALL_RasterPos4sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
-    ) );
+    glRasterPos4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Rectdv(GLbyte * pc)
+void
+__glXDispSwap_Rectdv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Rectdv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 16), 2 )
-    ) );
+    glRectdv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2),
+             (const GLdouble *) bswap_64_array((uint64_t *) (pc + 16), 2));
 }
 
-void __glXDispSwap_Rectfv(GLbyte * pc)
+void
+__glXDispSwap_Rectfv(GLbyte * pc)
 {
-    CALL_Rectfv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
-    ) );
+    glRectfv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2),
+             (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 2));
 }
 
-void __glXDispSwap_Rectiv(GLbyte * pc)
+void
+__glXDispSwap_Rectiv(GLbyte * pc)
 {
-    CALL_Rectiv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  8), 2 )
-    ) );
+    glRectiv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2),
+             (const GLint *) bswap_32_array((uint32_t *) (pc + 8), 2));
 }
 
-void __glXDispSwap_Rectsv(GLbyte * pc)
+void
+__glXDispSwap_Rectsv(GLbyte * pc)
 {
-    CALL_Rectsv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
-    ) );
+    glRectsv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2),
+             (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2));
 }
 
-void __glXDispSwap_TexCoord1dv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord1dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
-    ) );
+    glTexCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_TexCoord1fv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord1fv(GLbyte * pc)
 {
-    CALL_TexCoord1fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
+    glTexCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_TexCoord1iv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord1iv(GLbyte * pc)
 {
-    CALL_TexCoord1iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
+    glTexCoord1iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_TexCoord1sv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord1sv(GLbyte * pc)
 {
-    CALL_TexCoord1sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 1 )
-    ) );
+    glTexCoord1sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_TexCoord2dv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord2dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
-    ) );
+    glTexCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_TexCoord2fv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord2fv(GLbyte * pc)
 {
-    CALL_TexCoord2fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glTexCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_TexCoord2iv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord2iv(GLbyte * pc)
 {
-    CALL_TexCoord2iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glTexCoord2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_TexCoord2sv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord2sv(GLbyte * pc)
 {
-    CALL_TexCoord2sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
-    ) );
+    glTexCoord2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_TexCoord3dv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glTexCoord3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_TexCoord3fv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord3fv(GLbyte * pc)
 {
-    CALL_TexCoord3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glTexCoord3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_TexCoord3iv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord3iv(GLbyte * pc)
 {
-    CALL_TexCoord3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glTexCoord3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_TexCoord3sv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord3sv(GLbyte * pc)
 {
-    CALL_TexCoord3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glTexCoord3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_TexCoord4dv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_TexCoord4dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glTexCoord4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_TexCoord4fv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord4fv(GLbyte * pc)
 {
-    CALL_TexCoord4fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glTexCoord4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_TexCoord4iv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord4iv(GLbyte * pc)
 {
-    CALL_TexCoord4iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glTexCoord4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_TexCoord4sv(GLbyte * pc)
+void
+__glXDispSwap_TexCoord4sv(GLbyte * pc)
 {
-    CALL_TexCoord4sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
-    ) );
+    glTexCoord4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Vertex2dv(GLbyte * pc)
+void
+__glXDispSwap_Vertex2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex2dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
-    ) );
+    glVertex2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_Vertex2fv(GLbyte * pc)
+void
+__glXDispSwap_Vertex2fv(GLbyte * pc)
 {
-    CALL_Vertex2fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glVertex2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_Vertex2iv(GLbyte * pc)
+void
+__glXDispSwap_Vertex2iv(GLbyte * pc)
 {
-    CALL_Vertex2iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glVertex2iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_Vertex2sv(GLbyte * pc)
+void
+__glXDispSwap_Vertex2sv(GLbyte * pc)
 {
-    CALL_Vertex2sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 2 )
-    ) );
+    glVertex2sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_Vertex3dv(GLbyte * pc)
+void
+__glXDispSwap_Vertex3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glVertex3dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Vertex3fv(GLbyte * pc)
+void
+__glXDispSwap_Vertex3fv(GLbyte * pc)
 {
-    CALL_Vertex3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glVertex3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Vertex3iv(GLbyte * pc)
+void
+__glXDispSwap_Vertex3iv(GLbyte * pc)
 {
-    CALL_Vertex3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    glVertex3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Vertex3sv(GLbyte * pc)
+void
+__glXDispSwap_Vertex3sv(GLbyte * pc)
 {
-    CALL_Vertex3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    glVertex3sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_Vertex4dv(GLbyte * pc)
+void
+__glXDispSwap_Vertex4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Vertex4dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glVertex4dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Vertex4fv(GLbyte * pc)
+void
+__glXDispSwap_Vertex4fv(GLbyte * pc)
 {
-    CALL_Vertex4fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glVertex4fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Vertex4iv(GLbyte * pc)
+void
+__glXDispSwap_Vertex4iv(GLbyte * pc)
 {
-    CALL_Vertex4iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 4 )
-    ) );
+    glVertex4iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_Vertex4sv(GLbyte * pc)
+void
+__glXDispSwap_Vertex4sv(GLbyte * pc)
 {
-    CALL_Vertex4sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 4 )
-    ) );
+    glVertex4sv((const GLshort *) bswap_16_array((uint16_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_ClipPlane(GLbyte * pc)
+void
+__glXDispSwap_ClipPlane(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_ClipPlane( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glClipPlane((GLenum) bswap_ENUM(pc + 32),
+                (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 4));
 }
 
-void __glXDispSwap_ColorMaterial(GLbyte * pc)
+void
+__glXDispSwap_ColorMaterial(GLbyte * pc)
 {
-    CALL_ColorMaterial( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    glColorMaterial((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_CullFace(GLbyte * pc)
+void
+__glXDispSwap_CullFace(GLbyte * pc)
 {
-    CALL_CullFace( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glCullFace((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_Fogf(GLbyte * pc)
+void
+__glXDispSwap_Fogf(GLbyte * pc)
 {
-    CALL_Fogf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glFogf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_Fogfv(GLbyte * pc)
+void
+__glXDispSwap_Fogfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glFogfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                         __glFogfv_size(pname));
 
-    CALL_Fogfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glFogfv(pname, params);
 }
 
-void __glXDispSwap_Fogi(GLbyte * pc)
+void
+__glXDispSwap_Fogi(GLbyte * pc)
 {
-    CALL_Fogi( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 )
-    ) );
+    glFogi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_Fogiv(GLbyte * pc)
+void
+__glXDispSwap_Fogiv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glFogiv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                       __glFogiv_size(pname));
 
-    CALL_Fogiv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glFogiv(pname, params);
 }
 
-void __glXDispSwap_FrontFace(GLbyte * pc)
+void
+__glXDispSwap_FrontFace(GLbyte * pc)
 {
-    CALL_FrontFace( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glFrontFace((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_Hint(GLbyte * pc)
+void
+__glXDispSwap_Hint(GLbyte * pc)
 {
-    CALL_Hint( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    glHint((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_Lightf(GLbyte * pc)
+void
+__glXDispSwap_Lightf(GLbyte * pc)
 {
-    CALL_Lightf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glLightf((GLenum) bswap_ENUM(pc + 0),
+             (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_Lightfv(GLbyte * pc)
+void
+__glXDispSwap_Lightfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glLightfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glLightfv_size(pname));
 
-    CALL_Lightfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glLightfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_Lighti(GLbyte * pc)
+void
+__glXDispSwap_Lighti(GLbyte * pc)
 {
-    CALL_Lighti( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glLighti((GLenum) bswap_ENUM(pc + 0),
+             (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_Lightiv(GLbyte * pc)
+void
+__glXDispSwap_Lightiv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glLightiv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glLightiv_size(pname));
 
-    CALL_Lightiv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glLightiv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_LightModelf(GLbyte * pc)
+void
+__glXDispSwap_LightModelf(GLbyte * pc)
 {
-    CALL_LightModelf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glLightModelf((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_LightModelfv(GLbyte * pc)
+void
+__glXDispSwap_LightModelfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModelfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                         __glLightModelfv_size(pname));
 
-    CALL_LightModelfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glLightModelfv(pname, params);
 }
 
-void __glXDispSwap_LightModeli(GLbyte * pc)
+void
+__glXDispSwap_LightModeli(GLbyte * pc)
 {
-    CALL_LightModeli( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 )
-    ) );
+    glLightModeli((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_LightModeliv(GLbyte * pc)
+void
+__glXDispSwap_LightModeliv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glLightModeliv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                       __glLightModeliv_size(pname));
 
-    CALL_LightModeliv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    glLightModeliv(pname, params);
 }
 
-void __glXDispSwap_LineStipple(GLbyte * pc)
+void
+__glXDispSwap_LineStipple(GLbyte * pc)
 {
-    CALL_LineStipple( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLushort)bswap_CARD16 ( pc +  4 )
-    ) );
+    glLineStipple((GLint) bswap_CARD32(pc + 0),
+                  (GLushort) bswap_CARD16(pc + 4));
 }
 
-void __glXDispSwap_LineWidth(GLbyte * pc)
+void
+__glXDispSwap_LineWidth(GLbyte * pc)
 {
-    CALL_LineWidth( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 )
-    ) );
+    glLineWidth((GLfloat) bswap_FLOAT32(pc + 0));
 }
 
-void __glXDispSwap_Materialf(GLbyte * pc)
+void
+__glXDispSwap_Materialf(GLbyte * pc)
 {
-    CALL_Materialf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glMaterialf((GLenum) bswap_ENUM(pc + 0),
+                (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_Materialfv(GLbyte * pc)
+void
+__glXDispSwap_Materialfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glMaterialfv_size(pname));
 
-    CALL_Materialfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glMaterialfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_Materiali(GLbyte * pc)
+void
+__glXDispSwap_Materiali(GLbyte * pc)
 {
-    CALL_Materiali( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glMateriali((GLenum) bswap_ENUM(pc + 0),
+                (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_Materialiv(GLbyte * pc)
+void
+__glXDispSwap_Materialiv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glMaterialiv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glMaterialiv_size(pname));
 
-    CALL_Materialiv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glMaterialiv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_PointSize(GLbyte * pc)
+void
+__glXDispSwap_PointSize(GLbyte * pc)
 {
-    CALL_PointSize( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 )
-    ) );
+    glPointSize((GLfloat) bswap_FLOAT32(pc + 0));
 }
 
-void __glXDispSwap_PolygonMode(GLbyte * pc)
+void
+__glXDispSwap_PolygonMode(GLbyte * pc)
 {
-    CALL_PolygonMode( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    glPolygonMode((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_PolygonStipple(GLbyte * pc)
+void
+__glXDispSwap_PolygonStipple(GLbyte * pc)
 {
-    const GLubyte * const mask = (const GLubyte *) (pc + 20);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLubyte *const mask = (const GLubyte *) ((pc + 20));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_PolygonStipple( GET_DISPATCH(), (
-        mask
-    ) );
+    glPolygonStipple(mask);
 }
 
-void __glXDispSwap_Scissor(GLbyte * pc)
+void
+__glXDispSwap_Scissor(GLbyte * pc)
 {
-    CALL_Scissor( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLsizei )bswap_CARD32 ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 )
-    ) );
+    glScissor((GLint) bswap_CARD32(pc + 0),
+              (GLint) bswap_CARD32(pc + 4),
+              (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12));
 }
 
-void __glXDispSwap_ShadeModel(GLbyte * pc)
+void
+__glXDispSwap_ShadeModel(GLbyte * pc)
 {
-    CALL_ShadeModel( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glShadeModel((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_TexParameterf(GLbyte * pc)
+void
+__glXDispSwap_TexParameterf(GLbyte * pc)
 {
-    CALL_TexParameterf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glTexParameterf((GLenum) bswap_ENUM(pc + 0),
+                    (GLenum) bswap_ENUM(pc + 4),
+                    (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_TexParameterfv(GLbyte * pc)
+void
+__glXDispSwap_TexParameterfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameterfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glTexParameterfv_size(pname));
 
-    CALL_TexParameterfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexParameteri(GLbyte * pc)
+void
+__glXDispSwap_TexParameteri(GLbyte * pc)
 {
-    CALL_TexParameteri( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glTexParameteri((GLenum) bswap_ENUM(pc + 0),
+                    (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_TexParameteriv(GLbyte * pc)
+void
+__glXDispSwap_TexParameteriv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexParameteriv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glTexParameteriv_size(pname));
 
-    CALL_TexParameteriv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexImage1D(GLbyte * pc)
+void
+__glXDispSwap_TexImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 ),
-         (GLsizei )bswap_CARD32 ( pc + 32 ),
-         (GLint   )bswap_CARD32 ( pc + 40 ),
-         (GLenum  )bswap_ENUM   ( pc + 44 ),
-         (GLenum  )bswap_ENUM   ( pc + 48 ),
-        pixels
-    ) );
+    glTexImage1D((GLenum) bswap_ENUM(pc + 20),
+                 (GLint) bswap_CARD32(pc + 24),
+                 (GLint) bswap_CARD32(pc + 28),
+                 (GLsizei) bswap_CARD32(pc + 32),
+                 (GLint) bswap_CARD32(pc + 40),
+                 (GLenum) bswap_ENUM(pc + 44),
+                 (GLenum) bswap_ENUM(pc + 48), pixels);
 }
 
-void __glXDispSwap_TexImage2D(GLbyte * pc)
+void
+__glXDispSwap_TexImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 52);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 52));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 ),
-         (GLsizei )bswap_CARD32 ( pc + 32 ),
-         (GLsizei )bswap_CARD32 ( pc + 36 ),
-         (GLint   )bswap_CARD32 ( pc + 40 ),
-         (GLenum  )bswap_ENUM   ( pc + 44 ),
-         (GLenum  )bswap_ENUM   ( pc + 48 ),
-        pixels
-    ) );
+    glTexImage2D((GLenum) bswap_ENUM(pc + 20),
+                 (GLint) bswap_CARD32(pc + 24),
+                 (GLint) bswap_CARD32(pc + 28),
+                 (GLsizei) bswap_CARD32(pc + 32),
+                 (GLsizei) bswap_CARD32(pc + 36),
+                 (GLint) bswap_CARD32(pc + 40),
+                 (GLenum) bswap_ENUM(pc + 44),
+                 (GLenum) bswap_ENUM(pc + 48), pixels);
 }
 
-void __glXDispSwap_TexEnvf(GLbyte * pc)
+void
+__glXDispSwap_TexEnvf(GLbyte * pc)
 {
-    CALL_TexEnvf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glTexEnvf((GLenum) bswap_ENUM(pc + 0),
+              (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_TexEnvfv(GLbyte * pc)
+void
+__glXDispSwap_TexEnvfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnvfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glTexEnvfv_size(pname));
 
-    CALL_TexEnvfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexEnvfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexEnvi(GLbyte * pc)
+void
+__glXDispSwap_TexEnvi(GLbyte * pc)
 {
-    CALL_TexEnvi( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glTexEnvi((GLenum) bswap_ENUM(pc + 0),
+              (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_TexEnviv(GLbyte * pc)
+void
+__glXDispSwap_TexEnviv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexEnviv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glTexEnviv_size(pname));
 
-    CALL_TexEnviv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexEnviv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexGend(GLbyte * pc)
+void
+__glXDispSwap_TexGend(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_TexGend( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLenum  )bswap_ENUM   ( pc + 12 ),
-         (GLdouble)bswap_FLOAT64( pc +  0 )
-    ) );
+    glTexGend((GLenum) bswap_ENUM(pc + 8),
+              (GLenum) bswap_ENUM(pc + 12), (GLdouble) bswap_FLOAT64(pc + 0));
 }
 
-void __glXDispSwap_TexGendv(GLbyte * pc)
+void
+__glXDispSwap_TexGendv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLdouble * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLdouble *params;
 
 #ifdef __GLX_ALIGN64
     const GLuint compsize = __glTexGendv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    params = (const GLdouble *) bswap_64_array( (uint64_t *) (pc + 8), __glTexGendv_size(pname) );
+    params =
+        (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                          __glTexGendv_size(pname));
 
-    CALL_TexGendv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexGendv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexGenf(GLbyte * pc)
+void
+__glXDispSwap_TexGenf(GLbyte * pc)
 {
-    CALL_TexGenf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glTexGenf((GLenum) bswap_ENUM(pc + 0),
+              (GLenum) bswap_ENUM(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_TexGenfv(GLbyte * pc)
+void
+__glXDispSwap_TexGenfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGenfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glTexGenfv_size(pname));
 
-    CALL_TexGenfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexGenfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_TexGeni(GLbyte * pc)
+void
+__glXDispSwap_TexGeni(GLbyte * pc)
 {
-    CALL_TexGeni( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glTexGeni((GLenum) bswap_ENUM(pc + 0),
+              (GLenum) bswap_ENUM(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_TexGeniv(GLbyte * pc)
+void
+__glXDispSwap_TexGeniv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glTexGeniv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glTexGeniv_size(pname));
 
-    CALL_TexGeniv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glTexGeniv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_InitNames(GLbyte * pc)
+void
+__glXDispSwap_InitNames(GLbyte * pc)
 {
-    CALL_InitNames( GET_DISPATCH(), () );
+    glInitNames();
 }
 
-void __glXDispSwap_LoadName(GLbyte * pc)
+void
+__glXDispSwap_LoadName(GLbyte * pc)
 {
-    CALL_LoadName( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glLoadName((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_PassThrough(GLbyte * pc)
+void
+__glXDispSwap_PassThrough(GLbyte * pc)
 {
-    CALL_PassThrough( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 )
-    ) );
+    glPassThrough((GLfloat) bswap_FLOAT32(pc + 0));
 }
 
-void __glXDispSwap_PopName(GLbyte * pc)
+void
+__glXDispSwap_PopName(GLbyte * pc)
 {
-    CALL_PopName( GET_DISPATCH(), () );
+    glPopName();
 }
 
-void __glXDispSwap_PushName(GLbyte * pc)
+void
+__glXDispSwap_PushName(GLbyte * pc)
 {
-    CALL_PushName( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glPushName((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_DrawBuffer(GLbyte * pc)
+void
+__glXDispSwap_DrawBuffer(GLbyte * pc)
 {
-    CALL_DrawBuffer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glDrawBuffer((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_Clear(GLbyte * pc)
+void
+__glXDispSwap_Clear(GLbyte * pc)
 {
-    CALL_Clear( GET_DISPATCH(), (
-         (GLbitfield)bswap_CARD32 ( pc +  0 )
-    ) );
+    glClear((GLbitfield) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_ClearAccum(GLbyte * pc)
+void
+__glXDispSwap_ClearAccum(GLbyte * pc)
 {
-    CALL_ClearAccum( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 ),
-         (GLfloat )bswap_FLOAT32( pc + 12 )
-    ) );
+    glClearAccum((GLfloat) bswap_FLOAT32(pc + 0),
+                 (GLfloat) bswap_FLOAT32(pc + 4),
+                 (GLfloat) bswap_FLOAT32(pc + 8),
+                 (GLfloat) bswap_FLOAT32(pc + 12));
 }
 
-void __glXDispSwap_ClearIndex(GLbyte * pc)
+void
+__glXDispSwap_ClearIndex(GLbyte * pc)
 {
-    CALL_ClearIndex( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 )
-    ) );
+    glClearIndex((GLfloat) bswap_FLOAT32(pc + 0));
 }
 
-void __glXDispSwap_ClearColor(GLbyte * pc)
+void
+__glXDispSwap_ClearColor(GLbyte * pc)
 {
-    CALL_ClearColor( GET_DISPATCH(), (
-         (GLclampf)bswap_FLOAT32( pc +  0 ),
-         (GLclampf)bswap_FLOAT32( pc +  4 ),
-         (GLclampf)bswap_FLOAT32( pc +  8 ),
-         (GLclampf)bswap_FLOAT32( pc + 12 )
-    ) );
+    glClearColor((GLclampf) bswap_FLOAT32(pc + 0),
+                 (GLclampf) bswap_FLOAT32(pc + 4),
+                 (GLclampf) bswap_FLOAT32(pc + 8),
+                 (GLclampf) bswap_FLOAT32(pc + 12));
 }
 
-void __glXDispSwap_ClearStencil(GLbyte * pc)
+void
+__glXDispSwap_ClearStencil(GLbyte * pc)
 {
-    CALL_ClearStencil( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 )
-    ) );
+    glClearStencil((GLint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_ClearDepth(GLbyte * pc)
+void
+__glXDispSwap_ClearDepth(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_ClearDepth( GET_DISPATCH(), (
-         (GLclampd)bswap_FLOAT64( pc +  0 )
-    ) );
+    glClearDepth((GLclampd) bswap_FLOAT64(pc + 0));
 }
 
-void __glXDispSwap_StencilMask(GLbyte * pc)
+void
+__glXDispSwap_StencilMask(GLbyte * pc)
 {
-    CALL_StencilMask( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glStencilMask((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_ColorMask(GLbyte * pc)
+void
+__glXDispSwap_ColorMask(GLbyte * pc)
 {
-    CALL_ColorMask( GET_DISPATCH(), (
-        *(GLboolean *)(pc +  0),
-        *(GLboolean *)(pc +  1),
-        *(GLboolean *)(pc +  2),
-        *(GLboolean *)(pc +  3)
-    ) );
+    glColorMask(*(GLboolean *) (pc + 0),
+                *(GLboolean *) (pc + 1),
+                *(GLboolean *) (pc + 2), *(GLboolean *) (pc + 3));
 }
 
-void __glXDispSwap_DepthMask(GLbyte * pc)
+void
+__glXDispSwap_DepthMask(GLbyte * pc)
 {
-    CALL_DepthMask( GET_DISPATCH(), (
-        *(GLboolean *)(pc +  0)
-    ) );
+    glDepthMask(*(GLboolean *) (pc + 0));
 }
 
-void __glXDispSwap_IndexMask(GLbyte * pc)
+void
+__glXDispSwap_IndexMask(GLbyte * pc)
 {
-    CALL_IndexMask( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 )
-    ) );
+    glIndexMask((GLuint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_Accum(GLbyte * pc)
+void
+__glXDispSwap_Accum(GLbyte * pc)
 {
-    CALL_Accum( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glAccum((GLenum) bswap_ENUM(pc + 0), (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_Disable(GLbyte * pc)
+void
+__glXDispSwap_Disable(GLbyte * pc)
 {
-    CALL_Disable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glDisable((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_Enable(GLbyte * pc)
+void
+__glXDispSwap_Enable(GLbyte * pc)
 {
-    CALL_Enable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glEnable((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_PopAttrib(GLbyte * pc)
+void
+__glXDispSwap_PopAttrib(GLbyte * pc)
 {
-    CALL_PopAttrib( GET_DISPATCH(), () );
+    glPopAttrib();
 }
 
-void __glXDispSwap_PushAttrib(GLbyte * pc)
+void
+__glXDispSwap_PushAttrib(GLbyte * pc)
 {
-    CALL_PushAttrib( GET_DISPATCH(), (
-         (GLbitfield)bswap_CARD32 ( pc +  0 )
-    ) );
+    glPushAttrib((GLbitfield) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_MapGrid1d(GLbyte * pc)
+void
+__glXDispSwap_MapGrid1d(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_MapGrid1d( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 )
-    ) );
+    glMapGrid1d((GLint) bswap_CARD32(pc + 16),
+                (GLdouble) bswap_FLOAT64(pc + 0),
+                (GLdouble) bswap_FLOAT64(pc + 8));
 }
 
-void __glXDispSwap_MapGrid1f(GLbyte * pc)
+void
+__glXDispSwap_MapGrid1f(GLbyte * pc)
 {
-    CALL_MapGrid1f( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glMapGrid1f((GLint) bswap_CARD32(pc + 0),
+                (GLfloat) bswap_FLOAT32(pc + 4),
+                (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_MapGrid2d(GLbyte * pc)
+void
+__glXDispSwap_MapGrid2d(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_MapGrid2d( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc + 32 ),
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 36 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 ),
-         (GLdouble)bswap_FLOAT64( pc + 24 )
-    ) );
+    glMapGrid2d((GLint) bswap_CARD32(pc + 32),
+                (GLdouble) bswap_FLOAT64(pc + 0),
+                (GLdouble) bswap_FLOAT64(pc + 8),
+                (GLint) bswap_CARD32(pc + 36),
+                (GLdouble) bswap_FLOAT64(pc + 16),
+                (GLdouble) bswap_FLOAT64(pc + 24));
 }
 
-void __glXDispSwap_MapGrid2f(GLbyte * pc)
+void
+__glXDispSwap_MapGrid2f(GLbyte * pc)
 {
-    CALL_MapGrid2f( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLfloat )bswap_FLOAT32( pc + 16 ),
-         (GLfloat )bswap_FLOAT32( pc + 20 )
-    ) );
+    glMapGrid2f((GLint) bswap_CARD32(pc + 0),
+                (GLfloat) bswap_FLOAT32(pc + 4),
+                (GLfloat) bswap_FLOAT32(pc + 8),
+                (GLint) bswap_CARD32(pc + 12),
+                (GLfloat) bswap_FLOAT32(pc + 16),
+                (GLfloat) bswap_FLOAT32(pc + 20));
 }
 
-void __glXDispSwap_EvalCoord1dv(GLbyte * pc)
+void
+__glXDispSwap_EvalCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_EvalCoord1dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
-    ) );
+    glEvalCoord1dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_EvalCoord1fv(GLbyte * pc)
+void
+__glXDispSwap_EvalCoord1fv(GLbyte * pc)
 {
-    CALL_EvalCoord1fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
+    glEvalCoord1fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_EvalCoord2dv(GLbyte * pc)
+void
+__glXDispSwap_EvalCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_EvalCoord2dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
-    ) );
+    glEvalCoord2dv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_EvalCoord2fv(GLbyte * pc)
+void
+__glXDispSwap_EvalCoord2fv(GLbyte * pc)
 {
-    CALL_EvalCoord2fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 2 )
-    ) );
+    glEvalCoord2fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 2));
 }
 
-void __glXDispSwap_EvalMesh1(GLbyte * pc)
+void
+__glXDispSwap_EvalMesh1(GLbyte * pc)
 {
-    CALL_EvalMesh1( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glEvalMesh1((GLenum) bswap_ENUM(pc + 0),
+                (GLint) bswap_CARD32(pc + 4), (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_EvalPoint1(GLbyte * pc)
+void
+__glXDispSwap_EvalPoint1(GLbyte * pc)
 {
-    CALL_EvalPoint1( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 )
-    ) );
+    glEvalPoint1((GLint) bswap_CARD32(pc + 0));
 }
 
-void __glXDispSwap_EvalMesh2(GLbyte * pc)
+void
+__glXDispSwap_EvalMesh2(GLbyte * pc)
 {
-    CALL_EvalMesh2( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 )
-    ) );
+    glEvalMesh2((GLenum) bswap_ENUM(pc + 0),
+                (GLint) bswap_CARD32(pc + 4),
+                (GLint) bswap_CARD32(pc + 8),
+                (GLint) bswap_CARD32(pc + 12), (GLint) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_EvalPoint2(GLbyte * pc)
+void
+__glXDispSwap_EvalPoint2(GLbyte * pc)
 {
-    CALL_EvalPoint2( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 )
-    ) );
+    glEvalPoint2((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_AlphaFunc(GLbyte * pc)
+void
+__glXDispSwap_AlphaFunc(GLbyte * pc)
 {
-    CALL_AlphaFunc( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLclampf)bswap_FLOAT32( pc +  4 )
-    ) );
+    glAlphaFunc((GLenum) bswap_ENUM(pc + 0), (GLclampf) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_BlendFunc(GLbyte * pc)
+void
+__glXDispSwap_BlendFunc(GLbyte * pc)
 {
-    CALL_BlendFunc( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    glBlendFunc((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_LogicOp(GLbyte * pc)
+void
+__glXDispSwap_LogicOp(GLbyte * pc)
 {
-    CALL_LogicOp( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glLogicOp((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_StencilFunc(GLbyte * pc)
+void
+__glXDispSwap_StencilFunc(GLbyte * pc)
 {
-    CALL_StencilFunc( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLuint  )bswap_CARD32 ( pc +  8 )
-    ) );
+    glStencilFunc((GLenum) bswap_ENUM(pc + 0),
+                  (GLint) bswap_CARD32(pc + 4), (GLuint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_StencilOp(GLbyte * pc)
+void
+__glXDispSwap_StencilOp(GLbyte * pc)
 {
-    CALL_StencilOp( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 )
-    ) );
+    glStencilOp((GLenum) bswap_ENUM(pc + 0),
+                (GLenum) bswap_ENUM(pc + 4), (GLenum) bswap_ENUM(pc + 8));
 }
 
-void __glXDispSwap_DepthFunc(GLbyte * pc)
+void
+__glXDispSwap_DepthFunc(GLbyte * pc)
 {
-    CALL_DepthFunc( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glDepthFunc((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_PixelZoom(GLbyte * pc)
+void
+__glXDispSwap_PixelZoom(GLbyte * pc)
 {
-    CALL_PixelZoom( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glPixelZoom((GLfloat) bswap_FLOAT32(pc + 0),
+                (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_PixelTransferf(GLbyte * pc)
+void
+__glXDispSwap_PixelTransferf(GLbyte * pc)
 {
-    CALL_PixelTransferf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glPixelTransferf((GLenum) bswap_ENUM(pc + 0),
+                     (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_PixelTransferi(GLbyte * pc)
+void
+__glXDispSwap_PixelTransferi(GLbyte * pc)
 {
-    CALL_PixelTransferi( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 )
-    ) );
+    glPixelTransferi((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
-int __glXDispSwap_PixelStoref(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_PixelStoref(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_PixelStoref( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLfloat )bswap_FLOAT32( pc +  4 )
-        ) );
+    if (cx != NULL) {
+        glPixelStoref((GLenum) bswap_ENUM(pc + 0),
+                      (GLfloat) bswap_FLOAT32(pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_PixelStorei(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_PixelStorei(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        CALL_PixelStorei( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLint   )bswap_CARD32 ( pc +  4 )
-        ) );
+    if (cx != NULL) {
+        glPixelStorei((GLenum) bswap_ENUM(pc + 0),
+                      (GLint) bswap_CARD32(pc + 4));
         error = Success;
     }
 
     return error;
 }
 
-void __glXDispSwap_PixelMapfv(GLbyte * pc)
+void
+__glXDispSwap_PixelMapfv(GLbyte * pc)
 {
-    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_PixelMapfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        mapsize,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
+    glPixelMapfv((GLenum) bswap_ENUM(pc + 0),
+                 mapsize,
+                 (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8), 0));
 }
 
-void __glXDispSwap_PixelMapuiv(GLbyte * pc)
+void
+__glXDispSwap_PixelMapuiv(GLbyte * pc)
 {
-    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_PixelMapuiv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        mapsize,
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
+    glPixelMapuiv((GLenum) bswap_ENUM(pc + 0),
+                  mapsize,
+                  (const GLuint *) bswap_32_array((uint32_t *) (pc + 8), 0));
 }
 
-void __glXDispSwap_PixelMapusv(GLbyte * pc)
+void
+__glXDispSwap_PixelMapusv(GLbyte * pc)
 {
-    const GLsizei mapsize =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    const GLsizei mapsize = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_PixelMapusv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        mapsize,
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
-    ) );
+    glPixelMapusv((GLenum) bswap_ENUM(pc + 0),
+                  mapsize,
+                  (const GLushort *) bswap_16_array((uint16_t *) (pc + 8), 0));
 }
 
-void __glXDispSwap_ReadBuffer(GLbyte * pc)
+void
+__glXDispSwap_ReadBuffer(GLbyte * pc)
 {
-    CALL_ReadBuffer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glReadBuffer((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_CopyPixels(GLbyte * pc)
+void
+__glXDispSwap_CopyPixels(GLbyte * pc)
 {
-    CALL_CopyPixels( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLsizei )bswap_CARD32 ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLenum  )bswap_ENUM   ( pc + 16 )
-    ) );
+    glCopyPixels((GLint) bswap_CARD32(pc + 0),
+                 (GLint) bswap_CARD32(pc + 4),
+                 (GLsizei) bswap_CARD32(pc + 8),
+                 (GLsizei) bswap_CARD32(pc + 12), (GLenum) bswap_ENUM(pc + 16));
 }
 
-void __glXDispSwap_DrawPixels(GLbyte * pc)
+void
+__glXDispSwap_DrawPixels(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 36);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 36));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_DrawPixels( GET_DISPATCH(), (
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLenum  )bswap_ENUM   ( pc + 28 ),
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-        pixels
-    ) );
+    glDrawPixels((GLsizei) bswap_CARD32(pc + 20),
+                 (GLsizei) bswap_CARD32(pc + 24),
+                 (GLenum) bswap_ENUM(pc + 28),
+                 (GLenum) bswap_ENUM(pc + 32), pixels);
 }
 
-int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetBooleanv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetBooleanv_size(pname);
         GLboolean answerBuffer[200];
-        GLboolean * params = __glXGetAnswerBuffer(cl, compsize, answerBuffer, sizeof(answerBuffer), 1);
+        GLboolean *params =
+            __glXGetAnswerBuffer(cl, compsize, answerBuffer,
+                                 sizeof(answerBuffer), 1);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetBooleanv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
+        glGetBooleanv(pname, params);
         __glXSendReplySwap(cl->client, params, compsize, 1, GL_FALSE, 0);
         error = Success;
     }
@@ -1901,20 +1750,20 @@ int __glXDispSwap_GetBooleanv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetClipPlane(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble equation[4];
-        CALL_GetClipPlane( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            equation
-        ) );
-        (void) bswap_64_array( (uint64_t *) equation, 4 );
+
+        glGetClipPlane((GLenum) bswap_ENUM(pc + 0), equation);
+        (void) bswap_64_array((uint64_t *) equation, 4);
         __glXSendReplySwap(cl->client, equation, 4, 8, GL_TRUE, 0);
         error = Success;
     }
@@ -1922,28 +1771,30 @@ int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetDoublev(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetDoublev_size(pname);
         GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *params =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetDoublev( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, compsize );
+        glGetDoublev(pname, params);
+        (void) bswap_64_array((uint64_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -1951,16 +1802,19 @@ int __glXDispSwap_GetDoublev(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetError(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLenum retval;
-        retval = CALL_GetError( GET_DISPATCH(), () );
+
+        retval = glGetError();
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -1968,28 +1822,30 @@ int __glXDispSwap_GetError(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetFloatv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetFloatv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetFloatv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetFloatv(pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -1997,28 +1853,30 @@ int __glXDispSwap_GetFloatv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetIntegerv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetIntegerv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetIntegerv( GET_DISPATCH(), (
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetIntegerv(pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2026,29 +1884,30 @@ int __glXDispSwap_GetIntegerv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetLightfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetLightfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetLightfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetLightfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2056,29 +1915,30 @@ int __glXDispSwap_GetLightfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetLightiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetLightiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetLightiv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetLightiv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2086,30 +1946,31 @@ int __glXDispSwap_GetLightiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMapdv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
-        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum target = (GLenum) bswap_ENUM(pc + 0);
+        const GLenum query = (GLenum) bswap_ENUM(pc + 4);
 
-        const GLuint compsize = __glGetMapdv_size(target,query);
+        const GLuint compsize = __glGetMapdv_size(target, query);
         GLdouble answerBuffer[200];
-        GLdouble * v = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *v =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapdv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
-        (void) bswap_64_array( (uint64_t *) v, compsize );
+        glGetMapdv(target, query, v);
+        (void) bswap_64_array((uint64_t *) v, compsize);
         __glXSendReplySwap(cl->client, v, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -2117,30 +1978,31 @@ int __glXDispSwap_GetMapdv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMapfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
-        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum target = (GLenum) bswap_ENUM(pc + 0);
+        const GLenum query = (GLenum) bswap_ENUM(pc + 4);
 
-        const GLuint compsize = __glGetMapfv_size(target,query);
+        const GLuint compsize = __glGetMapfv_size(target, query);
         GLfloat answerBuffer[200];
-        GLfloat * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *v =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapfv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
-        (void) bswap_32_array( (uint32_t *) v, compsize );
+        glGetMapfv(target, query, v);
+        (void) bswap_32_array((uint32_t *) v, compsize);
         __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2148,30 +2010,31 @@ int __glXDispSwap_GetMapfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMapiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum target =  (GLenum  )bswap_ENUM   ( pc +  0 );
-        const GLenum query =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum target = (GLenum) bswap_ENUM(pc + 0);
+        const GLenum query = (GLenum) bswap_ENUM(pc + 4);
 
-        const GLuint compsize = __glGetMapiv_size(target,query);
+        const GLuint compsize = __glGetMapiv_size(target, query);
         GLint answerBuffer[200];
-        GLint * v = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *v =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (v == NULL) return BadAlloc;
+        if (v == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMapiv( GET_DISPATCH(), (
-            target,
-            query,
-            v
-        ) );
-        (void) bswap_32_array( (uint32_t *) v, compsize );
+        glGetMapiv(target, query, v);
+        (void) bswap_32_array((uint32_t *) v, compsize);
         __glXSendReplySwap(cl->client, v, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2179,29 +2042,30 @@ int __glXDispSwap_GetMapiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMaterialfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMaterialfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMaterialfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMaterialfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2209,29 +2073,30 @@ int __glXDispSwap_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMaterialiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMaterialiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMaterialiv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMaterialiv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2239,28 +2104,30 @@ int __glXDispSwap_GetMaterialiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetPixelMapfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum map = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetPixelMapfv_size(map);
         GLfloat answerBuffer[200];
-        GLfloat * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *values =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapfv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
-        (void) bswap_32_array( (uint32_t *) values, compsize );
+        glGetPixelMapfv(map, values);
+        (void) bswap_32_array((uint32_t *) values, compsize);
         __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2268,28 +2135,30 @@ int __glXDispSwap_GetPixelMapfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetPixelMapuiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum map = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetPixelMapuiv_size(map);
         GLuint answerBuffer[200];
-        GLuint * values = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLuint *values =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapuiv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
-        (void) bswap_32_array( (uint32_t *) values, compsize );
+        glGetPixelMapuiv(map, values);
+        (void) bswap_32_array((uint32_t *) values, compsize);
         __glXSendReplySwap(cl->client, values, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2297,28 +2166,30 @@ int __glXDispSwap_GetPixelMapuiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetPixelMapusv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum map =  (GLenum  )bswap_ENUM   ( pc +  0 );
+    if (cx != NULL) {
+        const GLenum map = (GLenum) bswap_ENUM(pc + 0);
 
         const GLuint compsize = __glGetPixelMapusv_size(map);
         GLushort answerBuffer[200];
-        GLushort * values = __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer, sizeof(answerBuffer), 2);
+        GLushort *values =
+            __glXGetAnswerBuffer(cl, compsize * 2, answerBuffer,
+                                 sizeof(answerBuffer), 2);
 
-        if (values == NULL) return BadAlloc;
+        if (values == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetPixelMapusv( GET_DISPATCH(), (
-            map,
-            values
-        ) );
-        (void) bswap_16_array( (uint16_t *) values, compsize );
+        glGetPixelMapusv(map, values);
+        (void) bswap_16_array((uint16_t *) values, compsize);
         __glXSendReplySwap(cl->client, values, compsize, 2, GL_FALSE, 0);
         error = Success;
     }
@@ -2326,29 +2197,30 @@ int __glXDispSwap_GetPixelMapusv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexEnvfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexEnvfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexEnvfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexEnvfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2356,29 +2228,30 @@ int __glXDispSwap_GetTexEnvfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexEnviv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexEnviv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexEnviv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexEnviv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2386,29 +2259,30 @@ int __glXDispSwap_GetTexEnviv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexGendv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexGendv_size(pname);
         GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
+        GLdouble *params =
+            __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer,
+                                 sizeof(answerBuffer), 8);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGendv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, compsize );
+        glGetTexGendv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_64_array((uint64_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -2416,29 +2290,30 @@ int __glXDispSwap_GetTexGendv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexGenfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexGenfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGenfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexGenfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2446,29 +2321,30 @@ int __glXDispSwap_GetTexGenfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexGeniv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexGeniv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexGeniv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexGeniv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2476,29 +2352,30 @@ int __glXDispSwap_GetTexGeniv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2506,29 +2383,30 @@ int __glXDispSwap_GetTexParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetTexParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2536,30 +2414,31 @@ int __glXDispSwap_GetTexParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexLevelParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 8);
 
         const GLuint compsize = __glGetTexLevelParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexLevelParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLint   )bswap_CARD32 ( pc +  4 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexLevelParameterfv((GLenum) bswap_ENUM(pc + 0),
+                                 (GLint) bswap_CARD32(pc + 4), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2567,30 +2446,31 @@ int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetTexLevelParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  8 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 8);
 
         const GLuint compsize = __glGetTexLevelParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetTexLevelParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLint   )bswap_CARD32 ( pc +  4 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetTexLevelParameteriv((GLenum) bswap_ENUM(pc + 0),
+                                 (GLint) bswap_CARD32(pc + 4), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -2598,18 +2478,19 @@ int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsEnabled(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsEnabled( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 )
-        ) );
+
+        retval = glIsEnabled((GLenum) bswap_ENUM(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2617,18 +2498,19 @@ int __glXDispSwap_IsEnabled(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsList(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsList( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = glIsList((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -2636,251 +2518,236 @@ int __glXDispSwap_IsList(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_DepthRange(GLbyte * pc)
+void
+__glXDispSwap_DepthRange(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 16);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 16);
         pc -= 4;
     }
 #endif
 
-    CALL_DepthRange( GET_DISPATCH(), (
-         (GLclampd)bswap_FLOAT64( pc +  0 ),
-         (GLclampd)bswap_FLOAT64( pc +  8 )
-    ) );
+    glDepthRange((GLclampd) bswap_FLOAT64(pc + 0),
+                 (GLclampd) bswap_FLOAT64(pc + 8));
 }
 
-void __glXDispSwap_Frustum(GLbyte * pc)
+void
+__glXDispSwap_Frustum(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 48);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 48);
         pc -= 4;
     }
 #endif
 
-    CALL_Frustum( GET_DISPATCH(), (
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 ),
-         (GLdouble)bswap_FLOAT64( pc + 24 ),
-         (GLdouble)bswap_FLOAT64( pc + 32 ),
-         (GLdouble)bswap_FLOAT64( pc + 40 )
-    ) );
+    glFrustum((GLdouble) bswap_FLOAT64(pc + 0),
+              (GLdouble) bswap_FLOAT64(pc + 8),
+              (GLdouble) bswap_FLOAT64(pc + 16),
+              (GLdouble) bswap_FLOAT64(pc + 24),
+              (GLdouble) bswap_FLOAT64(pc + 32),
+              (GLdouble) bswap_FLOAT64(pc + 40));
 }
 
-void __glXDispSwap_LoadIdentity(GLbyte * pc)
+void
+__glXDispSwap_LoadIdentity(GLbyte * pc)
 {
-    CALL_LoadIdentity( GET_DISPATCH(), () );
+    glLoadIdentity();
 }
 
-void __glXDispSwap_LoadMatrixf(GLbyte * pc)
+void
+__glXDispSwap_LoadMatrixf(GLbyte * pc)
 {
-    CALL_LoadMatrixf( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
-    ) );
+    glLoadMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
 }
 
-void __glXDispSwap_LoadMatrixd(GLbyte * pc)
+void
+__glXDispSwap_LoadMatrixd(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 128);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 128);
         pc -= 4;
     }
 #endif
 
-    CALL_LoadMatrixd( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
-    ) );
+    glLoadMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
 }
 
-void __glXDispSwap_MatrixMode(GLbyte * pc)
+void
+__glXDispSwap_MatrixMode(GLbyte * pc)
 {
-    CALL_MatrixMode( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glMatrixMode((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_MultMatrixf(GLbyte * pc)
+void
+__glXDispSwap_MultMatrixf(GLbyte * pc)
 {
-    CALL_MultMatrixf( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 16 )
-    ) );
+    glMultMatrixf((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 16));
 }
 
-void __glXDispSwap_MultMatrixd(GLbyte * pc)
+void
+__glXDispSwap_MultMatrixd(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 128);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 128);
         pc -= 4;
     }
 #endif
 
-    CALL_MultMatrixd( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 16 )
-    ) );
+    glMultMatrixd((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 16));
 }
 
-void __glXDispSwap_Ortho(GLbyte * pc)
+void
+__glXDispSwap_Ortho(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 48);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 48);
         pc -= 4;
     }
 #endif
 
-    CALL_Ortho( GET_DISPATCH(), (
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 ),
-         (GLdouble)bswap_FLOAT64( pc + 24 ),
-         (GLdouble)bswap_FLOAT64( pc + 32 ),
-         (GLdouble)bswap_FLOAT64( pc + 40 )
-    ) );
+    glOrtho((GLdouble) bswap_FLOAT64(pc + 0),
+            (GLdouble) bswap_FLOAT64(pc + 8),
+            (GLdouble) bswap_FLOAT64(pc + 16),
+            (GLdouble) bswap_FLOAT64(pc + 24),
+            (GLdouble) bswap_FLOAT64(pc + 32),
+            (GLdouble) bswap_FLOAT64(pc + 40));
 }
 
-void __glXDispSwap_PopMatrix(GLbyte * pc)
+void
+__glXDispSwap_PopMatrix(GLbyte * pc)
 {
-    CALL_PopMatrix( GET_DISPATCH(), () );
+    glPopMatrix();
 }
 
-void __glXDispSwap_PushMatrix(GLbyte * pc)
+void
+__glXDispSwap_PushMatrix(GLbyte * pc)
 {
-    CALL_PushMatrix( GET_DISPATCH(), () );
+    glPushMatrix();
 }
 
-void __glXDispSwap_Rotated(GLbyte * pc)
+void
+__glXDispSwap_Rotated(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 32);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 32);
         pc -= 4;
     }
 #endif
 
-    CALL_Rotated( GET_DISPATCH(), (
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 ),
-         (GLdouble)bswap_FLOAT64( pc + 24 )
-    ) );
+    glRotated((GLdouble) bswap_FLOAT64(pc + 0),
+              (GLdouble) bswap_FLOAT64(pc + 8),
+              (GLdouble) bswap_FLOAT64(pc + 16),
+              (GLdouble) bswap_FLOAT64(pc + 24));
 }
 
-void __glXDispSwap_Rotatef(GLbyte * pc)
+void
+__glXDispSwap_Rotatef(GLbyte * pc)
 {
-    CALL_Rotatef( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 ),
-         (GLfloat )bswap_FLOAT32( pc + 12 )
-    ) );
+    glRotatef((GLfloat) bswap_FLOAT32(pc + 0),
+              (GLfloat) bswap_FLOAT32(pc + 4),
+              (GLfloat) bswap_FLOAT32(pc + 8),
+              (GLfloat) bswap_FLOAT32(pc + 12));
 }
 
-void __glXDispSwap_Scaled(GLbyte * pc)
+void
+__glXDispSwap_Scaled(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Scaled( GET_DISPATCH(), (
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 )
-    ) );
+    glScaled((GLdouble) bswap_FLOAT64(pc + 0),
+             (GLdouble) bswap_FLOAT64(pc + 8),
+             (GLdouble) bswap_FLOAT64(pc + 16));
 }
 
-void __glXDispSwap_Scalef(GLbyte * pc)
+void
+__glXDispSwap_Scalef(GLbyte * pc)
 {
-    CALL_Scalef( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glScalef((GLfloat) bswap_FLOAT32(pc + 0),
+             (GLfloat) bswap_FLOAT32(pc + 4), (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_Translated(GLbyte * pc)
+void
+__glXDispSwap_Translated(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_Translated( GET_DISPATCH(), (
-         (GLdouble)bswap_FLOAT64( pc +  0 ),
-         (GLdouble)bswap_FLOAT64( pc +  8 ),
-         (GLdouble)bswap_FLOAT64( pc + 16 )
-    ) );
+    glTranslated((GLdouble) bswap_FLOAT64(pc + 0),
+                 (GLdouble) bswap_FLOAT64(pc + 8),
+                 (GLdouble) bswap_FLOAT64(pc + 16));
 }
 
-void __glXDispSwap_Translatef(GLbyte * pc)
+void
+__glXDispSwap_Translatef(GLbyte * pc)
 {
-    CALL_Translatef( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glTranslatef((GLfloat) bswap_FLOAT32(pc + 0),
+                 (GLfloat) bswap_FLOAT32(pc + 4),
+                 (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_Viewport(GLbyte * pc)
+void
+__glXDispSwap_Viewport(GLbyte * pc)
 {
-    CALL_Viewport( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLsizei )bswap_CARD32 ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 )
-    ) );
+    glViewport((GLint) bswap_CARD32(pc + 0),
+               (GLint) bswap_CARD32(pc + 4),
+               (GLsizei) bswap_CARD32(pc + 8), (GLsizei) bswap_CARD32(pc + 12));
 }
 
-void __glXDispSwap_BindTexture(GLbyte * pc)
+void
+__glXDispSwap_BindTexture(GLbyte * pc)
 {
-    CALL_BindTexture( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    glBindTexture((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_Indexubv(GLbyte * pc)
+void
+__glXDispSwap_Indexubv(GLbyte * pc)
 {
-    CALL_Indexubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    glIndexubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDispSwap_PolygonOffset(GLbyte * pc)
+void
+__glXDispSwap_PolygonOffset(GLbyte * pc)
 {
-    CALL_PolygonOffset( GET_DISPATCH(), (
-         (GLfloat )bswap_FLOAT32( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    glPolygonOffset((GLfloat) bswap_FLOAT32(pc + 0),
+                    (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_AreTexturesResident(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLboolean retval;
         GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
-            residences
-        ) );
+        GLboolean *residences =
+            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        retval =
+            glAreTexturesResident(n,
+                                  (const GLuint *)
+                                  bswap_32_array((uint32_t *) (pc + 4), 0),
+                                  residences);
         __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
         error = Success;
     }
@@ -2888,24 +2755,27 @@ int __glXDispSwap_AreTexturesResident(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_AreTexturesResidentEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLboolean retval;
         GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreTexturesResident( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
-            residences
-        ) );
+        GLboolean *residences =
+            __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
+        retval =
+            glAreTexturesResident(n,
+                                  (const GLuint *)
+                                  bswap_32_array((uint32_t *) (pc + 4), 0),
+                                  residences);
         __glXSendReplySwap(cl->client, residences, n, 1, GL_TRUE, retval);
         error = Success;
     }
@@ -2913,116 +2783,115 @@ int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_CopyTexImage1D(GLbyte * pc)
+void
+__glXDispSwap_CopyTexImage1D(GLbyte * pc)
 {
-    CALL_CopyTexImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 )
-    ) );
+    glCopyTexImage1D((GLenum) bswap_ENUM(pc + 0),
+                     (GLint) bswap_CARD32(pc + 4),
+                     (GLenum) bswap_ENUM(pc + 8),
+                     (GLint) bswap_CARD32(pc + 12),
+                     (GLint) bswap_CARD32(pc + 16),
+                     (GLsizei) bswap_CARD32(pc + 20),
+                     (GLint) bswap_CARD32(pc + 24));
 }
 
-void __glXDispSwap_CopyTexImage2D(GLbyte * pc)
+void
+__glXDispSwap_CopyTexImage2D(GLbyte * pc)
 {
-    CALL_CopyTexImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 )
-    ) );
+    glCopyTexImage2D((GLenum) bswap_ENUM(pc + 0),
+                     (GLint) bswap_CARD32(pc + 4),
+                     (GLenum) bswap_ENUM(pc + 8),
+                     (GLint) bswap_CARD32(pc + 12),
+                     (GLint) bswap_CARD32(pc + 16),
+                     (GLsizei) bswap_CARD32(pc + 20),
+                     (GLsizei) bswap_CARD32(pc + 24),
+                     (GLint) bswap_CARD32(pc + 28));
 }
 
-void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
+void
+__glXDispSwap_CopyTexSubImage1D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 )
-    ) );
+    glCopyTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
+                        (GLint) bswap_CARD32(pc + 4),
+                        (GLint) bswap_CARD32(pc + 8),
+                        (GLint) bswap_CARD32(pc + 12),
+                        (GLint) bswap_CARD32(pc + 16),
+                        (GLsizei) bswap_CARD32(pc + 20));
 }
 
-void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
+void
+__glXDispSwap_CopyTexSubImage2D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLint   )bswap_CARD32 ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 )
-    ) );
+    glCopyTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
+                        (GLint) bswap_CARD32(pc + 4),
+                        (GLint) bswap_CARD32(pc + 8),
+                        (GLint) bswap_CARD32(pc + 12),
+                        (GLint) bswap_CARD32(pc + 16),
+                        (GLint) bswap_CARD32(pc + 20),
+                        (GLsizei) bswap_CARD32(pc + 24),
+                        (GLsizei) bswap_CARD32(pc + 28));
 }
 
-int __glXDispSwap_DeleteTextures(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_DeleteTextures(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        CALL_DeleteTextures( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-        ) );
+        glDeleteTextures(n,
+                         (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         0));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_DeleteTexturesEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_DeleteTexturesEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        CALL_DeleteTextures( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-        ) );
+        glDeleteTextures(n,
+                         (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         0));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenTextures(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenTextures( GET_DISPATCH(), (
-            n,
-            textures
-        ) );
-        (void) bswap_32_array( (uint32_t *) textures, n );
+        GLuint *textures =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        glGenTextures(n, textures);
+        (void) bswap_32_array((uint32_t *) textures, n);
         __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -3030,23 +2899,24 @@ int __glXDispSwap_GenTextures(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenTexturesEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * textures = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenTextures( GET_DISPATCH(), (
-            n,
-            textures
-        ) );
-        (void) bswap_32_array( (uint32_t *) textures, n );
+        GLuint *textures =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        glGenTextures(n, textures);
+        (void) bswap_32_array((uint32_t *) textures, n);
         __glXSendReplySwap(cl->client, textures, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -3054,18 +2924,19 @@ int __glXDispSwap_GenTexturesEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsTexture(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsTexture( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -3073,18 +2944,19 @@ int __glXDispSwap_IsTexture(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsTextureEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsTexture( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = glIsTexture((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -3092,166 +2964,160 @@ int __glXDispSwap_IsTextureEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_PrioritizeTextures(GLbyte * pc)
+void
+__glXDispSwap_PrioritizeTextures(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    CALL_PrioritizeTextures( GET_DISPATCH(), (
-        n,
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
-         (const GLclampf *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-    ) );
+    glPrioritizeTextures(n,
+                         (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         0),
+                         (const GLclampf *)
+                         bswap_32_array((uint32_t *) (pc + 4), 0));
 }
 
-void __glXDispSwap_TexSubImage1D(GLbyte * pc)
+void
+__glXDispSwap_TexSubImage1D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexSubImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 ),
-         (GLsizei )bswap_CARD32 ( pc + 36 ),
-         (GLenum  )bswap_ENUM   ( pc + 44 ),
-         (GLenum  )bswap_ENUM   ( pc + 48 ),
-        pixels
-    ) );
+    glTexSubImage1D((GLenum) bswap_ENUM(pc + 20),
+                    (GLint) bswap_CARD32(pc + 24),
+                    (GLint) bswap_CARD32(pc + 28),
+                    (GLsizei) bswap_CARD32(pc + 36),
+                    (GLenum) bswap_ENUM(pc + 44),
+                    (GLenum) bswap_ENUM(pc + 48), pixels);
 }
 
-void __glXDispSwap_TexSubImage2D(GLbyte * pc)
+void
+__glXDispSwap_TexSubImage2D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 56);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 56));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexSubImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 ),
-         (GLint   )bswap_CARD32 ( pc + 32 ),
-         (GLsizei )bswap_CARD32 ( pc + 36 ),
-         (GLsizei )bswap_CARD32 ( pc + 40 ),
-         (GLenum  )bswap_ENUM   ( pc + 44 ),
-         (GLenum  )bswap_ENUM   ( pc + 48 ),
-        pixels
-    ) );
+    glTexSubImage2D((GLenum) bswap_ENUM(pc + 20),
+                    (GLint) bswap_CARD32(pc + 24),
+                    (GLint) bswap_CARD32(pc + 28),
+                    (GLint) bswap_CARD32(pc + 32),
+                    (GLsizei) bswap_CARD32(pc + 36),
+                    (GLsizei) bswap_CARD32(pc + 40),
+                    (GLenum) bswap_ENUM(pc + 44),
+                    (GLenum) bswap_ENUM(pc + 48), pixels);
 }
 
-void __glXDispSwap_BlendColor(GLbyte * pc)
+void
+__glXDispSwap_BlendColor(GLbyte * pc)
 {
-    CALL_BlendColor( GET_DISPATCH(), (
-         (GLclampf)bswap_FLOAT32( pc +  0 ),
-         (GLclampf)bswap_FLOAT32( pc +  4 ),
-         (GLclampf)bswap_FLOAT32( pc +  8 ),
-         (GLclampf)bswap_FLOAT32( pc + 12 )
-    ) );
+    glBlendColor((GLclampf) bswap_FLOAT32(pc + 0),
+                 (GLclampf) bswap_FLOAT32(pc + 4),
+                 (GLclampf) bswap_FLOAT32(pc + 8),
+                 (GLclampf) bswap_FLOAT32(pc + 12));
 }
 
-void __glXDispSwap_BlendEquation(GLbyte * pc)
+void
+__glXDispSwap_BlendEquation(GLbyte * pc)
 {
-    CALL_BlendEquation( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glBlendEquation((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_ColorTable(GLbyte * pc)
+void
+__glXDispSwap_ColorTable(GLbyte * pc)
 {
-    const GLvoid * const table = (const GLvoid *) (pc + 40);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const table = (const GLvoid *) ((pc + 40));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_ColorTable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLenum  )bswap_ENUM   ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-        table
-    ) );
+    glColorTable((GLenum) bswap_ENUM(pc + 20),
+                 (GLenum) bswap_ENUM(pc + 24),
+                 (GLsizei) bswap_CARD32(pc + 28),
+                 (GLenum) bswap_ENUM(pc + 32),
+                 (GLenum) bswap_ENUM(pc + 36), table);
 }
 
-void __glXDispSwap_ColorTableParameterfv(GLbyte * pc)
+void
+__glXDispSwap_ColorTableParameterfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameterfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glColorTableParameterfv_size(pname));
 
-    CALL_ColorTableParameterfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_ColorTableParameteriv(GLbyte * pc)
+void
+__glXDispSwap_ColorTableParameteriv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glColorTableParameteriv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glColorTableParameteriv_size(pname));
 
-    CALL_ColorTableParameteriv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_CopyColorTable(GLbyte * pc)
+void
+__glXDispSwap_CopyColorTable(GLbyte * pc)
 {
-    CALL_CopyColorTable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 )
-    ) );
+    glCopyColorTable((GLenum) bswap_ENUM(pc + 0),
+                     (GLenum) bswap_ENUM(pc + 4),
+                     (GLint) bswap_CARD32(pc + 8),
+                     (GLint) bswap_CARD32(pc + 12),
+                     (GLsizei) bswap_CARD32(pc + 16));
 }
 
-int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetColorTableParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3259,29 +3125,30 @@ int __glXDispSwap_GetColorTableParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetColorTableParameterfvSGI(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetColorTableParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetColorTableParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3289,29 +3156,30 @@ int __glXDispSwap_GetColorTableParameterfvSGI(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetColorTableParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3319,29 +3187,30 @@ int __glXDispSwap_GetColorTableParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetColorTableParameterivSGI(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetColorTableParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetColorTableParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetColorTableParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3349,176 +3218,168 @@ int __glXDispSwap_GetColorTableParameterivSGI(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_ColorSubTable(GLbyte * pc)
+void
+__glXDispSwap_ColorSubTable(GLbyte * pc)
 {
-    const GLvoid * const data = (const GLvoid *) (pc + 40);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const data = (const GLvoid *) ((pc + 40));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_ColorSubTable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-        data
-    ) );
+    glColorSubTable((GLenum) bswap_ENUM(pc + 20),
+                    (GLsizei) bswap_CARD32(pc + 24),
+                    (GLsizei) bswap_CARD32(pc + 28),
+                    (GLenum) bswap_ENUM(pc + 32),
+                    (GLenum) bswap_ENUM(pc + 36), data);
 }
 
-void __glXDispSwap_CopyColorSubTable(GLbyte * pc)
+void
+__glXDispSwap_CopyColorSubTable(GLbyte * pc)
 {
-    CALL_CopyColorSubTable( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLsizei )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 )
-    ) );
+    glCopyColorSubTable((GLenum) bswap_ENUM(pc + 0),
+                        (GLsizei) bswap_CARD32(pc + 4),
+                        (GLint) bswap_CARD32(pc + 8),
+                        (GLint) bswap_CARD32(pc + 12),
+                        (GLsizei) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const image = (const GLvoid *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_ConvolutionFilter1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLenum  )bswap_ENUM   ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-         (GLenum  )bswap_ENUM   ( pc + 40 ),
-        image
-    ) );
+    glConvolutionFilter1D((GLenum) bswap_ENUM(pc + 20),
+                          (GLenum) bswap_ENUM(pc + 24),
+                          (GLsizei) bswap_CARD32(pc + 28),
+                          (GLenum) bswap_ENUM(pc + 36),
+                          (GLenum) bswap_ENUM(pc + 40), image);
 }
 
-void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
 {
-    const GLvoid * const image = (const GLvoid *) (pc + 44);
-    __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);
+    const GLvoid *const image = (const GLvoid *) ((pc + 44));
+    __GLXpixelHeader *const hdr = (__GLXpixelHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_ConvolutionFilter2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 20 ),
-         (GLenum  )bswap_ENUM   ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLsizei )bswap_CARD32 ( pc + 32 ),
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-         (GLenum  )bswap_ENUM   ( pc + 40 ),
-        image
-    ) );
+    glConvolutionFilter2D((GLenum) bswap_ENUM(pc + 20),
+                          (GLenum) bswap_ENUM(pc + 24),
+                          (GLsizei) bswap_CARD32(pc + 28),
+                          (GLsizei) bswap_CARD32(pc + 32),
+                          (GLenum) bswap_ENUM(pc + 36),
+                          (GLenum) bswap_ENUM(pc + 40), image);
 }
 
-void __glXDispSwap_ConvolutionParameterf(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionParameterf(GLbyte * pc)
 {
-    CALL_ConvolutionParameterf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLfloat )bswap_FLOAT32( pc +  8 )
-    ) );
+    glConvolutionParameterf((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLfloat) bswap_FLOAT32(pc + 8));
 }
 
-void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionParameterfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLfloat * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameterfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                         __glConvolutionParameterfv_size
+                                         (pname));
 
-    CALL_ConvolutionParameterfv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_ConvolutionParameteri(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionParameteri(GLbyte * pc)
 {
-    CALL_ConvolutionParameteri( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 )
-    ) );
+    glConvolutionParameteri((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8));
 }
 
-void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
+void
+__glXDispSwap_ConvolutionParameteriv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-    const GLint * params;
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 8), __glConvolutionParameteriv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 8),
+                                       __glConvolutionParameteriv_size(pname));
 
-    CALL_ConvolutionParameteriv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-        pname,
-        params
-    ) );
+    glConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
 }
 
-void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
+void
+__glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc)
 {
-    CALL_CopyConvolutionFilter1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 )
-    ) );
+    glCopyConvolutionFilter1D((GLenum) bswap_ENUM(pc + 0),
+                              (GLenum) bswap_ENUM(pc + 4),
+                              (GLint) bswap_CARD32(pc + 8),
+                              (GLint) bswap_CARD32(pc + 12),
+                              (GLsizei) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
+void
+__glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc)
 {
-    CALL_CopyConvolutionFilter2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 )
-    ) );
+    glCopyConvolutionFilter2D((GLenum) bswap_ENUM(pc + 0),
+                              (GLenum) bswap_ENUM(pc + 4),
+                              (GLint) bswap_CARD32(pc + 8),
+                              (GLint) bswap_CARD32(pc + 12),
+                              (GLsizei) bswap_CARD32(pc + 16),
+                              (GLsizei) bswap_CARD32(pc + 20));
 }
 
-int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetConvolutionParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3526,29 +3387,30 @@ int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetConvolutionParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetConvolutionParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3556,29 +3418,30 @@ int __glXDispSwap_GetConvolutionParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetConvolutionParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3586,29 +3449,30 @@ int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetConvolutionParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetConvolutionParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetConvolutionParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetConvolutionParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3616,29 +3480,30 @@ int __glXDispSwap_GetConvolutionParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetHistogramParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetHistogramParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3646,29 +3511,30 @@ int __glXDispSwap_GetHistogramParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetHistogramParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetHistogramParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetHistogramParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3676,29 +3542,30 @@ int __glXDispSwap_GetHistogramParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetHistogramParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetHistogramParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3706,29 +3573,30 @@ int __glXDispSwap_GetHistogramParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetHistogramParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetHistogramParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetHistogramParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetHistogramParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3736,29 +3604,30 @@ int __glXDispSwap_GetHistogramParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMinmaxParameterfv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMinmaxParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3766,29 +3635,30 @@ int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMinmaxParameterfvEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameterfv_size(pname);
         GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLfloat *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameterfv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMinmaxParameterfv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3796,29 +3666,30 @@ int __glXDispSwap_GetMinmaxParameterfvEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMinmaxParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMinmaxParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3826,29 +3697,30 @@ int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetMinmaxParameterivEXT(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetMinmaxParameteriv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetMinmaxParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        glGetMinmaxParameteriv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -3856,563 +3728,582 @@ int __glXDispSwap_GetMinmaxParameterivEXT(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_Histogram(GLbyte * pc)
-{
-    CALL_Histogram( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLsizei )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-        *(GLboolean *)(pc + 12)
-    ) );
+void
+__glXDispSwap_Histogram(GLbyte * pc)
+{
+    glHistogram((GLenum) bswap_ENUM(pc + 0),
+                (GLsizei) bswap_CARD32(pc + 4),
+                (GLenum) bswap_ENUM(pc + 8), *(GLboolean *) (pc + 12));
 }
 
-void __glXDispSwap_Minmax(GLbyte * pc)
+void
+__glXDispSwap_Minmax(GLbyte * pc)
 {
-    CALL_Minmax( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-        *(GLboolean *)(pc +  8)
-    ) );
+    glMinmax((GLenum) bswap_ENUM(pc + 0),
+             (GLenum) bswap_ENUM(pc + 4), *(GLboolean *) (pc + 8));
 }
 
-void __glXDispSwap_ResetHistogram(GLbyte * pc)
+void
+__glXDispSwap_ResetHistogram(GLbyte * pc)
 {
-    CALL_ResetHistogram( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glResetHistogram((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_ResetMinmax(GLbyte * pc)
+void
+__glXDispSwap_ResetMinmax(GLbyte * pc)
 {
-    CALL_ResetMinmax( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glResetMinmax((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_TexImage3D(GLbyte * pc)
+void
+__glXDispSwap_TexImage3D(GLbyte * pc)
 {
-    const CARD32 ptr_is_null = *(CARD32 *)(pc + 76);
-    const GLvoid * const pixels = (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
-    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
+    const CARD32 ptr_is_null = *(CARD32 *) (pc + 76);
+    const GLvoid *const pixels =
+        (const GLvoid *) ((ptr_is_null != 0) ? NULL : (pc + 80));
+    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
+                  (GLint) bswap_CARD32(&hdr->imageHeight));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_IMAGES,
+                  (GLint) bswap_CARD32(&hdr->skipImages));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexImage3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-         (GLint   )bswap_CARD32 ( pc + 40 ),
-         (GLint   )bswap_CARD32 ( pc + 44 ),
-         (GLsizei )bswap_CARD32 ( pc + 48 ),
-         (GLsizei )bswap_CARD32 ( pc + 52 ),
-         (GLsizei )bswap_CARD32 ( pc + 56 ),
-         (GLint   )bswap_CARD32 ( pc + 64 ),
-         (GLenum  )bswap_ENUM   ( pc + 68 ),
-         (GLenum  )bswap_ENUM   ( pc + 72 ),
-        pixels
-    ) );
+    glTexImage3D((GLenum) bswap_ENUM(pc + 36),
+                 (GLint) bswap_CARD32(pc + 40),
+                 (GLint) bswap_CARD32(pc + 44),
+                 (GLsizei) bswap_CARD32(pc + 48),
+                 (GLsizei) bswap_CARD32(pc + 52),
+                 (GLsizei) bswap_CARD32(pc + 56),
+                 (GLint) bswap_CARD32(pc + 64),
+                 (GLenum) bswap_ENUM(pc + 68),
+                 (GLenum) bswap_ENUM(pc + 72), pixels);
 }
 
-void __glXDispSwap_TexSubImage3D(GLbyte * pc)
+void
+__glXDispSwap_TexSubImage3D(GLbyte * pc)
 {
-    const GLvoid * const pixels = (const GLvoid *) (pc + 88);
-    __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);
+    const GLvoid *const pixels = (const GLvoid *) ((pc + 88));
+    __GLXpixel3DHeader *const hdr = (__GLXpixel3DHeader *) (pc);
 
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES,   hdr->swapBytes) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST,    hdr->lsbFirst) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH,   (GLint) bswap_CARD32( & hdr->rowLength )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) bswap_CARD32( & hdr->imageHeight )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS,    (GLint) bswap_CARD32( & hdr->skipRows )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES,  (GLint) bswap_CARD32( & hdr->skipImages )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS,  (GLint) bswap_CARD32( & hdr->skipPixels )) );
-    CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT,    (GLint) bswap_CARD32( & hdr->alignment )) );
+    glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) bswap_CARD32(&hdr->rowLength));
+    glPixelStorei(GL_UNPACK_IMAGE_HEIGHT,
+                  (GLint) bswap_CARD32(&hdr->imageHeight));
+    glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) bswap_CARD32(&hdr->skipRows));
+    glPixelStorei(GL_UNPACK_SKIP_IMAGES,
+                  (GLint) bswap_CARD32(&hdr->skipImages));
+    glPixelStorei(GL_UNPACK_SKIP_PIXELS,
+                  (GLint) bswap_CARD32(&hdr->skipPixels));
+    glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) bswap_CARD32(&hdr->alignment));
 
-    CALL_TexSubImage3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 36 ),
-         (GLint   )bswap_CARD32 ( pc + 40 ),
-         (GLint   )bswap_CARD32 ( pc + 44 ),
-         (GLint   )bswap_CARD32 ( pc + 48 ),
-         (GLint   )bswap_CARD32 ( pc + 52 ),
-         (GLsizei )bswap_CARD32 ( pc + 60 ),
-         (GLsizei )bswap_CARD32 ( pc + 64 ),
-         (GLsizei )bswap_CARD32 ( pc + 68 ),
-         (GLenum  )bswap_ENUM   ( pc + 76 ),
-         (GLenum  )bswap_ENUM   ( pc + 80 ),
-        pixels
-    ) );
+    glTexSubImage3D((GLenum) bswap_ENUM(pc + 36),
+                    (GLint) bswap_CARD32(pc + 40),
+                    (GLint) bswap_CARD32(pc + 44),
+                    (GLint) bswap_CARD32(pc + 48),
+                    (GLint) bswap_CARD32(pc + 52),
+                    (GLsizei) bswap_CARD32(pc + 60),
+                    (GLsizei) bswap_CARD32(pc + 64),
+                    (GLsizei) bswap_CARD32(pc + 68),
+                    (GLenum) bswap_ENUM(pc + 76),
+                    (GLenum) bswap_ENUM(pc + 80), pixels);
 }
 
-void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
+void
+__glXDispSwap_CopyTexSubImage3D(GLbyte * pc)
 {
-    CALL_CopyTexSubImage3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLint   )bswap_CARD32 ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLsizei )bswap_CARD32 ( pc + 32 )
-    ) );
+    glCopyTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
+                        (GLint) bswap_CARD32(pc + 4),
+                        (GLint) bswap_CARD32(pc + 8),
+                        (GLint) bswap_CARD32(pc + 12),
+                        (GLint) bswap_CARD32(pc + 16),
+                        (GLint) bswap_CARD32(pc + 20),
+                        (GLint) bswap_CARD32(pc + 24),
+                        (GLsizei) bswap_CARD32(pc + 28),
+                        (GLsizei) bswap_CARD32(pc + 32));
 }
 
-void __glXDispSwap_ActiveTexture(GLbyte * pc)
+void
+__glXDispSwap_ActiveTexture(GLbyte * pc)
 {
-    CALL_ActiveTexture( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    glActiveTextureARB((GLenum) bswap_ENUM(pc + 0));
 }
 
-void __glXDispSwap_MultiTexCoord1dv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord1dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord1dv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
-    ) );
+    glMultiTexCoord1dvARB((GLenum) bswap_ENUM(pc + 8),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                         1));
 }
 
-void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord1fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
-    ) );
+    glMultiTexCoord1fvARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLfloat *)
+                          bswap_32_array((uint32_t *) (pc + 4), 1));
 }
 
-void __glXDispSwap_MultiTexCoord1iv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord1iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord1iv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
-    ) );
+    glMultiTexCoord1ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         1));
 }
 
-void __glXDispSwap_MultiTexCoord1sv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord1sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord1sv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
-    ) );
+    glMultiTexCoord1svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           1));
 }
 
-void __glXDispSwap_MultiTexCoord2dv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord2dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord2dv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 16 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 2 )
-    ) );
+    glMultiTexCoord2dvARB((GLenum) bswap_ENUM(pc + 16),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            2));
 }
 
-void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord2fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
-    ) );
+    glMultiTexCoord2fvARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLfloat *)
+                          bswap_32_array((uint32_t *) (pc + 4), 2));
 }
 
-void __glXDispSwap_MultiTexCoord2iv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord2iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord2iv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
-    ) );
+    glMultiTexCoord2ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         2));
 }
 
-void __glXDispSwap_MultiTexCoord2sv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord2sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord2sv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
-    ) );
+    glMultiTexCoord2svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           2));
 }
 
-void __glXDispSwap_MultiTexCoord3dv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord3dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord3dv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 24 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    glMultiTexCoord3dvARB((GLenum) bswap_ENUM(pc + 24),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            3));
 }
 
-void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord3fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
-    ) );
+    glMultiTexCoord3fvARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLfloat *)
+                          bswap_32_array((uint32_t *) (pc + 4), 3));
 }
 
-void __glXDispSwap_MultiTexCoord3iv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord3iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord3iv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
-    ) );
+    glMultiTexCoord3ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         3));
 }
 
-void __glXDispSwap_MultiTexCoord3sv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord3sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord3sv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
-    ) );
+    glMultiTexCoord3svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           3));
 }
 
-void __glXDispSwap_MultiTexCoord4dv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord4dv(GLbyte * pc)
 {
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_MultiTexCoord4dv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    glMultiTexCoord4dvARB((GLenum) bswap_ENUM(pc + 32),
+                          (const GLdouble *) bswap_64_array((uint64_t *) (pc + 0),
+                                                            4));
 }
 
-void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc)
 {
-    CALL_MultiTexCoord4fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    glMultiTexCoord4fvARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLfloat *)
+                          bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
-void __glXDispSwap_MultiTexCoord4iv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord4iv(GLbyte * pc)
 {
-    CALL_MultiTexCoord4iv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    glMultiTexCoord4ivARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                         4));
 }
 
-void __glXDispSwap_MultiTexCoord4sv(GLbyte * pc)
+void
+__glXDispSwap_MultiTexCoord4sv(GLbyte * pc)
 {
-    CALL_MultiTexCoord4sv( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    glMultiTexCoord4svARB((GLenum) bswap_ENUM(pc + 0),
+                          (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                           4));
 }
 
-void __glXDispSwap_CompressedTexImage1D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexImage1D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
+    PFNGLCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D =
+        __glGetProcAddress("glCompressedTexImage1D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
 
-    CALL_CompressedTexImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-        imageSize,
-         (const GLvoid *)(pc + 24)
-    ) );
+    CompressedTexImage1D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16),
+                         imageSize, (const GLvoid *) (pc + 24));
 }
 
-void __glXDispSwap_CompressedTexImage2D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexImage2D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 24 );
+    PFNGLCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D =
+        __glGetProcAddress("glCompressedTexImage2D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 24);
 
-    CALL_CompressedTexImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 ),
-         (GLint   )bswap_CARD32 ( pc + 20 ),
-        imageSize,
-         (const GLvoid *)(pc + 28)
-    ) );
+    CompressedTexImage2D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLsizei) bswap_CARD32(pc + 16),
+                         (GLint) bswap_CARD32(pc + 20),
+                         imageSize, (const GLvoid *) (pc + 28));
 }
 
-void __glXDispSwap_CompressedTexImage3D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexImage3D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
+    PFNGLCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D =
+        __glGetProcAddress("glCompressedTexImage3D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
 
-    CALL_CompressedTexImage3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-        imageSize,
-         (const GLvoid *)(pc + 32)
-    ) );
+    CompressedTexImage3D((GLenum) bswap_ENUM(pc + 0),
+                         (GLint) bswap_CARD32(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLsizei) bswap_CARD32(pc + 12),
+                         (GLsizei) bswap_CARD32(pc + 16),
+                         (GLsizei) bswap_CARD32(pc + 20),
+                         (GLint) bswap_CARD32(pc + 24),
+                         imageSize, (const GLvoid *) (pc + 32));
 }
 
-void __glXDispSwap_CompressedTexSubImage1D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexSubImage1D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 20 );
+    PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D =
+        __glGetProcAddress("glCompressedTexSubImage1D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 20);
 
-    CALL_CompressedTexSubImage1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLenum  )bswap_ENUM   ( pc + 16 ),
-        imageSize,
-         (const GLvoid *)(pc + 24)
-    ) );
+    CompressedTexSubImage1D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLsizei) bswap_CARD32(pc + 12),
+                            (GLenum) bswap_ENUM(pc + 16),
+                            imageSize, (const GLvoid *) (pc + 24));
 }
 
-void __glXDispSwap_CompressedTexSubImage2D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexSubImage2D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 28 );
+    PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D =
+        __glGetProcAddress("glCompressedTexSubImage2D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 28);
 
-    CALL_CompressedTexSubImage2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLenum  )bswap_ENUM   ( pc + 24 ),
-        imageSize,
-         (const GLvoid *)(pc + 32)
-    ) );
+    CompressedTexSubImage2D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLsizei) bswap_CARD32(pc + 16),
+                            (GLsizei) bswap_CARD32(pc + 20),
+                            (GLenum) bswap_ENUM(pc + 24),
+                            imageSize, (const GLvoid *) (pc + 32));
 }
 
-void __glXDispSwap_CompressedTexSubImage3D(GLbyte * pc)
+void
+__glXDispSwap_CompressedTexSubImage3D(GLbyte * pc)
 {
-    const GLsizei imageSize =  (GLsizei )bswap_CARD32 ( pc + 36 );
+    PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D =
+        __glGetProcAddress("glCompressedTexSubImage3D");
+    const GLsizei imageSize = (GLsizei) bswap_CARD32(pc + 36);
 
-    CALL_CompressedTexSubImage3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLsizei )bswap_CARD32 ( pc + 20 ),
-         (GLsizei )bswap_CARD32 ( pc + 24 ),
-         (GLsizei )bswap_CARD32 ( pc + 28 ),
-         (GLenum  )bswap_ENUM   ( pc + 32 ),
-        imageSize,
-         (const GLvoid *)(pc + 40)
-    ) );
+    CompressedTexSubImage3D((GLenum) bswap_ENUM(pc + 0),
+                            (GLint) bswap_CARD32(pc + 4),
+                            (GLint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLint) bswap_CARD32(pc + 16),
+                            (GLsizei) bswap_CARD32(pc + 20),
+                            (GLsizei) bswap_CARD32(pc + 24),
+                            (GLsizei) bswap_CARD32(pc + 28),
+                            (GLenum) bswap_ENUM(pc + 32),
+                            imageSize, (const GLvoid *) (pc + 40));
 }
 
-void __glXDispSwap_SampleCoverage(GLbyte * pc)
+void
+__glXDispSwap_SampleCoverage(GLbyte * pc)
 {
-    CALL_SampleCoverage( GET_DISPATCH(), (
-         (GLclampf)bswap_FLOAT32( pc +  0 ),
-        *(GLboolean *)(pc +  4)
-    ) );
+    PFNGLSAMPLECOVERAGEPROC SampleCoverage =
+        __glGetProcAddress("glSampleCoverage");
+    SampleCoverage((GLclampf) bswap_FLOAT32(pc + 0), *(GLboolean *) (pc + 4));
 }
 
-void __glXDispSwap_BlendFuncSeparate(GLbyte * pc)
+void
+__glXDispSwap_BlendFuncSeparate(GLbyte * pc)
 {
-    CALL_BlendFuncSeparate( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLenum  )bswap_ENUM   ( pc + 12 )
-    ) );
+    PFNGLBLENDFUNCSEPARATEPROC BlendFuncSeparate =
+        __glGetProcAddress("glBlendFuncSeparate");
+    BlendFuncSeparate((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4),
+                      (GLenum) bswap_ENUM(pc + 8),
+                      (GLenum) bswap_ENUM(pc + 12));
 }
 
-void __glXDispSwap_FogCoorddv(GLbyte * pc)
+void
+__glXDispSwap_FogCoorddv(GLbyte * pc)
 {
+    PFNGLFOGCOORDDVPROC FogCoorddv = __glGetProcAddress("glFogCoorddv");
+
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 8);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 8);
         pc -= 4;
     }
 #endif
 
-    CALL_FogCoorddv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 1 )
-    ) );
+    FogCoorddv((const GLdouble *) bswap_64_array((uint64_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_PointParameterf(GLbyte * pc)
+void
+__glXDispSwap_PointParameterf(GLbyte * pc)
 {
-    CALL_PointParameterf( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLfloat )bswap_FLOAT32( pc +  4 )
-    ) );
+    PFNGLPOINTPARAMETERFPROC PointParameterf =
+        __glGetProcAddress("glPointParameterf");
+    PointParameterf((GLenum) bswap_ENUM(pc + 0),
+                    (GLfloat) bswap_FLOAT32(pc + 4));
 }
 
-void __glXDispSwap_PointParameterfv(GLbyte * pc)
+void
+__glXDispSwap_PointParameterfv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLfloat * params;
+    PFNGLPOINTPARAMETERFVPROC PointParameterfv =
+        __glGetProcAddress("glPointParameterfv");
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLfloat *params;
 
-    params = (const GLfloat *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameterfv_size(pname) );
+    params =
+        (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                         __glPointParameterfv_size(pname));
 
-    CALL_PointParameterfv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    PointParameterfv(pname, params);
 }
 
-void __glXDispSwap_PointParameteri(GLbyte * pc)
+void
+__glXDispSwap_PointParameteri(GLbyte * pc)
 {
-    CALL_PointParameteri( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLPOINTPARAMETERIPROC PointParameteri =
+        __glGetProcAddress("glPointParameteri");
+    PointParameteri((GLenum) bswap_ENUM(pc + 0), (GLint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_PointParameteriv(GLbyte * pc)
+void
+__glXDispSwap_PointParameteriv(GLbyte * pc)
 {
-    const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  0 );
-    const GLint * params;
+    PFNGLPOINTPARAMETERIVPROC PointParameteriv =
+        __glGetProcAddress("glPointParameteriv");
+    const GLenum pname = (GLenum) bswap_ENUM(pc + 0);
+    const GLint *params;
 
-    params = (const GLint *) bswap_32_array( (uint32_t *) (pc + 4), __glPointParameteriv_size(pname) );
+    params =
+        (const GLint *) bswap_32_array((uint32_t *) (pc + 4),
+                                       __glPointParameteriv_size(pname));
 
-    CALL_PointParameteriv( GET_DISPATCH(), (
-        pname,
-        params
-    ) );
+    PointParameteriv(pname, params);
 }
 
-void __glXDispSwap_SecondaryColor3bv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3bv(GLbyte * pc)
 {
-    CALL_SecondaryColor3bv( GET_DISPATCH(), (
-         (const GLbyte *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3BVPROC SecondaryColor3bv =
+        __glGetProcAddress("glSecondaryColor3bv");
+    SecondaryColor3bv((const GLbyte *) (pc + 0));
 }
 
-void __glXDispSwap_SecondaryColor3dv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3dv(GLbyte * pc)
 {
+    PFNGLSECONDARYCOLOR3DVPROC SecondaryColor3dv =
+        __glGetProcAddress("glSecondaryColor3dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 24);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 24);
         pc -= 4;
     }
 #endif
 
-    CALL_SecondaryColor3dv( GET_DISPATCH(), (
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 3 )
-    ) );
+    SecondaryColor3dv((const GLdouble *)
+                      bswap_64_array((uint64_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_SecondaryColor3iv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3iv(GLbyte * pc)
 {
-    CALL_SecondaryColor3iv( GET_DISPATCH(), (
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    PFNGLSECONDARYCOLOR3IVPROC SecondaryColor3iv =
+        __glGetProcAddress("glSecondaryColor3iv");
+    SecondaryColor3iv((const GLint *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_SecondaryColor3sv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3sv(GLbyte * pc)
 {
-    CALL_SecondaryColor3sv( GET_DISPATCH(), (
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    PFNGLSECONDARYCOLOR3SVPROC SecondaryColor3sv =
+        __glGetProcAddress("glSecondaryColor3sv");
+    SecondaryColor3sv((const GLshort *)
+                      bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_SecondaryColor3ubv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3ubv(GLbyte * pc)
 {
-    CALL_SecondaryColor3ubv( GET_DISPATCH(), (
-         (const GLubyte *)(pc +  0)
-    ) );
+    PFNGLSECONDARYCOLOR3UBVPROC SecondaryColor3ubv =
+        __glGetProcAddress("glSecondaryColor3ubv");
+    SecondaryColor3ubv((const GLubyte *) (pc + 0));
 }
 
-void __glXDispSwap_SecondaryColor3uiv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3uiv(GLbyte * pc)
 {
-    CALL_SecondaryColor3uiv( GET_DISPATCH(), (
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    PFNGLSECONDARYCOLOR3UIVPROC SecondaryColor3uiv =
+        __glGetProcAddress("glSecondaryColor3uiv");
+    SecondaryColor3uiv((const GLuint *)
+                       bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_SecondaryColor3usv(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3usv(GLbyte * pc)
 {
-    CALL_SecondaryColor3usv( GET_DISPATCH(), (
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  0), 3 )
-    ) );
+    PFNGLSECONDARYCOLOR3USVPROC SecondaryColor3usv =
+        __glGetProcAddress("glSecondaryColor3usv");
+    SecondaryColor3usv((const GLushort *)
+                       bswap_16_array((uint16_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_WindowPos3fv(GLbyte * pc)
+void
+__glXDispSwap_WindowPos3fv(GLbyte * pc)
 {
-    CALL_WindowPos3fv( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
+    PFNGLWINDOWPOS3FVPROC WindowPos3fv = __glGetProcAddress("glWindowPos3fv");
+
+    WindowPos3fv((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_BeginQuery(GLbyte * pc)
+void
+__glXDispSwap_BeginQuery(GLbyte * pc)
 {
-    CALL_BeginQuery( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLBEGINQUERYPROC BeginQuery = __glGetProcAddress("glBeginQuery");
+
+    BeginQuery((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
-int __glXDispSwap_DeleteQueries(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_DeleteQueries(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLDELETEQUERIESPROC DeleteQueries =
+        __glGetProcAddress("glDeleteQueries");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        CALL_DeleteQueries( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-        ) );
+        DeleteQueries(n,
+                      (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                      0));
         error = Success;
     }
 
     return error;
 }
 
-void __glXDispSwap_EndQuery(GLbyte * pc)
+void
+__glXDispSwap_EndQuery(GLbyte * pc)
 {
-    CALL_EndQuery( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    PFNGLENDQUERYPROC EndQuery = __glGetProcAddress("glEndQuery");
+
+    EndQuery((GLenum) bswap_ENUM(pc + 0));
 }
 
-int __glXDispSwap_GenQueries(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenQueries(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGENQUERIESPROC GenQueries = __glGetProcAddress("glGenQueries");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * ids = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenQueries( GET_DISPATCH(), (
-            n,
-            ids
-        ) );
-        (void) bswap_32_array( (uint32_t *) ids, n );
+        GLuint *ids =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenQueries(n, ids);
+        (void) bswap_32_array((uint32_t *) ids, n);
         __glXSendReplySwap(cl->client, ids, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4420,29 +4311,32 @@ int __glXDispSwap_GenQueries(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetQueryObjectiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetQueryObjectiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYOBJECTIVPROC GetQueryObjectiv =
+        __glGetProcAddress("glGetQueryObjectiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetQueryObjectiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryObjectiv( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        GetQueryObjectiv((GLuint) bswap_CARD32(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4450,29 +4344,32 @@ int __glXDispSwap_GetQueryObjectiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetQueryObjectuiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetQueryObjectuiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYOBJECTUIVPROC GetQueryObjectuiv =
+        __glGetProcAddress("glGetQueryObjectuiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetQueryObjectuiv_size(pname);
         GLuint answerBuffer[200];
-        GLuint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLuint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryObjectuiv( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        GetQueryObjectuiv((GLuint) bswap_CARD32(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4480,29 +4377,31 @@ int __glXDispSwap_GetQueryObjectuiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetQueryiv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetQueryiv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLGETQUERYIVPROC GetQueryiv = __glGetProcAddress("glGetQueryiv");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetQueryiv_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetQueryiv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        GetQueryiv((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4510,18 +4409,20 @@ int __glXDispSwap_GetQueryiv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsQuery(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsQuery(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXSingleReq * const req = (xGLXSingleReq *) pc;
+    PFNGLISQUERYPROC IsQuery = __glGetProcAddress("glIsQuery");
+    xGLXSingleReq *const req = (xGLXSingleReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_SINGLE_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsQuery( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = IsQuery((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -4529,347 +4430,287 @@ int __glXDispSwap_IsQuery(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_BlendEquationSeparate(GLbyte * pc)
+void
+__glXDispSwap_BlendEquationSeparate(GLbyte * pc)
 {
-    CALL_BlendEquationSeparate( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    PFNGLBLENDEQUATIONSEPARATEPROC BlendEquationSeparate =
+        __glGetProcAddress("glBlendEquationSeparate");
+    BlendEquationSeparate((GLenum) bswap_ENUM(pc + 0),
+                          (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_DrawBuffers(GLbyte * pc)
+void
+__glXDispSwap_DrawBuffers(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    PFNGLDRAWBUFFERSPROC DrawBuffers = __glGetProcAddress("glDrawBuffers");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    CALL_DrawBuffers( GET_DISPATCH(), (
-        n,
-         (const GLenum *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-    ) );
+    DrawBuffers(n, (const GLenum *) bswap_32_array((uint32_t *) (pc + 4), 0));
 }
 
-int __glXDispSwap_GetVertexAttribdv(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribdv_size(pname);
-        GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribdv( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetVertexAttribfv(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribfv_size(pname);
-        GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribfv( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetVertexAttribiv(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribiv_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribiv( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-void __glXDispSwap_VertexAttrib1dv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVPROC VertexAttrib1dv =
+        __glGetProcAddress("glVertexAttrib1dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib1dv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 1 )
-    ) );
+    VertexAttrib1dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      1));
 }
 
-void __glXDispSwap_VertexAttrib1sv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1sv(GLbyte * pc)
 {
-    CALL_VertexAttrib1sv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
-    ) );
+    PFNGLVERTEXATTRIB1SVPROC VertexAttrib1sv =
+        __glGetProcAddress("glVertexAttrib1sv");
+    VertexAttrib1sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 1));
 }
 
-void __glXDispSwap_VertexAttrib2dv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVPROC VertexAttrib2dv =
+        __glGetProcAddress("glVertexAttrib2dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib2dv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 2 )
-    ) );
+    VertexAttrib2dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      2));
 }
 
-void __glXDispSwap_VertexAttrib2sv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2sv(GLbyte * pc)
 {
-    CALL_VertexAttrib2sv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
-    ) );
+    PFNGLVERTEXATTRIB2SVPROC VertexAttrib2sv =
+        __glGetProcAddress("glVertexAttrib2sv");
+    VertexAttrib2sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 2));
 }
 
-void __glXDispSwap_VertexAttrib3dv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVPROC VertexAttrib3dv =
+        __glGetProcAddress("glVertexAttrib3dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib3dv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 3 )
-    ) );
+    VertexAttrib3dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      3));
 }
 
-void __glXDispSwap_VertexAttrib3sv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3sv(GLbyte * pc)
 {
-    CALL_VertexAttrib3sv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
-    ) );
+    PFNGLVERTEXATTRIB3SVPROC VertexAttrib3sv =
+        __glGetProcAddress("glVertexAttrib3sv");
+    VertexAttrib3sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 3));
 }
 
-void __glXDispSwap_VertexAttrib4Nbv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Nbv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nbv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLbyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NBVPROC VertexAttrib4Nbv =
+        __glGetProcAddress("glVertexAttrib4Nbv");
+    VertexAttrib4Nbv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
 }
 
-void __glXDispSwap_VertexAttrib4Niv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Niv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Niv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4NIVPROC VertexAttrib4Niv =
+        __glGetProcAddress("glVertexAttrib4Niv");
+    VertexAttrib4Niv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
-void __glXDispSwap_VertexAttrib4Nsv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Nsv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nsv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4NSVPROC VertexAttrib4Nsv =
+        __glGetProcAddress("glVertexAttrib4Nsv");
+    VertexAttrib4Nsv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                      4));
 }
 
-void __glXDispSwap_VertexAttrib4Nubv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Nubv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nubv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4NUBVPROC VertexAttrib4Nubv =
+        __glGetProcAddress("glVertexAttrib4Nubv");
+    VertexAttrib4Nubv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLubyte *) (pc + 4));
 }
 
-void __glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Nuiv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nuiv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4NUIVPROC VertexAttrib4Nuiv =
+        __glGetProcAddress("glVertexAttrib4Nuiv");
+    VertexAttrib4Nuiv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                      4));
 }
 
-void __glXDispSwap_VertexAttrib4Nusv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4Nusv(GLbyte * pc)
 {
-    CALL_VertexAttrib4Nusv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4NUSVPROC VertexAttrib4Nusv =
+        __glGetProcAddress("glVertexAttrib4Nusv");
+    VertexAttrib4Nusv((GLuint) bswap_CARD32(pc + 0),
+                      (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                        4));
 }
 
-void __glXDispSwap_VertexAttrib4bv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4bv(GLbyte * pc)
 {
-    CALL_VertexAttrib4bv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLbyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4BVPROC VertexAttrib4bv =
+        __glGetProcAddress("glVertexAttrib4bv");
+    VertexAttrib4bv((GLuint) bswap_CARD32(pc + 0), (const GLbyte *) (pc + 4));
 }
 
-void __glXDispSwap_VertexAttrib4dv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4dv(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVPROC VertexAttrib4dv =
+        __glGetProcAddress("glVertexAttrib4dv");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib4dv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 4 )
-    ) );
+    VertexAttrib4dv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                      4));
 }
 
-void __glXDispSwap_VertexAttrib4iv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4iv(GLbyte * pc)
 {
-    CALL_VertexAttrib4iv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4IVPROC VertexAttrib4iv =
+        __glGetProcAddress("glVertexAttrib4iv");
+    VertexAttrib4iv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
-void __glXDispSwap_VertexAttrib4sv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4sv(GLbyte * pc)
 {
-    CALL_VertexAttrib4sv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4SVPROC VertexAttrib4sv =
+        __glGetProcAddress("glVertexAttrib4sv");
+    VertexAttrib4sv((GLuint) bswap_CARD32(pc + 0),
+                    (const GLshort *) bswap_16_array((uint16_t *) (pc + 4), 4));
 }
 
-void __glXDispSwap_VertexAttrib4ubv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4ubv(GLbyte * pc)
 {
-    CALL_VertexAttrib4ubv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4UBVPROC VertexAttrib4ubv =
+        __glGetProcAddress("glVertexAttrib4ubv");
+    VertexAttrib4ubv((GLuint) bswap_CARD32(pc + 0), (const GLubyte *) (pc + 4));
 }
 
-void __glXDispSwap_VertexAttrib4uiv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4uiv(GLbyte * pc)
 {
-    CALL_VertexAttrib4uiv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4UIVPROC VertexAttrib4uiv =
+        __glGetProcAddress("glVertexAttrib4uiv");
+    VertexAttrib4uiv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLuint *) bswap_32_array((uint32_t *) (pc + 4), 4));
 }
 
-void __glXDispSwap_VertexAttrib4usv(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4usv(GLbyte * pc)
 {
-    CALL_VertexAttrib4usv( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLushort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4USVPROC VertexAttrib4usv =
+        __glGetProcAddress("glVertexAttrib4usv");
+    VertexAttrib4usv((GLuint) bswap_CARD32(pc + 0),
+                     (const GLushort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       4));
 }
 
-void __glXDispSwap_ClampColor(GLbyte * pc)
+void
+__glXDispSwap_ClampColor(GLbyte * pc)
 {
-    CALL_ClampColor( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 )
-    ) );
+    PFNGLCLAMPCOLORPROC ClampColor = __glGetProcAddress("glClampColor");
+
+    ClampColor((GLenum) bswap_ENUM(pc + 0), (GLenum) bswap_ENUM(pc + 4));
 }
 
-void __glXDispSwap_BindProgramARB(GLbyte * pc)
+void
+__glXDispSwap_BindProgramARB(GLbyte * pc)
 {
-    CALL_BindProgramARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLBINDPROGRAMARBPROC BindProgramARB =
+        __glGetProcAddress("glBindProgramARB");
+    BindProgramARB((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
-int __glXDispSwap_DeleteProgramsARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_DeleteProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLDELETEPROGRAMSARBPROC DeleteProgramsARB =
+        __glGetProcAddress("glDeleteProgramsARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-        CALL_DeleteProgramsARB( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-        ) );
+        DeleteProgramsARB(n,
+                          (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                          0));
         error = Success;
     }
 
     return error;
 }
 
-int __glXDispSwap_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenProgramsARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENPROGRAMSARBPROC GenProgramsARB =
+        __glGetProcAddress("glGenProgramsARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * programs = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenProgramsARB( GET_DISPATCH(), (
-            n,
-            programs
-        ) );
-        (void) bswap_32_array( (uint32_t *) programs, n );
+        GLuint *programs =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenProgramsARB(n, programs);
+        (void) bswap_32_array((uint32_t *) programs, n);
         __glXSendReplySwap(cl->client, programs, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -4877,21 +4718,23 @@ int __glXDispSwap_GenProgramsARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMENVPARAMETERDVARBPROC GetProgramEnvParameterdvARB =
+        __glGetProcAddress("glGetProgramEnvParameterdvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble params[4];
-        CALL_GetProgramEnvParameterdvARB( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, 4 );
+
+        GetProgramEnvParameterdvARB((GLenum) bswap_ENUM(pc + 0),
+                                    (GLuint) bswap_CARD32(pc + 4), params);
+        (void) bswap_64_array((uint64_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4899,21 +4742,23 @@ int __glXDispSwap_GetProgramEnvParameterdvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMENVPARAMETERFVARBPROC GetProgramEnvParameterfvARB =
+        __glGetProcAddress("glGetProgramEnvParameterfvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLfloat params[4];
-        CALL_GetProgramEnvParameterfvARB( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 4 );
+
+        GetProgramEnvParameterfvARB((GLenum) bswap_ENUM(pc + 0),
+                                    (GLuint) bswap_CARD32(pc + 4), params);
+        (void) bswap_32_array((uint32_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4921,21 +4766,23 @@ int __glXDispSwap_GetProgramEnvParameterfvARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GetProgramLocalParameterdvARB =
+        __glGetProcAddress("glGetProgramLocalParameterdvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLdouble params[4];
-        CALL_GetProgramLocalParameterdvARB( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, 4 );
+
+        GetProgramLocalParameterdvARB((GLenum) bswap_ENUM(pc + 0),
+                                      (GLuint) bswap_CARD32(pc + 4), params);
+        (void) bswap_64_array((uint64_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
         error = Success;
     }
@@ -4943,21 +4790,23 @@ int __glXDispSwap_GetProgramLocalParameterdvARB(__GLXclientState *cl, GLbyte *pc
     return error;
 }
 
-int __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GetProgramLocalParameterfvARB =
+        __glGetProcAddress("glGetProgramLocalParameterfvARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLfloat params[4];
-        CALL_GetProgramLocalParameterfvARB( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 4 );
+
+        GetProgramLocalParameterfvARB((GLenum) bswap_ENUM(pc + 0),
+                                      (GLuint) bswap_CARD32(pc + 4), params);
+        (void) bswap_32_array((uint32_t *) params, 4);
         __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4965,29 +4814,32 @@ int __glXDispSwap_GetProgramLocalParameterfvARB(__GLXclientState *cl, GLbyte *pc
     return error;
 }
 
-int __glXDispSwap_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetProgramivARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETPROGRAMIVARBPROC GetProgramivARB =
+        __glGetProcAddress("glGetProgramivARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
+    if (cx != NULL) {
+        const GLenum pname = (GLenum) bswap_ENUM(pc + 4);
 
         const GLuint compsize = __glGetProgramivARB_size(pname);
         GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
+        GLint *params =
+            __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer,
+                                 sizeof(answerBuffer), 4);
 
-        if (params == NULL) return BadAlloc;
+        if (params == NULL)
+            return BadAlloc;
         __glXClearErrorOccured();
 
-        CALL_GetProgramivARB( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
+        GetProgramivARB((GLenum) bswap_ENUM(pc + 0), pname, params);
+        (void) bswap_32_array((uint32_t *) params, compsize);
         __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -4995,18 +4847,20 @@ int __glXDispSwap_GetProgramivARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsProgramARB(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsProgramARB(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISPROGRAMARBPROC IsProgramARB = __glGetProcAddress("glIsProgramARB");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsProgramARB( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+
+        retval = IsProgramARB((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5014,144 +4868,163 @@ int __glXDispSwap_IsProgramARB(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
+void
+__glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMENVPARAMETER4DVARBPROC ProgramEnvParameter4dvARB =
+        __glGetProcAddress("glProgramEnvParameter4dvARB");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_ProgramEnvParameter4dvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 4 )
-    ) );
+    ProgramEnvParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
+                              (GLuint) bswap_CARD32(pc + 4),
+                              (const GLdouble *)
+                              bswap_64_array((uint64_t *) (pc + 8), 4));
 }
 
-void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
+void
+__glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc)
 {
-    CALL_ProgramEnvParameter4fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
-    ) );
+    PFNGLPROGRAMENVPARAMETER4FVARBPROC ProgramEnvParameter4fvARB =
+        __glGetProcAddress("glProgramEnvParameter4fvARB");
+    ProgramEnvParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
+                              (GLuint) bswap_CARD32(pc + 4),
+                              (const GLfloat *)
+                              bswap_32_array((uint32_t *) (pc + 8), 4));
 }
 
-void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
+void
+__glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc)
 {
+    PFNGLPROGRAMLOCALPARAMETER4DVARBPROC ProgramLocalParameter4dvARB =
+        __glGetProcAddress("glProgramLocalParameter4dvARB");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 40);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 40);
         pc -= 4;
     }
 #endif
 
-    CALL_ProgramLocalParameter4dvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 4 )
-    ) );
+    ProgramLocalParameter4dvARB((GLenum) bswap_ENUM(pc + 0),
+                                (GLuint) bswap_CARD32(pc + 4),
+                                (const GLdouble *)
+                                bswap_64_array((uint64_t *) (pc + 8), 4));
 }
 
-void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
+void
+__glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc)
 {
-    CALL_ProgramLocalParameter4fvARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
-    ) );
+    PFNGLPROGRAMLOCALPARAMETER4FVARBPROC ProgramLocalParameter4fvARB =
+        __glGetProcAddress("glProgramLocalParameter4fvARB");
+    ProgramLocalParameter4fvARB((GLenum) bswap_ENUM(pc + 0),
+                                (GLuint) bswap_CARD32(pc + 4),
+                                (const GLfloat *)
+                                bswap_32_array((uint32_t *) (pc + 8), 4));
 }
 
-void __glXDispSwap_ProgramStringARB(GLbyte * pc)
+void
+__glXDispSwap_ProgramStringARB(GLbyte * pc)
 {
-    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
+    PFNGLPROGRAMSTRINGARBPROC ProgramStringARB =
+        __glGetProcAddress("glProgramStringARB");
+    const GLsizei len = (GLsizei) bswap_CARD32(pc + 8);
 
-    CALL_ProgramStringARB( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-        len,
-         (const GLvoid *)(pc + 12)
-    ) );
+    ProgramStringARB((GLenum) bswap_ENUM(pc + 0),
+                     (GLenum) bswap_ENUM(pc + 4),
+                     len, (const GLvoid *) (pc + 12));
 }
 
-void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib1fvARB( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
-    ) );
+    PFNGLVERTEXATTRIB1FVARBPROC VertexAttrib1fvARB =
+        __glGetProcAddress("glVertexAttrib1fvARB");
+    VertexAttrib1fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        1));
 }
 
-void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib2fvARB( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
-    ) );
+    PFNGLVERTEXATTRIB2FVARBPROC VertexAttrib2fvARB =
+        __glGetProcAddress("glVertexAttrib2fvARB");
+    VertexAttrib2fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        2));
 }
 
-void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib3fvARB( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
-    ) );
+    PFNGLVERTEXATTRIB3FVARBPROC VertexAttrib3fvARB =
+        __glGetProcAddress("glVertexAttrib3fvARB");
+    VertexAttrib3fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        3));
 }
 
-void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4fvARB(GLbyte * pc)
 {
-    CALL_VertexAttrib4fvARB( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4FVARBPROC VertexAttrib4fvARB =
+        __glGetProcAddress("glVertexAttrib4fvARB");
+    VertexAttrib4fvARB((GLuint) bswap_CARD32(pc + 0),
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        4));
 }
 
-void __glXDispSwap_BindFramebuffer(GLbyte * pc)
+void
+__glXDispSwap_BindFramebuffer(GLbyte * pc)
 {
-    CALL_BindFramebuffer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLBINDFRAMEBUFFERPROC BindFramebuffer =
+        __glGetProcAddress("glBindFramebuffer");
+    BindFramebuffer((GLenum) bswap_ENUM(pc + 0), (GLuint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_BindRenderbuffer(GLbyte * pc)
+void
+__glXDispSwap_BindRenderbuffer(GLbyte * pc)
 {
-    CALL_BindRenderbuffer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLBINDRENDERBUFFERPROC BindRenderbuffer =
+        __glGetProcAddress("glBindRenderbuffer");
+    BindRenderbuffer((GLenum) bswap_ENUM(pc + 0),
+                     (GLuint) bswap_CARD32(pc + 4));
 }
 
-void __glXDispSwap_BlitFramebuffer(GLbyte * pc)
+void
+__glXDispSwap_BlitFramebuffer(GLbyte * pc)
 {
-    CALL_BlitFramebuffer( GET_DISPATCH(), (
-         (GLint   )bswap_CARD32 ( pc +  0 ),
-         (GLint   )bswap_CARD32 ( pc +  4 ),
-         (GLint   )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLint   )bswap_CARD32 ( pc + 20 ),
-         (GLint   )bswap_CARD32 ( pc + 24 ),
-         (GLint   )bswap_CARD32 ( pc + 28 ),
-         (GLbitfield)bswap_CARD32 ( pc + 32 ),
-         (GLenum  )bswap_ENUM   ( pc + 36 )
-    ) );
+    PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer =
+        __glGetProcAddress("glBlitFramebuffer");
+    BlitFramebuffer((GLint) bswap_CARD32(pc + 0), (GLint) bswap_CARD32(pc + 4),
+                    (GLint) bswap_CARD32(pc + 8), (GLint) bswap_CARD32(pc + 12),
+                    (GLint) bswap_CARD32(pc + 16),
+                    (GLint) bswap_CARD32(pc + 20),
+                    (GLint) bswap_CARD32(pc + 24),
+                    (GLint) bswap_CARD32(pc + 28),
+                    (GLbitfield) bswap_CARD32(pc + 32),
+                    (GLenum) bswap_ENUM(pc + 36));
 }
 
-int __glXDispSwap_CheckFramebufferStatus(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_CheckFramebufferStatus(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus =
+        __glGetProcAddress("glCheckFramebufferStatus");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLenum retval;
-        retval = CALL_CheckFramebufferStatus( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 )
-        ) );
+
+        retval = CheckFramebufferStatus((GLenum) bswap_ENUM(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5159,98 +5032,110 @@ int __glXDispSwap_CheckFramebufferStatus(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_DeleteFramebuffers(GLbyte * pc)
+void
+__glXDispSwap_DeleteFramebuffers(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers =
+        __glGetProcAddress("glDeleteFramebuffers");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    CALL_DeleteFramebuffers( GET_DISPATCH(), (
-        n,
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-    ) );
+    DeleteFramebuffers(n,
+                       (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       0));
 }
 
-void __glXDispSwap_DeleteRenderbuffers(GLbyte * pc)
+void
+__glXDispSwap_DeleteRenderbuffers(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    PFNGLDELETERENDERBUFFERSPROC DeleteRenderbuffers =
+        __glGetProcAddress("glDeleteRenderbuffers");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
-    CALL_DeleteRenderbuffers( GET_DISPATCH(), (
-        n,
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-    ) );
+    DeleteRenderbuffers(n,
+                        (const GLuint *) bswap_32_array((uint32_t *) (pc + 4),
+                                                        0));
 }
 
-void __glXDispSwap_FramebufferRenderbuffer(GLbyte * pc)
+void
+__glXDispSwap_FramebufferRenderbuffer(GLbyte * pc)
 {
-    CALL_FramebufferRenderbuffer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLuint  )bswap_CARD32 ( pc + 12 )
-    ) );
+    PFNGLFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer =
+        __glGetProcAddress("glFramebufferRenderbuffer");
+    FramebufferRenderbuffer((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLenum) bswap_ENUM(pc + 8),
+                            (GLuint) bswap_CARD32(pc + 12));
 }
 
-void __glXDispSwap_FramebufferTexture1D(GLbyte * pc)
+void
+__glXDispSwap_FramebufferTexture1D(GLbyte * pc)
 {
-    CALL_FramebufferTexture1D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLuint  )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 )
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D =
+        __glGetProcAddress("glFramebufferTexture1D");
+    FramebufferTexture1D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_FramebufferTexture2D(GLbyte * pc)
+void
+__glXDispSwap_FramebufferTexture2D(GLbyte * pc)
 {
-    CALL_FramebufferTexture2D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLuint  )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 )
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D =
+        __glGetProcAddress("glFramebufferTexture2D");
+    FramebufferTexture2D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_FramebufferTexture3D(GLbyte * pc)
+void
+__glXDispSwap_FramebufferTexture3D(GLbyte * pc)
 {
-    CALL_FramebufferTexture3D( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLuint  )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 ),
-         (GLint   )bswap_CARD32 ( pc + 20 )
-    ) );
+    PFNGLFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D =
+        __glGetProcAddress("glFramebufferTexture3D");
+    FramebufferTexture3D((GLenum) bswap_ENUM(pc + 0),
+                         (GLenum) bswap_ENUM(pc + 4),
+                         (GLenum) bswap_ENUM(pc + 8),
+                         (GLuint) bswap_CARD32(pc + 12),
+                         (GLint) bswap_CARD32(pc + 16),
+                         (GLint) bswap_CARD32(pc + 20));
 }
 
-void __glXDispSwap_FramebufferTextureLayer(GLbyte * pc)
+void
+__glXDispSwap_FramebufferTextureLayer(GLbyte * pc)
 {
-    CALL_FramebufferTextureLayer( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLuint  )bswap_CARD32 ( pc +  8 ),
-         (GLint   )bswap_CARD32 ( pc + 12 ),
-         (GLint   )bswap_CARD32 ( pc + 16 )
-    ) );
+    PFNGLFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer =
+        __glGetProcAddress("glFramebufferTextureLayer");
+    FramebufferTextureLayer((GLenum) bswap_ENUM(pc + 0),
+                            (GLenum) bswap_ENUM(pc + 4),
+                            (GLuint) bswap_CARD32(pc + 8),
+                            (GLint) bswap_CARD32(pc + 12),
+                            (GLint) bswap_CARD32(pc + 16));
 }
 
-int __glXDispSwap_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenFramebuffers(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENFRAMEBUFFERSPROC GenFramebuffers =
+        __glGetProcAddress("glGenFramebuffers");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * framebuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenFramebuffers( GET_DISPATCH(), (
-            n,
-            framebuffers
-        ) );
-        (void) bswap_32_array( (uint32_t *) framebuffers, n );
+        GLuint *framebuffers =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenFramebuffers(n, framebuffers);
+        (void) bswap_32_array((uint32_t *) framebuffers, n);
         __glXSendReplySwap(cl->client, framebuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -5258,23 +5143,26 @@ int __glXDispSwap_GenFramebuffers(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GenRenderbuffers(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGENRENDERBUFFERSPROC GenRenderbuffers =
+        __glGetProcAddress("glGenRenderbuffers");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
+    if (cx != NULL) {
+        const GLsizei n = (GLsizei) bswap_CARD32(pc + 0);
 
         GLuint answerBuffer[200];
-        GLuint * renderbuffers = __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer), 4);
-        CALL_GenRenderbuffers( GET_DISPATCH(), (
-            n,
-            renderbuffers
-        ) );
-        (void) bswap_32_array( (uint32_t *) renderbuffers, n );
+        GLuint *renderbuffers =
+            __glXGetAnswerBuffer(cl, n * 4, answerBuffer, sizeof(answerBuffer),
+                                 4);
+        GenRenderbuffers(n, renderbuffers);
+        (void) bswap_32_array((uint32_t *) renderbuffers, n);
         __glXSendReplySwap(cl->client, renderbuffers, n, 4, GL_TRUE, 0);
         error = Success;
     }
@@ -5282,29 +5170,35 @@ int __glXDispSwap_GenRenderbuffers(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_GenerateMipmap(GLbyte * pc)
+void
+__glXDispSwap_GenerateMipmap(GLbyte * pc)
 {
-    CALL_GenerateMipmap( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
+    PFNGLGENERATEMIPMAPPROC GenerateMipmap =
+        __glGetProcAddress("glGenerateMipmap");
+    GenerateMipmap((GLenum) bswap_ENUM(pc + 0));
 }
 
-int __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState * cl,
+                                                  GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC
+        GetFramebufferAttachmentParameteriv =
+        __glGetProcAddress("glGetFramebufferAttachmentParameteriv");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLint params[1];
-        CALL_GetFramebufferAttachmentParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLenum  )bswap_ENUM   ( pc +  4 ),
-             (GLenum  )bswap_ENUM   ( pc +  8 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 1 );
+
+        GetFramebufferAttachmentParameteriv((GLenum) bswap_ENUM(pc + 0),
+                                            (GLenum) bswap_ENUM(pc + 4),
+                                            (GLenum) bswap_ENUM(pc + 8),
+                                            params);
+        (void) bswap_32_array((uint32_t *) params, 1);
         __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -5312,21 +5206,23 @@ int __glXDispSwap_GetFramebufferAttachmentParameteriv(__GLXclientState *cl, GLby
     return error;
 }
 
-int __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_GetRenderbufferParameteriv(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv =
+        __glGetProcAddress("glGetRenderbufferParameteriv");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLint params[1];
-        CALL_GetRenderbufferParameteriv( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLenum  )bswap_ENUM   ( pc +  4 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 1 );
+
+        GetRenderbufferParameteriv((GLenum) bswap_ENUM(pc + 0),
+                                   (GLenum) bswap_ENUM(pc + 4), params);
+        (void) bswap_32_array((uint32_t *) params, 1);
         __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
         error = Success;
     }
@@ -5334,37 +5230,21 @@ int __glXDispSwap_GetRenderbufferParameteriv(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-int __glXDispSwap_IsFramebuffer(__GLXclientState *cl, GLbyte *pc)
+int
+__glXDispSwap_IsFramebuffer(__GLXclientState * cl, GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISFRAMEBUFFERPROC IsFramebuffer =
+        __glGetProcAddress("glIsFramebuffer");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
+    if (cx != NULL) {
         GLboolean retval;
-        retval = CALL_IsFramebuffer( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
-        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
-        error = Success;
-    }
-
-    return error;
-}
 
-int __glXDispSwap_IsRenderbuffer(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLboolean retval;
-        retval = CALL_IsRenderbuffer( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 )
-        ) );
+        retval = IsFramebuffer((GLuint) bswap_CARD32(pc + 0));
         __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
@@ -5372,752 +5252,432 @@ int __glXDispSwap_IsRenderbuffer(__GLXclientState *cl, GLbyte *pc)
     return error;
 }
 
-void __glXDispSwap_RenderbufferStorage(GLbyte * pc)
-{
-    CALL_RenderbufferStorage( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLenum  )bswap_ENUM   ( pc +  4 ),
-         (GLsizei )bswap_CARD32 ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 )
-    ) );
-}
-
-void __glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc)
-{
-    CALL_RenderbufferStorageMultisample( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLsizei )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLsizei )bswap_CARD32 ( pc + 12 ),
-         (GLsizei )bswap_CARD32 ( pc + 16 )
-    ) );
-}
-
-void __glXDispSwap_SampleMaskSGIS(GLbyte * pc)
-{
-    CALL_SampleMaskSGIS( GET_DISPATCH(), (
-         (GLclampf)bswap_FLOAT32( pc +  0 ),
-        *(GLboolean *)(pc +  4)
-    ) );
-}
-
-void __glXDispSwap_SamplePatternSGIS(GLbyte * pc)
-{
-    CALL_SamplePatternSGIS( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
-}
-
-void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
+int
+__glXDispSwap_IsRenderbuffer(__GLXclientState * cl, GLbyte * pc)
 {
-    CALL_SecondaryColor3fvEXT( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 3 )
-    ) );
-}
-
-void __glXDispSwap_FogCoordfvEXT(GLbyte * pc)
-{
-    CALL_FogCoordfvEXT( GET_DISPATCH(), (
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  0), 1 )
-    ) );
-}
-
-int __glXDispSwap_AreProgramsResidentNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
+    PFNGLISRENDERBUFFERPROC IsRenderbuffer =
+        __glGetProcAddress("glIsRenderbuffer");
+    xGLXVendorPrivateReq *const req = (xGLXVendorPrivateReq *) pc;
     int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
+    __GLXcontext *const cx =
+        __glXForceCurrent(cl, bswap_CARD32(&req->contextTag), &error);
 
     pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
-
+    if (cx != NULL) {
         GLboolean retval;
-        GLboolean answerBuffer[200];
-        GLboolean * residences = __glXGetAnswerBuffer(cl, n, answerBuffer, sizeof(answerBuffer), 1);
-        retval = CALL_AreProgramsResidentNV( GET_DISPATCH(), (
-            n,
-             (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 ),
-            residences
-        ) );
-        __glXSendReplySwap(cl->client, residences, n, 1, GL_FALSE, retval);
-        error = Success;
-    }
-
-    return error;
-}
-
-void __glXDispSwap_ExecuteProgramNV(GLbyte * pc)
-{
-    CALL_ExecuteProgramNV( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
-    ) );
-}
-
-int __glXDispSwap_GetProgramParameterdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLdouble params[4];
-        CALL_GetProgramParameterdvNV( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-             (GLenum  )bswap_ENUM   ( pc +  8 ),
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, 4 );
-        __glXSendReplySwap(cl->client, params, 4, 8, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetProgramParameterfvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLfloat params[4];
-        CALL_GetProgramParameterfvNV( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-             (GLenum  )bswap_ENUM   ( pc +  8 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 4 );
-        __glXSendReplySwap(cl->client, params, 4, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetProgramivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetProgramivNV_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetProgramivNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetTrackMatrixivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        GLint params[1];
-        CALL_GetTrackMatrixivNV( GET_DISPATCH(), (
-             (GLenum  )bswap_ENUM   ( pc +  0 ),
-             (GLuint  )bswap_CARD32 ( pc +  4 ),
-             (GLenum  )bswap_ENUM   ( pc +  8 ),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 1 );
-        __glXSendReplySwap(cl->client, params, 1, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetVertexAttribdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribdvNV_size(pname);
-        GLdouble answerBuffer[200];
-        GLdouble * params = __glXGetAnswerBuffer(cl, compsize * 8, answerBuffer, sizeof(answerBuffer), 8);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribdvNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 8, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetVertexAttribfvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribfvNV_size(pname);
-        GLfloat answerBuffer[200];
-        GLfloat * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribfvNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
-        error = Success;
-    }
-
-    return error;
-}
-
-int __glXDispSwap_GetVertexAttribivNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
 
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLenum pname =  (GLenum  )bswap_ENUM   ( pc +  4 );
-
-        const GLuint compsize = __glGetVertexAttribivNV_size(pname);
-        GLint answerBuffer[200];
-        GLint * params = __glXGetAnswerBuffer(cl, compsize * 4, answerBuffer, sizeof(answerBuffer), 4);
-
-        if (params == NULL) return BadAlloc;
-        __glXClearErrorOccured();
-
-        CALL_GetVertexAttribivNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            pname,
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, compsize );
-        __glXSendReplySwap(cl->client, params, compsize, 4, GL_FALSE, 0);
+        retval = IsRenderbuffer((GLuint) bswap_CARD32(pc + 0));
+        __glXSendReplySwap(cl->client, dummy_answer, 0, 0, GL_FALSE, retval);
         error = Success;
     }
 
     return error;
 }
 
-void __glXDispSwap_LoadProgramNV(GLbyte * pc)
+void
+__glXDispSwap_RenderbufferStorage(GLbyte * pc)
 {
-    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  8 );
-
-    CALL_LoadProgramNV( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-        len,
-         (const GLubyte *)(pc + 12)
-    ) );
-}
-
-void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc)
-{
-    const GLsizei num =  (GLsizei )bswap_CARD32 ( pc +  8 );
-
-#ifdef __GLX_ALIGN64
-    const GLuint cmdlen = 16 + __GLX_PAD((num * 32)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
-        pc -= 4;
-    }
-#endif
-
-    CALL_ProgramParameters4dvNV( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-        num,
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc + 12), 0 )
-    ) );
+    PFNGLRENDERBUFFERSTORAGEPROC RenderbufferStorage =
+        __glGetProcAddress("glRenderbufferStorage");
+    RenderbufferStorage((GLenum) bswap_ENUM(pc + 0),
+                        (GLenum) bswap_ENUM(pc + 4),
+                        (GLsizei) bswap_CARD32(pc + 8),
+                        (GLsizei) bswap_CARD32(pc + 12));
 }
 
-void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc)
+void
+__glXDispSwap_RenderbufferStorageMultisample(GLbyte * pc)
 {
-    const GLsizei num =  (GLsizei )bswap_CARD32 ( pc +  8 );
-
-    CALL_ProgramParameters4fvNV( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-        num,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc + 12), 0 )
-    ) );
+    PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample =
+        __glGetProcAddress("glRenderbufferStorageMultisample");
+    RenderbufferStorageMultisample((GLenum) bswap_ENUM(pc + 0),
+                                   (GLsizei) bswap_CARD32(pc + 4),
+                                   (GLenum) bswap_ENUM(pc + 8),
+                                   (GLsizei) bswap_CARD32(pc + 12),
+                                   (GLsizei) bswap_CARD32(pc + 16));
 }
 
-void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc)
+void
+__glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  0 );
-
-    CALL_RequestResidentProgramsNV( GET_DISPATCH(), (
-        n,
-         (const GLuint *)bswap_32_array( (uint32_t *) (pc +  4), 0 )
-    ) );
+    PFNGLSECONDARYCOLOR3FVEXTPROC SecondaryColor3fvEXT =
+        __glGetProcAddress("glSecondaryColor3fvEXT");
+    SecondaryColor3fvEXT((const GLfloat *)
+                         bswap_32_array((uint32_t *) (pc + 0), 3));
 }
 
-void __glXDispSwap_TrackMatrixNV(GLbyte * pc)
+void
+__glXDispSwap_FogCoordfvEXT(GLbyte * pc)
 {
-    CALL_TrackMatrixNV( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 ),
-         (GLenum  )bswap_ENUM   ( pc +  8 ),
-         (GLenum  )bswap_ENUM   ( pc + 12 )
-    ) );
+    PFNGLFOGCOORDFVEXTPROC FogCoordfvEXT =
+        __glGetProcAddress("glFogCoordfvEXT");
+    FogCoordfvEXT((const GLfloat *) bswap_32_array((uint32_t *) (pc + 0), 1));
 }
 
-void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB1DVNVPROC VertexAttrib1dvNV =
+        __glGetProcAddress("glVertexAttrib1dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 12);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 12);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib1dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 1 )
-    ) );
+    VertexAttrib1dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        1));
 }
 
-void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib1fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 1 )
-    ) );
+    PFNGLVERTEXATTRIB1FVNVPROC VertexAttrib1fvNV =
+        __glGetProcAddress("glVertexAttrib1fvNV");
+    VertexAttrib1fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       1));
 }
 
-void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib1svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib1svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 1 )
-    ) );
+    PFNGLVERTEXATTRIB1SVNVPROC VertexAttrib1svNV =
+        __glGetProcAddress("glVertexAttrib1svNV");
+    VertexAttrib1svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       1));
 }
 
-void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB2DVNVPROC VertexAttrib2dvNV =
+        __glGetProcAddress("glVertexAttrib2dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 20);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 20);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib2dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 2 )
-    ) );
+    VertexAttrib2dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        2));
 }
 
-void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib2fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 2 )
-    ) );
+    PFNGLVERTEXATTRIB2FVNVPROC VertexAttrib2fvNV =
+        __glGetProcAddress("glVertexAttrib2fvNV");
+    VertexAttrib2fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       2));
 }
 
-void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib2svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib2svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 2 )
-    ) );
+    PFNGLVERTEXATTRIB2SVNVPROC VertexAttrib2svNV =
+        __glGetProcAddress("glVertexAttrib2svNV");
+    VertexAttrib2svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       2));
 }
 
-void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB3DVNVPROC VertexAttrib3dvNV =
+        __glGetProcAddress("glVertexAttrib3dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 28);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 28);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib3dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 3 )
-    ) );
+    VertexAttrib3dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        3));
 }
 
-void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib3fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 3 )
-    ) );
+    PFNGLVERTEXATTRIB3FVNVPROC VertexAttrib3fvNV =
+        __glGetProcAddress("glVertexAttrib3fvNV");
+    VertexAttrib3fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       3));
 }
 
-void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib3svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib3svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 3 )
-    ) );
+    PFNGLVERTEXATTRIB3SVNVPROC VertexAttrib3svNV =
+        __glGetProcAddress("glVertexAttrib3svNV");
+    VertexAttrib3svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       3));
 }
 
-void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4dvNV(GLbyte * pc)
 {
+    PFNGLVERTEXATTRIB4DVNVPROC VertexAttrib4dvNV =
+        __glGetProcAddress("glVertexAttrib4dvNV");
 #ifdef __GLX_ALIGN64
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, 36);
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, 36);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttrib4dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  4), 4 )
-    ) );
+    VertexAttrib4dvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLdouble *) bswap_64_array((uint64_t *) (pc + 4),
+                                                        4));
 }
 
-void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4fvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4FVNVPROC VertexAttrib4fvNV =
+        __glGetProcAddress("glVertexAttrib4fvNV");
+    VertexAttrib4fvNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLfloat *) bswap_32_array((uint32_t *) (pc + 4),
+                                                       4));
 }
 
-void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4svNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  4), 4 )
-    ) );
+    PFNGLVERTEXATTRIB4SVNVPROC VertexAttrib4svNV =
+        __glGetProcAddress("glVertexAttrib4svNV");
+    VertexAttrib4svNV((GLuint) bswap_CARD32(pc + 0),
+                      (const GLshort *) bswap_16_array((uint16_t *) (pc + 4),
+                                                       4));
 }
 
-void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc)
 {
-    CALL_VertexAttrib4ubvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-         (const GLubyte *)(pc +  4)
-    ) );
+    PFNGLVERTEXATTRIB4UBVNVPROC VertexAttrib4ubvNV =
+        __glGetProcAddress("glVertexAttrib4ubvNV");
+    VertexAttrib4ubvNV((GLuint) bswap_CARD32(pc + 0),
+                       (const GLubyte *) (pc + 4));
 }
 
-void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs1dvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS1DVNVPROC VertexAttribs1dvNV =
+        __glGetProcAddress("glVertexAttribs1dvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 8)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs1dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs1dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
-void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs1fvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS1FVNVPROC VertexAttribs1fvNV =
+        __glGetProcAddress("glVertexAttribs1fvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs1fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs1fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs1svNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS1SVNVPROC VertexAttribs1svNV =
+        __glGetProcAddress("glVertexAttribs1svNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs1svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs1svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs2dvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS2DVNVPROC VertexAttribs2dvNV =
+        __glGetProcAddress("glVertexAttribs2dvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 16)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs2dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs2dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
-void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs2fvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS2FVNVPROC VertexAttribs2fvNV =
+        __glGetProcAddress("glVertexAttribs2fvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs2fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs2fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs2svNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS2SVNVPROC VertexAttribs2svNV =
+        __glGetProcAddress("glVertexAttribs2svNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs2svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs2svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs3dvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS3DVNVPROC VertexAttribs3dvNV =
+        __glGetProcAddress("glVertexAttribs3dvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 24)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs3dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs3dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
-void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs3fvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS3FVNVPROC VertexAttribs3fvNV =
+        __glGetProcAddress("glVertexAttribs3fvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs3fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs3fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs3svNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS3SVNVPROC VertexAttribs3svNV =
+        __glGetProcAddress("glVertexAttribs3svNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_VertexAttribs3svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
-    ) );
+    VertexAttribs3svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs4dvNV(GLbyte * pc)
 {
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS4DVNVPROC VertexAttribs4dvNV =
+        __glGetProcAddress("glVertexAttribs4dvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
 #ifdef __GLX_ALIGN64
     const GLuint cmdlen = 12 + __GLX_PAD((n * 32)) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
+
+    if ((unsigned long) (pc) & 7) {
+        (void) memmove(pc - 4, pc, cmdlen);
         pc -= 4;
     }
 #endif
 
-    CALL_VertexAttribs4dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  8), 0 )
-    ) );
-}
-
-void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
-{
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
-
-    CALL_VertexAttribs4fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 0 )
-    ) );
-}
-
-void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
-{
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
-
-    CALL_VertexAttribs4svNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLshort *)bswap_16_array( (uint16_t *) (pc +  8), 0 )
-    ) );
-}
-
-void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
-{
-    const GLsizei n =  (GLsizei )bswap_CARD32 ( pc +  4 );
-
-    CALL_VertexAttribs4ubvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        n,
-         (const GLubyte *)(pc +  8)
-    ) );
-}
-
-void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
-{
-    CALL_ActiveStencilFaceEXT( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 )
-    ) );
-}
-
-int __glXDispSwap_GetProgramNamedParameterdvNV(__GLXclientState *cl, GLbyte *pc)
-{
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
-
-        GLdouble params[4];
-        CALL_GetProgramNamedParameterdvNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            len,
-             (const GLubyte *)(pc +  8),
-            params
-        ) );
-        (void) bswap_64_array( (uint64_t *) params, 4 );
-        __glXSendReplySwap(cl->client, params, 4, 8, GL_TRUE, 0);
-        error = Success;
-    }
-
-    return error;
+    VertexAttribs4dvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLdouble *) bswap_64_array((uint64_t *) (pc + 8),
+                                                         0));
 }
 
-int __glXDispSwap_GetProgramNamedParameterfvNV(__GLXclientState *cl, GLbyte *pc)
+void
+__glXDispSwap_VertexAttribs4fvNV(GLbyte * pc)
 {
-    xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;
-    int error;
-    __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);
-
-    pc += __GLX_VENDPRIV_HDR_SIZE;
-    if ( cx != NULL ) {
-        const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS4FVNVPROC VertexAttribs4fvNV =
+        __glGetProcAddress("glVertexAttribs4fvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-        GLfloat params[4];
-        CALL_GetProgramNamedParameterfvNV( GET_DISPATCH(), (
-             (GLuint  )bswap_CARD32 ( pc +  0 ),
-            len,
-             (const GLubyte *)(pc +  8),
-            params
-        ) );
-        (void) bswap_32_array( (uint32_t *) params, 4 );
-        __glXSendReplySwap(cl->client, params, 4, 4, GL_TRUE, 0);
-        error = Success;
-    }
-
-    return error;
+    VertexAttribs4fvNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLfloat *) bswap_32_array((uint32_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs4svNV(GLbyte * pc)
 {
-    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc + 36 );
+    PFNGLVERTEXATTRIBS4SVNVPROC VertexAttribs4svNV =
+        __glGetProcAddress("glVertexAttribs4svNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-#ifdef __GLX_ALIGN64
-    const GLuint cmdlen = 44 + __GLX_PAD(len) - 4;
-    if ((unsigned long)(pc) & 7) {
-        (void) memmove(pc-4, pc, cmdlen);
-        pc -= 4;
-    }
-#endif
-
-    CALL_ProgramNamedParameter4dvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc + 32 ),
-        len,
-         (const GLubyte *)(pc + 40),
-         (const GLdouble *)bswap_64_array( (uint64_t *) (pc +  0), 4 )
-    ) );
+    VertexAttribs4svNV((GLuint) bswap_CARD32(pc + 0),
+                       n,
+                       (const GLshort *) bswap_16_array((uint16_t *) (pc + 8),
+                                                        0));
 }
 
-void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc)
+void
+__glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc)
 {
-    const GLsizei len =  (GLsizei )bswap_CARD32 ( pc +  4 );
+    PFNGLVERTEXATTRIBS4UBVNVPROC VertexAttribs4ubvNV =
+        __glGetProcAddress("glVertexAttribs4ubvNV");
+    const GLsizei n = (GLsizei) bswap_CARD32(pc + 4);
 
-    CALL_ProgramNamedParameter4fvNV( GET_DISPATCH(), (
-         (GLuint  )bswap_CARD32 ( pc +  0 ),
-        len,
-         (const GLubyte *)(pc + 24),
-         (const GLfloat *)bswap_32_array( (uint32_t *) (pc +  8), 4 )
-    ) );
+    VertexAttribs4ubvNV((GLuint) bswap_CARD32(pc + 0),
+                        n, (const GLubyte *) (pc + 8));
 }
 
-void __glXDispSwap_BindFramebufferEXT(GLbyte * pc)
+void
+__glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc)
 {
-    CALL_BindFramebufferEXT( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
+    PFNGLACTIVESTENCILFACEEXTPROC ActiveStencilFaceEXT =
+        __glGetProcAddress("glActiveStencilFaceEXT");
+    ActiveStencilFaceEXT((GLenum) bswap_ENUM(pc + 0));
 }
-
-void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc)
-{
-    CALL_BindRenderbufferEXT( GET_DISPATCH(), (
-         (GLenum  )bswap_ENUM   ( pc +  0 ),
-         (GLuint  )bswap_CARD32 ( pc +  4 )
-    ) );
-}
-
diff --git a/xorg-server/glx/indirect_program.c b/xorg-server/glx/indirect_program.c
index 17204c17d..9a648b745 100644
--- a/xorg-server/glx/indirect_program.c
+++ b/xorg-server/glx/indirect_program.c
@@ -46,23 +46,14 @@
 #include "glthread.h"
 #include "dispatch.h"
 
-static int DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
-                              unsigned get_programiv_offset,
-                              unsigned get_program_string_offset, Bool do_swap);
-
 /**
  * Handle both types of glGetProgramString calls.
- *
- * This single function handles both \c glGetProgramStringARB and
- * \c glGetProgramStringNV.  The dispatch offsets for the functions to use
- * for \c glGetProgramivARB and \c glGetProgramStringARB are passed in by the
- * caller.  These can be the offsets of either the ARB versions or the NV
- * versions.
  */
-int
+static int
 DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
-                   unsigned get_programiv_offset,
-                   unsigned get_program_string_offset, Bool do_swap)
+                   PFNGLGETPROGRAMIVARBPROC get_programiv,
+                   PFNGLGETPROGRAMSTRINGARBPROC get_program_string,
+                   Bool do_swap)
 {
     xGLXVendorPrivateWithReplyReq *const req =
         (xGLXVendorPrivateWithReplyReq *) pc;
@@ -89,19 +80,13 @@ DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
         /* The value of the GL_PROGRAM_LENGTH_ARB and GL_PROGRAM_LENGTH_NV
          * enumerants is the same.
          */
-        CALL_by_offset(GET_DISPATCH(),
-                       (void (GLAPIENTRYP) (GLuint, GLenum, GLint *)),
-                       get_programiv_offset,
-                       (target, GL_PROGRAM_LENGTH_ARB, &compsize));
+        get_programiv(target, GL_PROGRAM_LENGTH_ARB, &compsize);
 
         if (compsize != 0) {
             __GLX_GET_ANSWER_BUFFER(answer, cl, compsize, 1);
             __glXClearErrorOccured();
 
-            CALL_by_offset(GET_DISPATCH(),
-                           (void (GLAPIENTRYP) (GLuint, GLenum, GLubyte *)),
-                           get_program_string_offset,
-                           (target, pname, (GLubyte *) answer));
+            get_program_string(target, pname, (GLubyte *) answer);
         }
 
         if (__glXErrorOccured()) {
@@ -124,27 +109,43 @@ DoGetProgramString(struct __GLXclientStateRec *cl, GLbyte * pc,
 int
 __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, _gloffset_GetProgramivARB,
-                              _gloffset_GetProgramStringARB, False);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, False);
 }
 
 int
 __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, _gloffset_GetProgramivARB,
-                              _gloffset_GetProgramStringARB, True);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, True);
 }
 
 int
 __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, _gloffset_GetProgramivNV,
-                              _gloffset_GetProgramStringNV, False);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, False);
 }
 
 int
 __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *cl, GLbyte * pc)
 {
-    return DoGetProgramString(cl, pc, _gloffset_GetProgramivNV,
-                              _gloffset_GetProgramStringNV, True);
+    PFNGLGETPROGRAMIVARBPROC get_program =
+        __glGetProcAddress("glGetProgramivARB");
+    PFNGLGETPROGRAMSTRINGARBPROC get_program_string =
+        __glGetProcAddress("glGetProgramStringARB");
+
+    return DoGetProgramString(cl, pc, get_program, get_program_string, True);
 }
diff --git a/xorg-server/glx/makefile b/xorg-server/glx/makefile
index 345734ecf..345734ecf 100755..100644
--- a/xorg-server/glx/makefile
+++ b/xorg-server/glx/makefile
diff --git a/xorg-server/glx/render2.c b/xorg-server/glx/render2.c
index 01e33d5c9..946ec2d3d 100644
--- a/xorg-server/glx/render2.c
+++ b/xorg-server/glx/render2.c
@@ -56,7 +56,7 @@ __glXDisp_Map1f(GLbyte * pc)
     points = (GLfloat *) (pc + 16);
     k = __glMap1f_size(target);
 
-    CALL_Map1f(GET_DISPATCH(), (target, u1, u2, k, order, points));
+    glMap1f(target, u1, u2, k, order, points);
 }
 
 void
@@ -79,9 +79,7 @@ __glXDisp_Map2f(GLbyte * pc)
     ustride = vorder * k;
     vstride = k;
 
-    CALL_Map2f(GET_DISPATCH(),
-               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-                points));
+    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 void
@@ -127,7 +125,7 @@ __glXDisp_Map1d(GLbyte * pc)
 #else
     points = (GLdouble *) pc;
 #endif
-    CALL_Map1d(GET_DISPATCH(), (target, u1, u2, k, order, points));
+    glMap1d(target, u1, u2, k, order, points);
 }
 
 void
@@ -179,9 +177,7 @@ __glXDisp_Map2d(GLbyte * pc)
 #else
     points = (GLdouble *) pc;
 #endif
-    CALL_Map2d(GET_DISPATCH(),
-               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-                points));
+    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 void
@@ -216,40 +212,45 @@ __glXDisp_DrawArrays(GLbyte * pc)
 
         switch (component) {
         case GL_VERTEX_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
-            CALL_VertexPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            glEnableClientState(GL_VERTEX_ARRAY);
+            glVertexPointer(numVals, datatype, stride, pc);
             break;
         case GL_NORMAL_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
-            CALL_NormalPointer(GET_DISPATCH(), (datatype, stride, pc));
+            glEnableClientState(GL_NORMAL_ARRAY);
+            glNormalPointer(datatype, stride, pc);
             break;
         case GL_COLOR_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
-            CALL_ColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            glEnableClientState(GL_COLOR_ARRAY);
+            glColorPointer(numVals, datatype, stride, pc);
             break;
         case GL_INDEX_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
-            CALL_IndexPointer(GET_DISPATCH(), (datatype, stride, pc));
+            glEnableClientState(GL_INDEX_ARRAY);
+            glIndexPointer(datatype, stride, pc);
             break;
         case GL_TEXTURE_COORD_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
-            CALL_TexCoordPointer(GET_DISPATCH(),
-                                 (numVals, datatype, stride, pc));
+            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+            glTexCoordPointer(numVals, datatype, stride, pc);
             break;
         case GL_EDGE_FLAG_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
-            CALL_EdgeFlagPointer(GET_DISPATCH(),
-                                 (stride, (const GLboolean *) pc));
+            glEnableClientState(GL_EDGE_FLAG_ARRAY);
+            glEdgeFlagPointer(stride, (const GLboolean *) pc);
             break;
         case GL_SECONDARY_COLOR_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
-            CALL_SecondaryColorPointer(GET_DISPATCH(),
-                                          (numVals, datatype, stride, pc));
+        {
+            PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
+                __glGetProcAddress("glSecondaryColorPointerEXT");
+            glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
+            SecondaryColorPointerEXT(numVals, datatype, stride, pc);
             break;
+        }
         case GL_FOG_COORD_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
-            CALL_FogCoordPointer(GET_DISPATCH(), (datatype, stride, pc));
+        {
+            PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
+                __glGetProcAddress("glFogCoordPointerEXT");
+            glEnableClientState(GL_FOG_COORD_ARRAY);
+            FogCoordPointerEXT(datatype, stride, pc);
             break;
+        }
         default:
             break;
         }
@@ -257,15 +258,15 @@ __glXDisp_DrawArrays(GLbyte * pc)
         pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
     }
 
-    CALL_DrawArrays(GET_DISPATCH(), (primType, 0, numVertexes));
+    glDrawArrays(primType, 0, numVertexes);
 
     /* turn off anything we might have turned on */
-    CALL_DisableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_NORMAL_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_INDEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_EDGE_FLAG_ARRAY);
+    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
+    glDisableClientState(GL_FOG_COORD_ARRAY);
 }
diff --git a/xorg-server/glx/render2swap.c b/xorg-server/glx/render2swap.c
index 435fa26ad..cb567952f 100644
--- a/xorg-server/glx/render2swap.c
+++ b/xorg-server/glx/render2swap.c
@@ -74,7 +74,7 @@ __glXDispSwap_Map1f(GLbyte * pc)
     }
     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
 
-    CALL_Map1f(GET_DISPATCH(), (target, u1, u2, k, order, points));
+    glMap1f(target, u1, u2, k, order, points);
 }
 
 void
@@ -118,9 +118,7 @@ __glXDispSwap_Map2f(GLbyte * pc)
     }
     __GLX_SWAP_FLOAT_ARRAY(points, compsize);
 
-    CALL_Map2f(GET_DISPATCH(),
-               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-                points));
+    glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 void
@@ -168,7 +166,7 @@ __glXDispSwap_Map1d(GLbyte * pc)
 #else
     points = (GLdouble *) pc;
 #endif
-    CALL_Map1d(GET_DISPATCH(), (target, u1, u2, k, order, points));
+    glMap1d(target, u1, u2, k, order, points);
 }
 
 void
@@ -224,9 +222,7 @@ __glXDispSwap_Map2d(GLbyte * pc)
 #else
     points = (GLdouble *) pc;
 #endif
-    CALL_Map2d(GET_DISPATCH(),
-               (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-                points));
+    glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 static void
@@ -338,40 +334,45 @@ __glXDispSwap_DrawArrays(GLbyte * pc)
 
         switch (component) {
         case GL_VERTEX_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
-            CALL_VertexPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            glEnableClientState(GL_VERTEX_ARRAY);
+            glVertexPointer(numVals, datatype, stride, pc);
             break;
         case GL_NORMAL_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
-            CALL_NormalPointer(GET_DISPATCH(), (datatype, stride, pc));
+            glEnableClientState(GL_NORMAL_ARRAY);
+            glNormalPointer(datatype, stride, pc);
             break;
         case GL_COLOR_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
-            CALL_ColorPointer(GET_DISPATCH(), (numVals, datatype, stride, pc));
+            glEnableClientState(GL_COLOR_ARRAY);
+            glColorPointer(numVals, datatype, stride, pc);
             break;
         case GL_INDEX_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
-            CALL_IndexPointer(GET_DISPATCH(), (datatype, stride, pc));
+            glEnableClientState(GL_INDEX_ARRAY);
+            glIndexPointer(datatype, stride, pc);
             break;
         case GL_TEXTURE_COORD_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
-            CALL_TexCoordPointer(GET_DISPATCH(),
-                                 (numVals, datatype, stride, pc));
+            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+            glTexCoordPointer(numVals, datatype, stride, pc);
             break;
         case GL_EDGE_FLAG_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
-            CALL_EdgeFlagPointer(GET_DISPATCH(),
-                                 (stride, (const GLboolean *) pc));
+            glEnableClientState(GL_EDGE_FLAG_ARRAY);
+            glEdgeFlagPointer(stride, (const GLboolean *) pc);
             break;
         case GL_SECONDARY_COLOR_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
-            CALL_SecondaryColorPointer(GET_DISPATCH(),
-                                          (numVals, datatype, stride, pc));
+        {
+            PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
+                __glGetProcAddress("glSecondaryColorPointerEXT");
+            glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
+            SecondaryColorPointerEXT(numVals, datatype, stride, pc);
             break;
+        }
         case GL_FOG_COORD_ARRAY:
-            CALL_EnableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
-            CALL_FogCoordPointer(GET_DISPATCH(), (datatype, stride, pc));
+        {
+            PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
+                __glGetProcAddress("glFogCoordPointerEXT");
+            glEnableClientState(GL_FOG_COORD_ARRAY);
+            FogCoordPointerEXT(datatype, stride, pc);
             break;
+        }
         default:
             break;
         }
@@ -379,15 +380,15 @@ __glXDispSwap_DrawArrays(GLbyte * pc)
         pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
     }
 
-    CALL_DrawArrays(GET_DISPATCH(), (primType, 0, numVertexes));
+    glDrawArrays(primType, 0, numVertexes);
 
     /* turn off anything we might have turned on */
-    CALL_DisableClientState(GET_DISPATCH(), (GL_VERTEX_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_NORMAL_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_COLOR_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_INDEX_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY));
-    CALL_DisableClientState(GET_DISPATCH(), (GL_FOG_COORD_ARRAY));
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_NORMAL_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_INDEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_EDGE_FLAG_ARRAY);
+    glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
+    glDisableClientState(GL_FOG_COORD_ARRAY);
 }
diff --git a/xorg-server/hw/kdrive/ephyr/ephyr.c b/xorg-server/hw/kdrive/ephyr/ephyr.c
index a10f47286..ac988b2bc 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyr.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyr.c
@@ -954,7 +954,7 @@ ephyrProcessMouseMotion(xcb_generic_event_t *xev)
 #ifdef XF86DRI
         EphyrWindowPair *pair = NULL;
 #endif
-        EPHYR_LOG("enqueuing mouse motion:%d\n", ephyrCurScreen);
+        EPHYR_LOG("enqueuing mouse motion:%d\n", screen->pScreen->myNum);
         x = motion->event_x;
         y = motion->event_y;
         EPHYR_LOG("initial (x,y):(%d,%d)\n", x, y);
@@ -988,7 +988,7 @@ ephyrProcessButtonPress(xcb_generic_event_t *xev)
 
     if (!ephyrMouse ||
         !((EphyrPointerPrivate *) ephyrMouse->driverPrivate)->enabled) {
-        EPHYR_LOG("skipping mouse press:%d\n", ephyrCurScreen);
+        EPHYR_LOG("skipping mouse press:%d\n", screen_from_window(button->event)->pScreen->myNum);
         return;
     }
 
@@ -998,7 +998,7 @@ ephyrProcessButtonPress(xcb_generic_event_t *xev)
      */
     mouseState |= 1 << (button->detail - 1);
 
-    EPHYR_LOG("enqueuing mouse press:%d\n", ephyrCurScreen);
+    EPHYR_LOG("enqueuing mouse press:%d\n", screen_from_window(button->event)->pScreen->myNum);
     KdEnqueuePointerEvent(ephyrMouse, mouseState | KD_MOUSE_DELTA, 0, 0, 0);
 }
 
@@ -1015,7 +1015,7 @@ ephyrProcessButtonRelease(xcb_generic_event_t *xev)
     ephyrUpdateModifierState(button->state);
     mouseState &= ~(1 << (button->detail - 1));
 
-    EPHYR_LOG("enqueuing mouse release:%d\n", ephyrCurScreen);
+    EPHYR_LOG("enqueuing mouse release:%d\n", screen_from_window(button->event)->pScreen->myNum);
     KdEnqueuePointerEvent(ephyrMouse, mouseState | KD_MOUSE_DELTA, 0, 0, 0);
 }
 
diff --git a/xorg-server/hw/xfree86/common/xf86AutoConfig.c b/xorg-server/hw/xfree86/common/xf86AutoConfig.c
index 95d58fe43..af2b7f8f2 100644
--- a/xorg-server/hw/xfree86/common/xf86AutoConfig.c
+++ b/xorg-server/hw/xfree86/common/xf86AutoConfig.c
@@ -267,14 +267,6 @@ listPossibleVideoDrivers(char *matches[], int nmatches)
     if (i < (nmatches - 1))
         i = xf86PciMatchDriver(matches, nmatches);
 #endif
-    /* Fallback to platform default hardware */
-    if (i < (nmatches - 1)) {
-#if defined(__i386__) || defined(__amd64__) || defined(__hurd__)
-        matches[i++] = xnfstrdup("vesa");
-#elif defined(__sparc__) && !defined(sun)
-        matches[i++] = xnfstrdup("sunffb");
-#endif
-    }
 
 #if defined(__linux__)
     matches[i++] = xnfstrdup("modesetting");
@@ -290,6 +282,15 @@ listPossibleVideoDrivers(char *matches[], int nmatches)
 #endif
     }
 #endif                          /* !sun */
+
+    /* Fallback to platform default hardware */
+    if (i < (nmatches - 1)) {
+#if defined(__i386__) || defined(__amd64__) || defined(__hurd__)
+        matches[i++] = xnfstrdup("vesa");
+#elif defined(__sparc__) && !defined(sun)
+        matches[i++] = xnfstrdup("sunffb");
+#endif
+    }
 }
 
 /* copy a screen section and enter the desired driver
diff --git a/xorg-server/hw/xfree86/common/xf86Config.c b/xorg-server/hw/xfree86/common/xf86Config.c
index 74d5ed3b7..b5efc02af 100644
--- a/xorg-server/hw/xfree86/common/xf86Config.c
+++ b/xorg-server/hw/xfree86/common/xf86Config.c
@@ -507,7 +507,7 @@ xf86InputDriverlistFromConfig(void)
 static void
 fixup_video_driver_list(char **drivers)
 {
-    static const char *fallback[4] = { "vesa", "fbdev", "wsfb", NULL };
+    static const char *fallback[4] = { "fbdev", "vesa", "wsfb", NULL };
     char **end, **drv;
     char *x;
     int i;
diff --git a/xorg-server/hw/xfree86/common/xf86Helper.c b/xorg-server/hw/xfree86/common/xf86Helper.c
index 721159d0b..f1e6783a7 100644
--- a/xorg-server/hw/xfree86/common/xf86Helper.c
+++ b/xorg-server/hw/xfree86/common/xf86Helper.c
@@ -1638,9 +1638,14 @@ xf86SetBackingStore(ScreenPtr pScreen)
     else {
         if (xf86GetOptValBool(options, OPTION_BACKING_STORE, &useBS))
             from = X_CONFIG;
+#ifdef COMPOSITE
+        if (from != X_CONFIG)
+            useBS = xf86ReturnOptValBool(options, OPTION_BACKING_STORE,
+                                         !noCompositeExtension);
+#endif
     }
     free(options);
-    pScreen->backingStoreSupport = useBS ? Always : NotUseful;
+    pScreen->backingStoreSupport = useBS ? WhenMapped : NotUseful;
     if (serverGeneration == 1)
         xf86DrvMsg(pScreen->myNum, from, "Backing store %s\n",
                    useBS ? "enabled" : "disabled");
diff --git a/xorg-server/hw/xfree86/dri2/dri2ext.c b/xorg-server/hw/xfree86/dri2/dri2ext.c
index e1decec9e..ffd66fad6 100644
--- a/xorg-server/hw/xfree86/dri2/dri2ext.c
+++ b/xorg-server/hw/xfree86/dri2/dri2ext.c
@@ -672,6 +672,11 @@ DRI2ExtensionInit(void)
 {
     ExtensionEntry *dri2Extension;
 
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension)
+        return;
+#endif
+
     dri2Extension = AddExtension(DRI2_NAME,
                                  DRI2NumberEvents,
                                  DRI2NumberErrors,
diff --git a/xorg-server/hw/xquartz/GL/indirect.c b/xorg-server/hw/xquartz/GL/indirect.c
index c4999b5ff..8dabda14d 100644
--- a/xorg-server/hw/xquartz/GL/indirect.c
+++ b/xorg-server/hw/xquartz/GL/indirect.c
@@ -48,8 +48,6 @@
 #include <glxserver.h>
 #include <glxutil.h>
 
-#include <glapi.h>
-
 #include "x-hash.h"
 
 #include "visualConfigs.h"
@@ -643,15 +641,20 @@ __glFloorLog2(GLuint val)
     "/System/Library/Frameworks/OpenGL.framework/OpenGL"
 #endif
 
+static void *opengl_framework_handle;
+
+static glx_gpa_proc
+get_proc_address(const char *sym)
+{
+    return (glx_gpa_proc) dlsym(opengl_framework_handle, sym);
+}
+
 static void
 setup_dispatch_table(void)
 {
-    static struct _glapi_table *disp = NULL;
-    static void *handle;
     const char *opengl_framework_path;
 
-    if (disp) {
-        _glapi_set_dispatch(disp);
+    if (opengl_framework_handle) {
         return;
     }
 
@@ -661,16 +664,13 @@ setup_dispatch_table(void)
     }
 
     (void)dlerror();             /*drain dlerror */
-    handle = dlopen(opengl_framework_path, RTLD_LOCAL);
+    opengl_framework_handle = dlopen(opengl_framework_path, RTLD_LOCAL);
 
-    if (!handle) {
+    if (!opengl_framework_handle) {
         ErrorF("unable to dlopen %s : %s, using RTLD_DEFAULT\n",
                opengl_framework_path, dlerror());
-        handle = RTLD_DEFAULT;
+        opengl_framework_handle = RTLD_DEFAULT;
     }
 
-    disp = _glapi_create_table_from_handle(handle, "gl");
-    assert(disp);
-
-    _glapi_set_dispatch(disp);
+    __glXsetGetProcAddress(get_proc_address);
 }
diff --git a/xorg-server/hw/xquartz/X11Controller.m b/xorg-server/hw/xquartz/X11Controller.m
index 3d094bfc7..752bda35c 100644
--- a/xorg-server/hw/xquartz/X11Controller.m
+++ b/xorg-server/hw/xquartz/X11Controller.m
@@ -347,7 +347,7 @@ extern char *bundle_id_prefix;
     const char *newargv[4];
     char buf[128];
     char *s;
-#if 0 && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
     int stdout_pipe[2];
     int stderr_pipe[2];
 #endif
@@ -363,7 +363,7 @@ extern char *bundle_id_prefix;
         setenv("DISPLAY", buf, TRUE);
     }
 
-#if 0 && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
     if (asl_log_descriptor) {
         char *asl_sender;
         aslmsg amsg = asl_new(ASL_TYPE_MSG);
@@ -413,7 +413,7 @@ extern char *bundle_id_prefix;
             _exit(1);
 
         case 0:                                     /* child2 */
-#if 0 && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
             if (asl_log_descriptor) {
                 /* Replace our stdout/stderr */
                 dup2(stdout_pipe[1], STDOUT_FILENO);
@@ -442,7 +442,7 @@ extern char *bundle_id_prefix;
         waitpid(child1, &status, 0);
     }
 
-#if 0 && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1080
     if (asl_log_descriptor) {
         /* Close the write ends of the pipe */
         close(stdout_pipe[1]);
diff --git a/xorg-server/hw/xwin/Makefile.am b/xorg-server/hw/xwin/Makefile.am
index aa73e618d..532120a57 100644
--- a/xorg-server/hw/xwin/Makefile.am
+++ b/xorg-server/hw/xwin/Makefile.am
@@ -158,7 +158,7 @@ XWIN_LIBS += 	$(top_builddir)/pseudoramiX/libPseudoramiX.la
 
 XWin_DEPENDENCIES = $(MULTIWINDOWEXTWM_LIBS) $(XWIN_GLX_LIBS) $(XWIN_LIBS) $(XSERVER_LIBS)
 XWin_LDADD = $(MULTIWINDOW_LIBS) $(MULTIWINDOWEXTWM_LIBS) $(XWIN_GLX_LIBS) $(XWIN_GLX_LINK_FLAGS) $(XWIN_LIBS) $(MAIN_LIB) $(XSERVER_LIBS) $(XSERVER_SYS_LIBS) $(XWIN_SYS_LIBS)
-XWin_LDFLAGS = -mwindows -static
+XWin_LDFLAGS = -mwindows -static -Wl,--disable-stdcall-fixup
 
 .rc.o:
 	$(AM_V_GEN)$(WINDRES) --use-temp-file -i $< --input-format=rc -o $@ -O coff -I $(top_builddir)/include
diff --git a/xorg-server/hw/xwin/glx/Makefile.am b/xorg-server/hw/xwin/glx/Makefile.am
index 067ee5b3c..f2dffbffb 100644
--- a/xorg-server/hw/xwin/glx/Makefile.am
+++ b/xorg-server/hw/xwin/glx/Makefile.am
@@ -1,14 +1,18 @@
 noinst_LTLIBRARIES = libXwinGLX.la
+lib_LTLIBRARIES = libnativeGLthunk.la
 
 libXwinGLX_la_SOURCES = \
 	winpriv.c \
 	winpriv.h \
 	glwindows.h \
-	glwrap.c \
+	glshim.c \
 	indirect.c \
 	wgl_ext_api.c \
 	wgl_ext_api.h
 
+libnativeGLthunk_la_SOURCES = \
+	glthunk.c
+
 if XWIN_MULTIWINDOW
 DEFS_MULTIWINDOW = -DXWIN_MULTIWINDOW
 endif
@@ -30,16 +34,32 @@ AM_CFLAGS = -DHAVE_XWIN_CONFIG_H $(DIX_CFLAGS) \
             -I$(top_srcdir) \
             -I$(top_srcdir)/hw/xwin/
 
+libnativeGLthunk_la_CFLAGS = $(AM_CFLAGS) -Wno-unused-function -Wno-missing-prototypes -Wno-missing-declarations
+libnativeGLthunk_la_LDFLAGS = -shared -no-undefined -avoid-version -lopengl32 -export-symbols generated_gl_thunks.def
+EXTRA_libnativeGLthunk_la_DEPENDENCIES = generated_gl_thunks.def
+
 if XWIN_GLX_WINDOWS
 
-generated_gl_wrappers.c: gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/gl.spec $(KHRONOS_SPEC_DIR)/gl.tm
-	$(AM_V_GEN)$(PYTHON) $(srcdir)/gen_gl_wrappers.py --spec=$(KHRONOS_SPEC_DIR)/gl.spec --typemap=$(KHRONOS_SPEC_DIR)/gl.tm --dispatch-header=$(top_srcdir)/glx/dispatch.h --staticwrappers >generated_gl_wrappers.c
+if DEBUG
+GENGLWRAPPERSOPTS=""
+else
+GENGLWRAPPERSOPTS="-nodebug"
+endif
+
+generated_wgl_wrappers.c: $(srcdir)/gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/wgl.xml $(KHRONOS_SPEC_DIR)/reg.py
+	$(AM_V_GEN)PYTHONPATH=$(KHRONOS_SPEC_DIR) $(PYTHON3) $(srcdir)/gen_gl_wrappers.py -registry $(KHRONOS_SPEC_DIR)/wgl.xml -prefix wgl -wrapper -preresolve $(GENGLWRAPPERSOPTS) -outfile $@
+
+generated_gl_shim.c: $(srcdir)/gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/gl.xml $(KHRONOS_SPEC_DIR)/reg.py
+	$(AM_V_GEN)PYTHONPATH=$(KHRONOS_SPEC_DIR) $(PYTHON3) $(srcdir)/gen_gl_wrappers.py -registry $(KHRONOS_SPEC_DIR)/gl.xml -shim $(GENGLWRAPPERSOPTS) -outfile $@
+
+generated_gl_thunks.c: $(srcdir)/gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/gl.xml $(KHRONOS_SPEC_DIR)/reg.py
+	$(AM_V_GEN)PYTHONPATH=$(KHRONOS_SPEC_DIR) $(PYTHON3) $(srcdir)/gen_gl_wrappers.py -registry $(KHRONOS_SPEC_DIR)/gl.xml -thunk $(GENGLWRAPPERSOPTS) -outfile $@
 
-generated_wgl_wrappers.c: gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/wglext.spec $(KHRONOS_SPEC_DIR)/wgl.tm
-	$(AM_V_GEN)$(PYTHON) $(srcdir)/gen_gl_wrappers.py --spec=$(KHRONOS_SPEC_DIR)/wglext.spec --typemap=$(KHRONOS_SPEC_DIR)/wgl.tm --prefix=wgl --preresolve >generated_wgl_wrappers.c
+generated_gl_thunks.def: $(srcdir)/gen_gl_wrappers.py $(KHRONOS_SPEC_DIR)/gl.xml $(KHRONOS_SPEC_DIR)/reg.py
+	$(AM_V_GEN)PYTHONPATH=$(KHRONOS_SPEC_DIR) $(PYTHON3) $(srcdir)/gen_gl_wrappers.py -registry $(KHRONOS_SPEC_DIR)/gl.xml -thunkdefs $(GENGLWRAPPERSOPTS) -outfile $@
 endif
 
-BUILT_SOURCES = generated_gl_wrappers.c generated_wgl_wrappers.c
+BUILT_SOURCES = generated_gl_shim.c generated_gl_thunks.c generated_gl_thunks.def generated_wgl_wrappers.c
 CLEANFILES = $(BUILT_SOURCES)
 
 EXTRA_DIST = gen_gl_wrappers.py
diff --git a/xorg-server/hw/xwin/glx/gen_gl_wrappers.py b/xorg-server/hw/xwin/glx/gen_gl_wrappers.py
index e5fa57142..683b9d903 100755
--- a/xorg-server/hw/xwin/glx/gen_gl_wrappers.py
+++ b/xorg-server/hw/xwin/glx/gen_gl_wrappers.py
@@ -1,5 +1,8 @@
 #!/usr/bin/python3
 #
+# python script to generate cdecl to stdcall wrappers for GL functions
+# adapted from genheaders.py
+#
 # Copyright (c) 2013 The Khronos Group Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -24,30 +27,23 @@
 import sys, time, pdb, string, cProfile
 from reg import *
 
-# debug - start header generation in debugger
-# dump - dump registry after loading
-# profile - enable Python profiling
-# protect - whether to use #ifndef protections
-# registry <filename> - use specified XML registry instead of gl.xml
-# timeit - time length of registry loading & header generation
-# validate - validate return & parameter group tags against <group>
-debug   = False
-dump    = False
-profile = False
-protect = True
-timeit  = False
-validate= False
 # Default input / log files
 errFilename = None
 diagFilename = 'diag.txt'
 regFilename = 'gl.xml'
 outFilename = 'gen_gl_wrappers.c'
-dispatchheader=None
+
+protect=True
 prefix="gl"
 preresolve=False
+wrapper=False
+shim=False
+thunk=False
+thunkdefs=False
 staticwrappers=False
-nodebugcallcounting=False
+nodebug=False
 
+#exclude base WGL API
 WinGDI={key: 1 for key in [
      "wglCopyContext"
     ,"wglCreateContext"
@@ -83,110 +79,45 @@ if __name__ == '__main__':
     while (i < len(sys.argv)):
         arg = sys.argv[i]
         i = i + 1
-        if (arg == '-debug'):
-            print('Enabling debug (-debug)', file=sys.stderr)
-            debug = True
-        elif (arg == '-dump'):
-            print('Enabling dump (-dump)', file=sys.stderr)
-            dump = True
-        elif (arg == '-noprotect'):
+        if (arg == '-noprotect'):
             print('Disabling inclusion protection in output headers', file=sys.stderr)
             protect = False
-        elif (arg == '-profile'):
-            print('Enabling profiling (-profile)', file=sys.stderr)
-            profile = True
         elif (arg == '-registry'):
             regFilename = sys.argv[i]
             i = i+1
-            print('Using registry ', regFilename, file=sys.stderr)
-        elif (arg == '-time'):
-            print('Enabling timing (-time)', file=sys.stderr)
-            timeit = True
-        elif (arg == '-validate'):
-            print('Enabling group validation (-validate)', file=sys.stderr)
-            validate = True
+            print('Using registry', regFilename, file=sys.stderr)
         elif (arg == '-outfile'):
             outFilename = sys.argv[i]
             i = i+1
         elif (arg == '-preresolve'):
             preresolve=True
+        elif (arg == '-wrapper'):
+            wrapper=True
+        elif (arg == '-shim'):
+            shim=True
+        elif (arg == '-thunk'):
+            thunk=True
+        elif (arg == '-thunkdefs'):
+            thunkdefs=True
         elif (arg == '-staticwrappers'):
             staticwrappers=True
-        elif (arg == '-dispatchheader'):
-            dispatchheader = sys.argv[i]
-            i = i+1
         elif (arg == '-prefix'):
             prefix = sys.argv[i]
             i = i+1
-        elif (arg == '-nodbgcount'):
-            nodebugcallcounting = True
+        elif (arg == '-nodebug'):
+            nodebug = True
         elif (arg[0:1] == '-'):
             print('Unrecognized argument:', arg, file=sys.stderr)
             exit(1)
-print('Generating ', outFilename, file=sys.stderr)
-
-# Simple timer functions
-startTime = None
-def startTimer():
-    global startTime
-    startTime = time.clock()
-def endTimer(msg):
-    global startTime
-    endTime = time.clock()
-    if (timeit):
-        print(msg, endTime - startTime)
-        startTime = None
+
+print('Generating', outFilename, file=sys.stderr)
 
 # Load & parse registry
 reg = Registry()
-
-startTimer()
 tree = etree.parse(regFilename)
-endTimer('Time to make ElementTree =')
-
-startTimer()
 reg.loadElementTree(tree)
-endTimer('Time to parse ElementTree =')
-
-if (validate):
-    reg.validateGroups()
-
-if (dump):
-    print('***************************************')
-    print('Performing Registry dump to regdump.txt')
-    print('***************************************')
-    reg.dumpReg(filehandle = open('regdump.txt','w'))
-
-# Turn a list of strings into a regexp string matching exactly those strings
-def makeREstring(list):
-    return '^(' + '|'.join(list) + ')$'
-
-# These are "mandatory" OpenGL ES 1 extensions, to
-# be included in the core GLES/gl.h header.
-es1CoreList = [
-    'GL_OES_read_format',
-    'GL_OES_compressed_paletted_texture',
-    'GL_OES_point_size_array',
-    'GL_OES_point_sprite'
-]
-
-# Descriptive names for various regexp patterns used to select
-# versions and extensions
-
-allVersions     = allExtensions = '.*'
-noVersions      = noExtensions = None
-gl12andLaterPat = '1\.[2-9]|[234]\.[0-9]'
-gles2onlyPat    = '2\.[0-9]'
-gles2and3Pat    = '[23]\.[0-9]'
-es1CorePat      = makeREstring(es1CoreList)
-# Extensions in old glcorearb.h but not yet tagged accordingly in gl.xml
-glCoreARBPat    = None
-glx13andLaterPat = '1\.[3-9]'
-
-# Defaults for generating re-inclusion protection wrappers (or not)
-protectFile = protect
-protectFeature = protect
-protectProto = protect
+
+allVersions = '.*'
 
 genOpts = CGeneratorOptions(
         apiname           = prefix,
@@ -194,16 +125,9 @@ genOpts = CGeneratorOptions(
         versions          = allVersions,
         emitversions      = allVersions,
         defaultExtensions = prefix,                   # Default extensions for GL
-#        addExtensions     = None,
-#        removeExtensions  = None,
-#        prefixText        = prefixStrings + glExtPlatformStrings + glextVersionStrings,
-#        genFuncPointers   = True,
-#        protectFile       = protectFile,
-#        protectFeature    = protectFeature,
-#        protectProto      = protectProto,
-#        apicall           = 'GLAPI ',
-#        apientry          = 'APIENTRY ',
-#        apientryp         = 'APIENTRYP '),
+        protectFile       = protect,
+        protectFeature    = protect,
+        protectProto      = protect,
         )
 
 # create error/warning & diagnostic files
@@ -213,28 +137,6 @@ else:
     errWarn = sys.stderr
 diag = open(diagFilename, 'w')
 
-#
-# look for all the SET_ macros in dispatch.h, this is the set of functions
-# we need to generate
-#
-
-dispatch = {}
-
-if dispatchheader :
-    fh = open(dispatchheader)
-    dispatchh = fh.readlines()
-
-    dispatch_regex = re.compile(r'(?:#define|static\s+INLINE\s+void)\s+SET_([^\()]+)\(')
-
-    for line in dispatchh :
-        line = line.strip()
-        m1 = dispatch_regex.search(line)
-
-        if m1 :
-            dispatch[prefix+m1.group(1)] = 1
-
-    del dispatch['glby_offset']
-
 class PreResolveOutputGenerator(OutputGenerator):
     def __init__(self,
                  errFile = sys.stderr,
@@ -243,7 +145,7 @@ class PreResolveOutputGenerator(OutputGenerator):
         OutputGenerator.__init__(self, errFile, warnFile, diagFile)
         self.wrappers={}
     def beginFile(self, genOpts):
-        pass
+        self.outFile.write('/* Automatically generated from %s - DO NOT EDIT */\n\n'%regFilename)
     def endFile(self):
         self.outFile.write('\nvoid ' + prefix + 'ResolveExtensionProcs(void)\n{\n')
         for funcname in self.wrappers.keys():
@@ -251,7 +153,6 @@ class PreResolveOutputGenerator(OutputGenerator):
         self.outFile.write('}\n\n')
     def beginFeature(self, interface, emit):
         OutputGenerator.beginFeature(self, interface, emit)
-        self.OldVersion = self.featureName.startswith('GL_VERSION_1_0') or self.featureName.startswith('GL_VERSION_1_1')
     def endFeature(self):
         OutputGenerator.endFeature(self)
     def genType(self, typeinfo, name):
@@ -260,21 +161,21 @@ class PreResolveOutputGenerator(OutputGenerator):
         OutputGenerator.genEnum(self, enuminfo, name)
     def genCmd(self, cmd, name):
         OutputGenerator.genCmd(self, cmd, name)
+
         if name in WinGDI:
             return
 
         self.outFile.write('RESOLVE_DECL(PFN' + name.upper() + 'PROC);\n')
         self.wrappers[name]=1
 
-class MyOutputGenerator(OutputGenerator):
+class WrapperOutputGenerator(OutputGenerator):
     def __init__(self,
                  errFile = sys.stderr,
                  warnFile = sys.stderr,
                  diagFile = sys.stdout):
         OutputGenerator.__init__(self, errFile, warnFile, diagFile)
-        self.wrappers={}
     def beginFile(self, genOpts):
-        pass
+        self.outFile.write('/* Automatically generated from %s - DO NOT EDIT */\n\n'%regFilename)
     def endFile(self):
         pass
     def beginFeature(self, interface, emit):
@@ -288,26 +189,18 @@ class MyOutputGenerator(OutputGenerator):
         OutputGenerator.genEnum(self, enuminfo, name)
     def genCmd(self, cmd, name):
         OutputGenerator.genCmd(self, cmd, name)
-        # Avoid generating wrappers which aren't referenced by the dispatch table
-        if dispatchheader and not name in dispatch :
-            self.outFile.write('/* No wrapper for ' + name + ', not in dispatch table */\n')
-            return
 
         if name in WinGDI:
             return
 
-        self.wrappers[name]=1
-
         proto=noneStr(cmd.elem.find('proto'))
         rettype=noneStr(proto.text)
         if rettype.lower()!="void ":
             plist = ([t for t in proto.itertext()])
             rettype = ''.join(plist[:-1])
-            #ptype=proto.find("ptype")
-            #if ptype!=None:
-            #    rettype = (noneStr(ptype.text))+" "
+        rettype=rettype.strip()
         if staticwrappers: self.outFile.write("static ")
-        self.outFile.write("%s__stdcall %sWrapper("%(rettype, name))
+        self.outFile.write("%s %sWrapper("%(rettype, name))
         params = cmd.elem.findall('param')
         plist=[]
         for param in params:
@@ -322,55 +215,230 @@ class MyOutputGenerator(OutputGenerator):
                 Comma=", "
         else:
             self.outFile.write("void")
+
+        self.outFile.write(")\n{\n")
+
+        # for GL 1.0 and 1.1 functions, generate stdcall wrappers which call the function directly
         if self.OldVersion:
-            if nodebugcallcounting:
-                self.outFile.write(")\n{\n")
+            if not nodebug:
+                self.outFile.write('  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");\n'%(prefix.upper(), name))
+                self.outFile.write("  glWinDirectProcCalls++;\n")
+                self.outFile.write("\n")
+
+            if rettype.lower()=="void":
+                self.outFile.write("  %s( "%(name))
             else:
-                self.outFile.write( """)
-{
-#ifdef _DEBUG
-  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");
-  glWinDirectProcCalls++;
-#endif
-"""%(prefix.upper(), name))
-            if rettype.lower()=="void ":
+                self.outFile.write("  return %s( "%(name))
+
+            Comma=""
+            for ptype, pname in plist:
+                self.outFile.write("%s%s_"%(Comma, pname))
+                Comma=", "
+
+        # for GL 1.2+ functions, generate stdcall wrappers which use wglGetProcAddress()
+        else:
+            if rettype.lower()=="void":
+                self.outFile.write('  RESOLVE(PFN%sPROC, "%s");\n'%(name.upper(), name))
+
+                if not nodebug:
+                    self.outFile.write("\n")
+                    self.outFile.write('  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");\n'%(prefix.upper(), name))
+                    self.outFile.write("\n")
+
+                self.outFile.write("  RESOLVED_PROC(PFN%sPROC)( """%(name.upper()))
+            else:
+                self.outFile.write('  RESOLVE_RET(PFN%sPROC, "%s", FALSE);\n'%(name.upper(), name))
+
+                if not nodebug:
+                    self.outFile.write("\n")
+                    self.outFile.write('  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");\n'%(prefix.upper(), name))
+                    self.outFile.write("\n")
+
+                self.outFile.write("  return RESOLVED_PROC(PFN%sPROC)("%(name.upper()))
+
+            Comma=""
+            for ptype, pname in plist:
+                self.outFile.write("%s%s_"%(Comma, pname))
+                Comma=", "
+        self.outFile.write(" );\n}\n\n")
+
+class ThunkOutputGenerator(OutputGenerator):
+    def __init__(self,
+                 errFile = sys.stderr,
+                 warnFile = sys.stderr,
+                 diagFile = sys.stdout):
+        OutputGenerator.__init__(self, errFile, warnFile, diagFile)
+    def beginFile(self, genOpts):
+        self.outFile.write('/* Automatically generated from %s - DO NOT EDIT */\n\n'%regFilename)
+    def endFile(self):
+        pass
+    def beginFeature(self, interface, emit):
+        OutputGenerator.beginFeature(self, interface, emit)
+        self.OldVersion = self.featureName.startswith('GL_VERSION_1_0') or self.featureName.startswith('GL_VERSION_1_1')
+    def endFeature(self):
+        OutputGenerator.endFeature(self)
+    def genType(self, typeinfo, name):
+        OutputGenerator.genType(self, typeinfo, name)
+    def genEnum(self, enuminfo, name):
+        OutputGenerator.genEnum(self, enuminfo, name)
+    def genCmd(self, cmd, name):
+        OutputGenerator.genCmd(self, cmd, name)
+
+        proto=noneStr(cmd.elem.find('proto'))
+        rettype=noneStr(proto.text)
+        if rettype.lower()!="void ":
+            plist = ([t for t in proto.itertext()])
+            rettype = ''.join(plist[:-1])
+        rettype=rettype.strip()
+        self.outFile.write("%s %sWrapper("%(rettype, name))
+        params = cmd.elem.findall('param')
+        plist=[]
+        for param in params:
+            paramlist = ([t for t in param.itertext()])
+            paramtype = ''.join(paramlist[:-1])
+            paramname = paramlist[-1]
+            plist.append((paramtype, paramname))
+        Comma=""
+        if len(plist):
+            for ptype, pname in plist:
+                self.outFile.write("%s%s%s_"%(Comma, ptype, pname))
+                Comma=", "
+        else:
+            self.outFile.write("void")
+
+        self.outFile.write(")\n{\n")
+
+        # for GL 1.0 and 1.1 functions, generate stdcall thunk wrappers which call the function directly
+        if self.OldVersion:
+            if rettype.lower()=="void":
                 self.outFile.write("  %s( "%(name))
             else:
                 self.outFile.write("  return %s( "%(name))
+
             Comma=""
             for ptype, pname in plist:
                 self.outFile.write("%s%s_"%(Comma, pname))
                 Comma=", "
+
+        # for GL 1.2+ functions, generate wrappers which use wglGetProcAddress()
         else:
-            if rettype.lower()=="void ":
-                self.outFile.write(""")
-{
-  RESOLVE(PFN%sPROC, "%s");"""%(name.upper(), name))
-                if not nodebugcallcounting: self.outFile.write("""
-#ifdef _DEBUG
-  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");
-#endif"""%(prefix.upper(), name))
-                self.outFile.write("""
-  RESOLVED_PROC(PFN%sPROC)( """%(name.upper()))
+            if rettype.lower()=="void":
+                self.outFile.write('  RESOLVE(PFN%sPROC, "%s");\n'%(name.upper(), name))
+                self.outFile.write("  RESOLVED_PROC(PFN%sPROC)( """%(name.upper()))
             else:
-                self.outFile.write(""")
-{
-  RESOLVE_RET(PFN%sPROC, "%s", FALSE);"""%(name.upper(), name))
-                if not nodebugcallcounting: self.outFile.write("""
-#ifdef _DEBUG
-  if (glxWinDebugSettings.enable%scallTrace) ErrorF("%s\\n");
-#endif"""%(prefix.upper(), name))
-                self.outFile.write("""
-  return RESOLVED_PROC(PFN%sPROC)( """%(name.upper()))
+                self.outFile.write('  RESOLVE_RET(PFN%sPROC, "%s", FALSE);\n'%(name.upper(), name))
+                self.outFile.write("  return RESOLVED_PROC(PFN%sPROC)("%(name.upper()))
+
             Comma=""
             for ptype, pname in plist:
                 self.outFile.write("%s%s_"%(Comma, pname))
                 Comma=", "
         self.outFile.write(" );\n}\n\n")
 
+class ThunkDefsOutputGenerator(OutputGenerator):
+    def __init__(self,
+                 errFile = sys.stderr,
+                 warnFile = sys.stderr,
+                 diagFile = sys.stdout):
+        OutputGenerator.__init__(self, errFile, warnFile, diagFile)
+    def beginFile(self, genOpts):
+        self.outFile.write("EXPORTS\n"); # this must be the first line for libtool to realize this is a .def file
+        self.outFile.write('; Automatically generated from %s - DO NOT EDIT\n\n'%regFilename)
+    def endFile(self):
+        pass
+    def beginFeature(self, interface, emit):
+        OutputGenerator.beginFeature(self, interface, emit)
+    def endFeature(self):
+        OutputGenerator.endFeature(self)
+    def genType(self, typeinfo, name):
+        OutputGenerator.genType(self, typeinfo, name)
+    def genEnum(self, enuminfo, name):
+        OutputGenerator.genEnum(self, enuminfo, name)
+    def genCmd(self, cmd, name):
+        OutputGenerator.genCmd(self, cmd, name)
+
+        # export the wrapper function with the name of the function it wraps
+        self.outFile.write("%s = %sWrapper\n"%(name, name))
+
+class ShimOutputGenerator(OutputGenerator):
+    def __init__(self,
+                 errFile = sys.stderr,
+                 warnFile = sys.stderr,
+                 diagFile = sys.stdout):
+        OutputGenerator.__init__(self, errFile, warnFile, diagFile)
+    def beginFile(self, genOpts):
+        self.outFile.write('/* Automatically generated from %s - DO NOT EDIT */\n\n'%regFilename)
+    def endFile(self):
+        pass
+    def beginFeature(self, interface, emit):
+        OutputGenerator.beginFeature(self, interface, emit)
+        self.OldVersion = self.featureName.startswith('GL_VERSION_1_0') or self.featureName.startswith('GL_VERSION_1_1') or self.featureName.startswith('GL_VERSION_1_2') or self.featureName.startswith('GL_ARB_imaging') or self.featureName.startswith('GL_ARB_multitexture') or self.featureName.startswith('GL_ARB_texture_compression')
+    def endFeature(self):
+        OutputGenerator.endFeature(self)
+    def genType(self, typeinfo, name):
+        OutputGenerator.genType(self, typeinfo, name)
+    def genEnum(self, enuminfo, name):
+        OutputGenerator.genEnum(self, enuminfo, name)
+    def genCmd(self, cmd, name):
+        OutputGenerator.genCmd(self, cmd, name)
+
+        if not self.OldVersion:
+            return
+
+        # for GL functions which are in the ABI, generate a shim which calls the function via GetProcAddress
+        proto=noneStr(cmd.elem.find('proto'))
+        rettype=noneStr(proto.text)
+        if rettype.lower()!="void ":
+            plist = ([t for t in proto.itertext()])
+            rettype = ''.join(plist[:-1])
+        rettype=rettype.strip()
+        self.outFile.write("%s %s("%(rettype, name))
+        params = cmd.elem.findall('param')
+        plist=[]
+        for param in params:
+            paramlist = ([t for t in param.itertext()])
+            paramtype = ''.join(paramlist[:-1])
+            paramname = paramlist[-1]
+            plist.append((paramtype, paramname))
+        Comma=""
+        if len(plist):
+            for ptype, pname in plist:
+                self.outFile.write("%s%s%s_"%(Comma, ptype, pname))
+                Comma=", "
+        else:
+            self.outFile.write("void")
+
+        self.outFile.write(")\n{\n")
+
+        self.outFile.write('  typedef %s (* PFN%sPROC)(' % (rettype, name.upper()))
+
+        if len(plist):
+            Comma=""
+            for ptype, pname in plist:
+                self.outFile.write("%s %s %s_"%(Comma, ptype, pname))
+                Comma=", "
+        else:
+            self.outFile.write("void")
+
+        self.outFile.write(');\n')
+
+        if rettype.lower()=="void":
+            self.outFile.write('  RESOLVE(PFN%sPROC, "%s");\n'%(name.upper(), name))
+            self.outFile.write('  RESOLVED_PROC(')
+        else:
+            self.outFile.write('  RESOLVE_RET(PFN%sPROC, "%s", 0);\n'%(name.upper(), name))
+            self.outFile.write('  return RESOLVED_PROC(')
+
+        Comma=""
+        for ptype, pname in plist:
+            self.outFile.write("%s%s_"%(Comma, pname))
+            Comma=", "
+
+        self.outFile.write(" );\n}\n\n")
+
 def genHeaders():
-    startTimer()
     outFile = open(outFilename,"w")
+
     if preresolve:
         gen = PreResolveOutputGenerator(errFile=errWarn,
                                         warnFile=errWarn,
@@ -378,40 +446,40 @@ def genHeaders():
         gen.outFile=outFile
         reg.setGenerator(gen)
         reg.apiGen(genOpts)
-    gen = MyOutputGenerator(errFile=errWarn,
-                            warnFile=errWarn,
-                            diagFile=diag)
-    gen.outFile=outFile
-    reg.setGenerator(gen)
-    reg.apiGen(genOpts)
 
-    # generate function to setup the dispatch table, which sets each
-    # dispatch table entry to point to it's wrapper function
-    # (assuming we were able to make one)
-
-    if dispatchheader :
-        outFile.write( 'void glWinSetupDispatchTable(void)\n')
-        outFile.write( '{\n')
-        outFile.write( '  struct _glapi_table *disp = _glapi_get_dispatch();\n')
+    if wrapper:
+        gen = WrapperOutputGenerator(errFile=errWarn,
+                                     warnFile=errWarn,
+                                     diagFile=diag)
+        gen.outFile=outFile
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
 
-        for d in sorted(dispatch.keys()) :
-                if d in gen.wrappers :
-                        outFile.write('  SET_'+ d[len(prefix):] + '(disp, (void *)' + d + 'Wrapper);\n')
-                else :
-                        outFile.write('#pragma message("No wrapper for ' + d + ' !")\n')
+    if shim:
+        gen = ShimOutputGenerator(errFile=errWarn,
+                                  warnFile=errWarn,
+                                  diagFile=diag)
+        gen.outFile=outFile
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
 
-        outFile.write('}\n')
+    if thunk:
+        gen = ThunkOutputGenerator(errFile=errWarn,
+                                   warnFile=errWarn,
+                                   diagFile=diag)
+        gen.outFile=outFile
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
 
 
+    if thunkdefs:
+        gen = ThunkDefsOutputGenerator(errFile=errWarn,
+                                       warnFile=errWarn,
+                                       diagFile=diag)
+        gen.outFile=outFile
+        reg.setGenerator(gen)
+        reg.apiGen(genOpts)
 
     outFile.close()
 
-if (debug):
-    pdb.run('genHeaders()')
-elif (profile):
-    import cProfile, pstats
-    cProfile.run('genHeaders()', 'profile.txt')
-    p = pstats.Stats('profile.txt')
-    p.strip_dirs().sort_stats('time').print_stats(50)
-else:
-    genHeaders()
+genHeaders()
diff --git a/xorg-server/hw/xwin/glx/glshim.c b/xorg-server/hw/xwin/glx/glshim.c
new file mode 100644
index 000000000..7109196c0
--- /dev/null
+++ b/xorg-server/hw/xwin/glx/glshim.c
@@ -0,0 +1,124 @@
+/*
+ * File: glshim.c
+ * Purpose: GL shim which redirects to a specified DLL
+ *
+ * Copyright (c) Jon TURNEY 2013
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+   A GL shim which redirects to a specified DLL
+
+   XWin is statically linked with this, rather than the system libGL, so that
+   GL calls can be directed to mesa cygGL-1.dll, or cygnativeGLthunk.dll
+   (which contains cdecl-to-stdcall thunks to the native openGL32.dll)
+*/
+
+#ifdef HAVE_XWIN_CONFIG_H
+#include <xwin-config.h>
+#endif
+
+#define GL_GLEXT_LEGACY
+#include <GL/gl.h>
+#undef GL_ARB_imaging
+#undef GL_VERSION_1_3
+#include <GL/glext.h>
+
+#include <X11/Xwindows.h>
+#include <os.h>
+#include "glwindows.h"
+#include <glx/glxserver.h>
+
+static HMODULE hMod = NULL;
+
+/*
+  Implement the __glGetProcAddress function by just using GetProcAddress() on the selected DLL
+*/
+void *glXGetProcAddressARB(const char *symbol)
+{
+    void *proc;
+
+    /* Default to the mesa GL implementation if one hasn't been selected yet */
+    if (!hMod)
+        glWinSelectImplementation(0);
+
+    proc = GetProcAddress(hMod, symbol);
+
+    if (glxWinDebugSettings.enableGLcallTrace)
+        ErrorF("glXGetProcAddressARB: Resolved '%s' in %p to %p\n", symbol, hMod, proc);
+
+    return proc;
+}
+
+/*
+  Select a GL implementation DLL
+*/
+int glWinSelectImplementation(int native)
+{
+    const char *dllname;
+
+    if (native) {
+        dllname = "cygnativeGLthunk.dll";
+    }
+    else {
+        dllname = "cygGL-1.dll";
+    }
+
+    hMod = LoadLibraryEx(dllname, NULL, 0);
+    if (hMod == NULL) {
+        ErrorF("glWinSelectGLimplementation: Could not load '%s'\n", dllname);
+        return -1;
+    }
+
+    ErrorF("glWinSelectGLimplementation: Loaded '%s'\n", dllname);
+
+    /* Connect __glGetProcAddress() to our implementation of glXGetProcAddressARB() above */
+    __glXsetGetProcAddress((glx_gpa_proc)glXGetProcAddressARB);
+
+    return 0;
+}
+
+#define RESOLVE_RET(proctype, symbol, retval) \
+    proctype proc = (proctype)glXGetProcAddressARB(symbol);   \
+    if (proc == NULL) return retval;
+
+#define RESOLVE(proctype, symbol) RESOLVE_RET(proctype, symbol,)
+#define RESOLVED_PROC proc
+
+/* Include generated shims for direct linkage to GL functions which are in the ABI */
+#include "generated_gl_shim.c"
+
+/*
+  Special wrapper for glAddSwapHintRectWIN for copySubBuffers
+
+  Only used with native GL if the GL_WIN_swap_hint extension is present, so we enable
+  GLX_MESA_copy_sub_buffer
+*/
+typedef void (__stdcall * PFNGLADDSWAPHINTRECTWIN) (GLint x, GLint y,
+                                                    GLsizei width,
+                                                    GLsizei height);
+
+void
+glAddSwapHintRectWINWrapper(GLint x, GLint y, GLsizei width,
+                            GLsizei height)
+{
+    RESOLVE(PFNGLADDSWAPHINTRECTWIN, "glAddSwapHintRectWIN");
+    RESOLVED_PROC(x, y, width, height);
+}
diff --git a/xorg-server/hw/xwin/glx/glwrap.c b/xorg-server/hw/xwin/glx/glthunk.c
index 9733e7526..565b63465 100644
--- a/xorg-server/hw/xwin/glx/glwrap.c
+++ b/xorg-server/hw/xwin/glx/glthunk.c
@@ -1,13 +1,8 @@
 /*
- * File: glwrap.c
- * Purpose: Wrapper functions for Win32 OpenGL functions
- *
- * Authors: Alexander Gottwald
- *          Jon TURNEY
- *
- * Copyright (c) Jon TURNEY 2009
- * Copyright (c) Alexander Gottwald 2004
+ * File: glthunk.c
+ * Purpose: cdecl thunk wrapper library for Win32 stdcall OpenGL library
  *
+ * Copyright (c) Jon TURNEY 2009,2013
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -37,37 +32,15 @@
 #endif
 
 #include <X11/Xwindows.h>
+
+#define GL_GLEXT_LEGACY
 #include <GL/gl.h>
+#undef GL_ARB_imaging
+#undef GL_VERSION_1_3
 #include <GL/glext.h>
 #include <glx/glheader.h>
-#include <glx/glxserver.h>
-#include <glx/glxext.h>
-#include <glx/glapi.h>
-#include <glx/dispatch.h>
-#include <glwindows.h>
 #include <winmsg.h>
-
 #ifdef _DEBUG
-static unsigned int glWinIndirectProcCalls = 0;
-static unsigned int glWinDirectProcCalls = 0;
-
-void
-glWinCallDelta(void)
-{
-    static unsigned int glWinIndirectProcCallsLast = 0;
-    static unsigned int glWinDirectProcCallsLast = 0;
-
-    if ((glWinIndirectProcCalls != glWinIndirectProcCallsLast) ||
-        (glWinDirectProcCalls != glWinDirectProcCallsLast)) {
-        if (glxWinDebugSettings.enableTrace) {
-            ErrorF("after %d direct and %d indirect GL calls\n",
-                   glWinDirectProcCalls - glWinDirectProcCallsLast,
-                   glWinIndirectProcCalls - glWinIndirectProcCallsLast);
-        }
-        glWinDirectProcCallsLast = glWinDirectProcCalls;
-        glWinIndirectProcCallsLast = glWinIndirectProcCalls;
-    }
-}
 #endif
 
 static PROC
@@ -79,11 +52,9 @@ glWinResolveHelper(PROC * cache, const char *symbol)
     if ((*cache) == NULL) {
         proc = wglGetProcAddress(symbol);
         if (proc == NULL) {
-            winDebug("glwrap: Can't resolve \"%s\"\n", symbol);
             (*cache) = (PROC) - 1;
         }
         else {
-            winDebug("glwrap: Resolved \"%s\"\n", symbol);
             (*cache) = proc;
         }
     }
@@ -109,10 +80,8 @@ glWinResolveHelper(PROC * cache, const char *symbol)
     static PROC cache = NULL; \
     proctype proc = (proctype)glWinResolveHelper(&cache, symbol); \
     if (proc == NULL) { \
-        __glXErrorCallBack(0); \
         return retval; \
-    } \
-    INCPROCCALLS
+    }
 
 #define RESOLVE(proctype, symbol) RESOLVE_RET(proctype, symbol,)
 
@@ -123,34 +92,6 @@ glWinResolveHelper(PROC * cache, const char *symbol)
 
   OpenGL 1.2 and upward is treated as extensions, function address must
   found using wglGetProcAddress(), but also stdcall so still need wrappers...
-
-  Include generated dispatch table setup function
 */
 
-#include "generated_gl_wrappers.c"
-
-/*
-  Special non-static wrapper for glGetString for debug output
-*/
-
-const GLubyte *
-glGetStringWrapperNonstatic(GLenum name)
-{
-    return glGetString(name);
-}
-
-/*
-  Special non-static wrapper for glAddSwapHintRectWIN for copySubBuffers
-*/
-
-typedef void (__stdcall * PFNGLADDSWAPHINTRECTWIN) (GLint x, GLint y,
-                                                    GLsizei width,
-                                                    GLsizei height);
-
-void
-glAddSwapHintRectWINWrapperNonstatic(GLint x, GLint y, GLsizei width,
-                                     GLsizei height)
-{
-    RESOLVE(PFNGLADDSWAPHINTRECTWIN, "glAddSwapHintRectWIN");
-    proc(x, y, width, height);
-}
+#include "generated_gl_thunks.c"
diff --git a/xorg-server/hw/xwin/glx/glwindows.h b/xorg-server/hw/xwin/glx/glwindows.h
index 42adc5b60..177dcf1bb 100644
--- a/xorg-server/hw/xwin/glx/glwindows.h
+++ b/xorg-server/hw/xwin/glx/glwindows.h
@@ -42,12 +42,9 @@ typedef struct {
 
 extern glxWinDebugSettingsRec glxWinDebugSettings;
 
-void glWinCallDelta(void);
 void glxWinPushNativeProvider(void);
-const GLubyte *glGetStringWrapperNonstatic(GLenum name);
-void glAddSwapHintRectWINWrapperNonstatic(GLint x, GLint y, GLsizei width,
-                                          GLsizei height);
-void glWinSetupDispatchTable(void);
+void glAddSwapHintRectWINWrapper(GLint x, GLint y, GLsizei width, GLsizei height);
+int glWinSelectImplementation(int native);
 
 #ifdef _DEBUG
 #ifdef _MSC_VER
diff --git a/xorg-server/hw/xwin/glx/indirect.c b/xorg-server/hw/xwin/glx/indirect.c
index 495e366ca..605f975c0 100644
--- a/xorg-server/hw/xwin/glx/indirect.c
+++ b/xorg-server/hw/xwin/glx/indirect.c
@@ -601,7 +601,9 @@ glxWinScreenProbe(ScreenPtr pScreen)
     if (NULL == screen)
         return NULL;
 
-    /* Dump out some useful information about the native renderer */
+    // Select the native GL implementation (WGL)
+    if (glWinSelectImplementation(1))
+        return NULL;
 
     // create window class
     {
@@ -650,11 +652,12 @@ glxWinScreenProbe(ScreenPtr pScreen)
     // (but we need to have a current context for them to be resolvable)
     wglResolveExtensionProcs();
 
-    winDebug("GL_VERSION:     %s\n", glGetStringWrapperNonstatic(GL_VERSION));
-    winDebug("GL_VENDOR:      %s\n", glGetStringWrapperNonstatic(GL_VENDOR));
-    gl_renderer = (const char *) glGetStringWrapperNonstatic(GL_RENDERER);
+    /* Dump out some useful information about the native renderer */
+    winDebug("GL_VERSION:     %s\n", glGetString(GL_VERSION));
+    winDebug("GL_VENDOR:      %s\n", glGetString(GL_VENDOR));
+    gl_renderer = (const char *) glGetString(GL_RENDERER);
     winDebug("GL_RENDERER:    %s\n", gl_renderer);
-    gl_extensions = (const char *) glGetStringWrapperNonstatic(GL_EXTENSIONS);
+    gl_extensions = (const char *) glGetString(GL_EXTENSIONS);
     wgl_extensions = wglGetExtensionsStringARBWrapper(hdc);
     if (!wgl_extensions)
         wgl_extensions = "";
@@ -668,7 +671,7 @@ glxWinScreenProbe(ScreenPtr pScreen)
         free(screen);
         LogMessage(X_ERROR,
                    "AIGLX: Won't use generic native renderer as it is not accelerated\n");
-        return NULL;
+        goto error;
     }
 
     // Can you see the problem here?  The extensions string is DC specific
@@ -779,7 +782,7 @@ glxWinScreenProbe(ScreenPtr pScreen)
             free(screen);
             LogMessage(X_ERROR,
                        "AIGLX: No fbConfigs could be made from native OpenGL pixel formats\n");
-            return NULL;
+            goto error;
         }
 
         /* These will be set by __glXScreenInit */
@@ -848,6 +851,13 @@ glxWinScreenProbe(ScreenPtr pScreen)
     pScreen->DestroyWindow = glxWinDestroyWindow;
 
     return &screen->base;
+
+ error:
+    // Something went wrong and we can't use the native GL implementation
+    // so make sure the mesa GL implementation is selected instead
+    glWinSelectImplementation(0);
+
+    return NULL;
 }
 
 /* ---------------------------------------------------------------------- */
@@ -1037,7 +1047,7 @@ static void
 glxWinDrawableCopySubBuffer(__GLXdrawable * drawable,
                             int x, int y, int w, int h)
 {
-    glAddSwapHintRectWINWrapperNonstatic(x, y, w, h);
+    glAddSwapHintRectWINWrapper(x, y, w, h);
     glxWinDrawableSwapBuffers(NULL, drawable);
 }
 
@@ -1619,7 +1629,6 @@ glxWinContextMakeCurrent(__GLXcontext * base)
 
 #ifdef _DEBUG
     GLWIN_TRACE_MSG("glxWinContextMakeCurrent context %p (native ctx %p)", gc, gc->ctx);
-    glWinCallDelta();
 #endif
 
     /* Keep a note of the last active context in the drawable */
@@ -1691,7 +1700,6 @@ glxWinContextLoseCurrent(__GLXcontext * base)
 
 #ifdef _DEBUG
     GLWIN_TRACE_MSG("glxWinContextLoseCurrent context %p (native ctx %p)", gc, gc->ctx);
-    glWinCallDelta();
 #endif
 
      /* Clear the last active context in the drawable */
@@ -1805,8 +1813,6 @@ glxWinCreateContext(__GLXscreen * screen,
     context->Dispatch=calloc(sizeof(void*), (sizeof(struct _glapi_table) / sizeof(void *) + MAX_EXTENSION_FUNCS));
     _glapi_set_dispatch(context->Dispatch);
 
-    glWinSetupDispatchTable();
-
     GLWIN_DEBUG_MSG("GLXcontext %p created", context);
 
     return &(context->base);
diff --git a/xorg-server/hw/xwin/glx/makefile b/xorg-server/hw/xwin/glx/makefile
index 3b0413312..3b0413312 100755..100644
--- a/xorg-server/hw/xwin/glx/makefile
+++ b/xorg-server/hw/xwin/glx/makefile
diff --git a/xorg-server/hw/xwin/swrastwgl_dri/makefile b/xorg-server/hw/xwin/swrastwgl_dri/makefile
index 201f2aeb9..201f2aeb9 100755..100644
--- a/xorg-server/hw/xwin/swrastwgl_dri/makefile
+++ b/xorg-server/hw/xwin/swrastwgl_dri/makefile
diff --git a/xorg-server/include/dix-config.h.in b/xorg-server/include/dix-config.h.in
index d4fbe99fa..306610000 100644
--- a/xorg-server/include/dix-config.h.in
+++ b/xorg-server/include/dix-config.h.in
@@ -466,4 +466,7 @@
 /* Wrap SIGBUS to catch MIT-SHM faults */
 #undef BUSFAULT
 
+/* Directory for shared memory temp files */
+#undef SHMDIR
+
 #endif /* _DIX_CONFIG_H_ */
diff --git a/xorg-server/include/os.h b/xorg-server/include/os.h
index 4689e573d..218b7f639 100644
--- a/xorg-server/include/os.h
+++ b/xorg-server/include/os.h
@@ -702,4 +702,7 @@ xorg_backtrace(void);
 #define snprintf _snprintf
 #endif
 
+extern _X_EXPORT int
+os_move_fd(int fd);
+
 #endif                          /* OS_H */
diff --git a/xorg-server/include/protocol-versions.h b/xorg-server/include/protocol-versions.h
index 95df8ce1a..fc428c8cf 100644
--- a/xorg-server/include/protocol-versions.h
+++ b/xorg-server/include/protocol-versions.h
@@ -46,6 +46,10 @@
 #define SERVER_DAMAGE_MAJOR_VERSION		1
 #define SERVER_DAMAGE_MINOR_VERSION		1
 
+/* DRI3 */
+#define SERVER_DRI3_MAJOR_VERSION               1
+#define SERVER_DRI3_MINOR_VERSION               0
+
 /* DMX */
 #define SERVER_DMX_MAJOR_VERSION		2
 #define SERVER_DMX_MINOR_VERSION		2
@@ -63,6 +67,10 @@
 #define SERVER_PANORAMIX_MAJOR_VERSION          1
 #define SERVER_PANORAMIX_MINOR_VERSION		1
 
+/* Present */
+#define SERVER_PRESENT_MAJOR_VERSION            1
+#define SERVER_PRESENT_MINOR_VERSION            0
+
 /* RandR */
 #define SERVER_RANDR_MAJOR_VERSION		1
 #define SERVER_RANDR_MINOR_VERSION		4
diff --git a/xorg-server/miext/sync/makefile b/xorg-server/miext/sync/makefile
index 295fdb250..295fdb250 100755..100644
--- a/xorg-server/miext/sync/makefile
+++ b/xorg-server/miext/sync/makefile
diff --git a/xorg-server/miext/sync/misyncshm.c b/xorg-server/miext/sync/misyncshm.c
index 3f9350af5..01f82fc00 100644
--- a/xorg-server/miext/sync/misyncshm.c
+++ b/xorg-server/miext/sync/misyncshm.c
@@ -32,12 +32,13 @@
 #include "pixmapstr.h"
 #include <sys/mman.h>
 #include <unistd.h>
+#include <fcntl.h>
 #include <X11/xshmfence.h>
 
 static DevPrivateKeyRec syncShmFencePrivateKey;
 
 typedef struct _SyncShmFencePrivate {
-    int32_t             *fence;
+    struct xshmfence    *fence;
     int                 fd;
 } SyncShmFencePrivateRec, *SyncShmFencePrivatePtr;
 
@@ -126,6 +127,7 @@ miSyncShmCreateFenceFromFd(ScreenPtr pScreen, SyncFence *pFence, int fd, Bool in
 
     miSyncInitFence(pScreen, pFence, initially_triggered);
 
+    fd = os_move_fd(fd);
     pPriv->fence = xshmfence_map_shm(fd);
     if (pPriv->fence) {
         pPriv->fd = fd;
@@ -145,6 +147,7 @@ miSyncShmGetFenceFd(ScreenPtr pScreen, SyncFence *pFence)
         pPriv->fd = xshmfence_alloc_shm();
         if (pPriv->fd < 0)
             return -1;
+        pPriv->fd = os_move_fd(pPriv->fd);
         pPriv->fence = xshmfence_map_shm(pPriv->fd);
         if (!pPriv->fence) {
             close (pPriv->fd);
diff --git a/xorg-server/os/osinit.c b/xorg-server/os/osinit.c
index 60d10694b..4d48ea94e 100644
--- a/xorg-server/os/osinit.c
+++ b/xorg-server/os/osinit.c
@@ -213,10 +213,18 @@ OsInit(void)
         dlinfo(RTLD_SELF, RTLD_DI_SETSIGNAL, &failure_signal);
 #endif
 
-#if !defined(__CYGWIN__)
+#if !defined(XQUARTZ)    /* STDIN is already /dev/null and STDOUT/STDERR is managed by console_redirect.c */
+# if defined(__APPLE__)
+        int devnullfd = open(devnull, O_RDWR, 0);
+        assert(devnullfd > 2);
+
+        dup2(devnullfd, STDIN_FILENO);
+        dup2(devnullfd, STDOUT_FILENO);
+        close(devnullfd);
+# elif !defined(__CYGWIN__)
         fclose(stdin);
         fclose(stdout);
-#endif
+# endif
         /* 
          * If a write of zero bytes to stderr returns non-zero, i.e. -1, 
          * then writing to stderr failed, and we'll write somewhere else 
@@ -250,6 +258,7 @@ OsInit(void)
             setlinebuf(stderr);
 #endif
         }
+#endif /* !XQUARTZ */
 
 #if !defined(WIN32) || defined(__CYGWIN__)
         if (getpgrp() == 0)
diff --git a/xorg-server/os/utils.c b/xorg-server/os/utils.c
index c40a938f7..ff3b7e40a 100644
--- a/xorg-server/os/utils.c
+++ b/xorg-server/os/utils.c
@@ -2129,3 +2129,27 @@ FormatUInt64Hex(uint64_t num, char *string)
 
     string[len] = '\0';
 }
+
+/* Move a file descriptor out of the way of our select mask; this
+ * is useful for file descriptors which will never appear in the
+ * select mask to avoid reducing the number of clients that can
+ * connect to the server
+ */
+int
+os_move_fd(int fd)
+{
+    int newfd;
+
+#ifdef F_DUPFD_CLOEXEC
+    newfd = fcntl(fd, F_DUPFD_CLOEXEC, MAXCLIENTS);
+#else
+    newfd = fcntl(fd, F_DUPFD, MAXCLIENTS);
+#endif
+    if (newfd < 0)
+        return fd;
+#ifndef F_DUPFD_CLOEXEC
+    fcntl(newfd, F_SETFD, FD_CLOEXEC);
+#endif
+    close(fd);
+    return newfd;
+}
diff --git a/xorg-server/present/present.c b/xorg-server/present/present.c
index 1bd528b23..96ca99241 100644
--- a/xorg-server/present/present.c
+++ b/xorg-server/present/present.c
@@ -115,7 +115,8 @@ present_check_flip(RRCrtcPtr    crtc,
     }
 
     /* Make sure the window hasn't been redirected with Composite */
-    if (screen->GetWindowPixmap(window) != screen->GetScreenPixmap(screen))
+    if (screen->GetWindowPixmap(window) != screen->GetScreenPixmap(screen) &&
+        screen->GetWindowPixmap(window) != screen_priv->flip_pixmap)
         return FALSE;
 
     /* Check for full-screen window */
@@ -311,6 +312,36 @@ present_flip_idle(ScreenPtr screen)
     }
 }
 
+struct pixmap_visit {
+    PixmapPtr   old;
+    PixmapPtr   new;
+};
+
+static int
+present_set_tree_pixmap_visit(WindowPtr window, pointer data)
+{
+    struct pixmap_visit *visit = data;
+    ScreenPtr           screen = window->drawable.pScreen;
+
+    if ((*screen->GetWindowPixmap)(window) != visit->old)
+        return WT_DONTWALKCHILDREN;
+    (*screen->SetWindowPixmap)(window, visit->new);
+    return WT_WALKCHILDREN;
+}
+    
+static void
+present_set_tree_pixmap(WindowPtr window, PixmapPtr pixmap)
+{
+    struct pixmap_visit visit;
+    ScreenPtr           screen = window->drawable.pScreen;
+
+    visit.old = (*screen->GetWindowPixmap)(window);
+    visit.new = pixmap;
+    if (visit.old == visit.new)
+        return;
+    TraverseTree(window, present_set_tree_pixmap_visit, &visit);
+}
+
 static void
 present_unflip(ScreenPtr screen)
 {
@@ -319,6 +350,12 @@ present_unflip(ScreenPtr screen)
     assert (!screen_priv->unflip_event_id);
     assert (!screen_priv->flip_pending);
 
+    if (screen_priv->flip_window)
+        present_set_tree_pixmap(screen_priv->flip_window,
+                                  (*screen->GetScreenPixmap)(screen));
+
+    present_set_tree_pixmap(screen->root, (*screen->GetScreenPixmap)(screen));
+
     /* Update the screen pixmap with the current flip pixmap contents
      */
     if (screen_priv->flip_pixmap && screen_priv->flip_window) {
@@ -348,6 +385,8 @@ present_flip_notify(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
 
     present_flip_idle(screen);
 
+    xorg_list_del(&vblank->event_queue);
+
     /* Transfer reference for pixmap and fence from vblank to screen_priv */
     screen_priv->flip_crtc = vblank->crtc;
     screen_priv->flip_window = vblank->window;
@@ -378,14 +417,12 @@ present_event_notify(uint64_t event_id, uint64_t ust, uint64_t msc)
     DebugPresent(("\te %lld ust %lld msc %lld\n", event_id, ust, msc));
     xorg_list_for_each_entry_safe(vblank, tmp, &present_exec_queue, event_queue) {
         if (vblank->event_id == event_id) {
-            xorg_list_del(&vblank->event_queue);
             present_execute(vblank, ust, msc);
             return;
         }
     }
     xorg_list_for_each_entry_safe(vblank, tmp, &present_flip_queue, event_queue) {
         if (vblank->event_id == event_id) {
-            xorg_list_del(&vblank->event_queue);
             present_flip_notify(vblank, ust, msc);
             return;
         }
@@ -447,7 +484,7 @@ present_check_flip_window (WindowPtr window)
 
     /* Now check any queued vblanks */
     xorg_list_for_each_entry(vblank, &window_priv->vblank, window_list) {
-        if (vblank->flip && !present_check_flip(vblank->crtc, window, vblank->pixmap, FALSE, NULL, 0, 0))
+        if (vblank->queued && vblank->flip && !present_check_flip(vblank->crtc, window, vblank->pixmap, FALSE, NULL, 0, 0))
             vblank->flip = FALSE;
     }
 }
@@ -486,7 +523,8 @@ static void
 present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
 {
     WindowPtr                   window = vblank->window;
-    present_screen_priv_ptr     screen_priv = present_screen_priv(window->drawable.pScreen);
+    ScreenPtr                   screen = window->drawable.pScreen;
+    present_screen_priv_ptr     screen_priv = present_screen_priv(screen);
 
     if (vblank->wait_fence) {
         if (!present_fence_check_triggered(vblank->wait_fence)) {
@@ -496,22 +534,45 @@ present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
     }
 
     xorg_list_del(&vblank->event_queue);
+    vblank->queued = FALSE;
+
     if (vblank->pixmap && vblank->window) {
 
         if (vblank->flip && screen_priv->flip_pending == NULL && !screen_priv->unflip_event_id) {
 
             DebugPresent(("\tf %p %8lld: %08lx -> %08lx\n", vblank, crtc_msc, vblank->pixmap->drawable.id, vblank->window->drawable.id));
-            /* Prepare to flip by removing from the window/screen lists
+            /* Prepare to flip by placing it in the flip queue and
              * and sticking it into the flip_pending field
              */
             screen_priv->flip_pending = vblank;
-            xorg_list_del(&vblank->window_list);
 
             xorg_list_add(&vblank->event_queue, &present_flip_queue);
             /* Try to flip
              */
-            if (present_flip(vblank->crtc, vblank->event_id, vblank->target_msc, vblank->pixmap, vblank->sync_flip))
+            if (present_flip(vblank->crtc, vblank->event_id, vblank->target_msc, vblank->pixmap, vblank->sync_flip)) {
+                RegionPtr damage;
+
+                /* Fix window pixmaps:
+                 *  1) Restore previous flip window pixmap
+                 *  2) Set current flip window pixmap to the new pixmap
+                 */
+                if (screen_priv->flip_window && screen_priv->flip_window != window)
+                    present_set_tree_pixmap(screen_priv->flip_window,
+                                              (*screen->GetScreenPixmap)(screen));
+                present_set_tree_pixmap(vblank->window, vblank->pixmap);
+                present_set_tree_pixmap(screen->root, vblank->pixmap);
+
+                /* Report update region as damaged
+                 */
+                if (vblank->update) {
+                    damage = vblank->update;
+                    RegionIntersect(damage, damage, &window->clipList);
+                } else
+                    damage = &window->clipList;
+
+                DamageDamageRegion(&vblank->window->drawable, damage);
                 return;
+            }
 
             xorg_list_del(&vblank->event_queue);
             /* Oops, flip failed. Clear the flip_pending field
@@ -531,7 +592,7 @@ present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc)
             /* Check current flip
              */
             if (window == screen_priv->flip_window)
-                present_unflip(window->drawable.pScreen);
+                present_unflip(screen);
         }
         present_copy_region(&window->drawable, vblank->pixmap, vblank->update, vblank->x_off, vblank->y_off);
 
@@ -577,7 +638,9 @@ present_pixmap(WindowPtr window,
     if (!window_priv)
         return BadAlloc;
 
-    if (!target_crtc) {
+    if (!screen_priv || !screen_priv->info)
+        target_crtc = NULL;
+    else if (!target_crtc) {
         /* Update the CRTC if we have a pixmap or we don't have a CRTC
          */
         if (!pixmap)
@@ -621,6 +684,11 @@ present_pixmap(WindowPtr window,
             if (vblank->crtc != target_crtc || vblank->target_msc != target_msc)
                 continue;
 
+            DebugPresent(("\tx %lld %p %8lld: %08lx -> %08lx (crtc %p)\n",
+                          vblank->event_id, vblank, target_msc,
+                          vblank->pixmap->drawable.id, vblank->window->drawable.id,
+                          vblank->crtc));
+
             present_pixmap_idle(vblank->pixmap, vblank->window, vblank->serial, vblank->idle_fence);
             present_fence_destroy(vblank->idle_fence);
             dixDestroyPixmap(vblank->pixmap, vblank->pixmap->drawable.id);
@@ -696,10 +764,12 @@ present_pixmap(WindowPtr window,
                       target_crtc));
 
     xorg_list_add(&vblank->event_queue, &present_exec_queue);
+    vblank->queued = TRUE;
     if (target_msc >= crtc_msc) {
         ret = present_queue_vblank(screen, target_crtc, vblank->event_id, target_msc);
         if (ret != Success) {
             xorg_list_del(&vblank->event_queue);
+            vblank->queued = FALSE;
             goto failure;
         }
     } else
@@ -732,6 +802,7 @@ present_abort_vblank(ScreenPtr screen, RRCrtcPtr crtc, uint64_t event_id, uint64
     xorg_list_for_each_entry_safe(vblank, tmp, &present_exec_queue, event_queue) {
         if (vblank->event_id == event_id) {
             xorg_list_del(&vblank->event_queue);
+            vblank->queued = FALSE;
             return;
         }
     }
diff --git a/xorg-server/present/present.h b/xorg-server/present/present.h
index 6a451fb23..0e3bdc08e 100644
--- a/xorg-server/present/present.h
+++ b/xorg-server/present/present.h
@@ -115,4 +115,13 @@ present_event_abandon(RRCrtcPtr crtc);
 extern _X_EXPORT Bool
 present_screen_init(ScreenPtr screen, present_screen_info_ptr info);
 
+typedef void (*present_complete_notify_proc)(WindowPtr window,
+                                             CARD8 mode,
+                                             CARD32 serial,
+                                             uint64_t ust,
+                                             uint64_t msc);
+
+extern _X_EXPORT void
+present_register_complete_notify(present_complete_notify_proc proc);
+
 #endif /* _PRESENT_H_ */
diff --git a/xorg-server/present/present_event.c b/xorg-server/present/present_event.c
index 9015c9371..3d0aaa799 100644
--- a/xorg-server/present/present_event.c
+++ b/xorg-server/present/present_event.c
@@ -136,6 +136,14 @@ present_send_config_notify(WindowPtr window, int x, int y, int w, int h, int bw,
     }
 }
 
+static present_complete_notify_proc complete_notify;
+
+void
+present_register_complete_notify(present_complete_notify_proc proc)
+{
+    complete_notify = proc;
+}
+
 void
 present_send_complete_notify(WindowPtr window, CARD8 kind, CARD8 mode, CARD32 serial, uint64_t ust, uint64_t msc)
 {
@@ -163,6 +171,8 @@ present_send_complete_notify(WindowPtr window, CARD8 kind, CARD8 mode, CARD32 se
             }
         }
     }
+    if (complete_notify)
+        (*complete_notify)(window, mode, serial, ust, msc);
 }
 
 void
diff --git a/xorg-server/present/present_priv.h b/xorg-server/present/present_priv.h
index 500c7c265..8d3e0079c 100644
--- a/xorg-server/present/present_priv.h
+++ b/xorg-server/present/present_priv.h
@@ -69,9 +69,10 @@ struct present_vblank {
     present_fence_ptr   wait_fence;
     present_notify_ptr  notifies;
     int                 num_notifies;
-    Bool                flip;
-    Bool                sync_flip;
-    Bool                abort_flip;
+    Bool                queued;         /* on present_exec_queue */
+    Bool                flip;           /* planning on using flip */
+    Bool                sync_flip;      /* do flip synchronous to vblank */
+    Bool                abort_flip;     /* aborting this flip */
 };
 
 typedef struct present_screen_priv {
diff --git a/xorg-server/present/present_request.c b/xorg-server/present/present_request.c
index cd2d334ff..275a29cdc 100644
--- a/xorg-server/present/present_request.c
+++ b/xorg-server/present/present_request.c
@@ -26,17 +26,19 @@
 
 #include "present_priv.h"
 #include "randrstr.h"
+#include <protocol-versions.h>
 
 static int
 proc_present_query_version(ClientPtr client)
 {
     xPresentQueryVersionReply rep;
     REQUEST(xPresentQueryVersionReq);
+
         rep.type = X_Reply;
         rep.sequenceNumber = client->sequence;
         rep.length = 0;
-        rep.majorVersion = PRESENT_MAJOR;
-        rep.minorVersion = PRESENT_MINOR;
+        rep.majorVersion = SERVER_PRESENT_MAJOR_VERSION;
+        rep.minorVersion = SERVER_PRESENT_MINOR_VERSION;
 
 
     REQUEST_SIZE_MATCH(xPresentQueryVersionReq);
diff --git a/xorg-server/present/present_screen.c b/xorg-server/present/present_screen.c
index 6df0c1d99..1e4f55d37 100644
--- a/xorg-server/present/present_screen.c
+++ b/xorg-server/present/present_screen.c
@@ -206,6 +206,11 @@ present_extension_init(void)
     ExtensionEntry *extension;
     int i;
 
+#ifdef PANORAMIX
+    if (!noPanoramiXExtension)
+        return;
+#endif
+
     extension = AddExtension(PRESENT_NAME, PresentNumberEvents, PresentNumberErrors,
                              proc_present_dispatch, sproc_present_dispatch,
                              NULL, StandardMinorOpcode);
diff --git a/xorg-server/xfixes/region.c b/xorg-server/xfixes/region.c
index 0e9ca443f..14a02ba1d 100644
--- a/xorg-server/xfixes/region.c
+++ b/xorg-server/xfixes/region.c
@@ -857,6 +857,7 @@ PanoramiXFixesSetWindowShapeRegion(ClientPtr client)
 {
     int result = Success, j;
     PanoramiXRes *win;
+    RegionPtr reg = NULL;
 
     REQUEST(xXFixesSetWindowShapeRegionReq);
 
@@ -869,10 +870,22 @@ PanoramiXFixesSetWindowShapeRegion(ClientPtr client)
         return result;
     }
 
+    if (win->u.win.root)
+        VERIFY_REGION_OR_NONE(reg, stuff->region, client, DixReadAccess);
+
     FOR_NSCREENS_FORWARD(j) {
+        ScreenPtr screen = screenInfo.screens[j];
         stuff->dest = win->info[j].id;
+
+        if (reg)
+            RegionTranslate(reg, -screen->x, -screen->y);
+
         result =
             (*PanoramiXSaveXFixesVector[X_XFixesSetWindowShapeRegion]) (client);
+
+        if (reg)
+            RegionTranslate(reg, screen->x, screen->y);
+
         if (result != Success)
             break;
     }
@@ -886,6 +899,7 @@ PanoramiXFixesSetPictureClipRegion(ClientPtr client)
     REQUEST(xXFixesSetPictureClipRegionReq);
     int result = Success, j;
     PanoramiXRes *pict;
+    RegionPtr reg = NULL;
 
     REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
 
@@ -896,10 +910,22 @@ PanoramiXFixesSetPictureClipRegion(ClientPtr client)
         return result;
     }
 
+    if (pict->u.pict.root)
+        VERIFY_REGION_OR_NONE(reg, stuff->region, client, DixReadAccess);
+
     FOR_NSCREENS_BACKWARD(j) {
+        ScreenPtr screen = screenInfo.screens[j];
         stuff->picture = pict->info[j].id;
+
+        if (reg)
+            RegionTranslate(reg, -screen->x, -screen->y);
+
         result =
             (*PanoramiXSaveXFixesVector[X_XFixesSetPictureClipRegion]) (client);
+
+        if (reg)
+            RegionTranslate(reg, screen->x, screen->y);
+
         if (result != Success)
             break;
     }
diff --git a/xorg-server/xkb/makefile b/xorg-server/xkb/makefile
index 71a327c8e..71a327c8e 100755..100644
--- a/xorg-server/xkb/makefile
+++ b/xorg-server/xkb/makefile
diff --git a/xorg-server/xkeyboard-config/rules/HDR b/xorg-server/xkeyboard-config/rules/HDR
index 769b8fc7f..9ee3e39d8 100644
--- a/xorg-server/xkeyboard-config/rules/HDR
+++ b/xorg-server/xkeyboard-config/rules/HDR
@@ -15,6 +15,7 @@
 ! model		layout[3]	variant[3]	=	symbols
 ! model		layout[4]	variant[4]	=	symbols
 ! model		=	symbols
+! model		layout		=	symbols
 ! layout	variant		=	compat
 ! layout[1]	variant[1]	=	compat
 ! layout[2]	variant[2]	=	compat
diff --git a/xorg-server/xkeyboard-config/rules/Makefile.am b/xorg-server/xkeyboard-config/rules/Makefile.am
index f2d73ce80..9ab91dcf3 100644
--- a/xorg-server/xkeyboard-config/rules/Makefile.am
+++ b/xorg-server/xkeyboard-config/rules/Makefile.am
@@ -23,6 +23,7 @@ endif
 if USE_COMPAT_RULES
 
 base_parts = base.hdr.part base.lists.part \
+base.lists.base.part \
 compat/base.lists.part \
 HDR base.m_k.part \
 HDR base.l1_k.part \
@@ -41,6 +42,7 @@ HDR compat/base.ml2v2_s.part  \
 HDR compat/base.ml3v3_s.part  \
 HDR compat/base.ml4v4_s.part  \
 HDR base.m_s.part \
+HDR base.ml_s1.part \
 HDR compat/base.lv_c.part   \
 HDR compat/base.l1v1_c.part \
 HDR compat/base.l2v2_c.part \
@@ -59,6 +61,7 @@ HDR base.o_c.part \
 HDR base.o_t.part
 
 evdev_parts = base.hdr.part base.lists.part \
+evdev.lists.part \
 compat/base.lists.part \
 HDR evdev.m_k.part \
 HDR base.l1_k.part \
@@ -77,6 +80,7 @@ HDR compat/base.ml2v2_s.part  \
 HDR compat/base.ml3v3_s.part  \
 HDR compat/base.ml4v4_s.part  \
 HDR evdev.m_s.part \
+HDR \
 HDR compat/base.lv_c.part   \
 HDR compat/base.l1v1_c.part \
 HDR compat/base.l2v2_c.part \
@@ -97,6 +101,7 @@ HDR base.o_t.part
 else
 
 base_parts = base.hdr.part base.lists.part \
+base.lists.base.part \
 HDR base.m_k.part \
 HDR base.l1_k.part \
 HDR base.l_k.part \
@@ -114,6 +119,7 @@ HDR \
 HDR \
 HDR \
 HDR base.m_s.part \
+HDR base.ml_s1.part \
 HDR \
 HDR \
 HDR \
@@ -132,6 +138,7 @@ HDR base.o_c.part \
 HDR base.o_t.part
 
 evdev_parts = base.hdr.part base.lists.part \
+evdev.lists.part \
 HDR evdev.m_k.part \
 HDR base.l1_k.part \
 HDR base.l_k.part  \
@@ -154,6 +161,7 @@ HDR \
 HDR \
 HDR \
 HDR \
+HDR \
 HDR base.ml_c.part \
 HDR base.ml1_c.part \
 HDR base.m_t.part \
@@ -170,6 +178,8 @@ endif
 
 all_parts_dist = HDR base.hdr.part \
 base.lists.part \
+base.lists.base.part \
+evdev.lists.part \
 base.m_k.part \
 base.l1_k.part \
 base.l_k.part \
@@ -183,6 +193,7 @@ base.ml2_s.part \
 base.ml3_s.part \
 base.ml4_s.part \
 base.m_s.part \
+base.ml_s1.part \
 base.ml_c.part \
 base.ml1_c.part \
 base.m_t.part \
diff --git a/xorg-server/xkeyboard-config/rules/base.extras.xml.in b/xorg-server/xkeyboard-config/rules/base.extras.xml.in
index c05fe0a08..aa47e3da0 100644
--- a/xorg-server/xkeyboard-config/rules/base.extras.xml.in
+++ b/xorg-server/xkeyboard-config/rules/base.extras.xml.in
@@ -685,8 +685,16 @@
         <name>se</name>
         <_shortDescription>sv</_shortDescription>
         <_description>Swedish</_description>
-	  </configItem>
-	  <variantList>
+      </configItem>
+      <variantList>
+        <variant>
+          <configItem>
+            <name>dvorak_a5</name>
+            <_description>Swedish (Dvorak A5)</_description>
+          </configItem>
+        </variant>
+      </variantList>
+      <variantList>
         <variant>
           <configItem>
             <name>sun_type6</name>
diff --git a/xorg-server/xkeyboard-config/rules/base.lists.base.part b/xorg-server/xkeyboard-config/rules/base.lists.base.part
new file mode 100644
index 000000000..1b2094894
--- /dev/null
+++ b/xorg-server/xkeyboard-config/rules/base.lists.base.part
@@ -0,0 +1,54 @@
+! $inetkbds = acer_c300 acer_ferrari4k acer_laptop \
+              airkey \
+              apple armada azonaRF2300 \
+              benqx brother \
+              btc5113rf btc9000 btc9000a btc9001ah btc5090 btc9019u \
+              cherryblue cherrybluea cherryblueb \
+              cherrycyboard cherrycmexpert \
+              chicony chicony0108 chicony0420 chicony9885 \
+              compalfl90 \
+              compaqeak8 compaqik7 compaqik13 compaqik18 \
+              creativedw7000 \
+              cymotionlinux \
+              dell dellm65 inspiron dellusbmm \
+              emachines ennyah_dkb1008 evdev \
+              genius geniuscomfy2 \
+              gyration honeywell_euroboard \
+              hp250x hp5xx hp500fa hpdv5 \
+              hpi6 hpxe3gc hpxe3gf hpxe4xxx hpxt1000 hpzt11xx htcdream \
+              ibm_spacesaver ipaq inspiron intel \
+              logiaccess logicda logicink \
+              logiex110 logiclx300 \
+              logiinkse logiinkseusb logiitc logiik \
+              logitech_base itouch logiultrax \
+              logitech_g15 \
+              logidinovo logidinovoedge \
+              microsoft4000 microsoft7000 microsoftinet microsoftprousb microsoftprooem microsoftprose \
+              microsoftoffice microsoftmult \
+              mx1998 mx2500 mx2750 \
+              oretec \
+              pc105 \
+              presario propeller \
+              qtronix \
+              rapidaccess rapidaccess2 thinkpad60 \
+              samsung4500 samsung4510 \
+              silvercrest \
+              sk1300 sk2500 sk6200 sk7100 \
+              sven sven303 symplon \
+              toshiba_s3000 trust trustda \
+              unitekkb1925 yahoo
+
+! $inetmediakbds = acer_ferrari4k acer_laptop btc5090 btc9019u cherryblueb \
+		cherrybluea herrycyboard chicony042 compaqik13 compaqik18 \
+		armada presario dellm65 inspiron dellusbmm diamond \
+		ennyah_dkb1008 genius geniuscomfy2 hpi6 hpxe3gc hpxe3gf \
+		hpxt1000 hpzt11xx hpdv5 hpxe4xxx hp5xx thinkpad60 ogitech_base \
+		logidinovo logidinovoedge logitech_g15 mx1998 mx2500 mx2750 \
+		microsoft4000 microsoft7000 microsoftprooem microsoftmult \
+		propeller samsung4500 samsung4510 sk1300 sk2500 sk7100 \
+		toshiba_s3000 trust trustda cymotionlinux silvercrest \
+		emachines benqx unitekkb1925 creativedw7000 compalfl90 \
+		pc105 a4techKB21 a4techKBS8 a4_rfkb23 asus_laptop btc6301urf \
+		dexxa dtk2000 fscaa1667g geniuskb19e geniuscomfy latitude \
+		microsoftpro precision_m scorpius sp_inet targa_v811 thinkpad \
+		tm2030USB-102 tm2030USB-106 trust_slimline
diff --git a/xorg-server/xkeyboard-config/rules/base.lists.part b/xorg-server/xkeyboard-config/rules/base.lists.part
index 97b3b907f..08c081821 100644
--- a/xorg-server/xkeyboard-config/rules/base.lists.part
+++ b/xorg-server/xkeyboard-config/rules/base.lists.part
@@ -33,45 +33,6 @@
 ! $azerty = be fr
 ! $qwertz = al cz de hr hu ro si sk 
 
-! $inetkbds = acer_c300 acer_ferrari4k acer_laptop \
-              airkey \
-              apple armada azonaRF2300 \
-              benqx brother \
-              btc5113rf btc9000 btc9000a btc9001ah btc5090 btc9019u \
-              cherryblue cherrybluea cherryblueb \
-              cherrycyboard cherrycmexpert \
-              chicony chicony0108 chicony0420 chicony9885 \
-              compalfl90 \
-              compaqeak8 compaqik7 compaqik13 compaqik18 \
-              creativedw7000 \
-              cymotionlinux \
-              dell dellm65 inspiron dellusbmm \
-              emachines ennyah_dkb1008 evdev \
-              genius geniuscomfy2 \
-              gyration honeywell_euroboard \
-              hp250x hp5xx hp500fa hpdv5 \
-              hpi6 hpxe3gc hpxe3gf hpxe4xxx hpxt1000 hpzt11xx htcdream \
-              ibm_spacesaver ipaq inspiron intel \
-              logiaccess logicda logicink \
-              logiex110 logiclx300 \
-              logiinkse logiinkseusb logiitc logiik \
-              logitech_base itouch logiultrax \
-              logitech_g15 \
-              logidinovo logidinovoedge \
-              microsoft4000 microsoft7000 microsoftinet microsoftprousb microsoftprooem microsoftprose \
-              microsoftoffice microsoftmult \
-              mx1998 mx2500 mx2750 \
-              oretec \
-              pc105 \
-              presario propeller \
-              qtronix \
-              rapidaccess rapidaccess2 thinkpad60 \
-              samsung4500 samsung4510 \
-              silvercrest \
-              sk1300 sk2500 sk6200 sk7100 \
-              sven sven303 symplon \
-              toshiba_s3000 trust trustda \
-              unitekkb1925 yahoo
 
 // all layouts with 3rd and 4th groups
 ! $threelevellayouts = al az \
@@ -95,8 +56,6 @@
               vn \
               za
 
-! $evdevkbds = ibm_spacesaver
-
 ! $thinkpads = thinkpad thinkpad60 thinkpadz60
 
 ! $sun = sun_type6_jp sun_type6_usb sun_type6_euro_usb \
@@ -117,3 +76,4 @@
 ! $sun_compat = sun_type6 sun_type6_suncompat sun_type7_suncompat suncompat
 
 ! $htcdreamlayouts = us it de
+
diff --git a/xorg-server/xkeyboard-config/rules/base.ml_s1.part b/xorg-server/xkeyboard-config/rules/base.ml_s1.part
new file mode 100644
index 000000000..1a35202da
--- /dev/null
+++ b/xorg-server/xkeyboard-config/rules/base.ml_s1.part
@@ -0,0 +1 @@
+ $inetmediakbds	jp	=	+jp(henkan)
diff --git a/xorg-server/xkeyboard-config/rules/base.o_s.part b/xorg-server/xkeyboard-config/rules/base.o_s.part
index 35b6ef3b6..a31556b55 100644
--- a/xorg-server/xkeyboard-config/rules/base.o_s.part
+++ b/xorg-server/xkeyboard-config/rules/base.o_s.part
@@ -8,6 +8,7 @@
   altwin:hyper_win	=	+altwin(hyper_win)
   altwin:alt_super_win	=	+altwin(alt_super_win)
   altwin:swap_alt_win	=	+altwin(swap_alt_win)
+  grab:debug		=	+srvr_ctrl(grab_debug)
   grp:switch		=	+group(switch)
   grp:lswitch		=	+group(lswitch)
   grp:win_switch	=	+group(win_switch)
diff --git a/xorg-server/xkeyboard-config/rules/base.xml.in b/xorg-server/xkeyboard-config/rules/base.xml.in
index 1c75531d8..42fda3fb2 100644
--- a/xorg-server/xkeyboard-config/rules/base.xml.in
+++ b/xorg-server/xkeyboard-config/rules/base.xml.in
@@ -1762,9 +1762,9 @@
     <layout>
       <configItem>
         <name>bd</name>
-        <!-- Keyboard indicator for Bengali layouts -->
+        <!-- Keyboard indicator for Bangla layouts -->
         <_shortDescription>bn</_shortDescription>
-        <_description>Bengali</_description>
+        <_description>Bangla</_description>
         <languageList>
           <iso639Id>ben</iso639Id>
         </languageList>
@@ -1773,7 +1773,7 @@
         <variant>
           <configItem>
             <name>probhat</name>
-            <_description>Bengali (Probhat)</_description>
+            <_description>Bangla (Probhat)</_description>
           </configItem>
         </variant>
       </variantList>
@@ -1789,9 +1789,9 @@
         <variant>
           <configItem>
             <name>ben</name>
-            <!-- Keyboard indicator for Bengali layouts -->
+            <!-- Keyboard indicator for Bangla layouts -->
             <_shortDescription>bn</_shortDescription>
-            <_description>Bengali (India)</_description>
+            <_description>Bangla (India)</_description>
             <languageList>
               <iso639Id>ben</iso639Id>
             </languageList>
@@ -1800,9 +1800,9 @@
         <variant>
           <configItem>
             <name>ben_probhat</name>
-            <!-- Keyboard indicator for Bengali layouts -->
+            <!-- Keyboard indicator for Bangla layouts -->
             <_shortDescription>bn</_shortDescription>
-            <_description>Bengali (India, Probhat)</_description>
+            <_description>Bangla (India, Probhat)</_description>
             <languageList>
               <iso639Id>ben</iso639Id>
             </languageList>
@@ -1811,28 +1811,28 @@
         <variant>
           <configItem>
             <name>ben_baishakhi</name>
-            <_description>Bengali (India, Baishakhi)</_description>
+            <_description>Bangla (India, Baishakhi)</_description>
             <languageList><iso639Id>ben</iso639Id></languageList>
           </configItem>
         </variant>
         <variant>
           <configItem>
             <name>ben_bornona</name>
-            <_description>Bengali (India, Bornona)</_description>
+            <_description>Bangla (India, Bornona)</_description>
             <languageList><iso639Id>ben</iso639Id></languageList>
             </configItem>
         </variant>
          <variant>
           <configItem>
             <name>ben_gitanjali</name>
-            <_description>Bengali (India, Uni Gitanjali)</_description>
+            <_description>Bangla (India, Uni Gitanjali)</_description>
             <languageList><iso639Id>ben</iso639Id></languageList>
           </configItem>
         </variant>
         <variant>
           <configItem>
             <name>ben_inscript</name>
-            <_description>Bengali (India, Baishakhi Inscript)</_description>
+            <_description>Bangla (India, Baishakhi Inscript)</_description>
             <languageList><iso639Id>ben</iso639Id></languageList>
           </configItem>
         </variant>
@@ -6033,6 +6033,24 @@
           <_description>Right Alt as Right Ctrl</_description>
         </configItem>
       </option>
+      <option>
+        <configItem>
+          <name>ctrl:swap_lalt_lctl</name>
+          <_description>Swap Left Alt key with Left Ctrl key</_description>
+        </configItem>
+      </option>
+      <option>
+        <configItem>
+          <name>ctrl:swap_lwin_lctl</name>
+          <_description>Swap Left Win key with Left Ctrl key</_description>
+        </configItem>
+      </option>
+      <option>
+        <configItem>
+          <name>ctrl:swap_lalt_lctl_lwin</name>
+          <_description>Left Alt as Ctrl, Left Ctrl as Win, Left Win as Alt</_description>
+        </configItem>
+      </option>
     </group>
     <group allowMultipleSelection="true">
       <!-- Using startard LEDs to indicate the alternative (not first) group(s) -->
@@ -6532,6 +6550,12 @@
           <_description>Allow breaking grabs with keyboard actions (warning: security risk)</_description>
         </configItem>
       </option>
+      <option>
+        <configItem>
+          <name>grab:debug_actions</name>
+          <_description>Allow grab and window tree logging</_description>
+        </configItem>
+      </option>
     </group>
     <group allowMultipleSelection="true">
       <!-- Special shortcuts for the Euro character -->
diff --git a/xorg-server/xkeyboard-config/rules/evdev.lists.part b/xorg-server/xkeyboard-config/rules/evdev.lists.part
new file mode 100644
index 000000000..7b5d0d46d
--- /dev/null
+++ b/xorg-server/xkeyboard-config/rules/evdev.lists.part
@@ -0,0 +1 @@
+! $evdevkbds = ibm_spacesaver
diff --git a/xorg-server/xkeyboard-config/symbols/af b/xorg-server/xkeyboard-config/symbols/af
index 972769b36..b93019a95 100644
--- a/xorg-server/xkeyboard-config/symbols/af
+++ b/xorg-server/xkeyboard-config/symbols/af
@@ -81,7 +81,7 @@ xkb_symbols "basic" {
 // 
 // 2006-02-15 file created by M. Emal Alekozai <memala@gmx.net>
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "ps" {
    name[Group1]= "Pashto";
 
@@ -152,7 +152,7 @@ xkb_symbols "ps" {
 // 
 // 2006-02-15 file created by M. Emal Alekozai <memala@gmx.net>
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "uz" {
    name[Group1]= "Uzbek (Afghanistan)";
 
@@ -212,7 +212,7 @@ xkb_symbols "uz" {
    include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "olpc-ps" {
 
    name[Group1]= "Pashto (Afghanistan, OLPC)";
@@ -273,7 +273,7 @@ xkb_symbols "olpc-ps" {
    include "group(olpc)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "fa-olpc" {
 
    name[Group1]= "Persian (Afghanistan, Dari OLPC)";
@@ -334,7 +334,7 @@ xkb_symbols "fa-olpc" {
    include "group(olpc)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "uz-olpc" {
 
    name[Group1]= "Uzbek (Afghanistan, OLPC)";
diff --git a/xorg-server/xkeyboard-config/symbols/altwin b/xorg-server/xkeyboard-config/symbols/altwin
index 333b7dacd..239d4878c 100644
--- a/xorg-server/xkeyboard-config/symbols/altwin
+++ b/xorg-server/xkeyboard-config/symbols/altwin
@@ -1,5 +1,5 @@
 // Meta is mapped to second level of Alt keys.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "meta_alt" {
     key <LALT> { [ Alt_L, Meta_L ] };
     key <RALT> { type[Group1] = "TWO_LEVEL",
@@ -9,7 +9,7 @@ xkb_symbols "meta_alt" {
 };
 
 // Alt is mapped to the Win keys (and the usual Alt keys).
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "alt_win" {
     key <LWIN> { [ Alt_L ] };
     key <RWIN> { [ Alt_R ] };
@@ -17,7 +17,7 @@ xkb_symbols "alt_win" {
 };
 
 // Ctrl is mapped to the Win keys (and the usual Ctrl keys).
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_win" {
     key <LWIN> { [ Control_L ] };
     key <RWIN> { [ Control_R ] };
@@ -25,19 +25,22 @@ xkb_symbols "ctrl_win" {
 };
 
 // Ctrl is mapped to the Alt keys, Alt to the Win keys, and Win to the Ctrl keys.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_alt_win" {
     key <LALT> { [ Control_L, Control_L  ] };
     key <RALT> { type[Group1] = "TWO_LEVEL",
                  symbols[Group1] = [ Control_R, Control_R ] };
     key <LWIN> { [ Alt_L, Meta_L ] };
     key <RWIN> { [ Alt_R, Meta_R ] };
+    key <LCTL> { [ Super_L ] };
+    key <RCTL> { [ Super_R ] };
     modifier_map Control { <RALT>, <LALT> };
     modifier_map Mod1 { <LWIN>, <RWIN> };
+    modifier_map Mod4 { <LCTL>, <RCTL> };
 };
 
 // Meta is mapped to the Win keys.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "meta_win" {
     key <LALT> { [ Alt_L, Alt_L ] };
     key <RALT> { type[Group1] = "TWO_LEVEL",
@@ -49,7 +52,7 @@ xkb_symbols "meta_win" {
 };
 
 // Meta is mapped to the left Win key.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "left_meta_win" {
     key <LALT> { [ Alt_L, Alt_L ] };
     key <LWIN> { [ Meta_L ] };
@@ -58,7 +61,7 @@ xkb_symbols "left_meta_win" {
 };
 
 // Hyper is mapped to the Win keys.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "hyper_win" {
     key <LWIN> { [ Hyper_L ] };
     key <RWIN> { [ Hyper_R ] };
@@ -66,13 +69,13 @@ xkb_symbols "hyper_win" {
 };
 
 // Menu is mapped to the Menu key.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "menu" {
     key <MENU> { [ Menu ] };
 };
 
 // Layout for Tux key caps with additional right Alt key
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "alt_super_win" {
     key <LALT> { [ Alt_L, Meta_L ] };
     key <RWIN> { [ Alt_R, Meta_R ] };
@@ -83,14 +86,14 @@ xkb_symbols "alt_super_win" {
 };
 
 // Swap the Alt and Win keys.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "swap_alt_win" {
     include "altwin(swap_lalt_lwin)"
     include "altwin(swap_ralt_rwin)"
 };
 
 // Swap the left Alt and Win keys.
-partial hidden modifier_keys 
+partial hidden modifier_keys
 xkb_symbols "swap_lalt_lwin" {
     key <LALT> { type[Group1] = "ONE_LEVEL",
                  symbols[Group1] = [ Super_L ] };
@@ -98,7 +101,7 @@ xkb_symbols "swap_lalt_lwin" {
 };
 
 // Swap the right Alt and Win keys.
-partial hidden modifier_keys 
+partial hidden modifier_keys
 xkb_symbols "swap_ralt_rwin" {
     key <RALT> { type[Group1] = "ONE_LEVEL",
                  symbols[Group1] = [ Super_R ] };
diff --git a/xorg-server/xkeyboard-config/symbols/am b/xorg-server/xkeyboard-config/symbols/am
index b7cc6f69e..dbe6e96d8 100644
--- a/xorg-server/xkeyboard-config/symbols/am
+++ b/xorg-server/xkeyboard-config/symbols/am
@@ -71,9 +71,9 @@ xkb_symbols "olpc" {
 xkb_symbols "phonetic" {
     include "am(basic)"
     name[Group1]= "Armenian (phonetic)";
-	
+
     key <BKSL> {	[ 0x1000577,  0x1000547 ]	};
-	
+
     key <AE01> {	[ 0x1000567,  0x1000537 ]	};
     key <AE02> {	[ 0x1000569,  0x1000539 ]	};
     key <AE03> {	[ 0x1000583,  0x1000553 ]	};
diff --git a/xorg-server/xkeyboard-config/symbols/apl b/xorg-server/xkeyboard-config/symbols/apl
index 4262d2480..0800b5bbd 100644
--- a/xorg-server/xkeyboard-config/symbols/apl
+++ b/xorg-server/xkeyboard-config/symbols/apl
@@ -5,7 +5,7 @@
 // This file supports:
 // -	The Sharp APL for Unix (SAX) layout
 // -	The IBM APL2 layout
-// -	The Manugistics APL*PLUS II (Version 5.1, 1993) keyboard layout
+// -	The Manugistics APL*PLUS II layout (version 5.1, 1993)
 // -	The Dyalog APL layout - with additions for box drawing and commands
 
 // Unicode APL table: http://aplwiki.com/UnicodeAplTable
@@ -16,27 +16,27 @@
 
 // This file doesn't deal with all the combining stuff -- I'm not an APL programmer,
 // and am not quite sure what's needed here.  However, it may be possible to get this
-// working with dead keys and the like.  Patches gratefully accepted.  
+// working with dead keys and the like.  Patches gratefully accepted.
 
 // Some of the shift-key assignments may differ from the APL tradition.  If
-// that's not considered acceptable, it should be possible to remap the 
+// that's not considered acceptable, it should be possible to remap the
 // shift keys.  I have striven, however, to ensure that the use of shift keys
-// in these maps is at least self-consistent.  
+// in these maps is at least self-consistent.
 
-// I'm assuming that this will be used with another keyboard layout (ie. for 
-// your language), with a special shift key to use these maps.  
+// I'm assuming that this will be used with another keyboard layout (i.e. for
+// your language), with a special shift key to use these maps.
 
-// 2011-12-22 Geoff Streeter: geoff@dyalog.com
-// Added the Dyalog support.
-// Corrected (what he thinks) are some errors.
-// 	Resolving the confusion between APL's and Unicode's concept of Left and Right tacks.
-// 	Unsure about some of the inheritance from APL2 into APLPLUS. Patches welcome.
-// Complied with freedesktop.org requirement that the keycodes be in sorted order. Which
-// leads to the bottom to top (roughly) definitions.
+// 2011-12-22 Geoff Streeter <geoff@dyalog.com>,
+// added the Dyalog support;
+// corrected (what he thinks) are some errors:
+//   resolving the confusion between APL's and Unicode's concept of Left and Right tacks;
+//   unsure about some of the inheritance from APL2 into APLPLUS -- patches welcome;
+// complied with freedesktop.org requirement that the keycodes be in sorted order,
+// which leads to the bottom to top (roughly) definitions.
 
-// default layout seems to have to be the first one. Choosing the basic Dyalog layout is definitely
-// better than using the "common" one. Choosing the complete Dyalog layout is not useful to non-Dyalog
-// users.
+// The default layout still has to be the first one. Choosing the basic Dyalog layout is
+// definitely better than using the "common" one. Choosing the complete Dyalog layout is
+// not useful to non-Dyalog users.
 
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
@@ -235,7 +235,7 @@ xkb_symbols "apl2" {
 	key <AB10> { [	slash,		backslash,	U233F	] }; // /: ⌿ -- AFS Slash Bar
 
 	key <AC10> { [	bracketleft, 	parenleft,	U234E	] }; // ;: ⍎ -- [See B key in SAX layout]
-	key <AC11> { [	bracketright, 	parenright, 	U2355	] }; // ': ⍕ -- [See N key in SAX layout] 
+	key <AC11> { [	bracketright, 	parenright, 	U2355	] }; // ': ⍕ -- [See N key in SAX layout]
 
 	key <AD11> { [	NoSymbol,	U2192,		U235E	] }; // [: (←) → ⍞ -- Rightwards Arrow / AFS Quote Quad
 	key <AD12> { [	U2337,		U2378,		U2359	] }; // ]: ⌷ ⍸ ⍙ -- AFS Squish Quad / AFS Iota Underbar / AFS Delta Underbar
@@ -255,7 +255,7 @@ xkb_symbols "apl2" {
 
 	key <BKSL> { [	U2261,		U2377,		U2364	] }; // \: ≡ ⍷ ⍤ -- Identical To / AFS Epsilon Underbar / AFS Jot Diaeresis
 
-	key <TLDE> { [	NoSymbol,	U233B,		U2342	] }; // `: ⌻ ⍂ -- 
+	key <TLDE> { [	NoSymbol,	U233B,		U2342	] }; // `: ⌻ ⍂ --
 
 	include "level3(ralt_switch)"
 };
@@ -289,7 +289,7 @@ xkb_symbols "aplplusII" {
 	name[Group1]= "APL keyboard symbols (Manugistics APL*PLUS II)";
 
 	key <AC10> { [	bracketleft,	parenleft,	U234E	] }; // ;: ⍎ -- [See B key in SAX layout]
-	key <AC11> { [	bracketright,	parenright,	U2355	] }; // ': ⍕ -- [See N key in SAX layout] 
+	key <AC11> { [	bracketright,	parenright,	U2355	] }; // ': ⍕ -- [See N key in SAX layout]
 	key <AD11> { [	U2190,		NoSymbol,	U235E	] }; // [: ← ⍞ -- Leftwards Arrow / AFS Quote Quad
 	key <AD12> { [	U2192,		NoSymbol,	U236C	] }; // ]: → ⍬ -- Rightwards Arrow / AFS Zilde
 	key <AE01> { [	NoSymbol, 	NoSymbol, 	U2261	] }; // 1: ≡ -- Identical To
@@ -350,22 +350,20 @@ xkb_symbols "aplx" {
 };
 
 // APL language support for the Dyalog keyboard.
-// Dyalog Ltd sell this keyboard with APL engravings. The current model is 
-// engraved on a Cherry G80. Base languages for US, UK and DK are availible.
+// Dyalog Ltd sells this keyboard with APL engravings. The current model is
+// engraved on a Cherry G80. Base languages for US, UK and DK are available.
 
-// Geoff Streeter, Dyalog Ltd. 2007-09-03
-// geoff@dyalog.com
+// Geoff Streeter, Dyalog Ltd. 2007-09-03  <geoff@dyalog.com>
 // extended for APL special actions 2008-09-09
-// add variant 2010-11-26
+// added a variant 2010-11-26
 
-// The intention is that this keyboard layout overlays a base keyboard that provides 
+// The intention is that this keyboard layout overlays a base keyboard that provides
 // the alphabet and similar. If this keyboard is placed as the 2nd layout then it can
 // be reached with a latching shift to increase group by one.
 
 partial hidden alphanumeric_keys
 xkb_symbols "dyalog_base" {
 
-
 // ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓
 // │     │ ⌶   │ ⍫   │ ⍒   │ ⍋   │ ⌽   │ ⍉   │ ⊖   │ ⍟   │ ⍱   │ ⍲   │ !   │ ⌹   ┃         ┃
 // │ ⋄   │ ¨   │ ¯   │ <   │ ≤   │ =   │ ≥   │ >   │ ≠   │ ∨   │ ∧   │ ×   │ ÷   ┃         ┃
@@ -383,7 +381,6 @@ xkb_symbols "dyalog_base" {
 // ┃       ┃       ┃       ┃                                   ┃       ┃       ┃       ┃
 // ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛
 
-
 	key <AB01> { [ U2282			] };	// subset of
 	key <AB02> { [ U2283			] };	// superset of
 	key <AB03> { [ U2229			] };	// intersection
@@ -460,14 +457,14 @@ xkb_symbols "dyalog_box" {
 	key <KP9>  { [ U2510 ] };	// box drawing light down and left
 	key <KPDL> { [ U2502 ] };	// box drawing light vertical
 
-}; 
+};
 
 partial hidden
 xkb_symbols "dyalog_codes" {
 
 //	Layout of private use area for this. In the style of the Unicode book
 //
-//				APL special actions		F800-F88F
+//		APL special actions		F800-F88F
 //
 //	│F800 F810 F820 F830 F840 F850 F860 F870 F880
 //	├────┬────┬────┬────┬────┬────┬────┬────┬────┐
@@ -504,7 +501,7 @@ xkb_symbols "dyalog_codes" {
 //     F│RL  │FD  │HK  │Lc  │BH  │PU  │    │    │OS  │
 //	└────┴────┴────┴────┴────┴────┴────┴────┴────┘
 //
-//				APL Function Keys		F700-F7FF
+//		APL Function Keys		F700-F7FF
 //
 //	│F700 ...                           ...  F7F0
 //	├────┬────┬────┬────┬....┬────┬────┬────┬────┐
@@ -514,9 +511,9 @@ xkb_symbols "dyalog_codes" {
 //	.
 //     F│F15 │F31 │F47 │F63 │    │F207│F223│F239│F255│
 //	└────┴────┴────┴────┴....┴────┴────┴────┴────┘
-//	
+//
 //	whilst these locations are defined. Dyalog's "aplkeys/xterm" file copes with
-//	normal function keys from the base keyboard rather than this overlay
+//	normal function keys from the base keyboard rather than this overlay.
 
 // ┌─────┐                                                                       ┌───┐
 // │     │                                                                       │ZM │
@@ -540,7 +537,6 @@ xkb_symbols "dyalog_codes" {
 // ┃       ┃       ┃       ┃              TO                   ┃       ┃       ┃       ┃
 // ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛
 
-
 	key <BKSP> { [ Uf850,	Uf855	] };	// BP CB
 	key <ESC>  { [ Uf800		] };	// QT
 	key <FK11> { [ Uf821,	Uf821	] };	// ZM, ZM put this on both, the unshifted one sometimes gets lost
@@ -561,7 +557,6 @@ xkb_symbols "dyalog_codes" {
 	key <RGHT> { [ Uf824,	Uf854	] };	// NX, RM
 	key <UP>   { [ Uf820		] };	// BK
 
-
 // ┌───┬───┬───┐
 // │PT │LL │UL │
 // │CP │LS │US │
@@ -589,7 +584,6 @@ xkb_symbols "dyalog_codes" {
 // │       │   │   │
 // └───────┴───┴───┘
 
-
 	key <KPAD> { [ Uf859 ] };	// TL
 	key <KPDV> { [ Uf819 ] };	// RD
 	key <KPMU> { [ Uf81a ] };	// TG
@@ -602,4 +596,3 @@ xkb_symbols "dyalog" {
 	include "apl(dyalog_codes)"
 	name[Group1] = "APL keyboard symbols (Dyalog)";
 };
-
diff --git a/xorg-server/xkeyboard-config/symbols/ara b/xorg-server/xkeyboard-config/symbols/ara
index 71b50daa5..e677aaab1 100644
--- a/xorg-server/xkeyboard-config/symbols/ara
+++ b/xorg-server/xkeyboard-config/symbols/ara
@@ -1,17 +1,14 @@
-// based on a keyboard map from an 'xkb/symbols/ar' file
-
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
     name[Group1]= "Arabic";
 
 // NOTES:
 //
-// there is also combined shadda diacritis in AltGr position of simple
-// diacritics fatha, fathatan, damma, dammatan, kasra and kasratan
-// should a third state be added to Group2 ?
-//
+// There is also a combined shadda diacritic in the AltGr position of the
+// simple diacritics fatha, fathatan, damma, dammatan, kasra and kasratan. (??)
+// Should a third state be added to Group2?
 
-    key <TLDE> {  [     Arabic_thal,      Arabic_shadda   ]	};
+    key <TLDE> {  [     Arabic_thal,   Arabic_shadda      ]     };
     key <AE01> {  [               1,          exclam      ]     };
     key <AE02> {  [               2,              at      ]     };
     key <AE03> {  [               3,      numbersign      ]     };
@@ -24,42 +21,42 @@ xkb_symbols "basic" {
     key <AE10> {  [               0,       parenleft      ]     };
     key <AE11> {  [           minus,      underscore      ]     };
     key <AE12> {  [           equal,            plus      ]     };
-						
+
     key <AD01> {  [      Arabic_dad,     Arabic_fatha     ]     };
-    key <AD02> {  [      Arabic_sad,     Arabic_fathatan  ]     };
+    key <AD02> {  [      Arabic_sad,  Arabic_fathatan     ]     };
     key <AD03> {  [     Arabic_theh,     Arabic_damma     ]     };
-    key <AD04> {  [      Arabic_qaf,     Arabic_dammatan  ]     };
-    key <AD05> {  [   Arabic_feh,  0x100fef9, 0x10006a4   ]     };
-    key <AD06> {  [   Arabic_ghain, Arabic_hamzaunderalef ]     };
-    key <AD07> {  [      Arabic_ain,         grave        ]     };
-    key <AD08> {  [       Arabic_ha,        division      ]     };
-    key <AD09> {  [     Arabic_khah,       multiply       ]     };
-    key <AD10> {  [      Arabic_hah,    Arabic_semicolon  ]     };
-    key <AD11> {  [     Arabic_jeem,   less, 0x1000686    ]     };
-    key <AD12> {  [      Arabic_dal,        greater       ]     };
-
-    key <AC01> {  [    Arabic_sheen,   Arabic_kasra       ]     };
-    key <AC02> {  [     Arabic_seen,   Arabic_kasratan    ]     };
-    key <AC03> {  [      Arabic_yeh,       bracketright   ]     };
-    key <AC04> {  [   Arabic_beh, bracketleft, 0x100067e  ]     };
-    key <AC05> {  [      Arabic_lam,       0x100fef7      ]     };
-    key <AC06> {  [     Arabic_alef,   Arabic_hamzaonalef ]     };
-    key <AC07> {  [      Arabic_teh,      Arabic_tatweel  ]     };
-    key <AC08> {  [     Arabic_noon,      Arabic_comma    ]     };
-    key <AC09> {  [     Arabic_meem,         slash        ]     };
-    key <AC10> {  [      Arabic_kaf,   colon, 0x10006af   ]     };
-    key <AC11> {  [      Arabic_tah,        quotedbl      ]     };
-
-    key <LSGT> {  [             bar,      brokenbar	  ]     };
-    key <AB01> {  [Arabic_hamzaonyeh, asciitilde, guillemotright  ]     };
-    key <AB02> {  [    Arabic_hamza,  Arabic_sukun, guillemotleft ]     };
+    key <AD04> {  [      Arabic_qaf,  Arabic_dammatan     ]     };
+    key <AD05> {  [      Arabic_feh,        0x100fef9,      0x10006a4   ]     };
+    key <AD06> {  [    Arabic_ghain, Arabic_hamzaunderalef]     };
+    key <AD07> {  [      Arabic_ain,            grave     ]     };
+    key <AD08> {  [       Arabic_ha,         division     ]     };
+    key <AD09> {  [     Arabic_khah,         multiply     ]     };
+    key <AD10> {  [      Arabic_hah, Arabic_semicolon     ]     };
+    key <AD11> {  [     Arabic_jeem,             less,      0x1000686   ]     };
+    key <AD12> {  [      Arabic_dal,          greater     ]     };
+
+    key <AC01> {  [    Arabic_sheen,     Arabic_kasra     ]     };
+    key <AC02> {  [     Arabic_seen,  Arabic_kasratan     ]     };
+    key <AC03> {  [      Arabic_yeh,     bracketright     ]     };
+    key <AC04> {  [      Arabic_beh,      bracketleft,      0x100067e   ]     };
+    key <AC05> {  [      Arabic_lam,        0x100fef7     ]     };
+    key <AC06> {  [     Arabic_alef, Arabic_hamzaonalef   ]     };
+    key <AC07> {  [      Arabic_teh,   Arabic_tatweel     ]     };
+    key <AC08> {  [     Arabic_noon,     Arabic_comma     ]     };
+    key <AC09> {  [     Arabic_meem,            slash     ]     };
+    key <AC10> {  [      Arabic_kaf,            colon,      0x10006af   ]     };
+    key <AC11> {  [      Arabic_tah,         quotedbl     ]     };
+
+    key <LSGT> {  [             bar,        brokenbar     ]     };
+    key <AB01> {  [Arabic_hamzaonyeh,      asciitilde,      guillemotright ]};
+    key <AB02> {  [    Arabic_hamza,     Arabic_sukun,      guillemotleft ]};
     key <AB03> {  [Arabic_hamzaonwaw,      braceright     ]     };
-    key <AB04> {  [       Arabic_ra,       braceleft      ]     };
-    key <AB05> {  [       0x100fefb,       0x100fef5      ]     };
+    key <AB04> {  [       Arabic_ra,        braceleft     ]     };
+    key <AB05> {  [       0x100fefb,        0x100fef5     ]     };
     key <AB06> {  [Arabic_alefmaksura, Arabic_maddaonalef ]     };
-    key <AB07> {  [Arabic_tehmarbuta,    apostrophe       ]     };
-    key <AB08> {  [      Arabic_waw,         comma        ]     };
-    key <AB09> {  [     Arabic_zain,         period       ]     };
+    key <AB07> {  [Arabic_tehmarbuta,      apostrophe     ]     };
+    key <AB08> {  [      Arabic_waw,            comma     ]     };
+    key <AB09> {  [     Arabic_zain,           period     ]     };
     key <AB10> {  [      Arabic_zah, Arabic_question_mark ]     };
 };
 
@@ -74,15 +71,15 @@ xkb_symbols "azerty" {
     include "ara(basic)"
     name[Group1]= "Arabic (azerty)";
 
-	// the north african arabic keyboard differs from the middle east one
-	// by the numeric row; it follows French keyboard style
+	// The North African Arabic keyboard differs from the Middle East one
+	// by the numeric row; it follows French keyboard style.
 	//
-	// PROBLEM: some chars are inaccessible: ! @ # $ % ^ *
-	// should they go elsewhere? replace " ' that are now in double ?
-	// also, dead_circumflex and dead_diaeresis from French keyboard
+	// PROBLEM: some characters are inaccessible: ! @ # $ % ^ *
+	// Should they go elsewhere?  Replacing " ' that are now doubled?
+	// Also, dead_circumflex and dead_diaeresis from French keyboard
 	// as well as ugrave are missing, which questions the utility of the
-	// other accentuated latin letters. Maybe this is useful only with
-	// a French keyboard in Group1 ? Then, shouldn't Group1 be filled ?
+	// other accentuated Latin letters. Maybe this is useful only with
+	// a French keyboard in Group1? Then, shouldn't Group1 be filled?
 
     key <AE01> {  [       ampersand,               1      ]       };
     key <AE02> {  [          eacute,               2      ]       };
@@ -101,21 +98,21 @@ partial alphanumeric_keys
 xkb_symbols "digits_KP" {
     name[Group1]= "Arabic (digits_KP)";
 
-       // use arabic script digits on KP
+    // Use Arabic-script digits on the keypad.
 
-    key <KP7>  {  [   KP_Home,       0x1000667 ] }; //
-    key <KP8>  {  [     KP_Up,       0x1000668 ] }; //
-    key <KP9>  {  [  KP_Prior,       0x1000669 ] }; //
+    key <KP7>  {  [   KP_Home,       0x1000667 ] };
+    key <KP8>  {  [     KP_Up,       0x1000668 ] };
+    key <KP9>  {  [  KP_Prior,       0x1000669 ] };
 
-    key <KP4>  {  [   KP_Left,       0x1000664 ] }; //
-    key <KP5>  {  [  KP_Begin,       0x1000665 ] }; //
-    key <KP6>  {  [  KP_Right,       0x1000666 ] }; //
+    key <KP4>  {  [   KP_Left,       0x1000664 ] };
+    key <KP5>  {  [  KP_Begin,       0x1000665 ] };
+    key <KP6>  {  [  KP_Right,       0x1000666 ] };
 
-    key <KP1>  {  [    KP_End,       0x1000661 ] }; //
-    key <KP2>  {  [   KP_Down,       0x1000662 ] }; //
-    key <KP3>  {  [   KP_Next,       0x1000663 ] }; //
+    key <KP1>  {  [    KP_End,       0x1000661 ] };
+    key <KP2>  {  [   KP_Down,       0x1000662 ] };
+    key <KP3>  {  [   KP_Next,       0x1000663 ] };
 
-    key <KP0>  {  [ KP_Insert,       0x1000660 ] }; //
+    key <KP0>  {  [ KP_Insert,       0x1000660 ] };
 };
 
 partial alphanumeric_keys
@@ -123,7 +120,7 @@ xkb_symbols "digits" {
     include "ara(basic)"
     name[Group1]= "Arabic (digits)";
 
-	// use arabic script digits
+    // Use Arabic-script digits on the numberic row.
 
     key <AE01> {  [       0x1000661,          exclam      ]       };
     key <AE02> {  [       0x1000662,              at      ]       };
@@ -149,7 +146,7 @@ partial alphanumeric_keys
 xkb_symbols "azerty_digits" {
     include "ara(azerty)"
     name[Group1]= "Arabic (azerty/digits)";
-	
+
     key <AE01> {  [       ampersand,       0x1000661      ]       };
     key <AE02> {  [          eacute,       0x1000662      ]       };
     key <AE03> {  [        quotedbl,       0x1000663      ]       };
@@ -166,9 +163,7 @@ xkb_symbols "azerty_digits" {
 // http://www.qamus.org/transliteration.htm
 // Martin Vidner
 
-// symbol names: see /usr/X11R6/include/X11/keysymdef.h (XFree86-devel.rpm)
-
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "buckwalter" {
     name[Group1]= "Arabic (Buckwalter)";
 
@@ -191,7 +186,7 @@ xkb_symbols "buckwalter" {
     key <AE10> {  [       0x1000660,   0x100fd3f          ]       };
     key <AE11> {  [       minus,       Arabic_tatweel     ]       };
     key <AE12> {  [       equal,       plus               ]       };
-						
+
     key <AD01> {  [      Arabic_qaf,   VoidSymbol         ]       };
     key <AD02> {  [      Arabic_waw,   Arabic_hamzaonwaw  ]       };
     key <AD03> {  [      VoidSymbol,   Arabic_ain         ]       };
@@ -218,9 +213,7 @@ xkb_symbols "buckwalter" {
     key <AC10> {  [    Arabic_semicolon, VoidSymbol       ]       };
     key <AC11> {  [    Arabic_hamza,   VoidSymbol         ]       };
 
-    key <BKSL> {  [      VoidSymbol,   Arabic_maddaonalef ]     };
-
-//    key <LSGT> {  [             bar,      brokenbar	  ]     };
+    key <BKSL> {  [    VoidSymbol,     Arabic_maddaonalef ]       };
 
     key <AB01> {  [    Arabic_zain,    Arabic_zah         ]       };
     key <AB02> {  [    Arabic_khah,    VoidSymbol         ]       };
@@ -285,7 +278,7 @@ xkb_symbols "olpc" {
 
     // REH isolated form?
     key <AB03> {  [ Arabic_hamzaonwaw,   Arabic_kasra ] };
-    key <AB04> {  [       Arabic_ra,  Arabic_kasratan ] };    
+    key <AB04> {  [       Arabic_ra,  Arabic_kasratan ] };
     key <AB05> {  [     Arabic_thal,      asciicircum ] };
 
     include "group(olpc)"
diff --git a/xorg-server/xkeyboard-config/symbols/at b/xorg-server/xkeyboard-config/symbols/at
index bd4ba988d..c78140f05 100644
--- a/xorg-server/xkeyboard-config/symbols/at
+++ b/xorg-server/xkeyboard-config/symbols/at
@@ -16,7 +16,7 @@ xkb_symbols "nodeadkeys" {
     name[Group1]="German (Austria, eliminate dead keys)";
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     include "de(mac)"
diff --git a/xorg-server/xkeyboard-config/symbols/ba b/xorg-server/xkeyboard-config/symbols/ba
index 9a27cbd96..0cc4988d4 100644
--- a/xorg-server/xkeyboard-config/symbols/ba
+++ b/xorg-server/xkeyboard-config/symbols/ba
@@ -6,7 +6,7 @@ xkb_symbols "basic" {
     include "rs(latin)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "us" {
 
     name[Group1]= "Bosnian (US keyboard with Bosnian letters)";
@@ -15,7 +15,7 @@ xkb_symbols "us" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "alternatequotes" {
 
     name[Group1]= "Bosnian (use guillemets for quotes)";
@@ -23,7 +23,7 @@ xkb_symbols "alternatequotes" {
     include "rs(latinalternatequotes)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "unicode" {
 
     name[Group1]= "Bosnian (use Bosnian digraphs)";
@@ -31,7 +31,7 @@ xkb_symbols "unicode" {
     include "rs(latinunicode)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "unicodeus" {
 
     name[Group1]= "Bosnian (US keyboard with Bosnian digraphs)";
diff --git a/xorg-server/xkeyboard-config/symbols/bd b/xorg-server/xkeyboard-config/symbols/bd
index 6a70d51a7..0fe144e8b 100644
--- a/xorg-server/xkeyboard-config/symbols/bd
+++ b/xorg-server/xkeyboard-config/symbols/bd
@@ -16,7 +16,7 @@
 
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
-   name[Group1]= "Bengali";
+   name[Group1]= "Bangla";
    key <ESC>  { [ Escape ] };
 
 // numbers
@@ -92,5 +92,5 @@ xkb_symbols "basic" {
 
 xkb_symbols "probhat" {
     include "in(ben_probhat)"
-    name[Group1]= "Bengali (Probhat)";
+    name[Group1]= "Bangla (Probhat)";
 };
diff --git a/xorg-server/xkeyboard-config/symbols/bg b/xorg-server/xkeyboard-config/symbols/bg
index 994380c80..f44b5c60d 100644
--- a/xorg-server/xkeyboard-config/symbols/bg
+++ b/xorg-server/xkeyboard-config/symbols/bg
@@ -5,12 +5,12 @@
 // both in source and binary form provided that the above copyright
 // notice and these terms are retained. The name of the author may not
 // be used to endorse or promote products derived from this software
-// without prior permission.  THIS SOFTWARE IS PROVIDES "AS IS" AND
+// without prior permission.  THIS SOFTWARE IS PROVIDED "AS IS" AND
 // ANY EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED.  IN NO EVENT
 // SHALL THE AUTHOR BE LIABLE FOR ANY DAMAGES ARISING IN ANY WAY OUT
 // OF THE USE OF THIS SOFTWARE.
 //
-////////////////////////////////////////////////////////////////////////// 
+//////////////////////////////////////////////////////////////////////////
 // Version 2.0
 
 // The following variants are defined in this file:
@@ -18,14 +18,14 @@
 // "bds" - the BDS keyboard layout compliant with the proposed
 //         Bulgarian state standard BDS 5237:2006
 
-// "phonetic" - Bulgarian phonetic layout with traditional position of
-//              the letters.
+// "phonetic" - the phonetic Bulgarian layout with the traditional position
+//              of the letters
 
 // "bas_phonetic" - the phonetic keyboard layout compliant with the
 //                  proposed Bulgarian state standard BDS 5237:2006
 
-// "latin" - an extended variant of the QWERTY layout with symbols
-//           Bulgarian users will type while the keyboard is in Latin mode.
+// "latin" - an extended variant of the QWERTY layout with symbols that
+//           Bulgarian users will type while the keyboard is in Latin mode
 
 // The reasons behind the layout of the symbols in levels 3 and 4 are
 // explained in http://arxiv.org/abs/0905.0484  (in Bulgarian).
@@ -39,7 +39,7 @@
 
 // 2. The layouts should not include level3(ralt_switch).
 
-////////////////////////////////////////////////////////////////////////// 
+//////////////////////////////////////////////////////////////////////////
 
 // Describes Bulgarian keyboard "BDS" modified according to the
 // the new state standard BDS 5237:2006 and extended with symbols in
@@ -48,314 +48,204 @@ default  partial alphanumeric_keys
 xkb_symbols "bds" {
 
   name[Group1]= "Bulgarian";
-  
-  key <TLDE> {   [ parenleft,         parenright,
-		   bracketleft,       bracketright        ]    };
-  key <AE01> {   [ 1,                 exclam              ]    };
-  key <AE02> {   [ 2,                 question            ]    };
-  key <AE03> {   [ 3,                 plus,
-		   dagger,            dagger              ]    };
-  key <AE04> {   [ 4,                 quotedbl            ]    };
-  key <AE05> {   [ 5,                 percent,
-		   U2329,             U232A               ]    };
-  key <AE06> {   [ 6,                 equal,
-		   emdash,            emdash              ]    };
-  key <AE07> {   [ 7,                 colon,
-		   ellipsis,          ellipsis            ]    };
-  key <AE08> {   [ 8,                 slash,
-		   U0300,             U0301               ]    };
-  key <AE09> {   [ 9,                 endash              ]    };
-  key <AE10> {   [ 0,                 numerosign          ]    };
-  key <AE11> {   [ minus,             dollar,
-		   U2011,             EuroSign            ]    };
-  key <AE12> {   [ period,            EuroSign            ]    };
-
-
-  key <AD01> {   [ comma,             Cyrillic_yeru,
-		   rightsinglequotemark, leftsinglequotemark ] };
-  key <AD02> {   [ Cyrillic_u,        Cyrillic_U          ]    };
-  key <AD03> {   [ Cyrillic_ie,       Cyrillic_IE,
-		   Cyrillic_e,        Cyrillic_E          ]    };
-  key <AD04> {   [ Cyrillic_i,        Cyrillic_I,
-		   U045D,             U040D               ]    };
-  key <AD05> {   [ Cyrillic_sha,      Cyrillic_SHA        ]    };
-  key <AD06> {   [ Cyrillic_shcha,    Cyrillic_SHCHA      ]    };
-  key <AD07> {   [ Cyrillic_ka,       Cyrillic_KA,
-		   copyright,         copyright           ]    };
-  key <AD08> {   [ Cyrillic_es,       Cyrillic_ES,
-		   copyright,         copyright           ]    };
-  key <AD09> {   [ Cyrillic_de,       Cyrillic_DE         ]    };
-  key <AD10> {   [ Cyrillic_ze,       Cyrillic_ZE         ]    };
-  key <AD11> {   [ Cyrillic_tse,      Cyrillic_TSE        ]    };
-  key <AD12> {   [ semicolon,         section             ]    };
-
-
-  key <AC01> {   [ Cyrillic_softsign, U045D,
-		   Cyrillic_yeru,     Cyrillic_YERU       ]    };
-  key <AC02> {   [ Cyrillic_ya,       Cyrillic_YA,
-		   U0463,             U0462               ]    };
-  key <AC03> {   [ Cyrillic_a,        Cyrillic_A          ]    };
-  key <AC04> {   [ Cyrillic_o,        Cyrillic_O          ]    };
-  key <AC05> {   [ Cyrillic_zhe,      Cyrillic_ZHE        ]    };
-  key <AC06> {   [ Cyrillic_ghe,      Cyrillic_GHE        ]    };
-  key <AC07> {   [ Cyrillic_te,       Cyrillic_TE,
-		   trademark,         trademark           ]    };
-  key <AC08> {   [ Cyrillic_en,       Cyrillic_EN         ]    };
-  key <AC09> {   [ Cyrillic_ve,       Cyrillic_VE         ]    };
-  key <AC10> {   [ Cyrillic_em,       Cyrillic_EM         ]    };
-  key <AC11> {   [ Cyrillic_che,      Cyrillic_CHE        ]    };
-  key <BKSL> {   [ doublelowquotemark, leftdoublequotemark,
-		   guillemotleft,     guillemotright      ]    };
-
-
-  key <LSGT> {   [ U045D,             U040D               ]    };
-  key <AB01> {   [ Cyrillic_yu,       Cyrillic_YU         ]    };
-  key <AB02> {   [ Cyrillic_shorti,   Cyrillic_SHORTI,
-		   U046D,             U046C               ]    };
-  key <AB03> {   [ Cyrillic_hardsign, Cyrillic_HARDSIGN,
-		   U046B,             U046A               ]    };
-  key <AB04> {   [ Cyrillic_e,        Cyrillic_E          ]    };
-  key <AB05> {   [ Cyrillic_ef,       Cyrillic_EF         ]    };
-  key <AB06> {   [ Cyrillic_ha,       Cyrillic_HA         ]    };
-  key <AB07> {   [ Cyrillic_pe,       Cyrillic_PE         ]    };
-  key <AB08> {   [ Cyrillic_er,       Cyrillic_ER,
-		   registered,        registered          ]    };
-  key <AB09> {   [ Cyrillic_el,       Cyrillic_EL         ]    };
-  key <AB10> {   [ Cyrillic_be,       Cyrillic_BE         ]    };
-
-
-  key <SPCE> {   [ space,             space,
-		   nobreakspace,      nobreakspace        ]    };
-    
-
-  key <KPDL> {   type[Group1] = "KEYPAD",
-                 [ KP_Delete,         KP_Separator        ]    };
+
+  key <TLDE> {[ parenleft,         parenright,        bracketleft,       bracketright        ]};
+  key <AE01> {[ 1,                 exclam                                                    ]};
+  key <AE02> {[ 2,                 question                                                  ]};
+  key <AE03> {[ 3,                 plus,              dagger,            dagger              ]};
+  key <AE04> {[ 4,                 quotedbl                                                  ]};
+  key <AE05> {[ 5,                 percent,           U2329,             U232A               ]};
+  key <AE06> {[ 6,                 equal,             emdash,            emdash              ]};
+  key <AE07> {[ 7,                 colon,             ellipsis,          ellipsis            ]};
+  key <AE08> {[ 8,                 slash,             U0300,             U0301               ]};
+  key <AE09> {[ 9,                 endash                                                    ]};
+  key <AE10> {[ 0,                 numerosign                                                ]};
+  key <AE11> {[ minus,             dollar,            U2011,             EuroSign            ]};
+  key <AE12> {[ period,            EuroSign                                                  ]};
+
+  key <AD01> {[ comma,             Cyrillic_yeru,  rightsinglequotemark, leftsinglequotemark ]};
+  key <AD02> {[ Cyrillic_u,        Cyrillic_U                                                ]};
+  key <AD03> {[ Cyrillic_ie,       Cyrillic_IE,       Cyrillic_e,        Cyrillic_E          ]};
+  key <AD04> {[ Cyrillic_i,        Cyrillic_I,        U045D,             U040D               ]};
+  key <AD05> {[ Cyrillic_sha,      Cyrillic_SHA                                              ]};
+  key <AD06> {[ Cyrillic_shcha,    Cyrillic_SHCHA                                            ]};
+  key <AD07> {[ Cyrillic_ka,       Cyrillic_KA,       copyright,         copyright           ]};
+  key <AD08> {[ Cyrillic_es,       Cyrillic_ES,       copyright,         copyright           ]};
+  key <AD09> {[ Cyrillic_de,       Cyrillic_DE                                               ]};
+  key <AD10> {[ Cyrillic_ze,       Cyrillic_ZE                                               ]};
+  key <AD11> {[ Cyrillic_tse,      Cyrillic_TSE                                              ]};
+  key <AD12> {[ semicolon,         section                                                   ]};
+
+  key <AC01> {[ Cyrillic_softsign, U045D,             Cyrillic_yeru,     Cyrillic_YERU       ]};
+  key <AC02> {[ Cyrillic_ya,       Cyrillic_YA,       U0463,             U0462               ]};
+  key <AC03> {[ Cyrillic_a,        Cyrillic_A                                                ]};
+  key <AC04> {[ Cyrillic_o,        Cyrillic_O                                                ]};
+  key <AC05> {[ Cyrillic_zhe,      Cyrillic_ZHE                                              ]};
+  key <AC06> {[ Cyrillic_ghe,      Cyrillic_GHE                                              ]};
+  key <AC07> {[ Cyrillic_te,       Cyrillic_TE,       trademark,         trademark           ]};
+  key <AC08> {[ Cyrillic_en,       Cyrillic_EN                                               ]};
+  key <AC09> {[ Cyrillic_ve,       Cyrillic_VE                                               ]};
+  key <AC10> {[ Cyrillic_em,       Cyrillic_EM                                               ]};
+  key <AC11> {[ Cyrillic_che,      Cyrillic_CHE                                              ]};
+  key <BKSL> {[ doublelowquotemark, leftdoublequotemark, guillemotleft,  guillemotright      ]};
+
+  key <LSGT> {[ U045D,             U040D                                                     ]};
+  key <AB01> {[ Cyrillic_yu,       Cyrillic_YU                                               ]};
+  key <AB02> {[ Cyrillic_shorti,   Cyrillic_SHORTI,   U046D,             U046C               ]};
+  key <AB03> {[ Cyrillic_hardsign, Cyrillic_HARDSIGN, U046B,             U046A               ]};
+  key <AB04> {[ Cyrillic_e,        Cyrillic_E                                                ]};
+  key <AB05> {[ Cyrillic_ef,       Cyrillic_EF                                               ]};
+  key <AB06> {[ Cyrillic_ha,       Cyrillic_HA                                               ]};
+  key <AB07> {[ Cyrillic_pe,       Cyrillic_PE                                               ]};
+  key <AB08> {[ Cyrillic_er,       Cyrillic_ER,       registered,        registered          ]};
+  key <AB09> {[ Cyrillic_el,       Cyrillic_EL                                               ]};
+  key <AB10> {[ Cyrillic_be,       Cyrillic_BE                                               ]};
+
+  key <SPCE> {[ space,             space,             nobreakspace,      nobreakspace        ]};
+
+  key <KPDL> { type[Group1] = "KEYPAD",             [ KP_Delete,         KP_Separator        ]};
 };
 
-// This is improved variant of the traditional Bulgarian phonetic
+// This is an improved variant of the traditional Bulgarian phonetic
 // keyboard.  Some unnecessary symbols in levels 1 and 2 are replaced
-// by more useful (the same way as in "bas_phonetic") and additional
-// symbols in levels 3 and 4 are added.
-partial alphanumeric_keys 
+// by more useful ones (similar as in "bas_phonetic") and additional
+// symbols are added in levels 3 and 4.
+partial alphanumeric_keys
 xkb_symbols "phonetic" {
   name[Group1]= "Bulgarian (traditional phonetic)";
-  
-  key <TLDE> {   [ Cyrillic_che,      Cyrillic_CHE        ]    };
-  key <AE01> {   [ 1,                 exclam              ]    };
-  key <AE02> {   [ 2,                 at                  ]    };
-  key <AE03> {   [ 3,                 numerosign          ]    };
-  key <AE04> {   [ 4,                 dollar,
-		   EuroSign,          EuroSign            ]    };
-  key <AE05> {   [ 5,                 percent             ]    };
-  key <AE06> {   [ 6,                 EuroSign            ]    };
-  key <AE07> {   [ 7,                 section             ]    };
-  key <AE08> {   [ 8,                 asterisk            ]    };
-  key <AE09> {   [ 9,                 parenleft,
-		   bracketleft,       U2329               ]    };
-  key <AE10> {   [ 0,                 parenright,
-		   bracketright,      U232A               ]    };
-  key <AE11> {   [ minus,             endash,
-		   U2011,             U2011               ]    };
-  key <AE12> {   [ equal,             plus,
-		   emdash,            dagger              ]    };
-
-  key <AD01> {   [ Cyrillic_ya,       Cyrillic_YA,
-		   U0463,             U0462               ]    };
-  key <AD02> {   [ Cyrillic_ve,       Cyrillic_VE         ]    };
-  key <AD03> {   [ Cyrillic_ie,       Cyrillic_IE,
-		   Cyrillic_e,        Cyrillic_E          ]    };
-  key <AD04> {   [ Cyrillic_er,       Cyrillic_ER,
-		   registered,        registered          ]    };
-  key <AD05> {   [ Cyrillic_te,       Cyrillic_TE,
-		   trademark,         trademark           ]    };
-  key <AD06> {   [ Cyrillic_hardsign, Cyrillic_HARDSIGN,
-		   U046B,             U046A               ]    };
-  key <AD07> {   [ Cyrillic_u,        Cyrillic_U          ]    };
-  key <AD08> {   [ Cyrillic_i,        Cyrillic_I,
-		   U045D,             U040D               ]    };
-  key <AD09> {   [ Cyrillic_o,        Cyrillic_O          ]    };
-  key <AD10> {   [ Cyrillic_pe,       Cyrillic_PE         ]    };
-  key <AD11> {   [ Cyrillic_sha,      Cyrillic_SHA        ]    };
-  key <AD12> {   [ Cyrillic_shcha,    Cyrillic_SHCHA      ]    };
-  
-  
-  key <AC01> {   [ Cyrillic_a,        Cyrillic_A          ]    };
-  key <AC02> {   [ Cyrillic_es,       Cyrillic_ES,
-		   copyright,         copyright           ]    };
-  key <AC03> {   [ Cyrillic_de,       Cyrillic_DE         ]    };
-  key <AC04> {   [ Cyrillic_ef,       Cyrillic_EF         ]    };
-  key <AC05> {   [ Cyrillic_ghe,      Cyrillic_GHE        ]    };
-  key <AC06> {   [ Cyrillic_ha,       Cyrillic_HA         ]    };
-  key <AC07> {   [ Cyrillic_shorti,   Cyrillic_SHORTI,
-		   U046D,             U046C               ]    };
-  key <AC08> {   [ Cyrillic_ka,       Cyrillic_KA         ]    };
-  key <AC09> {   [ Cyrillic_el,       Cyrillic_EL         ]    };
-  key <AC10> {   [ semicolon,         colon,
-		   ellipsis,          ellipsis            ]    };
-  key <AC11> {   [ apostrophe,        quotedbl,
-		   rightsinglequotemark, leftsinglequotemark ] };
-  key <BKSL> {   [ Cyrillic_yu,       Cyrillic_YU         ]    };
-  
-  
-  key <LSGT> {   [ U045D,             U040D               ]    };
-  key <AB01> {   [ Cyrillic_ze,       Cyrillic_ZE         ]    };
-  key <AB02> {   [ Cyrillic_softsign, U045D,
-		   Cyrillic_yeru,     Cyrillic_YERU       ]    };
-  key <AB03> {   [ Cyrillic_tse,      Cyrillic_TSE,
-		   copyright,         copyright           ]    };
-  key <AB04> {   [ Cyrillic_zhe,      Cyrillic_ZHE        ]    };
-  key <AB05> {   [ Cyrillic_be,       Cyrillic_BE         ]    };
-  key <AB06> {   [ Cyrillic_en,       Cyrillic_EN         ]    };
-  key <AB07> {   [ Cyrillic_em,       Cyrillic_EM         ]    };
-  key <AB08> {   [ comma,             doublelowquotemark,
-		   guillemotleft,     guillemotleft       ]    };
-  key <AB09> {   [ period,            leftdoublequotemark,
-		   guillemotright,    guillemotright      ]    };
-  key <AB10> {   [ slash,             question,
-		   U0300,             U0301               ]    };
-
-
-  key <SPCE> {   [ space,             space,
-		   nobreakspace,      nobreakspace        ]    };
-
-
-  key <KPDL> {   type[Group1] = "KEYPAD",
-                 [ KP_Delete,           KP_Separator         ]    };
 
+  key <TLDE> {[ Cyrillic_che,      Cyrillic_CHE                                              ]};
+  key <AE01> {[ 1,                 exclam                                                    ]};
+  key <AE02> {[ 2,                 at                                                        ]};
+  key <AE03> {[ 3,                 numerosign                                                ]};
+  key <AE04> {[ 4,                 dollar,            EuroSign,          EuroSign            ]};
+  key <AE05> {[ 5,                 percent                                                   ]};
+  key <AE06> {[ 6,                 EuroSign                                                  ]};
+  key <AE07> {[ 7,                 section                                                   ]};
+  key <AE08> {[ 8,                 asterisk                                                  ]};
+  key <AE09> {[ 9,                 parenleft,         bracketleft,       U2329               ]};
+  key <AE10> {[ 0,                 parenright,        bracketright,      U232A               ]};
+  key <AE11> {[ minus,             endash,            U2011,             U2011               ]};
+  key <AE12> {[ equal,             plus,              emdash,            dagger              ]};
+
+  key <AD01> {[ Cyrillic_ya,       Cyrillic_YA,       U0463,             U0462               ]};
+  key <AD02> {[ Cyrillic_ve,       Cyrillic_VE                                               ]};
+  key <AD03> {[ Cyrillic_ie,       Cyrillic_IE,       Cyrillic_e,        Cyrillic_E          ]};
+  key <AD04> {[ Cyrillic_er,       Cyrillic_ER,       registered,        registered          ]};
+  key <AD05> {[ Cyrillic_te,       Cyrillic_TE,       trademark,         trademark           ]};
+  key <AD06> {[ Cyrillic_hardsign, Cyrillic_HARDSIGN, U046B,             U046A               ]};
+  key <AD07> {[ Cyrillic_u,        Cyrillic_U                                                ]};
+  key <AD08> {[ Cyrillic_i,        Cyrillic_I,        U045D,             U040D               ]};
+  key <AD09> {[ Cyrillic_o,        Cyrillic_O                                                ]};
+  key <AD10> {[ Cyrillic_pe,       Cyrillic_PE                                               ]};
+  key <AD11> {[ Cyrillic_sha,      Cyrillic_SHA                                              ]};
+  key <AD12> {[ Cyrillic_shcha,    Cyrillic_SHCHA                                            ]};
+
+  key <AC01> {[ Cyrillic_a,        Cyrillic_A                                                ]};
+  key <AC02> {[ Cyrillic_es,       Cyrillic_ES,       copyright,         copyright           ]};
+  key <AC03> {[ Cyrillic_de,       Cyrillic_DE                                               ]};
+  key <AC04> {[ Cyrillic_ef,       Cyrillic_EF                                               ]};
+  key <AC05> {[ Cyrillic_ghe,      Cyrillic_GHE                                              ]};
+  key <AC06> {[ Cyrillic_ha,       Cyrillic_HA                                               ]};
+  key <AC07> {[ Cyrillic_shorti,   Cyrillic_SHORTI,   U046D,             U046C               ]};
+  key <AC08> {[ Cyrillic_ka,       Cyrillic_KA                                               ]};
+  key <AC09> {[ Cyrillic_el,       Cyrillic_EL                                               ]};
+  key <AC10> {[ semicolon,         colon,             ellipsis,          ellipsis            ]};
+  key <AC11> {[ apostrophe,        quotedbl,       rightsinglequotemark, leftsinglequotemark ]};
+  key <BKSL> {[ Cyrillic_yu,       Cyrillic_YU                                               ]};
+
+  key <LSGT> {[ U045D,             U040D                                                     ]};
+  key <AB01> {[ Cyrillic_ze,       Cyrillic_ZE                                               ]};
+  key <AB02> {[ Cyrillic_softsign, U045D,             Cyrillic_yeru,     Cyrillic_YERU       ]};
+  key <AB03> {[ Cyrillic_tse,      Cyrillic_TSE,      copyright,         copyright           ]};
+  key <AB04> {[ Cyrillic_zhe,      Cyrillic_ZHE                                              ]};
+  key <AB05> {[ Cyrillic_be,       Cyrillic_BE                                               ]};
+  key <AB06> {[ Cyrillic_en,       Cyrillic_EN                                               ]};
+  key <AB07> {[ Cyrillic_em,       Cyrillic_EM                                               ]};
+  key <AB08> {[ comma,            doublelowquotemark, guillemotleft,     guillemotleft       ]};
+  key <AB09> {[ period,          leftdoublequotemark, guillemotright,    guillemotright      ]};
+  key <AB10> {[ slash,             question,          U0300,             U0301               ]};
+
+  key <SPCE> {[ space,             space,             nobreakspace,      nobreakspace        ]};
+
+  key <KPDL> { type[Group1] = "KEYPAD",             [ KP_Delete,         KP_Separator        ]};
 };
 
-// This is the Bulgarian phonetic keyboard acording to the proposed
-// state standard BDS 5237:2006 with additional symbols in
-// levels 3 and 4.
-partial alphanumeric_keys 
+// This is the Bulgarian phonetic keyboard according to the proposed
+// state standard BDS 5237:2006 with additional symbols in levels 3 and 4.
+partial alphanumeric_keys
 xkb_symbols "bas_phonetic" {
   include "bg(phonetic)"
   name[Group1]= "Bulgarian (new phonetic)";
-  
-  key <TLDE> {   [ Cyrillic_yu,       Cyrillic_YU         ]    };
-  key <AD01> {   [ Cyrillic_che,      Cyrillic_CHE        ]    };
-  key <AD02> {   [ Cyrillic_sha,      Cyrillic_SHA        ]    };
-  key <AD11> {   [ Cyrillic_ya,       Cyrillic_YA,
-		   U0463,             U0462               ]    };
-  key <BKSL> {   [ Cyrillic_softsign, U045D,
-		   Cyrillic_yeru,     Cyrillic_YERU       ]    };
-  key <AB02> {   [ Cyrillic_zhe,      Cyrillic_ZHE        ]    };
-  key <AB04> {   [ Cyrillic_ve,       Cyrillic_VE         ]    };
+
+  key <TLDE> {[ Cyrillic_yu,       Cyrillic_YU                                               ]};
+  key <AD01> {[ Cyrillic_che,      Cyrillic_CHE                                              ]};
+  key <AD02> {[ Cyrillic_sha,      Cyrillic_SHA                                              ]};
+  key <AD11> {[ Cyrillic_ya,       Cyrillic_YA,       U0463,             U0462               ]};
+  key <BKSL> {[ Cyrillic_softsign, U045D,             Cyrillic_yeru,     Cyrillic_YERU       ]};
+  key <AB02> {[ Cyrillic_zhe,      Cyrillic_ZHE                                              ]};
+  key <AB04> {[ Cyrillic_ve,       Cyrillic_VE                                               ]};
 };
 
 
-// This is extended variant of the standard Latin QWERTY layout with
+// This is an extended variant of the standard Latin QWERTY layout with
 // additional symbols in levels 3 and 4.
-partial hidden alphanumeric_keys 
+partial hidden alphanumeric_keys
 xkb_symbols "latin" {
-  
-  key <TLDE> {   [ grave,             asciitilde,
-		   U2248,             U2245               ]    };
-  key <AE01> {   [ 1,                 exclam,
-		   notsign,           notsign             ]    };
-  key <AE02> {   [ 2,                 at,
-		   twosuperior,       enfilledcircbullet  ]    };
-  key <AE03> {   [ 3,                 numbersign,
-		   threesuperior,     notequal            ]    };
-  key <AE04> {   [ 4,                 dollar,
-		   EuroSign,          sterling            ]    };
-  key <AE05> {   [ 5,                 percent,
-		   U2030,             U2030               ]    };
-  key <AE06> {   [ 6,                 asciicircum,
-		   logicaland,        logicalor           ]    };
-  key <AE07> {   [ 7,                 ampersand,
-		   section,           section             ]    };
-  key <AE08> {   [ 8,                 asterisk,
-		   infinity,          multiply            ]    };
-  key <AE09> {   [ 9,                 parenleft,
-		   U2202,             nabla               ]    };
-  key <AE10> {   [ 0,                 parenright,
-		   U2300,             U2300               ]    };
-  key <AE11> {   [ minus,             underscore,
-		   U2011,             endash              ]    };
-  key <AE12> {   [ equal,             plus,
-		   emdash,            plusminus           ]    };
-
-
-  key <AD01> {   [ q,                 Q,
-		   Greek_THETA,       Greek_theta         ]    };
-  key <AD02> {   [ w,                 W,
-		   Greek_OMEGA,       Greek_omega         ]    };
-  key <AD03> {   [ e,                 E,
-		   U2203,             Greek_epsilon       ]    };
-  key <AD04> {   [ r,                 R,
-		   registered,        Greek_rho           ]    };
-  key <AD05> {   [ t,                 T,
-		   trademark,         Greek_tau           ]    };
-  key <AD06> {   [ y,                 Y,
-		   yen,               Greek_upsilon       ]    };
-  key <AD07> {   [ u,                 U,
-		   intersection,      union               ]    };
-  key <AD08> {   [ i,                 I,
-		   integral,          Greek_iota          ]    };
-  key <AD09> {   [ o,                 O,
-		   degree,            U222E               ]    };
-  key <AD10> {   [ p,                 P,
-		   Greek_PI,          Greek_pi            ]    };
-  key <AD11> {   [ bracketleft,       braceleft,
-		   U2286,             includedin          ]    };
-  key <AD12> {   [ bracketright,      braceright,
-		   U2208,             U2209               ]    };
-
-
-  key <AC01> {   [ a,                 A,
-		   U2200,             Greek_alpha         ]    };
-  key <AC02> {   [ s,                 S,
-		   Greek_SIGMA,       Greek_sigma         ]    };
-  key <AC03> {   [ d,                 D,
-		   Greek_DELTA,       Greek_delta         ]    };
-  key <AC04> {   [ f,                 F,
-		   Greek_PHI,         Greek_phi           ]    };
-  key <AC05> {   [ g,                 G,
-		   Greek_GAMMA,       Greek_gamma         ]    };
-  key <AC06> {   [ h,                 H,
-		   U2225,             Greek_eta           ]    };
-  key <AC07> {   [ j,                 J                   ]    };
-  key <AC08> {   [ k,                 K,
-		   U03F0,             Greek_kappa         ]    };
-  key <AC09> {   [ l,                 L,
-		   Greek_LAMBDA,      Greek_lambda        ]    };
-  key <AC10> {   [ semicolon,         colon,
-		   division,          division            ]    };
-  key <AC11> {   [ apostrophe,        quotedbl,
-		   leftdoublequotemark, rightdoublequotemark ] };
-  key <BKSL> {   [ backslash,         bar,
-		   identical,         downtack            ]    };
-
-
-  key <LSGT> {   [ less,              greater,
-		   U2266,             U2267               ]    };
-  key <AB01> {   [ z,                 Z,
-		   U2220,             Greek_zeta          ]    };
-  key <AB02> {   [ x,                 X,
-		   Greek_XI,          Greek_xi            ]    };
-  key <AB03> {   [ c,                 C,
-		   copyright,         Greek_chi           ]    };
-  key <AB04> {   [ v,                 V,
-		   Greek_PSI,         Greek_psi           ]    };
-  key <AB05> {   [ b,                 B,
-		   U03D1,             Greek_beta          ]    };
-  key <AB06> {   [ n,                 N,
-		   U207F,             Greek_nu            ]    };
-  key <AB07> {   [ m,                 M,
-		   Greek_mu,          Greek_mu            ]    };
-  key <AB08> {   [ comma,             less,
-		   U2266,             U21D4               ]    };
-  key <AB09> {   [ period,            greater,
-		   U2267,             U21D2               ]    };
-  key <AB10> {   [ slash,             question,
-		   leftsinglequotemark, rightsinglequotemark ] };
-
-
-  key <SPCE> {   [ space,             space,
-		   nobreakspace,      nobreakspace        ]    };
-
-
-  key <KPDL> {   type[Group1] = "KEYPAD",
-                 [ KP_Delete,           KP_Decimal        ]    };
+
+  key <TLDE> {[ grave,             asciitilde,        U2248,             U2245               ]};
+  key <AE01> {[ 1,                 exclam,            notsign,           notsign             ]};
+  key <AE02> {[ 2,                 at,                twosuperior,       enfilledcircbullet  ]};
+  key <AE03> {[ 3,                 numbersign,        threesuperior,     notequal            ]};
+  key <AE04> {[ 4,                 dollar,            EuroSign,          sterling            ]};
+  key <AE05> {[ 5,                 percent,           U2030,             U2030               ]};
+  key <AE06> {[ 6,                 asciicircum,       logicaland,        logicalor           ]};
+  key <AE07> {[ 7,                 ampersand,         section,           section             ]};
+  key <AE08> {[ 8,                 asterisk,          infinity,          multiply            ]};
+  key <AE09> {[ 9,                 parenleft,         U2202,             nabla               ]};
+  key <AE10> {[ 0,                 parenright,        U2300,             U2300               ]};
+  key <AE11> {[ minus,             underscore,        U2011,             endash              ]};
+  key <AE12> {[ equal,             plus,              emdash,            plusminus           ]};
+
+  key <AD01> {[ q,                 Q,                 Greek_THETA,       Greek_theta         ]};
+  key <AD02> {[ w,                 W,                 Greek_OMEGA,       Greek_omega         ]};
+  key <AD03> {[ e,                 E,                 U2203,             Greek_epsilon       ]};
+  key <AD04> {[ r,                 R,                 registered,        Greek_rho           ]};
+  key <AD05> {[ t,                 T,                 trademark,         Greek_tau           ]};
+  key <AD06> {[ y,                 Y,                 yen,               Greek_upsilon       ]};
+  key <AD07> {[ u,                 U,                 intersection,      union               ]};
+  key <AD08> {[ i,                 I,                 integral,          Greek_iota          ]};
+  key <AD09> {[ o,                 O,                 degree,            U222E               ]};
+  key <AD10> {[ p,                 P,                 Greek_PI,          Greek_pi            ]};
+  key <AD11> {[ bracketleft,       braceleft,         U2286,             includedin          ]};
+  key <AD12> {[ bracketright,      braceright,        U2208,             U2209               ]};
+
+  key <AC01> {[ a,                 A,                 U2200,             Greek_alpha         ]};
+  key <AC02> {[ s,                 S,                 Greek_SIGMA,       Greek_sigma         ]};
+  key <AC03> {[ d,                 D,                 Greek_DELTA,       Greek_delta         ]};
+  key <AC04> {[ f,                 F,                 Greek_PHI,         Greek_phi           ]};
+  key <AC05> {[ g,                 G,                 Greek_GAMMA,       Greek_gamma         ]};
+  key <AC06> {[ h,                 H,                 U2225,             Greek_eta           ]};
+  key <AC07> {[ j,                 J                                                         ]};
+  key <AC08> {[ k,                 K,                 U03F0,             Greek_kappa         ]};
+  key <AC09> {[ l,                 L,                 Greek_LAMBDA,      Greek_lambda        ]};
+  key <AC10> {[ semicolon,         colon,             division,          division            ]};
+  key <AC11> {[ apostrophe,        quotedbl,        leftdoublequotemark, rightdoublequotemark]};
+  key <BKSL> {[ backslash,         bar,               identical,         downtack            ]};
+
+  key <LSGT> {[ less,              greater,           U2266,             U2267               ]};
+  key <AB01> {[ z,                 Z,                 U2220,             Greek_zeta          ]};
+  key <AB02> {[ x,                 X,                 Greek_XI,          Greek_xi            ]};
+  key <AB03> {[ c,                 C,                 copyright,         Greek_chi           ]};
+  key <AB04> {[ v,                 V,                 Greek_PSI,         Greek_psi           ]};
+  key <AB05> {[ b,                 B,                 U03D1,             Greek_beta          ]};
+  key <AB06> {[ n,                 N,                 U207F,             Greek_nu            ]};
+  key <AB07> {[ m,                 M,                 Greek_mu,          Greek_mu            ]};
+  key <AB08> {[ comma,             less,              U2266,             U21D4               ]};
+  key <AB09> {[ period,            greater,           U2267,             U21D2               ]};
+  key <AB10> {[ slash,             question,        leftsinglequotemark, rightsinglequotemark]};
+
+  key <SPCE> {[ space,             space,             nobreakspace,      nobreakspace        ]};
+
+  key <KPDL> { type[Group1] = "KEYPAD",             [ KP_Delete,         KP_Decimal          ]};
 };
diff --git a/xorg-server/xkeyboard-config/symbols/bt b/xorg-server/xkeyboard-config/symbols/bt
index c02505e98..e53942107 100644
--- a/xorg-server/xkeyboard-config/symbols/bt
+++ b/xorg-server/xkeyboard-config/symbols/bt
@@ -18,7 +18,7 @@ xkb_symbols "basic" {
       name[Group1]= "Dzongkha";
 
       key <TLDE> { [      0x1000F09, 0x1000F0A, 0x1000F6C, 0x1000F6D ]	};
-      
+
 // numbers e.a.
       key <AE01> { [      0x1000F21, 0x1000F04, 1, exclam ]	};
       key <AE02> { [      0x1000F22, 0x1000F05, 2, at     ]	};
@@ -63,7 +63,7 @@ xkb_symbols "basic" {
       key <AC09> { [      0x1000F59, 0x1000FA9, 0x1000F39, VoidSymbol ]	};
       key <AC10> { [      0x1000F5A, 0x1000FAA, colon, semicolon ]	};
       key <AC11> { [      0x1000F5B, 0x1000FAB, apostrophe, quotedbl ]	};
-      
+
 // TODO: BKSL and LSGT are from gb layout, are there any variants?
       key <BKSL> { [      0x1000F5D, 0x1000FAD, backslash, 0x1000FBA ]	};
       key <LSGT> { [      0x1000F0D, 0x1000F11, 0x1000F10, 0x1000F0F ]	};
diff --git a/xorg-server/xkeyboard-config/symbols/bw b/xorg-server/xkeyboard-config/symbols/bw
index 48de2e2df..ab14cc7d8 100644
--- a/xorg-server/xkeyboard-config/symbols/bw
+++ b/xorg-server/xkeyboard-config/symbols/bw
@@ -4,7 +4,7 @@ xkb_symbols "tswana" {
     include "us"
 
     name[Group1]= "Tswana";
-        
+
     key <AC10> { [ semicolon,	    colon,  0x01000324,  0x01000324 ] };	//COMBINING DIAERESIS BELOW	
     key <AC11> { [apostrophe,    quotedbl,  0x01000301,  0x01000308 ] };	//COMBINING ACUTE ACCENT, COMBINING DIAERESIS
     key <TLDE> { [     grave,  asciitilde,  0x01000300,  0x01000303 ] };	//COMBINING GRAVE ACCENT, COMBINING TILDE
diff --git a/xorg-server/xkeyboard-config/symbols/by b/xorg-server/xkeyboard-config/symbols/by
index 00ecd6a8d..d82bcf57e 100644
--- a/xorg-server/xkeyboard-config/symbols/by
+++ b/xorg-server/xkeyboard-config/symbols/by
@@ -19,7 +19,7 @@ partial alphanumeric_keys
 xkb_symbols "legacy" {
 	include "by(basic)"
 	name[Group1]= "Belarusian (legacy)";
-	
+
 	key <AE03> {        [               3,      numbersign      ]       };
 	key <AE04> {        [               4,        asterisk      ]       };
 	key <AE05> {        [               5,           colon      ]       };
@@ -36,7 +36,7 @@ partial alphanumeric_keys
 xkb_symbols "latin" {
 	include "latin"
 	name[Group1]= "Belarusian (Latin)";
-	
+
 	key <AD02> {        [    w,    W,    scaron,    Scaron    ]       };
 	key <AD07> {        [    u,    U,    ubreve,    Ubreve    ]       };
 	key <AC02> {        [    s,    S,    sacute,    Sacute    ]       };
@@ -46,6 +46,6 @@ xkb_symbols "latin" {
 	key <AB03> {        [    c,    C,    cacute,    Cacute    ]       };
 	key <AB04> {        [    v,    V,    ccaron,    Ccaron    ]       };
 	key <AB06> {        [    n,    N,    nacute,    Nacute    ]       };
-	
+
 	include "level3(ralt_switch)"
 };
diff --git a/xorg-server/xkeyboard-config/symbols/ca b/xorg-server/xkeyboard-config/symbols/ca
index c4d37ad5c..abfbbd9f7 100644
--- a/xorg-server/xkeyboard-config/symbols/ca
+++ b/xorg-server/xkeyboard-config/symbols/ca
@@ -266,7 +266,7 @@ xkb_symbols "multi-2gr" {
 // Inuktitut keyboard for X11
 // written by Pablo Saratxaga <pablo@mandrakesoft.com>
 
-alphanumeric_keys 
+alphanumeric_keys
 xkb_symbols "ike" {
 
     name[Group1]= "Inuktitut";
@@ -453,18 +453,18 @@ xkb_symbols "multix" {
 xkb_symbols "olpc" {
 
     include "ca(fr)"
-    
+
     key <AE02>	{ [          2,    quotedbl,          ograve,        Ograve ] };
     key <AE03>	{ [          3,    slash,          at,        VoidSymbol ] };
-    
+
     key <AD03>	{ [          e,    E,          EuroSign, VoidSymbol]	};
-        
+
     key <AB09>	{ [  period,         period,         0x1002010 ]	};
-    
+
     key <I219>  { [  guillemotleft,  guillemotright, degree, VoidSymbol ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "eng" {
     name[Group1] = "English (Canada)";
     include "us(basic)"
@@ -472,7 +472,7 @@ xkb_symbols "eng" {
 
 // EXTRAS:
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "kut" {
 
     // Ejective U0313 and acute accents are taken from shs layout.
@@ -501,7 +501,7 @@ xkb_symbols "kut" {
 
 // Secwepemctsin keyboard for X11
 // written by Neskie Manuel <neskiem@gmail.com>
-partial alphanumeric_keys  
+partial alphanumeric_keys
 xkb_symbols "shs" {
 
     include "us"
diff --git a/xorg-server/xkeyboard-config/symbols/capslock b/xorg-server/xkeyboard-config/symbols/capslock
index 337c5efd2..928d79a3e 100644
--- a/xorg-server/xkeyboard-config/symbols/capslock
+++ b/xorg-server/xkeyboard-config/symbols/capslock
@@ -68,7 +68,7 @@ xkb_symbols "ctrl_modifier" {
     replace key <CAPS> {
         type[Group1] = "ONE_LEVEL",
         symbols[Group1] = [ Caps_Lock ],
-        actions[Group1] = [ SetMods(modifiers=Control) ]    
+        actions[Group1] = [ SetMods(modifiers=Control) ]
     };
     modifier_map Control { <CAPS> };
 };
diff --git a/xorg-server/xkeyboard-config/symbols/ch b/xorg-server/xkeyboard-config/symbols/ch
index 54663f1fa..62c69f958 100644
--- a/xorg-server/xkeyboard-config/symbols/ch
+++ b/xorg-server/xkeyboard-config/symbols/ch
@@ -36,7 +36,7 @@ xkb_symbols "basic" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "legacy" {
     include "ch(basic)"
 
@@ -44,12 +44,12 @@ xkb_symbols "legacy" {
     key <AE07> { [          7,      slash,    brokenbar             ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "de" {
     include "ch(basic)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "de_Sundeadkeys" {
     // modify the basic Swiss German layout to use Sun dead keys
     include "ch(basic)"
@@ -58,13 +58,13 @@ xkb_symbols "de_Sundeadkeys" {
     key <AD12> { [ dead_diaeresis,      exclam, bracketright   ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "de_sundeadkeys" {
     include "ch(de_Sundeadkeys)"
     name[Group1]= "German (Switzerland, Sun dead keys)";
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "de_nodeadkeys" {
     // modify the basic Swiss German layout not to have any dead keys
     include "ch(basic)"
@@ -74,7 +74,7 @@ xkb_symbols "de_nodeadkeys" {
     key <AD12> { [   diaeresis,   exclam, bracketright  ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "fr" {
 
     include "ch(basic)"
@@ -123,7 +123,7 @@ xkb_symbols "fr_nodeadkeys" {
 
 partial alphanumeric_keys
 xkb_symbols "de_mac" {
-    
+
     name[Group1]= "German (Switzerland, Macintosh)";
 
     key <AE01> { [	1,	plus, 	plusminus,	infinity		]	};
@@ -143,7 +143,7 @@ xkb_symbols "de_mac" {
     key <AD02> { [	w,	W, 	Greek_SIGMA,	Aacute			]	};
     key <AD03> { [ 	e,	E, 	EuroSign,	Ediaeresis		]	};
     key <AD04> { [ 	r,	R, 	registered,	Egrave			]	};
-    key <AD05> { [ 	t,	T, 	dagger,		Icircumflex		]	}; 
+    key <AD05> { [ 	t,	T, 	dagger,		Icircumflex		]	};
     key <AD06> { [	z,	Z, 	Greek_OMEGA,	Iacute			]	};
     key <AD07> { [ 	u,	U, 	degree,		Ugrave			]	};
     key <AD08> { [ 	i,	I, 	exclamdown,	idotless		]	};
@@ -152,7 +152,7 @@ xkb_symbols "de_mac" {
     key <AD11> { [	udiaeresis,	egrave, 	section,	ydiaeresis		]	};
     key <AD12> { [	dead_diaeresis,	exclam, 	grave,		apostrophe		]	};
     key <AC01> { [ 	a,	A, 	aring,		Aring			]	};
-    key <AC02> { [ 	s,	S, 	ssharp, 	NoSymbol		]	}; 
+    key <AC02> { [ 	s,	S, 	ssharp, 	NoSymbol		]	};
 					// ligature fl
     key <AC03> { [ 	d,	D, 	Greek_sigma,	NoSymbol		]	};
 			// partialderivative is not available here att
@@ -168,7 +168,7 @@ xkb_symbols "de_mac" {
     key <AB02> { [ 	x,	X, 	similarequal,	trademark		]	};
     key <AB03> { [ 	c,	C, 	copyright,	NoSymbol		]	};
     key <AB04> { [ 	v,	V, 	radical,	diamond			]	};
-    key <AB05> { [ 	b,	B, 	integral,	NoSymbol		]	};  
+    key <AB05> { [ 	b,	B, 	integral,	NoSymbol		]	};
     key <AB06> { [ 	n,	N, 	dead_tilde, 	enopencircbullet	]       };
 					// to be fixed att
     key <AB07> { [ 	m,	M, 	mu,		dead_abovering		]       };
@@ -186,7 +186,7 @@ xkb_symbols "de_mac" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "fr_mac" {
 
     include "ch(de_mac)"
diff --git a/xorg-server/xkeyboard-config/symbols/cn b/xorg-server/xkeyboard-config/symbols/cn
index 8c2ffe422..6b6562dbc 100644
--- a/xorg-server/xkeyboard-config/symbols/cn
+++ b/xorg-server/xkeyboard-config/symbols/cn
@@ -58,7 +58,7 @@ xkb_symbols "basic" {
 // you and maybe they'll find a fix. You won't notice it unless you're
 // fast at typing Tibetan anyway.
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tib" {
 
     name[Group1]= "Tibetan";
@@ -113,7 +113,7 @@ xkb_symbols "tib" {
     key <AB08> { [ 0x1000f50, 0x1000f4b, 0x1000fa0, 0x1000f9b ] }; # ཐ ཋ ྠ ྛ
     key <AB09> { [ 0x1000f47, 0x1000f3a, 0x1000f97, 0x1000f8b ] }; # ཇ ༺ ྗ ྋ
     key <AB10> { [ 0x1000f49, 0x1000f3b, 0x1000f99, 0x1000f8a ] }; # ཉ ༻ ྙ ྊ
- 
+
 };
 
 // Tibetan Standard Keyboard with ASCII numerals
@@ -131,7 +131,7 @@ xkb_symbols "tib" {
 // email addresses are not possible.) This mapping may change in the future
 // if a clearly better use for the shifted numerals is pointed out by users.
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tib_asciinum" {
     include "cn(tib)"
 
diff --git a/xorg-server/xkeyboard-config/symbols/ctrl b/xorg-server/xkeyboard-config/symbols/ctrl
index ca019ec7d..785777cfe 100644
--- a/xorg-server/xkeyboard-config/symbols/ctrl
+++ b/xorg-server/xkeyboard-config/symbols/ctrl
@@ -1,57 +1,80 @@
 // Eliminate CapsLock, making it another Ctrl.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "nocaps" {
-    replace key <CAPS>	{ [ Control_L, Control_L ] };
+    replace key <CAPS> { [ Control_L, Control_L ] };
     modifier_map  Control { <CAPS>, <LCTL> };
 };
 
 // Make the left Ctrl key a left Meta.
 xkb_symbols "lctrl_meta" {
-    replace key <LCTL>	{ [ Meta_L ] };
+    replace key <LCTL> { [ Meta_L ] };
 };
 
 // Swap the functions of the CapsLock key and the left Ctrl key.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "swapcaps" {
-    replace key <CAPS>	{ [ Control_L ] };
-    replace key <LCTL>	{ [ Caps_Lock ] };
+    replace key <CAPS> { [ Control_L ] };
+    replace key <LCTL> { [ Caps_Lock ] };
 };
 
 // Move Ctrl to the leftmost key on the middle row and CapsLock to the
 // leftmost key on the bottom row.  Only works if the geometry or keycodes
 // file has defined appropriate aliases for the keys in question.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ac_ctrl" {
-    replace key <AC00>	{ [ Control_L ] };
-    replace key <AA00>	{ [ Caps_Lock ] };
+    replace key <AC00> { [ Control_L ] };
+    replace key <AA00> { [ Caps_Lock ] };
 };
 
 // Move Ctrl to the leftmost key on the bottom row and CapsLock to the
 // leftmost key on the middle row.  Only works if the geometry or keycodes
 // file has defined appropriate aliases for the keys in question.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "aa_ctrl" {
-    replace key <AA00>	{ [ Control_L ] };
-    replace key <AC00>	{ [ Caps_Lock ] };
+    replace key <AA00> { [ Control_L ] };
+    replace key <AC00> { [ Caps_Lock ] };
 };
 
 // Right Ctrl key functions as another right Alt.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "rctrl_ralt" {
-    key <RCTL>	{ symbols[Group1]= [ Alt_R ] };
+    key <RCTL> { symbols[Group1]= [ Alt_R ] };
 };
 
 // Menu key functions as another right Ctrl.
 partial modifier_keys
 xkb_symbols "menu_rctrl" {
-    replace key <MENU>	{ [ Control_R, Control_R ] };
+    replace key <MENU> { [ Control_R, Control_R ] };
     modifier_map Control { Control_L, <MENU> };
 };
 
 // Right Alt key functions as another right Ctrl.
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ralt_rctrl" {
     replace key <RALT> { type[Group1] = "TWO_LEVEL",
                          symbols[Group1] = [ Control_R, Control_R ] };
-    modifier_map Control { <RALT> }; 
+    modifier_map Control { <RALT> };
+};
+
+// Swap the functions of the left Alt key and the left Ctrl key.
+partial modifier_keys
+xkb_symbols "swap_lalt_lctl" {
+    replace key <LALT> { [ Control_L, Control_L ] };
+    replace key <LCTL> { [ Alt_L, Meta_L ] };
+};
+
+// Swap the functions of the left Win key and the left Ctrl key.
+partial modifier_keys
+xkb_symbols "swap_lwin_lctl" {
+    replace key <LWIN> { [ Control_L ] };
+    replace key <LCTL> { [ Super_L ] };
+};
+
+// Map Ctrl to the left Alt key, Alt to the left Win key,
+// and Super to the left Ctrl key.
+partial modifier_keys
+xkb_symbols "swap_lalt_lctl_lwin" {
+    replace key <LALT> { [ Control_L, Control_L ] };
+    replace key <LWIN> { [ Alt_L, Meta_L ] };
+    replace key <LCTL> { [ Super_L ] };
 };
diff --git a/xorg-server/xkeyboard-config/symbols/cz b/xorg-server/xkeyboard-config/symbols/cz
index 20af4b281..083cc7674 100644
--- a/xorg-server/xkeyboard-config/symbols/cz
+++ b/xorg-server/xkeyboard-config/symbols/cz
@@ -1,6 +1,6 @@
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
-     
+
      // This layout conforms to a new cz compromise standard designed 
      // to satisfy most unix, windows and mac users.
      // 2001 by Kamil Toman <ktoman@email.cz>
@@ -46,7 +46,7 @@ xkb_symbols "basic" {
     key <AC07>	{ [         j,          J,   apostrophe,     NoSymbol ]	};
     key <AC08>	{ [         k,          K,      lstroke,     NoSymbol ]	};
     key <AC09>	{ [         l,          L,      Lstroke,     NoSymbol ]	};
-                  
+
     key <AC10>	{ [     uring,   quotedbl,       dollar,     NoSymbol ]	};
     key <AC11>	{ [   section,     exclam,   apostrophe,       ssharp ]	};
     key <AC12>	{ [  EuroSign, dead_diaeresis, NoSymbol,     NoSymbol ]	};
@@ -77,14 +77,14 @@ xkb_symbols "bksl" {
     key <BKSL>	{ [ backslash,        bar,        slash,     NoSymbol ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "qwerty" {
- 
+
     // This layout represent actual keyboard layout. It complies with symbols
     // printed on keys.
     // -----------------------------------------------------------------------
     // This layout was created in 2011 by Lukáš Mojžíš <lmojzis@grenames.cz>
-    
+
     include "cz(basic)"
     name[Group1]= "Czech (qwerty)";
 
diff --git a/xorg-server/xkeyboard-config/symbols/de b/xorg-server/xkeyboard-config/symbols/de
index 01bde5d20..a497d7f48 100644
--- a/xorg-server/xkeyboard-config/symbols/de
+++ b/xorg-server/xkeyboard-config/symbols/de
@@ -39,7 +39,7 @@ xkb_symbols "basic" {
     key <AB02>	{ [         x,          X,        guillemotleft,    U2039 	] };
     key <AB04>	{ [         v,          V,   doublelowquotemark, singlelowquotemark ]	};
     key <AB05>	{ [         b,          B,  leftdoublequotemark, leftsinglequotemark ] };
-    key <AB06>	{ [         n,          N, rightdoublequotemark, rightsinglequotemark ]	};    
+    key <AB06>	{ [         n,          N, rightdoublequotemark, rightsinglequotemark ]	};
     key <AB08>  { [     comma,  semicolon,       periodcentered,     multiply	] };
     key <AB09>	{ [    period,      colon,                U2026,     division 	] };
     key <AB10>	{ [     minus, underscore,               endash,     emdash	] };
@@ -221,7 +221,7 @@ xkb_symbols "ro_nodeadkeys" {
 // in many programming languages.
 // to use this keymap, use a 105-key-keyboard and the command setxkbmap -model pc105 -layout dvorak -variant de
 // source: http://www-lehre.informatik.uni-osnabrueck.de/~rfreund/dvorak.php
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
     include "us(dvorak)"
 
@@ -479,7 +479,7 @@ xkb_symbols "neo" {
 // Copied from macintosh_vndr/de
 // olh@suse.de   very close to MacOS map
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     include "de"
@@ -496,7 +496,7 @@ xkb_symbols "mac" {
     key <AD07>	{ [         u,          U,    diaeresis,       Aacute ]	};
     key <AD08>	{ [         i,          I,        slash,  Ucircumflex ]	};
     key <AD11>	{ [ udiaeresis, Udiaeresis, periodcentered,    degree ]	};
-    key <AD12>	{ [      plus,   asterisk,   asciitilde       ]	}; 
+    key <AD12>	{ [      plus,   asterisk,   asciitilde       ]	};
     key <AC01>	{ [         a,          A,        aring,        Aring ]	};
     key <AC05>	{ [         g,          G,    copyright       ]	};
     key <AC06>	{ [         h,          H,  ordfeminine       ]	};
@@ -506,7 +506,7 @@ xkb_symbols "mac" {
 
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac_nodeadkeys" {
     // modify the standard German mac layout to not have any dead keys
     include "de(mac)"
@@ -571,13 +571,13 @@ xkb_symbols "dsb_qwertz"
 	key <AD09> { [              o,              O,         oacute,         Oacute ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "qwerty" {
- 
+
     // This layout should work exactly as a de with the exception 
     // of 'Z' and 'Y' keys, which are in the qwerty style (ie. swapped).
     // 2008 by Matej Košík <kosik@fiit.stuba.sk>
-    
+
     include "de(basic)"
 
     name[Group1] = "German (qwerty)";
@@ -594,7 +594,7 @@ partial alphanumeric_keys
 xkb_symbols "ru" {
 
     include "de(basic)"
- 
+
     name[Group1]= "Russian (Germany, phonetic)";
 
     key.type[group1]="FOUR_LEVEL_ALPHABETIC";
diff --git a/xorg-server/xkeyboard-config/symbols/dk b/xorg-server/xkeyboard-config/symbols/dk
index 34667fc48..838478bf8 100644
--- a/xorg-server/xkeyboard-config/symbols/dk
+++ b/xorg-server/xkeyboard-config/symbols/dk
@@ -43,7 +43,7 @@ xkb_symbols "nodeadkeys" {
 };
 
 // Copied from macintosh_vndr/dk
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     include "dk"
@@ -55,7 +55,7 @@ xkb_symbols "mac" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac_nodeadkeys" {
     include "dk(mac)"
     name[Group1]= "Danish (Macintosh, eliminate dead keys)";
@@ -64,7 +64,7 @@ xkb_symbols "mac_nodeadkeys" {
     key <AD12>	{ [diaeresis, asciicircum,   asciitilde,  dead_macron ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
     include "no(dvorak)"
 
diff --git a/xorg-server/xkeyboard-config/symbols/ee b/xorg-server/xkeyboard-config/symbols/ee
index 9384bee83..9e6865e55 100644
--- a/xorg-server/xkeyboard-config/symbols/ee
+++ b/xorg-server/xkeyboard-config/symbols/ee
@@ -59,7 +59,7 @@ partial alphanumeric_keys
 xkb_symbols "dvorak" {
    include "us(dvorak)"
    name[Group1]= "Estonian (Dvorak)";
-   
+
     key <AE03>	{ [         3, numbersign,   sterling ]	};
     key <AE04>	{ [         4,     dollar,    section,   currency ]	};
     key <AE08>	{ [         8,   asterisk,    onehalf ]	};
@@ -68,7 +68,7 @@ xkb_symbols "dvorak" {
     key <AC02>	{ [         o,          O,     otilde,     Otilde ]	};
     key <AC03>	{ [         e,          E, odiaeresis, Odiaeresis ]	};
     key <AC04>	{ [         u,          U, udiaeresis, Udiaeresis ]	};
-    key <AC10>	{ [         s,          S,     scaron,     Scaron ]	};   
+    key <AC10>	{ [         s,          S,     scaron,     Scaron ]	};
     key <AB10>	{ [         z,          Z,     zcaron,     Zcaron ]	};
 
     include "level3(ralt_switch)"
diff --git a/xorg-server/xkeyboard-config/symbols/es b/xorg-server/xkeyboard-config/symbols/es
index 62e2b2c6a..9e963a23f 100644
--- a/xorg-server/xkeyboard-config/symbols/es
+++ b/xorg-server/xkeyboard-config/symbols/es
@@ -141,7 +141,7 @@ xkb_symbols "ast" {
 };
 
 // Copied from macintosh_vndr/es
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
     include "es"
     name[Group1]= "Spanish (Macintosh)";
@@ -179,7 +179,7 @@ xkb_symbols "olpc" {
     key <AB08> { [        comma,      semicolon                  ] };
     key <AB09> { [       period,          colon                  ] };
     key <AB10> { [        minus,     underscore                  ] };
-  
+
     key <I219> { [         less,        greater,  ISO_Next_Group ] };
 
     include "level3(ralt_switch)"
diff --git a/xorg-server/xkeyboard-config/symbols/fo b/xorg-server/xkeyboard-config/symbols/fo
index dc9fa6b45..1000c9cf0 100644
--- a/xorg-server/xkeyboard-config/symbols/fo
+++ b/xorg-server/xkeyboard-config/symbols/fo
@@ -30,7 +30,7 @@ xkb_symbols "basic" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "nodeadkeys" {
 
     include "fo(basic)"
diff --git a/xorg-server/xkeyboard-config/symbols/fr b/xorg-server/xkeyboard-config/symbols/fr
index 3898b1c57..9c89db825 100644
--- a/xorg-server/xkeyboard-config/symbols/fr
+++ b/xorg-server/xkeyboard-config/symbols/fr
@@ -36,6 +36,8 @@ xkb_symbols "basic" {
     key <AB09>	{ [     colon,      slash, periodcentered,   division ]	};
     key <AB10>	{ [    exclam,    section, dead_belowdot, dead_abovedot ] };
 
+    include "kpdl(comma)"
+
     include "level3(ralt_switch)"
 };
 
diff --git a/xorg-server/xkeyboard-config/symbols/gb b/xorg-server/xkeyboard-config/symbols/gb
index 7bf071cca..ead9e7b1c 100644
--- a/xorg-server/xkeyboard-config/symbols/gb
+++ b/xorg-server/xkeyboard-config/symbols/gb
@@ -25,7 +25,7 @@ xkb_symbols "basic" {
     include "level3(ralt_switch_multikey)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "intl" { 
 
     // Describes the differences between a very simple en_US 
@@ -41,7 +41,7 @@ xkb_symbols "intl" {
 
     include "latin" 
 
-    name[Group1]="English (UK, international with dead keys)"; 
+    name[Group1]="English (UK, international with dead keys)";
 
     key <AE02>  { [   2,  dead_diaeresis,      twosuperior,     onehalf ] };
     key <AE03>  { [   3,        sterling,    threesuperior,    onethird ] };
@@ -57,7 +57,7 @@ xkb_symbols "intl" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "extd" {
     // Clone of the Microsoft "English (UK, Extended" layout, which
     // includes dead keys for: grave; diaeresis; circumflex; tilde; and
@@ -73,9 +73,9 @@ xkb_symbols "extd" {
     include "latin"
 
     name[Group1]="English (UK, extended WinKeys)";
-    
+
     key <TLDE> { [ dead_grave,    notsign,       brokenbar,    NoSymbol ] };
-    
+
     key <AE02> { [     2,        quotedbl,  dead_diaeresis,     onehalf ] };
     key <AE03> { [     3,        sterling,   threesuperior,    onethird ] };
     key <AE04> { [     4,          dollar,        EuroSign,  onequarter ] };
@@ -155,7 +155,7 @@ xkb_symbols "dvorakukp" {
 };
 
 // Copied from macintosh_vndr/gb
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     // Describes the differences between a very simple en_US
@@ -175,12 +175,12 @@ xkb_symbols "mac" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac_intl" { 
 
     include "latin" 
 
-    name[Group1]="English (UK, Macintosh international)"; 
+    name[Group1]="English (UK, Macintosh international)";
 
     key <AE02>  { [   2,                       at,           EuroSign,    onehalf ] };
     key <AE03>  { [   3,                 sterling,        twosuperior,   onethird ] };
diff --git a/xorg-server/xkeyboard-config/symbols/ge b/xorg-server/xkeyboard-config/symbols/ge
index 8c2e2e9a0..4f590a440 100644
--- a/xorg-server/xkeyboard-config/symbols/ge
+++ b/xorg-server/xkeyboard-config/symbols/ge
@@ -123,7 +123,7 @@ xkb_symbols "ergonomic" {
     key <AC07> { [ 0x010010db, noSymbol     ]       };
     key <AC08> { [ 0x010010e1, noSymbol     ]       };
     key <AC09> { [ 0x010010e0, noSymbol, L  ]       };
-    key <AC10> { [ 0x010010d1, noSymbol, colon         ] }; 
+    key <AC10> { [ 0x010010d1, noSymbol, colon         ] };
     key <AC11> { [ 0x010010d2, noSymbol, 0x010010f9, quotedbl ] };
     key <BKSL> { [ slash, section, backslash, bar ] };
 
diff --git a/xorg-server/xkeyboard-config/symbols/gh b/xorg-server/xkeyboard-config/symbols/gh
index bd31a0b39..f29c25d5c 100644
--- a/xorg-server/xkeyboard-config/symbols/gh
+++ b/xorg-server/xkeyboard-config/symbols/gh
@@ -16,7 +16,7 @@ xkb_symbols "akan" {
     name[Group1]= "Akan";
 
     key <AD01> { [ 0x0100025B, 0x01000190,          q,          Q ] };
-    key <AB02> { [ 0x01000254, 0x01000186,          x,          X ] }; 
+    key <AB02> { [ 0x01000254, 0x01000186,          x,          X ] };
 };
 
 partial alphanumeric_keys
@@ -26,8 +26,8 @@ xkb_symbols "ga" {
     name[Group1]= "Ga";
 
     key <AD01> { [ 0x0100025B, 0x01000190,          q,          Q ] };
-    key <AB02> { [ 0x01000254, 0x01000186,          x,          X ] }; 
-    key <AB03> { [ 0x0100014B, 0x0100014A,          c,          C ] }; 
+    key <AB02> { [ 0x01000254, 0x01000186,          x,          X ] };
+    key <AB03> { [ 0x0100014B, 0x0100014A,          c,          C ] };
 };
 
 partial alphanumeric_keys
@@ -37,13 +37,13 @@ xkb_symbols "ewe" {
     name[Group1]= "Ewe";
 
     key <AD01> { [ 0x0100025B, 0x01000190,          q,          Q ] };
-    key <AB03> { [ 0x0100014B, 0x0100014A,          c,          C ] }; 
-    key <AD11> { [ 0x01000254, 0x01000186,  braceleft,  braceleft ] }; 
-    key <AD12> { [ 0x0100028B, 0x010001B2, braceright, braceright ] }; 
+    key <AB03> { [ 0x0100014B, 0x0100014A,          c,          C ] };
+    key <AD11> { [ 0x01000254, 0x01000186,  braceleft,  braceleft ] };
+    key <AD12> { [ 0x0100028B, 0x010001B2, braceright, braceright ] };
     key <BKSL> { [ 0x01000256, 0x01000189,  backslash,  backslash ] };
     key <AC07> { [ 0x01000192, 0x01000191,          j,          J ] };
     key <AC05> { [          g,          G, 0x01000263, 0x01000194 ] };
- 
+
 };
 
 partial alphanumeric_keys
@@ -113,7 +113,7 @@ xkb_symbols "avn" {
     key <AB03> { [ 0x01000254,      0x01000186                           ] }; // ɔ, Ɔ
 
     include "level3(ralt_switch)"
- 
+
 };
 
 // This keyboard layout fully imitates the 'Ghana Unicode' layout which is used in GILLBT on Windows with Keyman.
@@ -146,6 +146,6 @@ xkb_symbols "gillbt" {
     key <AB01> { [ z,          Z,           0x01000292,   0x010001B7  ] }; // ʒ, Ʒ
     key <AB02> { [ 0x01000269, 0x01000196,  x,            X           ] }; // ɩ, Ɩ
     key <AB03> { [ c,          C,           0x010000E7,   0x010000C7  ] }; // ç, Ç
-    
+
     include "level3(ralt_switch)"
 };
diff --git a/xorg-server/xkeyboard-config/symbols/group b/xorg-server/xkeyboard-config/symbols/group
index fb2f879d0..8592f4344 100644
--- a/xorg-server/xkeyboard-config/symbols/group
+++ b/xorg-server/xkeyboard-config/symbols/group
@@ -1,108 +1,92 @@
-// using the group(switch) map, the right alt key temporarily chooses 
-// the second keyboard group (until it is released).
-//
-partial modifier_keys 
+// The right Alt key (while pressed) chooses the second keyboard group.
+partial modifier_keys
 xkb_symbols "switch" {
-    key <RALT>	{ 	
-	symbols[Group1]= [	Mode_switch, Multi_key 	],
-	virtualMods= AltGr
+    key <RALT> {
+        symbols[Group1] = [ Mode_switch, Multi_key ],
+        virtualMods= AltGr
     };
 };
 
-// using the group(lswitch) map, the left alt key temporarily chooses
-// the second keyboard group (until it is released).
-//
-partial modifier_keys 
+// The left Alt key (while pressed) chooses the second keyboard group.
+partial modifier_keys
 xkb_symbols "lswitch" {
-    key <LALT>	{ 	
-	symbols[Group1]= [	Mode_switch, Multi_key 	],
-	virtualMods= AltGr
+    key <LALT> {
+        symbols[Group1] = [ Mode_switch, Multi_key ],
+        virtualMods= AltGr
     };
 };
 
-
-// using the group(win_switch) map, both Windows'logo keys temporarily
-// choose the second keyboard group (until release).  If you use this
-// map, you would declare you keyboard as pc101 or pc102 instead of
-// pc104 or pc105.
+// Either Win key (while pressed) chooses the second keyboard group.
 partial modifier_keys
 xkb_symbols "win_switch" {
     include "group(lwin_switch)"
     include "group(rwin_switch)"
 };
 
-// using the group(lwin_switch) map, the left Windows' logo key
-// temporarily chooses the second keyboard group (until it is
-// released).  If you use this map, you would declare you keyboard as
-// pc101 or pc102 instead of pc104 or pc105.
+// The left Win key (while pressed) chooses the second keyboard group.
+// (Using this map, you should declare your keyboard as pc101 or pc102
+// instead of pc104 or pc105.)
 partial modifier_keys
 xkb_symbols "lwin_switch" {
-  key <LWIN> {
-    symbols[Group1] = [ Mode_switch, Multi_key ],
-    virtualMods= AltGr
+    key <LWIN> {
+        symbols[Group1] = [ Mode_switch, Multi_key ],
+        virtualMods= AltGr
     };
 };
 
-// using the group(rwin_switch) map, the right Windows' logo key
-// temporarily chooses the second keyboard group (until it is
-// released).  If you use this map, you would declare you keyboard as
-// pc101 or pc102 instead of pc104 or pc105.
+// The right Win key (while pressed) chooses the second keyboard group.
+// (Using this map, you should declare your keyboard as pc101 or pc102
+// instead of pc104 or pc105.)
 partial modifier_keys
 xkb_symbols "rwin_switch" {
-  key <RWIN> {
-    symbols[Group1] = [ Mode_switch, Multi_key ],
-    virtualMods= AltGr
+    key <RWIN> {
+        symbols[Group1] = [ Mode_switch, Multi_key ],
+        virtualMods= AltGr
     };
 };
 
-// Right Ctrl key temporary chooses the second keyboard group.
-// Needed mainly for Canadian keyboard
+// The right Ctrl key (while pressed) chooses the second keyboard group.
+// (Needed mainly for the Canadian keyboard.)
 partial modifier_keys
 xkb_symbols "rctrl_switch" {
-    key <RCTL>  {
-        symbols[Group1]= [ Mode_switch ]
+    key <RCTL> {
+        symbols[Group1] = [ Mode_switch ]
     };
 };
 
-// using the group(toggle) map, pressing the right alt key switches to
-// the next sequential group (until the next explicit group change).
-partial modifier_keys 
+// Pressing the right Alt key switches to the next group.
+partial modifier_keys
 xkb_symbols "toggle" {
     virtual_modifiers AltGr;
-    key <RALT>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    key <RALT> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// using the group(shifts_toggle) map, pressing both shift keys together
-// locks the next or previous sequential keyboard group 
-// (depending on which shift is pressed first - right or left, 
-// correspongingly)
-partial modifier_keys 
+// Pressing both Shift keys switches to the next or previous group
+// (depending on which Shift is pressed first).
+partial modifier_keys
 xkb_symbols "shifts_toggle" {
-    key <LFSH>	{	[	Shift_L,	ISO_Prev_Group ]	};
-    key <RTSH>	{	[	Shift_R,	ISO_Next_Group ]	};
+    key <LFSH> { [ Shift_L, ISO_Prev_Group ] };
+    key <RTSH> { [ Shift_R, ISO_Next_Group ] };
 };
 
-// using the group(shift_caps_toggle) map, pressing:
-//     Shift+Caps Lock toggles group
+// Pressing Shift+Caps_Lock switches to the next group.
 partial modifier_keys
 xkb_symbols "shift_caps_toggle" {
-    key	<CAPS> {	[  Caps_Lock,		ISO_Next_Group	]	};
+    key <CAPS> { [ Caps_Lock, ISO_Next_Group ] };
 };
 
-// using the group(shift_caps_switch) map, pressing:
-// Caps Lock selects the first group
-// Shift+Caps Lock selects the last group
+// Pressing Caps_Lock selects the first group,
+// pressing Shift+Caps_Lock selects the last group.
 partial modifier_keys
 xkb_symbols "shift_caps_switch" {
     key <CAPS> { [ ISO_First_Group, ISO_Last_Group ] };
 };
 
-// using the group(win_menu_switch) map, pressing:
-// LWIN selects the first group
-// RWIN or MENU selects the last group
+// Pressing the left Win key selects the first group,
+// pressing the right Win or the Menu key selects the last group.
 partial modifier_keys
 xkb_symbols "win_menu_switch" {
     virtual_modifiers AltGr;
@@ -120,9 +104,8 @@ xkb_symbols "win_menu_switch" {
     };
 };
 
-// using the group(lctrl_rctrl_switch) map, pressing:
-// Left Control selects the first group
-// Right Control selects the last group
+// Pressing the left Ctrl key selects the first group,
+// pressing the right Ctrl key selects the last group.
 partial modifier_keys
 xkb_symbols "lctrl_rctrl_switch" {
     virtual_modifiers AltGr;
@@ -140,20 +123,20 @@ xkb_symbols "lctrl_rctrl_switch" {
 //
 // CTRL-SHIFT toggle section
 //
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "lctrl_lshift_toggle" {
     key <LFSH> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ Shift_L, ISO_Next_Group ]
+        symbols[Group1] = [ Shift_L, ISO_Next_Group ]
     };
     key <LCTL> { [ Control_L, ISO_Next_Group ] };
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "lctrl_lshift_toggle_rev" {
     key <LFSH> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ Shift_L, ISO_Prev_Group ]
+        symbols[Group1] = [ Shift_L, ISO_Prev_Group ]
     };
     key <LCTL> { [ Control_L, ISO_Prev_Group ] };
 };
@@ -162,18 +145,18 @@ partial modifier_keys
 xkb_symbols "rctrl_rshift_toggle" {
     key <RTSH> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ Shift_R, ISO_Next_Group ]
+        symbols[Group1] = [ Shift_R, ISO_Next_Group ]
     };
     key <RCTL> { [ Control_R, ISO_Next_Group ] };
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_shift_toggle" {
     include "group(lctrl_lshift_toggle)"
     include "group(rctrl_rshift_toggle)"
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_shift_toggle_bidir" {
     include "group(lctrl_lshift_toggle_rev)"
     include "group(rctrl_rshift_toggle)"
@@ -188,12 +171,12 @@ xkb_symbols "lctrl_lalt_toggle" {
     virtual_modifiers Alt;
     key <LALT> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ NoSymbol,    ISO_Next_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
         virtualMods= Alt
     };
     key <LCTL> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Control_L,   ISO_Next_Group ]
+        symbols[Group1] = [ Control_L, ISO_Next_Group ]
     };
 };
 
@@ -202,12 +185,12 @@ xkb_symbols "lctrl_lalt_toggle_rev" {
     virtual_modifiers Alt;
     key <LALT> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ NoSymbol,    ISO_Prev_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Prev_Group ],
         virtualMods= Alt
     };
     key <LCTL> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Control_L,   ISO_Prev_Group ]
+        symbols[Group1] = [ Control_L, ISO_Prev_Group ]
     };
 };
 
@@ -216,22 +199,22 @@ xkb_symbols "rctrl_ralt_toggle" {
     virtual_modifiers Alt;
     key <RALT> {
         type[Group1]="PC_CONTROL_LEVEL2",
-        symbols[Group1]= [ NoSymbol,    ISO_Next_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
         virtualMods= Alt
     };
     key <RCTL> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Control_R,   ISO_Next_Group ]
+        symbols[Group1] = [ Control_R, ISO_Next_Group ]
     };
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_alt_toggle" {
     include "group(lctrl_lalt_toggle)"
     include "group(rctrl_ralt_toggle)"
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "ctrl_alt_toggle_bidir" {
     include "group(lctrl_lalt_toggle_rev)"
     include "group(rctrl_ralt_toggle)"
@@ -245,12 +228,12 @@ partial modifier_keys
 xkb_symbols "lalt_lshift_toggle" {
     virtual_modifiers Alt;
     key <LALT> {
-        symbols[Group1]= [ NoSymbol,    ISO_Next_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
         virtualMods= Alt
     };
     key <LFSH> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Shift_L,     ISO_Next_Group ]
+        symbols[Group1] = [ Shift_L, ISO_Next_Group ]
     };
 };
 
@@ -258,12 +241,12 @@ partial modifier_keys
 xkb_symbols "lalt_lshift_toggle_rev" {
     virtual_modifiers Alt;
     key <LALT> {
-        symbols[Group1]= [ NoSymbol,    ISO_Prev_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Prev_Group ],
         virtualMods= Alt
     };
     key <LFSH> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Shift_L,     ISO_Prev_Group ]
+        symbols[Group1] = [ Shift_L, ISO_Prev_Group ]
     };
 };
 
@@ -271,187 +254,186 @@ partial modifier_keys
 xkb_symbols "ralt_rshift_toggle" {
     virtual_modifiers Alt;
     key <RALT> {
-        symbols[Group1]= [ NoSymbol,    ISO_Next_Group ],
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
         virtualMods= Alt
     };
     key <RTSH> {
         type[Group1]="PC_ALT_LEVEL2",
-        symbols[Group1]= [ Shift_R,     ISO_Next_Group ]
+        symbols[Group1] = [ Shift_R, ISO_Next_Group ]
     };
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "alt_shift_toggle" {
     include "group(lalt_lshift_toggle)"
     include "group(ralt_rshift_toggle)"
 };
 
-partial modifier_keys 
+partial modifier_keys
 xkb_symbols "alt_shift_toggle_bidir" {
     include "group(lalt_lshift_toggle_rev)"
     include "group(ralt_rshift_toggle)"
 };
 
 
-// using the group(menu_toggle) map, pressing:
-//     Menu key toggles groups
-//     Shift+Menu acts as Menu
+// Pressing the Menu key switches to the next group,
+// while Shift+Menu acts as Menu.
 partial modifier_keys
 xkb_symbols "menu_toggle" {
-    key	<MENU> {	[  ISO_Next_Group,	 Menu	]	};
+    key <MENU> { [ ISO_Next_Group, Menu ] };
 };
 
-// using the group(lwin_toggle) map, pressing the left Windows' logo key
-// toggles groups.  If you use this map, you would declare you keyboard
-// as pc101 or pc102 instead of pc104 or pc105.
+// Pressing the left Win key switches to the next group.
+// (Using this map, you should declare your keyboard as
+// pc101 or pc102 instead of pc104 or pc105.)
 partial modifier_keys
 xkb_symbols "lwin_toggle" {
-  virtual_modifiers AltGr;
-  key <LWIN> {
-    virtualMods= AltGr,
-    symbols[Group1] = [ ISO_Next_Group ]
+    virtual_modifiers AltGr;
+    key <LWIN> {
+         virtualMods= AltGr,
+        symbols[Group1] = [ ISO_Next_Group ]
     };
 };
 
-// using the group(rwin_toggle) map, pressing the right Windows' logo key
-// toggles groups.  If you use this map, you would declare you keyboard
-// as pc101 or pc102 instead of pc104 or pc105.
+// Pressing the right Win key switches to the next group.
+// (Using this map, you should declare your keyboard as
+// pc101 or pc102 instead of pc104 or pc105.)
 partial modifier_keys
 xkb_symbols "rwin_toggle" {
-  virtual_modifiers AltGr;
-  key <RWIN> {
-    virtualMods= AltGr,
-    symbols[Group1] = [ ISO_Next_Group ]
+    virtual_modifiers AltGr;
+    key <RWIN> {
+        virtualMods= AltGr,
+        symbols[Group1] = [ ISO_Next_Group ]
     };
 };
 
-// Both Ctrls pressed together toggle group
+// Pressing both Ctrl keys switches to the next or previous group
+// (depending on which Ctrl is pressed first).
 partial modifier_keys
 xkb_symbols "ctrls_toggle" {
-  virtual_modifiers LControl, RControl;
+    virtual_modifiers LControl, RControl;
     key <LCTL> {
-	type[Group1]="PC_RCONTROL_LEVEL2",
-	symbols[Group1]= [ NoSymbol,	ISO_Prev_Group ],
-	virtualMods= LControl
+        type[Group1]="PC_RCONTROL_LEVEL2",
+        symbols[Group1] = [ NoSymbol, ISO_Prev_Group ],
+        virtualMods= LControl
     };
     key <RCTL> {
-	type[Group1]="PC_LCONTROL_LEVEL2",
-	symbols[Group1]= [ NoSymbol,	ISO_Next_Group ],
-	virtualMods= RControl
+        type[Group1]="PC_LCONTROL_LEVEL2",
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
+        virtualMods= RControl
     };
 };
 
-// Both Alts pressed together toggle group
+// Pressing both Alt keys switches to the next or previous group
+// (depending on which Alt is pressed first).
 partial modifier_keys
 xkb_symbols "alts_toggle" {
-  virtual_modifiers LAlt, RAlt;
+    virtual_modifiers LAlt, RAlt;
     key <LALT> {
-	type[Group1]="PC_RALT_LEVEL2",
-	symbols[Group1]= [ NoSymbol,	ISO_Prev_Group ],
-	virtualMods= LAlt
+        type[Group1]="PC_RALT_LEVEL2",
+        symbols[Group1] = [ NoSymbol, ISO_Prev_Group ],
+        virtualMods= LAlt
     };
     key <RALT> {
-	type[Group1]="PC_LALT_LEVEL2",
-	symbols[Group1]= [ NoSymbol,	ISO_Next_Group ],
-	virtualMods= RAlt
+        type[Group1]="PC_LALT_LEVEL2",
+        symbols[Group1] = [ NoSymbol, ISO_Next_Group ],
+        virtualMods= RAlt
     };
 };
 
-// Left Shift key toggles group
+// Pressing the left Shift key switches to the next group.
 partial modifier_keys
 xkb_symbols "lshift_toggle" {
-  virtual_modifiers AltGr;
-    key <LFSH>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    virtual_modifiers AltGr;
+    key <LFSH> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// Right Shift key toggles group
+// Pressing the right Shift key switches to the next group.
 partial modifier_keys
 xkb_symbols "rshift_toggle" {
-  virtual_modifiers AltGr;
-    key <RTSH>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    virtual_modifiers AltGr;
+    key <RTSH> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// Left Alt key toggles group
+// Pressing the left Alt key switches to the next group.
 partial modifier_keys
 xkb_symbols "lalt_toggle" {
-  virtual_modifiers AltGr;
-    key <LALT>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    virtual_modifiers AltGr;
+    key <LALT> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// Left Ctrl key toggles group
+// Pressing the left Ctrl key switches to the next group.
 partial modifier_keys
 xkb_symbols "lctrl_toggle" {
-  virtual_modifiers AltGr;
-    key <LCTL>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    virtual_modifiers AltGr;
+    key <LCTL> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// Right Ctrl key toggles group
+// Pressing the right Ctrl key switches to the next group.
 partial modifier_keys
 xkb_symbols "rctrl_toggle" {
-  virtual_modifiers AltGr;
-    key <RCTL>	{	
-	symbols[Group1]= [	ISO_Next_Group	],
-	virtualMods= AltGr
+    virtual_modifiers AltGr;
+    key <RCTL> {
+        symbols[Group1] = [ ISO_Next_Group ],
+        virtualMods= AltGr
     };
 };
 
-// using the group(alt_caps_toggle) map, pressing:
-//     Alt+Caps Lock toggles group
-//     Caps Lock toggles caps lock
+// Pressing Alt+Caps_Lock switches to the next group,
+// pressing Caps_Lock toggles CapsLock.
 partial modifier_keys
 xkb_symbols "alt_caps_toggle" {
-    key        <CAPS> {
+    key <CAPS> {
        type="PC_ALT_LEVEL2",
-       symbols[Group1]= [  Caps_Lock,  ISO_Next_Group]
+       symbols[Group1] = [ Caps_Lock, ISO_Next_Group ]
     };
 };
 
 partial hidden modifier_keys
 xkb_symbols "olpc" {
-  key <I219>  { [ ISO_Next_Group, ISO_Prev_Group ] };
+    key <I219> { [ ISO_Next_Group, ISO_Prev_Group ] };
 };
 
 partial modifier_keys
 xkb_symbols "alt_space_toggle" {
     key <SPCE> {
-    type[Group1]="PC_ALT_LEVEL2",
-    symbols[Group1]= [ space,   ISO_Next_Group ]
+        type[Group1]="PC_ALT_LEVEL2",
+        symbols[Group1] = [ space, ISO_Next_Group ]
     };
 };
 
-// using the group(sclk_toggle) map, pressing the Scroll Lock key
-// toggles groups.
+// Pressing the Scroll Lock key switches to the next group,
 partial modifier_keys
 xkb_symbols "sclk_toggle" {
-  virtual_modifiers AltGr;
-  key <SCLK> {
-    virtualMods= AltGr,
-    symbols[Group1] = [ ISO_Next_Group ]
+    virtual_modifiers AltGr;
+    key <SCLK> {
+        virtualMods= AltGr,
+        symbols[Group1] = [ ISO_Next_Group ]
     };
 };
 
-// Control_L+Win_L locks the first group (presumably Lat).
-// Control_R+Menu locks the second group (presumably Rus).
+// Control_L+Win_L selects the first group (presumably Lat),
+// Control_R+Menu selects the second group (presumably Rus).
 partial modifier_keys
 xkb_symbols "lctrl_lwin_rctrl_menu" {
     key <LWIN> {
-        type[ Group1 ]    = "PC_CONTROL_LEVEL2",
-        symbols[ Group1 ] = [ Super_L,    ISO_First_Group ]
+        type[Group1] = "PC_CONTROL_LEVEL2",
+        symbols[Group1] = [ Super_L, ISO_First_Group ]
     };
     key <MENU> {
-        type[ Group1 ]    = "PC_CONTROL_LEVEL2",
-        symbols[ Group1 ] = [ Menu,       ISO_Last_Group ]
+        type[Group1] = "PC_CONTROL_LEVEL2",
+        symbols[Group1] = [ Menu, ISO_Last_Group ]
     };
-}; // lctrl_lwin_rctrl_menu
+};
diff --git a/xorg-server/xkeyboard-config/symbols/hr b/xorg-server/xkeyboard-config/symbols/hr
index bda2afd22..1ec0c809a 100644
--- a/xorg-server/xkeyboard-config/symbols/hr
+++ b/xorg-server/xkeyboard-config/symbols/hr
@@ -13,7 +13,7 @@ xkb_symbols "basic" {
     key <AB10> { [     minus, underscore, dead_belowdot, dead_abovedot ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "us" {
 
     name[Group1]= "Croatian (US keyboard with Croatian letters)";
@@ -48,7 +48,7 @@ xkb_symbols "us" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "alternatequotes" {
 
     name[Group1]= "Croatian (use guillemets for quotes)";
@@ -56,7 +56,7 @@ xkb_symbols "alternatequotes" {
     include "rs(latinalternatequotes)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "unicode" {
 
     name[Group1]= "Croatian (use Croatian digraphs)";
@@ -64,7 +64,7 @@ xkb_symbols "unicode" {
     include "rs(latinunicode)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "unicodeus" {
 
     name[Group1]= "Croatian (US keyboard with Croatian digraphs)";
diff --git a/xorg-server/xkeyboard-config/symbols/hu b/xorg-server/xkeyboard-config/symbols/hu
index 75b17fee5..e743360a3 100644
--- a/xorg-server/xkeyboard-config/symbols/hu
+++ b/xorg-server/xkeyboard-config/symbols/hu
@@ -353,7 +353,7 @@ hidden partial keypad_keys
 xkb_symbols "def_dot" { 	 
     key <KPDL>  { [    KP_Delete,   KP_Decimal                                     ] }; 	 
 }; 	 
- 
+
 
 // def_dead:
 // Dead keys support part
@@ -398,6 +398,7 @@ hidden partial alphanumeric_keys
 xkb_symbols "def_common" {
     key <AD01>  { [            q,            Q,         backslash                  ] };
     key <AD02>  { [            w,            W,               bar                  ] };
+    key <AD03>  { [            e,            E,        Adiaeresis                  ] };
     key <AD07>  { [            u,            U,          EuroSign                  ] };
     key <AD08>  { [            i,            I,            Iacute,          iacute ] };
     key <AD09>	{ [            o,            O,        doublelowquotemark          ] };
diff --git a/xorg-server/xkeyboard-config/symbols/ie b/xorg-server/xkeyboard-config/symbols/ie
index 48f7232f0..0830fede4 100644
--- a/xorg-server/xkeyboard-config/symbols/ie
+++ b/xorg-server/xkeyboard-config/symbols/ie
@@ -86,7 +86,7 @@ xkb_symbols "basic" {
     key <AC10> { [  semicolon,         colon,             ellipsis,         doubledagger ] };
     key <AC11> { [ apostrophe,            at,                   ae,                   AE ] };
     key <BKSL> { [ numbersign,    asciitilde,        guillemotleft,       guillemotright ] };
-                                                                  
+
 
     //
     // \ZXCVBNM,./
@@ -401,7 +401,7 @@ xkb_symbols "ogam_is434" {
     // Also overcomes annoying use of Scroll Lock LED inherited from
     // US symbols but not relevant here since we're not changing group.
     key <SCLK> {type[Group1] = "ONE_LEVEL", [ Shift_Lock ] };
-    modifier_map Shift { Shift_Lock }; 
+    modifier_map Shift { Shift_Lock };
 
     include "compose(rwin)"
 };
diff --git a/xorg-server/xkeyboard-config/symbols/il b/xorg-server/xkeyboard-config/symbols/il
index fa7564fb5..a1f615c62 100644
--- a/xorg-server/xkeyboard-config/symbols/il
+++ b/xorg-server/xkeyboard-config/symbols/il
@@ -43,12 +43,12 @@ xkb_symbols "basic" {
     key <AB09> { [ hebrew_finalzade,	less	]	};
 
     key.type[Group1] = "THREE_LEVEL";
-    
+
     key <TLDE> { [ semicolon,	asciitilde,0x10005b0	]}; // Sheva
     key <AB10> { [ period,	question,  0x10005c3	]}; // Sof Pasuq
     key <AD03> { [ hebrew_qoph,	E,	EuroSign	]};
     key <AC01> { [ hebrew_shin,	A,	0x10020AA	]};
-  
+
     // The following may get overriden by the iso9995-3(basic101) symbols.
     // therefore they are included here. 
     // Including them isn't a great idea (for instance: what if group 1 uses
@@ -67,11 +67,11 @@ xkb_symbols "basic" {
     key <AE10> { [     0, parenleft  , 0x10005c1	]}; // Shin dot
     key <AE11> { [ minus, underscore  , 0x10005b9	]}; // Holam
     key <AE12> { [ equal, plus        , 0x10005bc	]}; // Dagesh/Shuruq
-  
+
     // Mirrored: 
     key <AD11> { [ bracketright, braceright, 0x10005bf	]}; // Rafe
     key <AD12> { [ bracketleft,  braceleft,  0x10005bd	]}; // Meteg
-                                      
+
     key <BKSL> { [ backslash,    bar,  0x10005bb	]}; // Qubuts    
 
     include "level3(ralt_switch)"
@@ -79,7 +79,7 @@ xkb_symbols "basic" {
 
 
 // nikud patter based on Dekel Tsur's Hebrew mapping for LyX
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "lyx" {
     name[Group1]= "Hebrew (lyx)";
 
@@ -103,7 +103,7 @@ xkb_symbols "lyx" {
     key <AC01> { [ hebrew_shin,	0x10005b0	]	}; // Sheva
     key <AC02> { [ hebrew_dalet,	0x10005bc	]       }; // Dagesh/Shuruq
     key <AC03> { [ hebrew_gimel,	hebrew_gimel	]       };
-    key <AC04> { [ hebrew_kaph,	hebrew_kaph	]	}; 
+    key <AC04> { [ hebrew_kaph,	hebrew_kaph	]	};
     key <AC05> { [ hebrew_ayin,	0x10005c2	]       }; // Sin dot
     key <AC06> { [ hebrew_yod,	0x10005c1	]       }; // Shin dot
     key <AC07> { [ hebrew_chet,	0x10005b4	]	}; // Hiriq
@@ -136,13 +136,13 @@ xkb_symbols "lyx" {
     key <AE08> { [ 8, asterisk    ]};
     key <AE09> { [ 9, parenright  ]};
     key <AE10> { [ 0, parenleft	  ]};
-    
+
     key <AE11> { [ minus     ,	0x10005be	]	}; // H. Hiphen
     key <AE12> { [ equal     ,	plus		]	};
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "phonetic" {
 
     // uses the phonetic layout from old Slackware 'il.map' file
@@ -199,7 +199,7 @@ xkb_symbols "phonetic" {
 // layout below does not include 'il(basic)' but redoes the _whole_ thing from
 // scratch.
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "biblical" {
 	name[Group1]= "Hebrew (Biblical, Tiro)";
 	key.type = "FOUR_LEVEL_SEMIALPHABETIC";
@@ -267,7 +267,7 @@ xkb_symbols "biblical" {
 // The layout corresponds phonetically to a US standard layout or similar (Qwerty).
 // If you are using an actual Hebrew keyboard, you are probably better off using a Tiro compliant scholarly layout
 // This linux port created and maintained by Dennis Meulensteen, dennis@meulensteen.nl
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "biblicalSIL" {
 	name[Group1]= "Hebrew (Biblical, SIL phonetic)";
 	key.type = "FOUR_LEVEL_SEMIALPHABETIC";
diff --git a/xorg-server/xkeyboard-config/symbols/in b/xorg-server/xkeyboard-config/symbols/in
index 68f63e528..fdf008887 100644
--- a/xorg-server/xkeyboard-config/symbols/in
+++ b/xorg-server/xkeyboard-config/symbols/in
@@ -1,6 +1,6 @@
 // This layout includes all Indian layouts, including:
 //     - Devanagari (Hindi, Marathi, Sanskrit)
-//     - Bengali
+//     - Bangla
 //     - Gujarati
 //     - Kannada
 //     - Malayalam
@@ -12,12 +12,12 @@
 // Links:
 // - Indic INSCRIPT keyboard layout diagrams:
 //     http://java.sun.com/products/jfc/tsc/articles/InputMethod/indiclayout.html
-// - Bengali Baishakhi (Bengali layouts):
-// - Bengali Baishakhi Inscript (Bengali layouts):
-// - Bengali Bornona (Bengali layouts):
-// - Uni Gitanjali (Bengali layouts):
+// - Bangla Baishakhi (Bangla layouts):
+// - Bangla Baishakhi Inscript (Bangla layouts):
+// - Bangla Bornona (Bangla layouts):
+// - Uni Gitanjali (Bangla layouts):
 //     http://nltr.org
-// - Ekusheyr Shadhinota (Bengali layouts):
+// - Ekusheyr Shadhinota (Bangla layouts):
 //     http://ekushey.org/projects/shadhinota/index.html
 // - Microsoft Windows XP SP2: Indic Language Standards - an Introduction:
 //     http://www.bhashaindia.com/MSProducts/XpSp2/Articles/IndicLanguageStandards.aspx
@@ -135,9 +135,9 @@ xkb_symbols "bolnagri" {
     key <AD08>   { [   U093F,   U0940,	U0907,	U0908   ] };  // I: i, ii matras
     key <AD09>   { [   U094B,   U094C,	U0913,	U0914   ] };  // O: o, au matras
     key <AD10>   { [   U092A,   U092B   ] };  // P: pa, pha
-    key <AD11>   { [   bracketleft,   braceleft   ] };  
+    key <AD11>   { [   bracketleft,   braceleft   ] };
     key <AD12>	 { [   bracketright, braceright   ] };
-    
+
     //A Row
     key <AC01>   { [   U093E,	 U0906,	U0905,	U0906  ] };   // A: aa, full A, AA
     key <AC02>   { [   U0938,    U0937   ] };  // S: sa, ssa
@@ -148,7 +148,7 @@ xkb_symbols "bolnagri" {
     key <AC07>   { [   U091C,    U091D   ] };  // J: ja, jha
     key <AC08>   { [   U0915,    U0916   ] };  // K: ka, kha
     key <AC09>   { [   U0932,	 U0933,	U0962,   U090C   ] };  // L: la, vocalic L or lru matra
-    key <AC10>   { [   semicolon, colon  ] }; 
+    key <AC10>   { [   semicolon, colon  ] };
     key <AC11>   { [apostrophe, quotedbl ] };
 
     //Z Row
@@ -176,7 +176,7 @@ xkb_symbols "bolnagri" {
 
 partial alphanumeric_keys
 xkb_symbols "ben" {
-    name[Group1]= "Bengali (India)";
+    name[Group1]= "Bangla (India)";
 
       // Mainly numbers.
       key <AE01> { [      U09E7 		]	};
@@ -244,7 +244,7 @@ xkb_symbols "ben" {
 };
 
 xkb_symbols "ben_probhat" {
- name[Group1]= "Bengali (India, Probhat)";
+ name[Group1]= "Bangla (India, Probhat)";
    key <ESC>  { [ Escape ] };
 
 // numbers
@@ -318,10 +318,10 @@ xkb_symbols "ben_probhat" {
     include "rupeesign(4)"
 };
 
-// Bengali Baishakhi, Bengali Baishakhi Inscript, Bengali Bornona, Uni Gitanjali Layouts are added by Promathesh Mandal <promathesh812004@gmail.com>
+// Bangla Baishakhi, Bangla Baishakhi Inscript, Bangla Bornona, Uni Gitanjali Layouts are added by Promathesh Mandal <promathesh812004@gmail.com>
 
 xkb_symbols "ben_baishakhi" {
- name[Group1]= "Bengali (India, Baishakhi)";
+ name[Group1]= "Bangla (India, Baishakhi)";
    key <ESC>   { [ Escape 					] };
 
 // numbers
@@ -398,7 +398,7 @@ xkb_symbols "ben_baishakhi" {
 };
 
 xkb_symbols "ben_inscript" {
-    name[Group1]= "Bengali (India, Baishakhi Inscript)";
+    name[Group1]= "Bangla (India, Baishakhi Inscript)";
 
       // Mainly numbers.
       key <TLDE> { [      0x100200D, 0x100200C	] 	};
@@ -464,7 +464,7 @@ xkb_symbols "ben_inscript" {
 };
 
 xkb_symbols "ben_gitanjali" {
- name[Group1]= "Bengali (India, Uni Gitanjali)";
+ name[Group1]= "Bangla (India, Uni Gitanjali)";
    key <ESC>   { [ Escape			] };
 
 // numbers
@@ -542,7 +542,7 @@ xkb_symbols "ben_gitanjali" {
 
 
 xkb_symbols "ben_bornona" {
- name[Group1]= "Bengali (India, Bornona)";
+ name[Group1]= "Bangla (India, Bornona)";
    key <ESC>  { [ Escape 					] };
 
 // numbers
@@ -616,7 +616,7 @@ xkb_symbols "ben_bornona" {
 
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "guj" {
       name[Group1]= "Gujarati";
 
@@ -683,7 +683,7 @@ xkb_symbols "guj" {
       include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "kan" {
 
     // Inscript layout for Kannada  
@@ -719,7 +719,7 @@ xkb_symbols "kan" {
     key <AD10> { [  U0c9c, U0c9d	] };
     key <AD11> { [  U0ca1, U0ca2	] };
     key <AD12> { [  U0cbc, U0c9e	] };
- 
+
     key <AC01> { [  U0ccb, U0c93	] };
     key <AC02> { [  U0cc7, U0c8f	] };
     key <AC03> { [  U0ccd, U0c85	] };
@@ -757,13 +757,13 @@ xkb_symbols "kan" {
 // Date        : Sat Aug  17 21:10:48 IST 2002
 // Mapping:
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mal" {
 
     name[Group1] = "Malayalam";
 
     //From grave to backslash (\)
-    
+
     key <TLDE> { [ U0d4a , U0d12           ] };
 
 // svu: 
@@ -771,7 +771,7 @@ xkb_symbols "mal" {
 // but the digits are replaced with the ones from 'mal_plusnum' -
 // for the integrity of all Indian layouts
 //
-//    key <AE01> { [1           ,     exclam           ] }; 
+//    key <AE01> { [1           ,     exclam           ] };
 //    key <AE02> { [2           ,         at           ] };
 //    key <AE03> { [3           , numbersign           ] };
 //    key <AE04> { [4           ,     dollar           ] };
@@ -797,9 +797,9 @@ xkb_symbols "mal" {
     key <AE12> { [ U0d43 , U0d0b           ] };
     key <BKSL>  { [U0200c, U05C ]};//bksl: ZWNJ 
 
-  
+
     // From 'q' to right bracket (])
-    
+
     key <AD01> { [ U0d4c , U0d14 ] };
     key <AD02> { [ U0d48 , U0d10 ] };
     key <AD03> { [ U0d3e , U0d06 ] };
@@ -814,7 +814,7 @@ xkb_symbols "mal" {
     key <AD12> { [ U0200d , U0d1e ] };
 
     // From 'a' to apostrophe (')
-    
+
     key <AC01> { [ U0d4b , U0d13 ] };
     key <AC02> { [ U0d47 , U0d0f ] };
     key <AC03> { [ U0d4d , U0d05 ] };
@@ -826,9 +826,9 @@ xkb_symbols "mal" {
     key <AC09> { [ U0d24 , U0d25 ] };
     key <AC10> { [ U0d1a , U0d1b ] };
     key <AC11> { [ U0d1f , U0d20 ] };
-    
+
     // From 'z' to slash (/)
-    
+
     key <AB01> { [ U0d46 , U0d0e ] };
     key <AB02> { [ U0d02 , U200b ] };//X:ZWSP
     key <AB03> { [ U0d2e , U0d23 ] };
@@ -884,7 +884,7 @@ xkb_symbols "mal_lalitha" {
     key <AD10>   { [   U0D2A   ] };  // P: pa
     key <AD11>   { [   bracketleft,   braceleft   ] };//braceleft:   
     key <AD12>	 { [   bracketright, braceright   ] };//braceright:
-    
+
     //A Row
     key <AC01>   { [   U0D3E,	 U0D05,	U0D06,	U0D05  ] };   // A: a,aa
     key <AC02>   { [   U0D38,    U0D37   ] };  // S: sa, ssa
@@ -895,7 +895,7 @@ xkb_symbols "mal_lalitha" {
     key <AC07>   { [   U0D1C,    U0D1D   ] };  // J: ja, jha
     key <AC08>   { [   U0D15,    U0D16   ] };  // K: ka, kha
     key <AC09>   { [   U0D32,	 U0D33   ] };  // L: la, vocalic L or lru matra`
-    key <AC10>   { [   semicolon, colon  ] }; 
+    key <AC10>   { [   semicolon, colon  ] };
     key <AC11>   { [apostrophe, quotedbl ] };
 
     //Z Row
@@ -919,14 +919,14 @@ xkb_symbols "mal_lalitha" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "ori" {
     // Inscript layout for Oriya  
     // Author: G Karunakar <karunakar@freedomink.org>
     // Date: Wed Nov 13 18:16:19 IST 2002
 
     name[Group1]= "Oriya";
-    
+
     key <AE01> { [  U0b67			] };
     key <AE02> { [  U0b68			] };
     key <AE03> { [  U0b69			] };
@@ -952,7 +952,7 @@ xkb_symbols "ori" {
     key <AD10> { [  U0b1c, U0b1d	] };
     key <AD11> { [  U0b21, U0b22	] };
     key <AD12> { [  U0b3c, U0b1e	] };
- 
+
     key <AC01> { [  U0b4b, U0b13	] };
     key <AC02> { [  U0b47, U0b0f	] };
     key <AC03> { [  U0b4d, U0b05	] };
@@ -964,7 +964,7 @@ xkb_symbols "ori" {
     key <AC09> { [  U0b24, U0b25	] };
     key <AC10> { [  U0b1a, U0b1b	] };
     key <AC11> { [  U0b1f, U0b20	] };
- 
+
     key <AB02> { [  U0b02, U0b01	] };
     key <AB03> { [  U0b2e, U0b23	] };
     key <AB04> { [  U0b28			] };
@@ -985,7 +985,7 @@ xkb_symbols "ori" {
 
 // based on a keyboard map from an 'xkb/symbols/tml' file
 // INSCRIPT
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tam" {
       name[Group1]= "Tamil";
 
@@ -1016,7 +1016,7 @@ xkb_symbols "tam" {
 // Mainly voiced consonants
 
       key <AD07> { [      U0BB9, U0B99	]	};
-      key <AD10> { [      U0B9c 	]	}; 
+      key <AD10> { [      U0B9c 	]	};
       key <AD12> { [      U0B9E				]	};
 
 // Mainly short vowels
@@ -1051,7 +1051,7 @@ xkb_symbols "tam" {
       include "rupeesign(4)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tam_unicode" {
 
 // Description: A keymap based on the TamilNet'99 typewriter keyboard 
@@ -1061,7 +1061,7 @@ xkb_symbols "tam_unicode" {
 // Secondary contact: Sri Ramadoss M <amachu@au-kbc.org>
 // Date  : Fri Sep 4 11:32:00 CST 2009
 // Mapping:
-  
+
     name[Group1]= "Tamil (Unicode)";
 
     // granthas
@@ -1105,7 +1105,7 @@ xkb_symbols "tam_unicode" {
     key <AC09> { [ U0B9F ] };
     key <AC10> { [ U0BCD, U0B83 ] };
     key <AC11> { [ U0B99 ] };
-    
+
     // Zrow
     key <AB01> { [ U0BA3 ]  };
     key <AB02> { [ U0B92, U0B93 ]  };
@@ -1182,7 +1182,7 @@ xkb_symbols "tam_keyboard_with_numerals" {
     key <AB08> { [ U0B87, U0B88 ]  };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tam_TSCII" {
 
 // Description	: A Tamil typewrite-style keymap 
@@ -1200,7 +1200,7 @@ xkb_symbols "tam_TSCII" {
     key <AE05> {  [ 0x1000085, 0x100008a ] }; // sa
     key <AE06> {  [ 0x1000086, 0x100008b ] }; // ha
     key <AE07> {  [ 0x1000087, 0x100008c ] }; // ksha
-	
+
     // Qrow
     key <AD01> {  [ 0x10000bb, 0x100009a ] }; // nja
     key <AD02> {  [ 0x10000c8, 0x10000da ] }; // Ra
@@ -1226,7 +1226,7 @@ xkb_symbols "tam_TSCII" {
     key <AC09> { [ 0x10000bc, 0x10000ce ] }; // da
     key <AC10> { [ 0x10000c6, 0x10000d8 ] }; // zha
     key <AC11> { [ 0x10000b9, 0x1000099 ] }; // nga
-    
+
     // Zrow
     key <AB01> { [ 0x10000bd, 0x10000cf ] }; // Na
     key <AB02> { [ 0x10000b4, 0x10000b5 ] }; // o, O
@@ -1239,7 +1239,7 @@ xkb_symbols "tam_TSCII" {
 
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tam_TAB" {
 
 // Description: A keymap based on the TamilNet'99 typewriter keyboard 
@@ -1257,7 +1257,7 @@ xkb_symbols "tam_TAB" {
     key <AE05> {  [ 0x10000fd ] } ;
     key <AE06> {  [ 0x10000fe ] } ;
     key <AE07> {  [ 0x10000ff ] } ;
-	
+
     // q-row
     key <AD01> {  [ 0x10000eb, 0x10000b3 ] };
     key <AD02> {  [ 0x10000f8, 0x10000c1 ] };
@@ -1283,7 +1283,7 @@ xkb_symbols "tam_TAB" {
     key <AC09> {  [ 0x10000ec, 0x10000b4 ] };
     key <AC10> {  [ 0x10000f6, 0x10000bf ] };
     key <AC11> {  [ 0x10000e9, 0x10000b1 ] };
-    
+
     // z-row
     key <AB01> {  [ 0x10000ed, 0x10000b5 ] };
     key <AB02> {  [ 0x10000e5, 0x10000e6 ] };
@@ -1295,7 +1295,7 @@ xkb_symbols "tam_TAB" {
     key <AB08> {  [ 0x10000de, 0x10000df ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tel" {
 
     // Inscript layout for Telugu using Unicode 
@@ -1318,8 +1318,8 @@ xkb_symbols "tel" {
     key <AE10> { [  U0c66, parenright	] };
     key <AE11> { [  U0c03, underscore	] };
     key <AE12> { [  U0c43, U0c0b	] };
-    key <BKSP> { [  BackSpace			] };    
- 
+    key <BKSP> { [  BackSpace			] };
+
     key <AD01> { [  U0c4c, U0c14	] };
     key <AD02> { [  U0c48, U0c10	] };
     key <AD03> { [  U0c3e, U0c06	] };
@@ -1332,7 +1332,7 @@ xkb_symbols "tel" {
     key <AD10> { [  U0c1c, U0c1d	] };
     key <AD11> { [  U0c21, U0c22	] };
     key <AD12> { [  U0c1e			] };
-  
+
     key <AC01> { [  U0c4b, U0c13	] };
     key <AC02> { [  U0c47, U0c0f	] };
     key <AC03> { [  U0c4d, U0c05	] };
@@ -1344,7 +1344,7 @@ xkb_symbols "tel" {
     key <AC09> { [  U0c24, U0c25	] };
     key <AC10> { [  U0c1a, U0c1b	] };
     key <AC11> { [  U0c1f, U0c20	] };
- 
+
     key <AB01> { [  U0c46, U0c0e	] };
     key <AB02> { [  U0c02, U0c01	] };
     key <AB03> { [  U0c2e, U0c23	] };
@@ -1364,19 +1364,19 @@ xkb_symbols "tel" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "urd-phonetic" {
     include "pk(urd-phonetic)"
     name[Group1]= "Urdu (phonetic)";
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "urd-phonetic3" {
     include "pk(urd-crulp)"
     name[Group1]= "Urdu (alternative phonetic)";
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "urd-winkeys" {
     include "pk(urd-nla)"
     name[Group1]= "Urdu (WinKeys)";
@@ -1457,7 +1457,7 @@ xkb_symbols "guru" {
 //			http://www.satluj.org/Jhelum.html
 //Modified for Inscript to make
 //Original Author :	Amanpreet Singh Alam <apreet.alam@gmail.com
- 
+
 partial alphanumeric_keys
 xkb_symbols "jhelum" {
       name[Group1] = "Punjabi (Gurmukhi Jhelum)";
@@ -1478,7 +1478,7 @@ xkb_symbols "jhelum" {
      key <AE11>	{ [   minus,underscore] };
      key <AE12>	{ [   equal,plus] };
      key <BKSL>  { [   U0964,U0965,U007C,U005C] }; //pipe : danda, double danda
- 
+
      //Q Row	
      key <AD01>   { [   U0A4C, 	U0A14   ] };  // Q: oo, ooh
      key <AD02>   { [   U0A48,  	U0A10	] };  // W: ee, ae
@@ -1490,9 +1490,9 @@ xkb_symbols "jhelum" {
      key <AD08>   { [   U0A17,   U0A18, U0A5A   ] };  // I:ga, gha
      key <AD09>   { [   U0A24,   U0A1F   ] };  // O: ta, tha
      key <AD10>   { [   U0A2A,   U0A5E, VoidSymbol,U0A5E  ] };  // P: pa, pha
-     key <AD11>   { [   U0A21,   U0A22,   bracketleft,   braceleft   ] };  
+     key <AD11>   { [   U0A21,   U0A22,   bracketleft,   braceleft   ] };
      key <AD12>	 { [   U0A19,   U0A1E,   bracketright, braceright   ] };
-     
+
      //A Row
      key <AC01>   { [   U0A4B,	 U0A13  ] };   // A: o, oo
      key <AC02>   { [   U0A47,    U0A0F   ] };  // S: e, ee
@@ -1505,7 +1505,7 @@ xkb_symbols "jhelum" {
      key <AC09>   { [   U0A32,	 U0A25, U0A33   ] };  // L: la, tha
      key <AC10>   { [   U0A38,   colon, U0A36  ] }; //; sa
      key <AC11>   { [apostrophe, quotedbl ] };
- 
+
      //Z Row
      key <AB01>   { [   U0A71,	 U0A3C 	 ] };  // Z: addak, par bindi
      key <AB02>   { [   U0A02,    U0A70	 ] };  // X: bindi, tippi
@@ -1517,7 +1517,7 @@ xkb_symbols "jhelum" {
      key <AB08>   { [   comma,    U262C	 ] };// comma: comma, dev abbreviation sign
      key <AB09>   { [   period,   U0A74 	 ] };  // period: period, nukta
      key <AB10>   { [   slash,   question ] };
- 
+
 //    modifier_map Shift  { Shift_L };
 //    modifier_map Lock   { Caps_Lock };
 //    modifier_map Control{ Control_L };
@@ -1534,15 +1534,15 @@ xkb_symbols "olpc" {
   key <TLDE> { [	U094A,	U0912 ] }; // DEVANAGARI VOWEL SIGN SHORT O; DEVANAGARI LETTER SHORT O
   key <AE01> { [	U0967,	U090D ] }; // DEVANAGARI DIGIT ONE; DEVANAGARI LETTER CANDRA E
   key <AE02> { [	U0968,	U0945 ] }; // DEVANAGARI DIGIT TWO; DEVANAGARI VOWEL SIGN CANDRA E
-  key <AE03> { [	U0969	 ] }; // DEVANAGARI DIGIT THREE; 
-  key <AE04> { [	U096A	 ] }; // DEVANAGARI DIGIT FOUR; 
-  key <AE05> { [	U096B	 ] }; // DEVANAGARI DIGIT FIVE; 
-  key <AE06> { [	U096C	 ] }; // DEVANAGARI DIGIT SIX; 
-  key <AE07> { [	U096D	 ] }; // DEVANAGARI DIGIT SEVEN; 
-  key <AE08> { [	U096E	 ] }; // DEVANAGARI DIGIT EIGHT; 
-  key <AE09> { [	U096F,	parenleft ] }; // DEVANAGARI DIGIT NINE; 
-  key <AE10> { [	U0966,	parenright ] }; // DEVANAGARI DIGIT ZERO; 
-  key <AE11> { [	minus,		U0903 ] }; // DEVANAGARI SIGN VISARGA; 
+  key <AE03> { [	U0969	 ] }; // DEVANAGARI DIGIT THREE;
+  key <AE04> { [	U096A	 ] }; // DEVANAGARI DIGIT FOUR;
+  key <AE05> { [	U096B	 ] }; // DEVANAGARI DIGIT FIVE;
+  key <AE06> { [	U096C	 ] }; // DEVANAGARI DIGIT SIX;
+  key <AE07> { [	U096D	 ] }; // DEVANAGARI DIGIT SEVEN;
+  key <AE08> { [	U096E	 ] }; // DEVANAGARI DIGIT EIGHT;
+  key <AE09> { [	U096F,	parenleft ] }; // DEVANAGARI DIGIT NINE;
+  key <AE10> { [	U0966,	parenright ] }; // DEVANAGARI DIGIT ZERO;
+  key <AE11> { [	minus,		U0903 ] }; // DEVANAGARI SIGN VISARGA;
   key <AE12> { [	U0943,	U090B ] }; // DEVANAGARI VOWEL SIGN VOCALIC R; DEVANAGARI LETTER VOCALIC R
 
   key <AD01> { [	U094C,	U0914 ] }; // DEVANAGARI VOWEL SIGN AU; DEVANAGARI LETTER AU
@@ -1591,7 +1591,7 @@ xkb_symbols "olpc" {
   include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "hin-wx" {
 
     name[Group1]= "Hindi (Wx)";
@@ -1678,13 +1678,13 @@ xkb_symbols "eng" {
 // Comment     : Based on the Inscript Keyboard created by M Baiju
 // Mapping:
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mal_enhanced" {
 
     name[Group1] = "Malayalam (enhanced Inscript with Rupee Sign)";
 
    //From grave to backslash (\)
-    
+
       key <TLDE> { [ U0d4a ,       U0d12 ] };
       key <AE01> { [ U0d67 ,      exclam ] };
       key <AE02> { [ U0d68 ,          at ] };
@@ -1703,7 +1703,7 @@ xkb_symbols "mal_enhanced" {
 
 
   // From 'q' to right bracket (])
-    
+
     key <AD01> { [ U0d57 , U0d14 ] };
     key <AD02> { [ U0d48 , U0d10 ] };
     key <AD03> { [ U0d3e , U0d06 ] };
@@ -1718,7 +1718,7 @@ xkb_symbols "mal_enhanced" {
     key <AD12> { [ U0200d , U0d1e ] };
 
     // From 'a' to apostrophe (')
-    
+
     key <AC01> { [ U0d4b , U0d13 ] };
     key <AC02> { [ U0d47 , U0d0f ] };
     key <AC03> { [ U0d4d , U0d05 ] };
@@ -1730,9 +1730,9 @@ xkb_symbols "mal_enhanced" {
     key <AC09> { [ U0d24 , U0d25 ] };
     key <AC10> { [ U0d1a , U0d1b ] };
     key <AC11> { [ U0d1f , U0d20 ] };
-    
+
     // From 'z' to slash (/)
-    
+
     key <AB01> { [ U0d46 , U0d0e ] };
     key <AB02> { [ U0d02 , U0d7a ] };
     key <AB03> { [ U0d2e , U0d23 ] };
diff --git a/xorg-server/xkeyboard-config/symbols/inet b/xorg-server/xkeyboard-config/symbols/inet
index 839439a96..fe21f1ed7 100644
--- a/xorg-server/xkeyboard-config/symbols/inet
+++ b/xorg-server/xkeyboard-config/symbols/inet
@@ -1,8 +1,8 @@
-// EAK (Easy Access, Internet, Multimedia, PDA) keyboards
+// EAK (Easy Access keyboards: Internet, Multimedia, PDA)
 // Copyright (C) 2002 Stanislav Brabec <sbrabec@suse.cz>
 //
-// Based on LinEAK project
-// LinEAK - Linux support for Easy Access and Internet Keyboards      
+// Based on the LinEAK project.
+// LinEAK - Linux support for Easy Access and Internet Keyboards
 // Copyright (C) 2001, 2002 Mark Smulders <Mark@PIRnet.nl>
 
 // Usage in XF86Config:
@@ -13,28 +13,25 @@
 // Simple command line usage:
 // setxkbmap 'my_kb_layout' -variant 'my_kb_variant' -model 'my_eak_type'
 
-// All keyboards listed here should be also mentioned in
-// rules/base, base.lst and base.xml.
-
-// Very common set of media keys
+// Very common set of media keys.
 partial hidden alphanumeric_keys
 xkb_symbols "media_common" {
-    key <I01>   {       [ XF86AudioMedia        ] }; 
+    key <I01>   {       [ XF86AudioMedia        ] };
     key <I10>   {       [ XF86AudioPrev         ] };
     key <I19>   {       [ XF86AudioNext         ] };
     key <I20>   {       [ XF86AudioMute         ] };
     key <I22>   {       [ XF86AudioPlay, XF86AudioPause ] };
     key <I24>   {       [ XF86AudioStop, XF86Eject ] };
-    key <I2E>   {       [ XF86AudioLowerVolume  ] };	
+    key <I2E>   {       [ XF86AudioLowerVolume  ] };
     key <I30>   {       [ XF86AudioRaiseVolume  ] };
     key <K5A>   {       [ XF86Eject             ] };
     key <K6C>   {       [ XF86Eject             ] };
 };
 
-// popular web navigation combination
+// Popular web navigation keys.
 partial hidden alphanumeric_keys
 xkb_symbols "nav_common" {
-    key <I21>   {       [ XF86Calculator        ] }; 
+    key <I21>   {       [ XF86Calculator        ] };
     key <I32>   {       [ XF86WWW               ] };
     key <I65>   {       [ XF86Search            ] };
     key <I66>   {       [ XF86Favorites         ] };
@@ -44,7 +41,7 @@ xkb_symbols "nav_common" {
     key <I6A>   {       [ XF86Back              ] };
     key <I6B>   {       [ XF86MyComputer        ] };
     key <I6C>   {       [ XF86Mail              ] };
-    key <I6D>   {       [ XF86AudioMedia        ] }; 
+    key <I6D>   {       [ XF86AudioMedia        ] };
 };
 
 // ACPI Standard
@@ -58,7 +55,7 @@ xkb_symbols "acpi_common" {
     key <I16>	{	[ XF86Sleep		]	};
 };
 
-// Combined sections, for simplicity
+// Combined sections, for simplicity.
 partial hidden alphanumeric_keys
 xkb_symbols "media_nav_common" {
     include "inet(media_common)"
@@ -122,7 +119,7 @@ xkb_symbols "evdev" {
 
     key <FK20>   {      [ XF86AudioMicMute      ]       };
 
-//  key <I120>   {      [ ]       }; // KEY_MACRO 
+//  key <I120>   {      [ ]       }; // KEY_MACRO
     key <I126>   {      [ plusminus             ]       };
     key <I128>   {      [ XF86LaunchA           ]       };
     key <I147>   {      [ XF86MenuKB            ]       };
@@ -139,8 +136,8 @@ xkb_symbols "evdev" {
     key <I158>   {      [ XF86WWW               ]       };
     key <I159>   {      [ XF86DOS               ]       };
     key <I160>   {      [ XF86ScreenSaver       ]       };
-//  key <I161>   {      [ ]       }; // KEY_DIRECTION
-    key <I162>   {      [ XF86RotateWindows     ]       };
+    key <I161>   {      [ XF86RotateWindows     ]       };
+    key <I162>   {      [ XF86TaskPane          ]       };
     key <I163>   {      [ XF86Mail              ]       };
     key <I164>   {      [ XF86Favorites         ]       };
     key <I165>   {      [ XF86MyComputer        ]       };
@@ -220,7 +217,7 @@ xkb_symbols "evdev" {
 //  key <I253>   {      [ ]       }; // KEY_DISPLAY_OFF  --  turn off display
 //  key <I254>   {      [ ]       }; // KEY_WIMAX
     key <I255>   {      [ XF86Hibernate         ]       }; // KEY_HIBERNATE
- 
+
     key <FK13>   {      [ XF86Tools         ]       };
     key <FK14>   {      [ XF86Launch5       ]       };
     key <FK15>   {      [ XF86Launch6       ]       };
@@ -230,6 +227,8 @@ xkb_symbols "evdev" {
 };
 
 
+// Acer
+
 // Acer AirKey V
 partial alphanumeric_keys
 xkb_symbols "airkey" {
@@ -299,15 +298,16 @@ xkb_symbols "acer_laptop" {
     key <K66>   {       [ XF86Launch3           ]        }; // Fn+F2 (HAL)
 
     // Special Characters
-    // To avoid setting a precedent/ standard that will be broken in later
+    // To avoid setting a precedent/standard that will be broken in later
     // versions of HAL, these keys are commented out for now. When they are no
     // longer marked 'FIXME' and have saner keycodes, these two entries can be
     // fixed and permanently uncommented. In the meantime, just uncomment these
-    // to make the keys work
+    // to make the keys work.
 //  key <K5D>   {       [ EuroSign              ]        }; // Euro (HAL)
 //  key <K5E>   {       [ dollar                ]        }; // Dollar (HAL)
 };
 
+
 // Azona
 
 // Azona RF2300 wireless Internet Keyboard
@@ -374,7 +374,6 @@ xkb_symbols "btc5113rf" {
     key <I32>	{	[ XF86Search		]	};
 };
 
-
 // BTC 9000
 partial alphanumeric_keys
 xkb_symbols "btc9000" {
@@ -444,7 +443,8 @@ xkb_symbols "btc9019u" {
     key <I02>  {	[ XF86HomePage		]	};
 };
 
-// Cherry Blue Line
+
+// Cherry
 
 // Cherry Blue Line CyBo@rd
 partial alphanumeric_keys
@@ -509,7 +509,7 @@ xkb_symbols "cherrycyboard" {
 };
 
 // Cherry CyMotion Expert
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "cherrycmexpert" {
     include "inet(cherryblueb)"
     include "inet(acpi_common)"
@@ -520,7 +520,7 @@ xkb_symbols "cherrycmexpert" {
 // Chicony
 
 // Chicony Internet Keyboard
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "chicony" {
     include "inet(acpi_common)"
     key <I12>	{	[ XF86AudioMute		]	};
@@ -542,7 +542,7 @@ xkb_symbols "chicony" {
 };
 
 // Chicony KU-0108
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "chicony0108" {
     include "inet(cherrycyboard)"
 };
@@ -592,7 +592,7 @@ xkb_symbols "compaqeak8" {
 };
 
 // Compaq Internet Keyboard (7 keys)
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "compaqik7" {
     key <I12>	{	[ XF86LightBulb		]	};
     key <I1E>	{	[ XF86Mail		]	};
@@ -630,7 +630,6 @@ xkb_symbols "compaqik18" {
     key <I68>	{	[ Print			]	};
 };
 
-
 // Laptop/notebook Compaq (eg. Armada, Evo) Laptop Keyboard
 partial alphanumeric_keys
 xkb_symbols "armada" {
@@ -639,9 +638,9 @@ xkb_symbols "armada" {
     key <I1E>	{	[ XF86Mail		]	};
     key <I1F>	{	[ XF86HomePage		]	};
     key <I23>	{	[ XF86WWW		]	};
-    key <I59>   {       [ XF86Launch2           ]       }; // Battery Monitor 
+    key <I59>   {       [ XF86Launch2           ]       }; // Battery Monitor
     key <I6F>	{	[ XF86AudioMedia	]	};
-    key <I75>   {       [ XF86Launch0           ]       }; // Info Center 
+    key <I75>   {       [ XF86Launch0           ]       }; // Info Center
 };
 
 // Laptop/notebook Compaq (eg. Presario) Internet Keyboard
@@ -707,8 +706,8 @@ xkb_symbols "dellusbmm" {
     // From Olivier Lahaye <olivier dot lahaye at motorola dot com>
     include "inet(media_nav_acpi_common)"
     key <I02>	{	[ XF86HomePage		]	};
-    key <K67>	{	[ XF86MyComputer	]	}; 
-    key <XFER>	{	[ XF86AudioMedia	]	};  
+    key <K67>	{	[ XF86MyComputer	]	};
+    key <XFER>	{	[ XF86AudioMedia	]	};
 };
 
 
@@ -751,8 +750,7 @@ xkb_symbols "genius" {
     key <I32>   {	[ XF86WWW		]	};
 };
 
-
-// GeniusComfy21e
+// Genius Comfy 21e
 partial alphanumeric_keys
 xkb_symbols "geniuscomfy2" {
     // Describes the extra keys on a Genius Comfy KB-21e-Scroll
@@ -761,6 +759,7 @@ xkb_symbols "geniuscomfy2" {
     key <I23>   {       [ Return                ]       };
 };
 
+
 // Gyration
 
 partial alphanumeric_keys
@@ -781,7 +780,7 @@ xkb_symbols "gyration" {
 // Hewlett-Packard
 
 // Hewlett-Packard Internet Keyboard
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "hpi6" {
     include "inet(media_nav_acpi_common)"
     key <I02>   {       [ XF86HomePage          ]       };
@@ -944,9 +943,8 @@ xkb_symbols "honeywell_euroboard" {
 
 // IBM
 
-
 // IBM Rapid Access
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "rapidaccess" {
     key <I12>	{	[ XF86AudioMute		]	};
     key <I17>	{	[ XF86Launch2		]	};
@@ -965,7 +963,7 @@ xkb_symbols "rapidaccess" {
 };
 
 // IBM Rapid Access II
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "rapidaccess2" {
     include "inet(acpi_common)"
     key <I12>	{	[ XF86AudioNext		]	};
@@ -999,6 +997,7 @@ xkb_symbols "ibm_spacesaver" {
     };
 };
 
+
 // Logitech
 
 // Logitech common definitions
@@ -1041,8 +1040,8 @@ xkb_symbols "logitech_set3" {
 partial alphanumeric_keys
 xkb_symbols "logiaccess" {
     include "inet(logitech_base)"
-    key <FK13>	{	[ XF86MailForward	]	}; 
-    key <FK14>	{	[ XF86Send		]	}; 
+    key <FK13>	{	[ XF86MailForward	]	};
+    key <FK14>	{	[ XF86Send		]	};
     key <I11>	{	[ XF86Messenger		]	};
     key <I12>	{	[ XF86WebCam		]	};
 };
@@ -1069,10 +1068,9 @@ partial alphanumeric_keys
 xkb_symbols "logiex110" {
     include "inet(logitech_base)"
     key <I2F>   {       [ XF86Close             ]       };      // Close
-
 // Extended function keys
 // In the Console before starting X
-// Using setkeycodes e03b 212 e03c 213 e03d 214 e03e 215 e03f 216 e040 217 
+// Using setkeycodes e03b 212 e03c 213 e03d 214 e03e 215 e03f 216 e040 217
 //       setkeycodes e041 218 e042 219 e043 220 e044 221 e057 222 e058 223 6d 206
 // *=keys that are there but need different symbol names.
     key <I3B>   {       [ Help                  ]       };      // F1
@@ -1163,7 +1161,7 @@ xkb_symbols "logiultraxc" {
     key <KPDC>  {       [ XF86AudioRaiseVolume  ]       };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "logidinovo" {
     include "inet(media_nav_common)"
     key <I02>	{	[ XF86HomePage		]	};
@@ -1175,7 +1173,7 @@ xkb_symbols "logidinovo" {
     key <XFER>	{	[ XF86AudioMedia	]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "logidinovoedge" {
     include "inet(media_acpi_common)"
     key <I02>	{	[ XF86HomePage		]	};
@@ -1315,39 +1313,39 @@ xkb_symbols "microsoftinet" {
     key <I68>	{	[ XF86AudioStop		]	};
 };
 
-// Microsoft Natural Keyboard Pro USB  
-partial alphanumeric_keys  
- xkb_symbols "microsoftprousb" {  
+// Microsoft Natural Keyboard Pro USB
+partial alphanumeric_keys
+xkb_symbols "microsoftprousb" {
     include "inet(nav_common)"
-     key <FK16>   {   [ XF86Reload      ]   };  
-     key <I01>   {   [ XF86AudioMedia   ]   };  
-     key <I02>   {   [ XF86HomePage      ]   };  
-     key <I17>   {   [ XF86AudioStop      ]   };  
-     key <I1E>   {   [ XF86AudioRaiseVolume   ]   };  
-     key <I1F>   {   [ XF86AudioPlay, XF86AudioPause ] };  
-     key <I22>   {   [ XF86AudioNext      ]   };  
-     key <I24>   {   [ XF86AudioPrev      ]   };  
-     key <I25>   {   [ XF86AudioLowerVolume   ]   };  
-     key <I26>   {   [ XF86AudioMute      ]   };  
-     key <I63>   {   [ XF86Standby      ]   };  
- //   Internet Section -- Left Side  
- //   Multimedia Section -- Right Side  
- //   My Computer Section -- Far Right  
- //  My computer maps to printscreen, so leaving commented out for now   
- //  key <PRSC>   {   [ XF86MyComputer   ]   };  
-}; 
-
-// Microsoft Natural Keyboard Pro OEM 
-partial alphanumeric_keys  
-xkb_symbols "microsoftprooem" { 
+    key <FK16>   {   [ XF86Reload      ]   };
+    key <I01>   {   [ XF86AudioMedia   ]   };
+    key <I02>   {   [ XF86HomePage      ]   };
+    key <I17>   {   [ XF86AudioStop      ]   };
+    key <I1E>   {   [ XF86AudioRaiseVolume   ]   };
+    key <I1F>   {   [ XF86AudioPlay, XF86AudioPause ] };
+    key <I22>   {   [ XF86AudioNext      ]   };
+    key <I24>   {   [ XF86AudioPrev      ]   };
+    key <I25>   {   [ XF86AudioLowerVolume   ]   };
+    key <I26>   {   [ XF86AudioMute      ]   };
+    key <I63>   {   [ XF86Standby      ]   };
+//   Internet Section -- Left Side
+//   Multimedia Section -- Right Side
+//   My Computer Section -- Far Right
+//   My computer maps to printscreen, so leaving commented out for now
+//   key <PRSC>   {   [ XF86MyComputer   ]   };
+};
+
+// Microsoft Natural Keyboard Pro OEM
+partial alphanumeric_keys
+xkb_symbols "microsoftprooem" {
     include "inet(media_nav_common)"
-    key <FK17>	{	[ XF86Search		]	}; 
-    key <I02>	{	[ XF86HomePage		]	}; 
-    key <I63>	{	[ XF86Standby		]	}; 
-    key <K67>	{	[ XF86MyComputer	]	}; 
-//   Internet Section -- Left Side 
-//   Multimedia Section -- Right Side 
-//   My Computer Section -- Far Right 
+    key <FK17>	{	[ XF86Search		]	};
+    key <I02>	{	[ XF86HomePage		]	};
+    key <I63>	{	[ XF86Standby		]	};
+    key <K67>	{	[ XF86MyComputer	]	};
+//   Internet Section -- Left Side
+//   Multimedia Section -- Right Side
+//   My Computer Section -- Far Right
 };
 
 // Microsoft Internet Keyboard Pro, Swedish
@@ -1401,28 +1399,28 @@ xkb_symbols "microsoftoffice" {
     key <RCTL>	{	[ XF86Paste		]	};
 };
 
-// Microsoft Wireless Multimedia Keyboard 1.0A 
-partial alphanumeric_keys 
-xkb_symbols "microsoftmult" { 
+// Microsoft Wireless Multimedia Keyboard 1.0A
+partial alphanumeric_keys
+xkb_symbols "microsoftmult" {
     include "inet(media_nav_acpi_common)"
-    key <AE13>  {       [ XF86Messenger         ]       }; 
-    key <FK14>	{	[ XF86New		]	}; 
-    key <FK15>	{	[ XF86Open		]	}; 
-    key <FK16>	{	[ XF86Close		]	}; 
-    key <FK17>	{	[ XF86Reply		]	}; 
-    key <I07>	{	[ Redo			]	}; 
-    key <I08>	{	[ Undo			]	}; 
-    key <I16>   {       [ XF86LogOff            ]       }; 
-    key <I23>	{	[ XF86Spell		]	}; 
-    key <I3B>	{	[ Help			]	}; 
-    key <I3C>   {       [ XF86Music     ]       }; 
-    key <I42>	{	[ XF86Forward		]	}; 
-    key <I43>	{	[ XF86Send		]	}; 
-    key <I57>	{	[ XF86Save		]	}; 
-    key <I58>	{	[ Print			]	}; 
-    key <I64>   {       [ XF86Pictures  ]       }; 
-    key <I80>   {       [ XF86Documents ]       }; 
-}; 
+    key <AE13>  {       [ XF86Messenger         ]       };
+    key <FK14>	{	[ XF86New		]	};
+    key <FK15>	{	[ XF86Open		]	};
+    key <FK16>	{	[ XF86Close		]	};
+    key <FK17>	{	[ XF86Reply		]	};
+    key <I07>	{	[ Redo			]	};
+    key <I08>	{	[ Undo			]	};
+    key <I16>   {       [ XF86LogOff            ]       };
+    key <I23>	{	[ XF86Spell		]	};
+    key <I3B>	{	[ Help			]	};
+    key <I3C>   {       [ XF86Music     ]       };
+    key <I42>	{	[ XF86Forward		]	};
+    key <I43>	{	[ XF86Send		]	};
+    key <I57>	{	[ XF86Save		]	};
+    key <I58>	{	[ Print			]	};
+    key <I64>   {       [ XF86Pictures  ]       };
+    key <I80>   {       [ XF86Documents ]       };
+};
 
 
 // Oretec
@@ -1646,6 +1644,7 @@ xkb_symbols "symplon" {
     key <UP>	{	[ XF86MenuPB		]	};
 };
 
+
 // Toshiba
 
 // Toshiba Satellite S3000
@@ -1663,6 +1662,7 @@ xkb_symbols "toshiba_s3000" {
     key <I76>	{	[ XF86AudioLowerVolume	]	};
 };
 
+
 // Trust
 
 // Trust Wireless Keyboard Classic
@@ -1673,7 +1673,6 @@ xkb_symbols "trust" {
     key <I1E>	{	[ XF86Eject		]	};
 };
 
-
 // Trust Direct Access Keyboard
 partial alphanumeric_keys
 xkb_symbols "trustda" {
@@ -1711,6 +1710,7 @@ xkb_symbols "yahoo" {
     key <I28>	{	[ XF86WWW		]	};
 };
 
+
 // Apple keyboards (macbooks, powerbooks, powermac G5, etc)
 partial alphanumeric_keys
 xkb_symbols "apple" {
@@ -1751,14 +1751,15 @@ xkb_symbols "cymotionlinux" {
     key <XFER>	{	[	XF86AudioMedia		]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "silvercrest" {
     include "inet(media_nav_acpi_common)"
-    key <I02>	{	[ XF86HomePage		]	};    
+    key <I02>	{	[ XF86HomePage		]	};
     key <I21>	{	[ XF86Launch2		]	};
     key <K67>	{	[ XF86Launch1		]	};
 };
 
+
 // eMachines
 
 partial alphanumeric_keys
@@ -1782,13 +1783,12 @@ xkb_symbols "emachines" {
     key <KPSU> {  [ KP_Subtract                   ]  };
 };
 
+
 // BenQ
 
+// BenQ X* (X730, X500, X800)
 //
-// BenQ X*
-// (X730, X500, X800)
-//
-// to make the FN_LOCK and CONFIG key work on the BenQ X500 , use ...
+// To make the FN_LOCK and CONFIG key work on the BenQ X500 , use:
 // setkeycodes e074 130 # KEY_PROPS  from /usr/include/linux/input.h
 // setkeycodes e075 171 # KEY_CONFIG from /usr/include/linux/input.h
 partial alphanumeric_keys
@@ -1800,15 +1800,17 @@ xkb_symbols "benqx" {
     key <I31> { [ XF86Calendar ] };
 };
 
+
 // Intel
 
 // Intel Classmate
 partial alphanumeric_keys
 xkb_symbols "classmate" {
-    key <I2E>   {       [ XF86AudioLowerVolume  ] };	
+    key <I2E>   {       [ XF86AudioLowerVolume  ] };
     key <I30>   {       [ XF86AudioRaiseVolume  ] };
 };
 
+
 // Unitek
 
 partial alphanumeric_keys
@@ -1822,6 +1824,7 @@ xkb_symbols "unitekkb1925" {
     key <I1A> { [ XF86Reload ] };
 };
 
+
 // Creative
 
 // Creative Desktop Wireless 7000
@@ -1831,6 +1834,7 @@ xkb_symbols "creativedw7000" {
     key <I66>   {       [ XF86Pictures ]       };
 };
 
+
 // Compal
 
 // Compal FL90
@@ -1846,13 +1850,13 @@ xkb_symbols "pc105" {
     include "inet(media_nav_acpi_common)"
 };
 
+
 // HTC Dream
 partial alphanumeric_keys
 xkb_symbols "htcdream" {
 	key <BKSP> { [ BackSpace ] };
 	key <RTRN> { [ Return ] };
 
-        //first row
         key <AE01> { [ 1, 1, exclam, exclam ] };
         key <AE02> { [ 2, 2, at, at ] };
         key <AE03> { [ 3, 3, numbersign, numbersign ] };
@@ -1864,12 +1868,10 @@ xkb_symbols "htcdream" {
         key <AE09> { [ 9, 9, parenleft, parenleft ] };
         key <AE10> { [ 0, 0, parenright, parenright ] };
 
-	//fifth row
 	key <LFSH> { [ Shift_L ] };
 	key <SPCE> { [ space ] };
 	key <AB09> { [ period, period, slash, slash ] };
 	key <RTSH> { [ Shift_R ] };
 
-	//modifiers
 	modifier_map Shift { <LFSH>, <RTSH> };
 };
diff --git a/xorg-server/xkeyboard-config/symbols/ir b/xorg-server/xkeyboard-config/symbols/ir
index d0a11b749..983bf60d9 100644
--- a/xorg-server/xkeyboard-config/symbols/ir
+++ b/xorg-server/xkeyboard-config/symbols/ir
@@ -62,7 +62,7 @@ xkb_symbols "pes_part_basic" {
     key <AD09> { [ Arabic_khah,		bracketright,		0x100202e	] };
     key <AD10> { [ Arabic_hah,		bracketleft,		0x100202c	] };
     key <AD11> { [ Arabic_jeem,		braceright,		0x100202a	] };
-    key <AD12> { [ Arabic_tcheh,		braceleft,		0x100202b	] };
+    key <AD12> { [ Arabic_tcheh,	braceleft,		0x100202b	] };
 
     key <AC01> { [ Arabic_sheen,	Arabic_hamzaonwaw,	VoidSymbol	] };
     key <AC02> { [ Arabic_seen,		Arabic_hamzaonyeh,	VoidSymbol	] };
@@ -73,17 +73,15 @@ xkb_symbols "pes_part_basic" {
     key <AC07> { [ Arabic_teh,		Arabic_tehmarbuta,	VoidSymbol	] };
     key <AC08> { [ Arabic_noon,		guillemotright,		0x100fd3e	] };
     key <AC09> { [ Arabic_meem,		guillemotleft,		0x100fd3f	] };
-    key <AC10> { [ Arabic_keheh,		colon,			semicolon	] };
+    key <AC10> { [ Arabic_keheh,	colon,			semicolon	] };
     key <AC11> { [ Arabic_gaf,		Arabic_semicolon,	quotedbl	] };
 
     key <AB01> { [ Arabic_zah,		Arabic_kaf,		VoidSymbol	] };
     key <AB02> { [ Arabic_tah,		0x1000653,		VoidSymbol	] };
     key <AB03> { [ Arabic_zain,		Arabic_jeh,		VoidSymbol	] };
-    key <AB04> { [ Arabic_ra,		Arabic_superscript_alef
-,		0x1000656	] };
+    key <AB04> { [ Arabic_ra,		Arabic_superscript_alef,0x1000656	] };
     key <AB05> { [ Arabic_thal,		0x100200c,		0x100200d	] };
-    key <AB06> { [ Arabic_dal,		Arabic_hamza_above
-,		Arabic_hamza_below	] };
+    key <AB06> { [ Arabic_dal,		Arabic_hamza_above,	Arabic_hamza_below	] };
     key <AB07> { [ Arabic_peh,		Arabic_hamza,		ellipsis	] };
     key <AB08> { [ Arabic_waw,		greater,		comma		] };
     key <AB09> { [ period,		less,			apostrophe	] };
@@ -169,7 +167,7 @@ xkb_symbols "ku_alt" {
 //
 // Copyright (C) 2006 Erdal Ronahî, published under the GPL v2
 //
-// Special copyright note: author explicitly permitted to license this 
+// Special copyright note: author explicitly permitted to license this
 // layout under MIT/X11 license, for details see
 // https://bugs.freedesktop.org/show_bug.cgi?id=9541
 //
@@ -256,51 +254,51 @@ xkb_symbols "ave"
 {
 	name[Group1] = "Avestan";
 
-	key <AB01> { [ U10B30,         U10B32 ] }; // 𐬰 𐬲 
-	key <AB02> { [ U10B11,         U10B12 ] }; // 𐬑 𐬒 
-	key <AB03> { [ U10B17,          UE102 ] }; // 𐬗  
-	key <AB04> { [ U10B2C,         U10B13 ] }; // 𐬬 𐬓 
-	key <AB05> { [ U10B20,         U10B21 ] }; // 𐬠 𐬡 
-	key <AB06> { [ U10B25,         U10B27 ] }; // 𐬥 𐬧 
-	key <AB07> { [ U10B28,         U10B29 ] }; // 𐬨 𐬩 
-	key <AB08> { [ U10B3C,         U10B39 ] }; // 𐬼 𐬹 
-	key <AB09> { [ U10B3E,         U10B3D ] }; // 𐬾 𐬽 
-	key <AB10> { [ U10B3F, periodcentered ] }; // 𐬿 · 
-
-	key <AC01> { [ U10B00,         U10B01 ] }; // 𐬀 𐬁 
-	key <AC02> { [ U10B2F,         U10B31 ] }; // 𐬯 𐬱 
-	key <AC03> { [ U10B1B,         U10B1C ] }; // 𐬛 𐬜 
-	key <AC04> { [ U10B1F,         U10B16 ] }; // 𐬟 𐬖 
-	key <AC05> { [ U10B14,         U10B15 ] }; // 𐬔 𐬕 
-	key <AC06> { [ U10B35,          UE100 ] }; // 𐬵  
-	key <AC07> { [ U10B18,         U10B24 ] }; // 𐬘 𐬤 
-	key <AC08> { [ U10B10,          UE101 ] }; // 𐬐  
-	key <AC09> { [ U10B2E,          UE103 ] }; // 𐬮  
-	key <AC10> { [ U10B3B,         U10B3A ] }; // 𐬻 𐬺 
-	key <AC11> { [ U10B1D                 ] }; // 𐬝 
-
-	key <AD01> { [ U10B22,         U10B23 ] }; // 𐬢 𐬣 
-	key <AD02> { [ U10B33,         U10B34 ] }; // 𐬳 𐬴 
-	key <AD03> { [ U10B08,         U10B09 ] }; // 𐬈 𐬉 
-	key <AD04> { [ U10B2D,         U10B26 ] }; // 𐬭 𐬦 
-	key <AD05> { [ U10B19,         U10B1A ] }; // 𐬙 𐬚 
-	key <AD06> { [ U10B2B,         U10B2A ] }; // 𐬫 𐬪 
-	key <AD07> { [ U10B0E,         U10B0F ] }; // 𐬎 𐬏 
-	key <AD08> { [ U10B0C,         U10B0D ] }; // 𐬌 𐬍 
+	key <AB01> { [ U10B30,         U10B32 ] }; // 𐬰 𐬲
+	key <AB02> { [ U10B11,         U10B12 ] }; // 𐬑 𐬒
+	key <AB03> { [ U10B17,          UE102 ] }; // 𐬗 
+	key <AB04> { [ U10B2C,         U10B13 ] }; // 𐬬 𐬓
+	key <AB05> { [ U10B20,         U10B21 ] }; // 𐬠 𐬡
+	key <AB06> { [ U10B25,         U10B27 ] }; // 𐬥 𐬧
+	key <AB07> { [ U10B28,         U10B29 ] }; // 𐬨 𐬩
+	key <AB08> { [ U10B3C,         U10B39 ] }; // 𐬼 𐬹
+	key <AB09> { [ U10B3E,         U10B3D ] }; // 𐬾 𐬽
+	key <AB10> { [ U10B3F, periodcentered ] }; // 𐬿 ·
+
+	key <AC01> { [ U10B00,         U10B01 ] }; // 𐬀 𐬁
+	key <AC02> { [ U10B2F,         U10B31 ] }; // 𐬯 𐬱
+	key <AC03> { [ U10B1B,         U10B1C ] }; // 𐬛 𐬜
+	key <AC04> { [ U10B1F,         U10B16 ] }; // 𐬟 𐬖
+	key <AC05> { [ U10B14,         U10B15 ] }; // 𐬔 𐬕
+	key <AC06> { [ U10B35,          UE100 ] }; // 𐬵 
+	key <AC07> { [ U10B18,         U10B24 ] }; // 𐬘 𐬤
+	key <AC08> { [ U10B10,          UE101 ] }; // 𐬐 
+	key <AC09> { [ U10B2E,          UE103 ] }; // 𐬮 
+	key <AC10> { [ U10B3B,         U10B3A ] }; // 𐬻 𐬺
+	key <AC11> { [ U10B1D                 ] }; // 𐬝
+
+	key <AD01> { [ U10B22,         U10B23 ] }; // 𐬢 𐬣
+	key <AD02> { [ U10B33,         U10B34 ] }; // 𐬳 𐬴
+	key <AD03> { [ U10B08,         U10B09 ] }; // 𐬈 𐬉
+	key <AD04> { [ U10B2D,         U10B26 ] }; // 𐬭 𐬦
+	key <AD05> { [ U10B19,         U10B1A ] }; // 𐬙 𐬚
+	key <AD06> { [ U10B2B,         U10B2A ] }; // 𐬫 𐬪
+	key <AD07> { [ U10B0E,         U10B0F ] }; // 𐬎 𐬏
+	key <AD08> { [ U10B0C,         U10B0D ] }; // 𐬌 𐬍
 	key <AD09> { [ U10B0A,         U10B0B ] }; // 𐬊 𐬋
-	key <AD10> { [ U10B1E                 ] }; // 𐬞 
-	key <AD11> { [ U10B06,         U10B07 ] }; // 𐬆 𐬇 
-	key <AD12> { [ U10B02,         U10B03 ] }; // 𐬂 𐬃 
-
-	key <AE01> { [ U10B78                 ] }; // 𐭸 
-	key <AE02> { [ U10B79                 ] }; // 𐭹 
-	key <AE03> { [ U10B7A                 ] }; // 𐭺 
-	key <AE04> { [ U10B7B                 ] }; // 𐭻 
-	key <AE05> { [ U10B7C                 ] }; // 𐭼 
-	key <AE06> { [ U10B7D                 ] }; // 𐭽 
-	key <AE07> { [ U10B7E                 ] }; // 𐭾 
-	key <AE08> { [ U10B7F                 ] }; // 𐭿 
-
-	key <BKSL> { [ U10B04,         U10B05 ] }; // 𐬄 𐬅 
-	key <LSGT> { [ U10B04,         U10B05 ] }; // 𐬄 𐬅 
+	key <AD10> { [ U10B1E                 ] }; // 𐬞
+	key <AD11> { [ U10B06,         U10B07 ] }; // 𐬆 𐬇
+	key <AD12> { [ U10B02,         U10B03 ] }; // 𐬂 𐬃
+
+	key <AE01> { [ U10B78                 ] }; // 𐭸
+	key <AE02> { [ U10B79                 ] }; // 𐭹
+	key <AE03> { [ U10B7A                 ] }; // 𐭺
+	key <AE04> { [ U10B7B                 ] }; // 𐭻
+	key <AE05> { [ U10B7C                 ] }; // 𐭼
+	key <AE06> { [ U10B7D                 ] }; // 𐭽
+	key <AE07> { [ U10B7E                 ] }; // 𐭾
+	key <AE08> { [ U10B7F                 ] }; // 𐭿
+
+	key <BKSL> { [ U10B04,         U10B05 ] }; // 𐬄 𐬅
+	key <LSGT> { [ U10B04,         U10B05 ] }; // 𐬄 𐬅
 };
diff --git a/xorg-server/xkeyboard-config/symbols/is b/xorg-server/xkeyboard-config/symbols/is
index 5137e2d71..34d6bed33 100644
--- a/xorg-server/xkeyboard-config/symbols/is
+++ b/xorg-server/xkeyboard-config/symbols/is
@@ -125,7 +125,7 @@ xkb_symbols "mac" {
 	key <AE11> {	[	odiaeresis,	Odiaeresis, 	oslash,		Ooblique	]	};
 	key <AE12> {	[	minus,		underscore, 	endash,		emdash		]	};
 
-	
+
 	//-- Row 4 (D) --//
 	key <AD01> {	[	q,		Q, 	paragraph,	VoidSymbol	]	};
 	key <AD02> {	[	w,		W, 	U2211,		VoidSymbol	]	};
@@ -139,8 +139,8 @@ xkb_symbols "mac" {
 	key <AD10> {	[	p,		P, 	Greek_pi,	Greek_PI	]	};
 	key <AD11> {	[	eth,		Eth, 	U201e,		U201c		]	};
 	key <AD12> {	[	apostrophe,	question, 	questiondown,	U00B7		]	};
-	
-	
+
+
 	//-- Row 3 (C) --//
 	key <AC01> {	[	a,		A, 	aring,		Aring		]	};
 	key <AC02> {	[	s,		S, 	ssharp,		abovedot	]	};
@@ -154,8 +154,8 @@ xkb_symbols "mac" {
 	key <AC10> {	[	ae,		AE, 	oe,		OE		]	};
 	key <AC11> {	[	dead_acute,	dead_diaeresis, 	U201A,		U2018		]	};
 	key <BKSL> {	[	plus,		asterisk, 	U2022,		plusminus	]	};
-	
-	
+
+
 	//-- Row 2  (B) --//
 	key <LSGT> {	[	less,		greater, 	section,	UF8FF		]	};
 	key <AB01> {	[	z,		Z, 	U3A9,		VoidSymbol	]	};
@@ -191,7 +191,7 @@ xkb_symbols "mac" {
 //     -- Ævar Arnfjörð Bjarmason <avarab@gmail.com>
 
 // Icelandic Dvorak
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
     name[Group1]= "Icelandic (Dvorak)";
 
diff --git a/xorg-server/xkeyboard-config/symbols/it b/xorg-server/xkeyboard-config/symbols/it
index 3e402c98a..8a66a306a 100644
--- a/xorg-server/xkeyboard-config/symbols/it
+++ b/xorg-server/xkeyboard-config/symbols/it
@@ -33,6 +33,8 @@ xkb_symbols "basic" {
 
     key <LSGT>	{ [      less,    greater,guillemotleft,guillemotright] };
 
+    include "kpdl(comma)"
+
     include "level3(ralt_switch)"
 };
 
@@ -175,7 +177,7 @@ xkb_symbols "us" {
     include "us(euro)"
 
     name[Group1]= "Italian (US keyboard with Italian letters)";
-    
+
     key <TLDE> { [     grave, asciitilde,    dead_grave,       dead_tilde ] };
     key <AE01> { [         1,     exclam,   onesuperior                   ] };
     key <AE02> { [         2,         at,   twosuperior                   ] };
diff --git a/xorg-server/xkeyboard-config/symbols/jp b/xorg-server/xkeyboard-config/symbols/jp
index 189228e57..52f574623 100644
--- a/xorg-server/xkeyboard-config/symbols/jp
+++ b/xorg-server/xkeyboard-config/symbols/jp
@@ -101,6 +101,14 @@ xkb_symbols "common" {
 };
 
 partial alphanumeric_keys
+xkb_symbols "henkan" {
+    key <XFER> {
+	type[Group1]="PC_ALT_LEVEL2",
+	symbols[Group1]= [ Henkan, Mode_switch ]
+    };
+};
+
+partial alphanumeric_keys
 xkb_symbols "OADG109A" {
 
     include "jp(common)"
diff --git a/xorg-server/xkeyboard-config/symbols/ke b/xorg-server/xkeyboard-config/symbols/ke
index 74e8c2dd2..d58796d76 100644
--- a/xorg-server/xkeyboard-config/symbols/ke
+++ b/xorg-server/xkeyboard-config/symbols/ke
@@ -9,7 +9,7 @@ xkb_symbols "swa" {
     include "us"
 
     name[Group1]= "Swahili (Kenya)";
-    
+
     key <AC10> { [ semicolon,	    colon,  0x01000324,  0x01000324 ] };	//COMBINING DIAERESIS BELOW	
     key <AC11> { [apostrophe,    quotedbl,  0x01000301,  0x01000308 ] };	//COMBINING ACUTE ACCENT, COMBINING DIAERESIS
     key <TLDE> { [     grave,  asciitilde,  0x01000300,  0x01000303 ] };	//COMBINING GRAVE ACCENT, COMBINING TILDE
@@ -18,17 +18,17 @@ xkb_symbols "swa" {
     key <AE09> { [	   9,   parenleft,  0x01000306	            ] };	//COMBINING BREVE
     key <AE10> { [	   0,  parenright,  0x0100030c 	            ] };	//COMBINING CARON
     key <AE11> { [     minus,  underscore,  0x01000304,  0x01000331 ] };	//COMBINING MACRON,COMBINING MACRON BELOW   
-	
+
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys  
+partial alphanumeric_keys
 xkb_symbols "kik" {
 
     include "us"
 
     name[Group1]= "Kikuyu";
-    
+
     key <AC10> { [ semicolon,	    colon,  0x01000324,  0x01000324 ] };	//COMBINING DIAERESIS BELOW	
     key <AC11> { [apostrophe,    quotedbl,  0x01000301,  0x01000308 ] };	//COMBINING ACUTE ACCENT, COMBINING DIAERESIS
     key <TLDE> { [     grave,  asciitilde,  0x01000300,  0x01000303 ] };	//COMBINING GRAVE ACCENT, COMBINING TILDE
@@ -37,6 +37,6 @@ xkb_symbols "kik" {
     key <AE09> { [	   9,   parenleft,  0x01000306	            ] };	//COMBINING BREVE
     key <AE10> { [	   0,  parenright,  0x0100030c 	            ] };	//COMBINING CARON
     key <AE11> { [     minus,  underscore,  0x01000304,  0x01000331 ] };	//COMBINING MACRON,COMBINING MACRON BELOW 
-	
+
     include "level3(ralt_switch)"
 };
diff --git a/xorg-server/xkeyboard-config/symbols/keypad b/xorg-server/xkeyboard-config/symbols/keypad
index bc47a90e9..9b49a5773 100644
--- a/xorg-server/xkeyboard-config/symbols/keypad
+++ b/xorg-server/xkeyboard-config/symbols/keypad
@@ -349,7 +349,7 @@ xkb_symbols "legacynumber" {
     key <KP7>  { [   KP_Home,       KP_7 ] }; //   <home> 7
     key <KP8>  { [     KP_Up,       KP_8 ] }; //     <up> 8
     key <KP9>  { [  KP_Prior,       KP_9 ] }; //  <prior> 9
- 
+
     key <KP4>  { [   KP_Left,       KP_4 ] }; //   <left> 4
     key <KP5>  { [  KP_Begin,       KP_5 ] }; //  <begin> 5
     key <KP6>  { [  KP_Right,       KP_6 ] }; //  <right> 6
@@ -391,7 +391,7 @@ xkb_symbols "legacynumber_wang" {
     key <KP7>  { [   KP_Home,   KP_7,         less ] }; //   <home> 7 <
     key <KP8>  { [     KP_Up,   KP_8,      greater ] }; //     <up> 8 >
     key <KP9>  { [  KP_Prior,   KP_9,  asciicircum ] }; //  <prior> 9 ^
- 
+
     key <KP4>  { [   KP_Left,   KP_4,  bracketleft ] }; //   <left> 4 [
     key <KP5>  { [  KP_Begin,   KP_5, bracketright ] }; //  <begin> 5 ]
     key <KP6>  { [  KP_Right,   KP_6,       dollar ] }; //  <right> 6 $
@@ -431,7 +431,7 @@ xkb_symbols "ossnumber" {
     key <KP7>  { [   KP_Home,   KP_7, 0x1002196, 0x10021D6 ] }; //   <home> 7 ↖ ⇖
     key <KP8>  { [     KP_Up,   KP_8, 0x1002191, 0x10021D1 ] }; //     <up> 8 ↑ ⇑
     key <KP9>  { [  KP_Prior,   KP_9, 0x1002197, 0x10021D7 ] }; //  <prior> 9 ↗ ⇗
- 
+
     key <KP4>  { [   KP_Left,   KP_4, 0x1002190, 0x10021D0 ] }; //   <left> 4 ← ⇐
     key <KP5>  { [  KP_Begin,   KP_5, 0x1002194, 0x10021D4 ] }; //  <begin> 5 ↔ ⇔
     key <KP6>  { [  KP_Right,   KP_6, 0x1002192, 0x10021D2 ] }; //  <right> 6 → ⇒
@@ -471,7 +471,7 @@ xkb_symbols "ossnumber_wang" {
     key <KP7>  { [   KP_Home,   KP_7,         less, 0x1002196 ] }; //   <home> 7 < ↖
     key <KP8>  { [     KP_Up,   KP_8,      greater, 0x1002191 ] }; //     <up> 8 > ↑
     key <KP9>  { [  KP_Prior,   KP_9,  asciicircum, 0x1002197 ] }; //  <prior> 9 ^ ↗
- 
+
     key <KP4>  { [   KP_Left,   KP_4,  bracketleft, 0x1002190 ] }; //   <left> 4 [ ←
     key <KP5>  { [  KP_Begin,   KP_5, bracketright, 0x1002194 ] }; //  <begin> 5 ] ↔
     key <KP6>  { [  KP_Right,   KP_6,       dollar, 0x1002192 ] }; //  <right> 6 $ →
@@ -532,7 +532,7 @@ xkb_symbols "hex" {
     key <KP7>  { [ NoSymbol,  NoSymbol,  a          ] };
     key <KP8>  { [ NoSymbol,  NoSymbol,  b          ] };
     key <KP9>  { [ NoSymbol,  NoSymbol,  c          ] };
- 
+
     // home row
     key <KP4>  { [ NoSymbol,  NoSymbol,  d          ] };
     key <KP5>  { [ NoSymbol,  NoSymbol,  e          ] };
diff --git a/xorg-server/xkeyboard-config/symbols/kh b/xorg-server/xkeyboard-config/symbols/kh
index ee58abf2f..5c1723324 100644
--- a/xorg-server/xkeyboard-config/symbols/kh
+++ b/xorg-server/xkeyboard-config/symbols/kh
@@ -27,7 +27,7 @@
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
     name[Group1]= "Khmer (Cambodia)";
-    
+
 // there are four levels defined:
 //
 //                 normal           shift			right-alt	right-alt + shift
@@ -93,13 +93,13 @@ xkb_symbols "basic" {
 
 // third level with right-Alt
     include "level3(ralt_switch)"
-    
+
 };
 
 partial alphanumeric_keys
 xkb_symbols "olpc" {
     include "kh(basic)"
-    
+
 // Contact Walter@laptop.org
 
     key <AC10> { [ 0x10017be,		0x10017c8,		0x10017d6, 	0x10019f5	] };
diff --git a/xorg-server/xkeyboard-config/symbols/kr b/xorg-server/xkeyboard-config/symbols/kr
index ced9a0720..84c0effca 100644
--- a/xorg-server/xkeyboard-config/symbols/kr
+++ b/xorg-server/xkeyboard-config/symbols/kr
@@ -16,13 +16,13 @@ xkb_symbols "kr104" {
 partial hidden function_keys
 xkb_symbols "koreankeys" {
     key <K71> { [ Hangul ] };
-    key <K72> { [ Hangul_Hanja ] };    
+    key <K72> { [ Hangul_Hanja ] };
 };
 
 partial hidden function_keys
 xkb_symbols "koreankeys_raltctl" {
     key <RALT> { [ Hangul ] };
-    key <RCTL> { [ Hangul_Hanja ] };    
+    key <RCTL> { [ Hangul_Hanja ] };
 };
 
 // EXTRAS:
diff --git a/xorg-server/xkeyboard-config/symbols/lt b/xorg-server/xkeyboard-config/symbols/lt
index 8b6b80e5f..ee6b73708 100644
--- a/xorg-server/xkeyboard-config/symbols/lt
+++ b/xorg-server/xkeyboard-config/symbols/lt
@@ -68,7 +68,7 @@ xkb_symbols "us" {
 //
 // Made by Gediminas Paulauskas <menesis@delfi.lt>
 // Minor modifications by Ričardas Čepas and Rimas Kudelis
- 
+
 partial alphanumeric_keys modifier_keys
 xkb_symbols "std" {
 
@@ -121,7 +121,7 @@ xkb_symbols "std" {
 //
 // Made by Piter PUNK <piterpk@terra.com.br>
 // Minor modifications and cleanup by Rimas Kudelis, 2010
- 
+
 partial alphanumeric_keys modifier_keys
 xkb_symbols "ibm" {
 
@@ -169,12 +169,12 @@ xkb_symbols "ibm" {
 
 partial alphanumeric_keys modifier_keys
 xkb_symbols "lekp" {
-    
+
     include "capslock(backspace)"
     include "level3(ralt_switch)"
-    
+
     name[Group1]="Lithuanian (LEKP)";
-    
+
     key <TLDE> {[        grave,          asciitilde,         acute ]};
     key <AE01> {[        slash,          numbersign,           bar ]};
     key <AE02> {[    backslash,                  at,       section ]};
diff --git a/xorg-server/xkeyboard-config/symbols/mao b/xorg-server/xkeyboard-config/symbols/mao
index bf3482679..cc73d25f3 100644
--- a/xorg-server/xkeyboard-config/symbols/mao
+++ b/xorg-server/xkeyboard-config/symbols/mao
@@ -2,7 +2,7 @@ default  partial alphanumeric_keys
 xkb_symbols "basic" {
 
     // Adds the macrons needed for the Maori language to
-    // a simple us keyboard layout.
+    // a simple US keyboard layout.
 
     include "latin"
 
@@ -16,6 +16,7 @@ xkb_symbols "basic" {
     key <AD07>  { [ u,   U,  umacron, Umacron ] };
 
     key <RALT>  { type[Group1]="TWO_LEVEL",
-                  [ ISO_Level3_Shift, Multi_key ]   };
+                  [ ISO_Level3_Shift, Multi_key ] };
+
     modifier_map Mod5   { <RALT> };
 };
diff --git a/xorg-server/xkeyboard-config/symbols/md b/xorg-server/xkeyboard-config/symbols/md
index 1664da9cd..cd3430beb 100644
--- a/xorg-server/xkeyboard-config/symbols/md
+++ b/xorg-server/xkeyboard-config/symbols/md
@@ -29,11 +29,11 @@ xkb_symbols "basic" {
 
 partial alphanumeric_keys								
 xkb_symbols "gag" {								
-								
+
     include "us(basic)"
 
     name[Group1]="Moldavian (Gagauz)";
-								
+
     key <TLDE> 	{	[	grave,	asciitilde			]	};
     key <AE01> 	{	[	1,	exclam			]	};
     key <AE02> 	{	[	2,	quotedbl,	at	]	};
@@ -47,7 +47,7 @@ xkb_symbols "gag" {
     key <AE10> 	{	[	0,	parenright			]	};
     key <AE11> 	{	[	minus,	underscore			]	};
     key <AE12> 	{	[	equal,	plus			]	};
-								
+
     key <AD01> 	{	[	tcedilla,	Tcedilla,	q,	Q	]	};
     key <AD02> 	{	[	ecircumflex,	Ecircumflex,	w,	W	]	};
     key <AD03> 	{	[	e,	E			]	};
@@ -60,7 +60,7 @@ xkb_symbols "gag" {
     key <AD10> 	{	[	p,	P			]	};
     key <AD11> 	{	[	odiaeresis,	Odiaeresis,	bracketleft,	braceleft	]	};
     key <AD12> 	{	[	udiaeresis,	Udiaeresis,	bracketright,	braceright	]	};
-								
+
     key <AC01> 	{	[	a,	A			]	};
     key <AC02> 	{	[	s,	S			]	};
     key <AC03> 	{	[	d,	D			]	};
@@ -72,7 +72,7 @@ xkb_symbols "gag" {
     key <AC09> 	{	[	l,	L			]	};
     key <AC10> 	{	[	scedilla,	Scedilla			]	};
     key <AC11> 	{	[	idotless,	I,	apostrophe		]	};
-								
+
     key <AB01> 	{	[	z,	Z			]	};
     key <AB02> 	{	[	ccedilla,	Ccedilla,	x,	X	]	};
     key <AB03> 	{	[	c,	Ccedilla			]	};
@@ -83,7 +83,7 @@ xkb_symbols "gag" {
     key <AB08> 	{	[	adiaeresis,	Adiaeresis			]	};
     key <AB09> 	{	[	comma,	less			]	};
     key <AB10> 	{	[	period,	greater,	slash		]	};
-								
+
     key <BKSL> 	{	[	backslash,	bar			]	};
 
     include "level3(ralt_switch)"
diff --git a/xorg-server/xkeyboard-config/symbols/mk b/xorg-server/xkeyboard-config/symbols/mk
index 40075848a..0903d6617 100644
--- a/xorg-server/xkeyboard-config/symbols/mk
+++ b/xorg-server/xkeyboard-config/symbols/mk
@@ -53,7 +53,7 @@ xkb_symbols "basic" {
     key <AB08> { [           comma,       semicolon	]	};
     key <AB09> { [          period,           colon	]	};
     key <AB10> { [           slash,        question	]	};
- 
+
     include "kpdl(comma)"
 };
 
diff --git a/xorg-server/xkeyboard-config/symbols/mv b/xorg-server/xkeyboard-config/symbols/mv
index cb05b8b3c..e6836f3bb 100644
--- a/xorg-server/xkeyboard-config/symbols/mv
+++ b/xorg-server/xkeyboard-config/symbols/mv
@@ -18,7 +18,7 @@ xkb_symbols "basic" {
     key <AE10> { [               0,      parenright      ]       };
     key <AE11> { [           minus,      underscore      ]       };
     key <AE12> { [           equal,            plus      ]       };
-						
+
     key <AD01> { [	0x10007B0,	0x10007A4      ]       };
     key <AD02> { [	0x1000787,	0x10007A2      ]       };
     key <AD03> { [	0x10007AC,     	0x10007AD      ]       };
diff --git a/xorg-server/xkeyboard-config/symbols/ng b/xorg-server/xkeyboard-config/symbols/ng
index ea1fca278..ccd9d81ce 100644
--- a/xorg-server/xkeyboard-config/symbols/ng
+++ b/xorg-server/xkeyboard-config/symbols/ng
@@ -15,8 +15,8 @@ xkb_symbols "yoruba" {
     name[Group1]= "Yoruba";
 
     key <AD01> { [ 0x01001EB9, 0x01001EB8,          q,          Q ] };
-    key <AB02> { [ 0x01001ECD, 0x01001ECC,          x,          X ] }; 
-    key <AB04> { [ 0x01001E63, 0x01001E62,          v,          V ] }; 
+    key <AB02> { [ 0x01001ECD, 0x01001ECC,          x,          X ] };
+    key <AB04> { [ 0x01001E63, 0x01001E62,          v,          V ] };
 };
 
 partial alphanumeric_keys
@@ -26,7 +26,7 @@ xkb_symbols "igbo" {
     name[Group1]= "Igbo";
 
     key <AD01> { [ 0x01001ECB, 0x01001ECA,          q,          Q ] };
-    key <AB02> { [ 0x01001E45, 0x01001E44,          x,          X ] }; 
+    key <AB02> { [ 0x01001E45, 0x01001E44,          x,          X ] };
     key <AC10> { [ 0x01001EE5, 0x01001EE4,   semicolon,	    colon ] };
     key <AD11> { [ 0x01001ECD, 0x01001ECC, bracketleft, braceleft ] };		 
 };
diff --git a/xorg-server/xkeyboard-config/symbols/nl b/xorg-server/xkeyboard-config/symbols/nl
index ff60dbba7..1dde405f8 100644
--- a/xorg-server/xkeyboard-config/symbols/nl
+++ b/xorg-server/xkeyboard-config/symbols/nl
@@ -49,6 +49,8 @@ xkb_symbols "basic" {
 
     key <LSGT>	{ [bracketright, bracketleft,       bar,    brokenbar ]	};
 
+    include "kpdl(comma)"
+
     include "level3(ralt_switch)"
 };
 
@@ -132,7 +134,7 @@ xkb_symbols "sundeadkeys" {
 };
 
 // Copied from macintosh_vndr/nl
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     include "latin"
diff --git a/xorg-server/xkeyboard-config/symbols/no b/xorg-server/xkeyboard-config/symbols/no
index 5bba1959e..5609de06e 100644
--- a/xorg-server/xkeyboard-config/symbols/no
+++ b/xorg-server/xkeyboard-config/symbols/no
@@ -53,7 +53,7 @@ xkb_symbols "nodeadkeys" {
 };
 
 // Norwegian Dvorak
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
     include "us(dvorak)"
 
@@ -186,7 +186,7 @@ xkb_symbols "smi_nodeadkeys" {
 };
 
 // Copied from macintosh_vndr/no
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     // Describes the differences between a very simple en_US
@@ -211,7 +211,7 @@ xkb_symbols "mac" {
     key <BKSL>	{ [        at,   asterisk     ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac_nodeadkeys" {
 
     // Modifies the basic Norwegian layout to eliminate dead keys
@@ -222,7 +222,7 @@ xkb_symbols "mac_nodeadkeys" {
     key <AD12>	{ [  diaeresis, asciicircum, asciitilde,       macron ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "colemak" {
 
     // Colemak layout - http://colemak.com/
diff --git a/xorg-server/xkeyboard-config/symbols/pk b/xorg-server/xkeyboard-config/symbols/pk
index b85d887a3..8ab26ed5e 100644
--- a/xorg-server/xkeyboard-config/symbols/pk
+++ b/xorg-server/xkeyboard-config/symbols/pk
@@ -86,7 +86,7 @@ xkb_symbols "urd-crulp" {
    key <AE10> {  [     0x10006F0  ,       0x1000030, 0x1000028      ]     };
 
    key <AE11> {  [     0x100002D  ,       0x100005F      ]     };
-   key <AE12> {  [     0x100003D  ,       0x100002B      ]     };   
+   key <AE12> {  [     0x100003D  ,       0x100002B      ]     };
    key <AD01> {  [     0x1000642  ,       0x1000652      ]     };
    key <AD02> {  [     0x1000648  ,       0x1000651, 0x1000602      ]     };
    key <AD03> {  [     0x1000639  ,       0x1000670, 0x1000656      ]     };
diff --git a/xorg-server/xkeyboard-config/symbols/pl b/xorg-server/xkeyboard-config/symbols/pl
index a448e2baa..a468e790d 100644
--- a/xorg-server/xkeyboard-config/symbols/pl
+++ b/xorg-server/xkeyboard-config/symbols/pl
@@ -62,6 +62,7 @@ xkb_symbols "legacy" {
     name[Group1]="Polish (legacy)";
 
     key <AD03>	{ [         e,          E,      eogonek,      Eogonek ]	};
+    key <AD07>  { [         u,          U,	EuroSign,     cent    ] };
     key <AD09>	{ [         o,          O,       oacute,       Oacute ]	};
 
     key <AC01>	{ [         a,          A,      aogonek,      Aogonek ]	};
@@ -131,10 +132,10 @@ xkb_symbols "qwertz" {
 // "1/!" key. If you do not use Polish quotes at all, you can use "pl_basic" map.
 
 // Basic Polish keymap (without Polish quotes)
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
     include "us(dvorak)"
-    
+
     name[Group1] = "Polish (Dvorak)";
 
     key <AD08> { [	    c,	C,	cacute,	Cacute		]	};
@@ -146,7 +147,7 @@ xkb_symbols "dvorak" {
     key <AC10> { [	    s,	S,      sacute, Sacute		]	};
     key <AB09> { [	    v,	V,      zacute, Zacute		]	};
     key <AB10> { [	    z,	Z,   zabovedot, Zabovedot	]	};
-    
+
     include "kpdl(comma)"
 
     include "level3(ralt_switch)"
@@ -156,7 +157,7 @@ xkb_symbols "dvorak" {
 partial alphanumeric_keys
 xkb_symbols "dvorak_quotes" {
     include "pl(dvorak)"
-    
+
     name[Group1] = "Polish (Dvorak, Polish quotes on quotemark key)";
 
     key <AD01> { [  apostrophe,	quotedbl, doublelowquotemark, rightdoublequotemark	] };
@@ -482,7 +483,7 @@ xkb_symbols "colemak" {
     key <AB02> { [            x,            X, 	        zacute,           Zacute ] };
     key <AB03> { [            c,            C,          cacute,           Cacute ] };
     key <AC01> { [            a,            A,         aogonek,          Aogonek ] };
-    key <AC03> { [            s,            S,          sacute,           Sacute ] }; 
+    key <AC03> { [            s,            S,          sacute,           Sacute ] };
     key <AC07> { [            n,            N,          nacute,           Nacute ] };
     key <AC08> { [            e,            E,         eogonek,          Eogonek ] };
     key <AC10> { [            o,            O,          oacute,           Oacute ] };
diff --git a/xorg-server/xkeyboard-config/symbols/ru b/xorg-server/xkeyboard-config/symbols/ru
index c48637637..043e011e6 100644
--- a/xorg-server/xkeyboard-config/symbols/ru
+++ b/xorg-server/xkeyboard-config/symbols/ru
@@ -22,7 +22,7 @@ xkb_symbols "winkeys" {
     key <BKSL> {        [       backslash,           slash      ]       };
 };
 
-partial hidden alphanumeric_keys 
+partial hidden alphanumeric_keys
 xkb_symbols "common" {
 
     key	<AE01> {	[		1,	    exclam 	]	};
@@ -179,7 +179,7 @@ xkb_symbols "phonetic" {
     key	<LatA> {	[      Cyrillic_a,	Cyrillic_A	]	};
     key	<LatW> {	[     Cyrillic_ve,     Cyrillic_VE	]	};
     key	<LatC> {	[    Cyrillic_tse,    Cyrillic_TSE	]	};
-    key	<LatX> {	[Cyrillic_softsign,Cyrillic_SOFTSIGN	]	};
+    key	<LatX> {	[     Cyrillic_ha,     Cyrillic_HA	]	};
     key	<LatD> {	[     Cyrillic_de,     Cyrillic_DE	]	};
     key	<LatE> {	[     Cyrillic_ie,     Cyrillic_IE	]	};
     key	<LatV> {	[    Cyrillic_zhe,    Cyrillic_ZHE	]	};
@@ -188,7 +188,7 @@ xkb_symbols "phonetic" {
     key	<LatR> {	[     Cyrillic_er,     Cyrillic_ER	]	};
     key	<LatN> {	[     Cyrillic_en,     Cyrillic_EN	]	};
     key	<LatB> {	[     Cyrillic_be,     Cyrillic_BE	]	};
-    key	<LatH> {	[     Cyrillic_ha,     Cyrillic_HA	]	};
+    key	<LatH> {	[     Cyrillic_che,     Cyrillic_CHE	]	};
     key	<LatG> {	[    Cyrillic_ghe,    Cyrillic_GHE	]	};
     key	<LatY> {	[   Cyrillic_yeru,   Cyrillic_YERU	]	};
     key	<LatM> {	[     Cyrillic_em,     Cyrillic_EM	]	};
@@ -201,7 +201,7 @@ xkb_symbols "phonetic" {
     key	<LatP> {	[     Cyrillic_pe,     Cyrillic_PE	]	};
 
     key	<AD11> {	[    Cyrillic_sha,    Cyrillic_SHA	]	};
-    key	<AE12> {	[    Cyrillic_che,    Cyrillic_CHE	]	};
+    key	<AE12> {	[ Cyrillic_softsign, Cyrillic_softsign  ]	};
     key	<AD12> {	[  Cyrillic_shcha,  Cyrillic_SHCHA	]	};
     key	<BKSL> {	[      Cyrillic_e,	Cyrillic_E	]	};
 };
@@ -242,7 +242,7 @@ xkb_symbols "tt" {
 
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "os_legacy" {
     include "ru(common)"
 
@@ -253,7 +253,7 @@ xkb_symbols "os_legacy" {
     key	<AC11> {	[      0x010004D5,      0x010004D4      ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "os_winkeys" {
     include "ru(winkeys)"
 
@@ -336,7 +336,7 @@ xkb_symbols "cv_latin" {
 // Vlad Shakhov <lumpen.intellectual@gmail.com>
 // Last Changes 2007/10/23 by Vlad Shakhov <lumpen.intellectual@gmail.com>
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "kom" {
 
     include "ru(winkeys)"
@@ -348,7 +348,7 @@ xkb_symbols "kom" {
 // cyrilllic o with diaeresis 
     key	<AC07> { [ 	Cyrillic_o,		Cyrillic_O,		
 			U04E7,  		U04E6		] };
-    
+
 // hard I as additional key for soft Cyrillic_I 
     key <AB05> { [      Cyrillic_i,		Cyrillic_I,
 			Ukrainian_i,     	Ukrainian_I     ] };
@@ -404,7 +404,7 @@ xkb_symbols "sah" {
 //based on the Kalmyk language layout: http://soft.oyrat.org/
 //Nikolay Korneev <halmg@oyrat.org>
 //Toli Miron <mirontoli@gmail.com>
-        
+
 partial alphanumeric_keys
 xkb_symbols "xal" {
     include "ru(winkeys)"
@@ -416,24 +416,24 @@ xkb_symbols "xal" {
     key <AE01> {        [                     question,                  exclam,               1      ]       };
     key <AE02> {        [      	            numerosign,                quotedbl,               2      ]       };
     key <AE03> {        [          Cyrillic_u_straight,     Cyrillic_U_straight,               3      ]       };
-    key <AE04> {        [               Cyrillic_schwa,          Cyrillic_SCHWA,               4      ]       }; 
+    key <AE04> {        [               Cyrillic_schwa,          Cyrillic_SCHWA,               4      ]       };
     key <AE05> {        [                     asterisk,                 percent,               5      ]       };
     key <AE06> {        [        Cyrillic_en_descender,   Cyrillic_EN_descender,               6      ]       };
-    key <AE07> {        [               Cyrillic_o_bar,          Cyrillic_O_bar,               7      ]       }; 
-    key <AE08> {        [                Cyrillic_shha,           Cyrillic_SHHA,               8      ]       }; 
+    key <AE07> {        [               Cyrillic_o_bar,          Cyrillic_O_bar,               7      ]       };
+    key <AE08> {        [                Cyrillic_shha,           Cyrillic_SHHA,               8      ]       };
     key <AE09> {        [       Cyrillic_zhe_descender,  Cyrillic_ZHE_descender,               9      ]       };
     key <AE10> {        [                    semicolon,                   colon,               0      ]       };
 
     key <TLDE> {        [                    parenleft,               parenright, Cyrillic_io, Cyrillic_IO    ]       };
 
     key <AD02> {        [                 Cyrillic_tse,             Cyrillic_TSE,         dollar      ]       };
-    key <AD03> {        [                   Cyrillic_u,               Cyrillic_U,       EuroSign      ]       }; 
-    key <AD04> {        [                  Cyrillic_ka,              Cyrillic_KA,     registered      ]       }; 
-    key <AD05> {        [                  Cyrillic_ie,              Cyrillic_IE,      trademark      ]       }; 
-    key <AD11> {        [                  Cyrillic_ha,              Cyrillic_HA,    bracketleft      ]       }; 
+    key <AD03> {        [                   Cyrillic_u,               Cyrillic_U,       EuroSign      ]       };
+    key <AD04> {        [                  Cyrillic_ka,              Cyrillic_KA,     registered      ]       };
+    key <AD05> {        [                  Cyrillic_ie,              Cyrillic_IE,      trademark      ]       };
+    key <AD11> {        [                  Cyrillic_ha,              Cyrillic_HA,    bracketleft      ]       };
     key <AD12> {        [            Cyrillic_hardsign,        Cyrillic_HARDSIGN,   bracketright      ]       };
     key <AC11> {        [                   Cyrillic_e,               Cyrillic_E,     apostrophe      ]       };
-    key <AB03> {        [                  Cyrillic_es,              Cyrillic_ES,      copyright      ]       }; 
+    key <AB03> {        [                  Cyrillic_es,              Cyrillic_ES,      copyright      ]       };
     key <AB08> {        [                  Cyrillic_be,              Cyrillic_BE,           less      ]       };
     key <AB09> {        [                  Cyrillic_yu,              Cyrillic_YU,        greater      ]       };
 
@@ -476,7 +476,7 @@ xkb_symbols "bak" {
     key <AE11> { [     minus,            percent,       minus,    underscore     ]};
     key <AE12> { [     0x010004af, 0x010004ae,    equal,  plus    ]};
     key <BKSL> { [     0x010004a3, 0x010004a2,    backslash,        slash     ]};	
-	
+
     include "level3(ralt_switch)"
 };
 
@@ -511,7 +511,7 @@ xkb_symbols "srp" {
 partial alphanumeric_keys
 xkb_symbols "chm" {
     include "ru(common)"
-    
+
     name[Group1]= "Mari";
 
     key.type[group1]="FOUR_LEVEL_ALPHABETIC";
diff --git a/xorg-server/xkeyboard-config/symbols/se b/xorg-server/xkeyboard-config/symbols/se
index a498f693d..7c37d2a1d 100644
--- a/xorg-server/xkeyboard-config/symbols/se
+++ b/xorg-server/xkeyboard-config/symbols/se
@@ -45,7 +45,7 @@ xkb_symbols "nodeadkeys" {
 };
 
 // Swedish Dvorak
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "dvorak" {
 
     name[Group1]="Swedish (Dvorak)";
@@ -162,7 +162,7 @@ xkb_symbols "smi" {
 };
 
 // Copied from macintosh_vndr/se
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "mac" {
 
     // Describes the differences between a very simple en_US
diff --git a/xorg-server/xkeyboard-config/symbols/si b/xorg-server/xkeyboard-config/symbols/si
index 6733d2bd1..cff5f5602 100644
--- a/xorg-server/xkeyboard-config/symbols/si
+++ b/xorg-server/xkeyboard-config/symbols/si
@@ -8,7 +8,7 @@ xkb_symbols "basic" {
     key <TLDE> { type[Group1]="TWO_LEVEL", [ cedilla, diaeresis ] };
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "us" {
 
     name[Group1]= "Slovenian (US keyboard with Slovenian letters)";
@@ -19,7 +19,7 @@ xkb_symbols "us" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "alternatequotes" {
 
     name[Group1]= "Slovenian (use guillemets for quotes)";
diff --git a/xorg-server/xkeyboard-config/symbols/sk b/xorg-server/xkeyboard-config/symbols/sk
index b48e5aa8d..2162d533d 100644
--- a/xorg-server/xkeyboard-config/symbols/sk
+++ b/xorg-server/xkeyboard-config/symbols/sk
@@ -1,6 +1,6 @@
 default  partial alphanumeric_keys
 xkb_symbols "basic" {
-     
+
      // This layout conforms to a new sk compromise standard designed 
      // to satisfy most unix, windows and mac users.
      // 2001 by Kamil Toman <ktoman@email.cz>
@@ -46,7 +46,7 @@ xkb_symbols "basic" {
     key <AC07>	{ [         j,          J,   apostrophe,     NoSymbol ]	};
     key <AC08>	{ [         k,          K,      lstroke,     NoSymbol ]	};
     key <AC09>	{ [         l,          L,      Lstroke,     NoSymbol ]	};
-                  
+
     key <AC10>	{ [ocircumflex,   quotedbl,      dollar,     NoSymbol ]	};
     key <AC11>	{ [   section,     exclam,   apostrophe,       ssharp ]	};
     key <AC12>	{ [  EuroSign, dead_diaeresis, NoSymbol,     NoSymbol ]	};
@@ -78,13 +78,13 @@ xkb_symbols "bksl" {
     key <BKSL>	{ [ backslash,        bar,        slash,     NoSymbol ]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "qwerty" {
- 
+
     // This layout should work exactly as a sk with the exception 
     // of 'Z' and 'Y' keys, which are in the qwerty style (ie. swapped).
     // 2001 by Kamil Toman <ktoman@email.cz>
-    
+
     include "sk(basic)"
 
     name[Group1] = "Slovak (qwerty)";
diff --git a/xorg-server/xkeyboard-config/symbols/srvr_ctrl b/xorg-server/xkeyboard-config/symbols/srvr_ctrl
index 52b4eb9a0..902c51cf7 100644
--- a/xorg-server/xkeyboard-config/symbols/srvr_ctrl
+++ b/xorg-server/xkeyboard-config/symbols/srvr_ctrl
@@ -1,4 +1,4 @@
-// Actions which control the server's behavior
+// Actions which control the server's behavior.
 
 partial keypad_keys function_keys
 xkb_symbols "xfree86" {
@@ -6,7 +6,7 @@ xkb_symbols "xfree86" {
     include "srvr_ctrl(fkey2vt)"
 };
 
-partial function_keys 
+partial function_keys
 xkb_symbols "fkey2vt" {
 
     key <FK01> {
@@ -68,7 +68,6 @@ xkb_symbols "fkey2vt" {
 	type="CTRL+ALT",
 	symbols[Group1]= [ F12, F12, F12, F12, XF86_Switch_VT_12 ]
     };
-
 };
 
 partial function_keys keypad_keys
@@ -94,3 +93,18 @@ xkb_symbols "no_srvr_keys" {
     key <KPSU> { [ KP_Subtract,	KP_Subtract	] };
     key <KPAD> { [ KP_Add,	KP_Add		] };
 };
+
+partial function_keys
+xkb_symbols "grab_debug" {
+
+    key <FK11> {
+	type="CTRL+ALT",
+	symbols[Group1]= [ F11, F11, F11, F11, XF86LogGrabInfo ]
+    };
+
+    key <FK12> {
+	type="CTRL+ALT",
+	symbols[Group1]= [ F12, F12, F12, F12, XF86LogWindowTree ]
+    };
+
+};
diff --git a/xorg-server/xkeyboard-config/symbols/th b/xorg-server/xkeyboard-config/symbols/th
index 9cdde53cd..c2390ffc4 100644
--- a/xorg-server/xkeyboard-config/symbols/th
+++ b/xorg-server/xkeyboard-config/symbols/th
@@ -59,12 +59,12 @@ xkb_symbols "basic" {
     key <BKSL> { [ Thai_khokhuat,	Thai_khokhon	]	};
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "pat" {
     name[Group1]= "Thai (Pattachote)";
     // The thai layout defines a second keyboard group and changes
     // the behavior of a few modifier keys.
-    
+
     // converted to THai keysysms - Pablo Saratxaga pablo@mandrakesoft.com
     // Pattachote modification by Visanu Euarchukiati -- visanu@inet.co.th
     key <TLDE> { [ underscore,		Thai_baht	] };
@@ -121,7 +121,7 @@ xkb_symbols "pat" {
 };
 
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "tis" {
     name[Group1]= "Thai (TIS-820.2538)";
     // The thai layout defines a second keyboard group and changes
diff --git a/xorg-server/xkeyboard-config/symbols/tj b/xorg-server/xkeyboard-config/symbols/tj
index 38a7cd257..e7816cbf9 100644
--- a/xorg-server/xkeyboard-config/symbols/tj
+++ b/xorg-server/xkeyboard-config/symbols/tj
@@ -16,57 +16,57 @@ xkb_symbols "basic"
 {
 	name[Group1] = "Tajik";
 
-    	include "kpdl(comma)"
+	include "kpdl(comma)"
 	include "level3(ralt_switch)"
 
-	key <AB01> { [    Cyrillic_ya,    Cyrillic_YA                                 ] }; // я Я 
-	key <AB02> { [   Cyrillic_che,   Cyrillic_CHE                                 ] }; // ч Ч 
-	key <AB03> { [    Cyrillic_es,    Cyrillic_ES                                 ] }; // с С 
-	key <AB04> { [    Cyrillic_em,    Cyrillic_EM                                 ] }; // м М 
-	key <AB05> { [     Cyrillic_i,     Cyrillic_I                                 ] }; // и И 
-	key <AB06> { [    Cyrillic_te,    Cyrillic_TE                                 ] }; // т Т 
-	key <AB07> { [      0x10004e3,      0x10004e2                                 ] }; // ӣ Ӣ 
-	key <AB08> { [    Cyrillic_be,    Cyrillic_BE                                 ] }; // б Б 
-	key <AB09> { [    Cyrillic_yu,    Cyrillic_YU                                 ] }; // ю Ю 
-	key <AB10> { [         period,          comma                                 ] }; // . , 
-	key <AC01> { [    Cyrillic_ef,    Cyrillic_EF                                 ] }; // ф Ф 
-	key <AC02> { [      0x10004b7,      0x10004b6                                 ] }; // ҷ Ҷ 
-	key <AC03> { [    Cyrillic_ve,    Cyrillic_VE                                 ] }; // в В 
-	key <AC04> { [     Cyrillic_a,     Cyrillic_A                                 ] }; // а А 
-	key <AC05> { [    Cyrillic_pe,    Cyrillic_PE                                 ] }; // п П 
-	key <AC06> { [    Cyrillic_er,    Cyrillic_ER                                 ] }; // р Р 
-	key <AC07> { [     Cyrillic_o,     Cyrillic_O                                 ] }; // о О 
-	key <AC08> { [    Cyrillic_el,    Cyrillic_EL                                 ] }; // л Л 
-	key <AC09> { [    Cyrillic_de,    Cyrillic_DE                                 ] }; // д Д 
-	key <AC10> { [   Cyrillic_zhe,   Cyrillic_ZHE                                 ] }; // ж Ж 
-	key <AC11> { [     Cyrillic_e,     Cyrillic_E                                 ] }; // э Э 
-	key <AD01> { [ Cyrillic_shorti, Cyrillic_SHORTI                               ] }; // й Й 
-	key <AD02> { [      0x100049b,      0x100049a                                 ] }; // қ Қ 
-	key <AD03> { [     Cyrillic_u,     Cyrillic_U                                 ] }; // у У 
-	key <AD04> { [    Cyrillic_ka,    Cyrillic_KA                                 ] }; // к К 
-	key <AD05> { [    Cyrillic_ie,    Cyrillic_IE                                 ] }; // е Е 
-	key <AD06> { [    Cyrillic_en,    Cyrillic_EN                                 ] }; // н Н 
-	key <AD07> { [   Cyrillic_ghe,   Cyrillic_GHE                                 ] }; // г Г 
-	key <AD08> { [   Cyrillic_sha,   Cyrillic_SHA                                 ] }; // ш Ш 
-	key <AD09> { [      0x10004b3,      0x10004b2                                 ] }; // ҳ Ҳ 
-	key <AD10> { [    Cyrillic_ze,    Cyrillic_ZE                                 ] }; // з З 
-	key <AD11> { [    Cyrillic_ha,    Cyrillic_HA                                 ] }; // х Х 
-	key <AD12> { [ Cyrillic_hardsign, Cyrillic_HARDSIGN                           ] }; // ъ Ъ 
-	key <AE01> { [              1,         exclam,      0x10000a7                 ] }; // 1 ! § 
-	key <AE02> { [              2,       quotedbl,      0x10000ab,      0x10000bb ] }; // 2 " « » 
-	key <AE03> { [              3,     numerosign                                 ] }; // 3 № 
-	key <AE04> { [              4,      semicolon                                 ] }; // 4 ; 
-	key <AE05> { [              5,        percent                                 ] }; // 5 % 
-	key <AE06> { [              6,          colon,      0x1002013                 ] }; // 6 : – 
-	key <AE07> { [              7,       question,      ampersand                 ] }; // 7 ? & 
-	key <AE08> { [              8,       asterisk                                 ] }; // 8 * 
-	key <AE09> { [              9,      parenleft                                 ] }; // 9 ( 
-	key <AE10> { [              0,     parenright,      0x10000b0                 ] }; // 0 ) ° 
-	key <AE11> { [      0x1000493,      0x1000492,          minus,     underscore ] }; // ғ Ғ - _ 
-	key <AE12> { [      0x10004ef,      0x10004ee,          equal,           plus ] }; // ӯ Ӯ = + 
-	key <BKSL> { [      backslash,          slash                                 ] }; // \ / 
-	key <LSGT> { [          slash,            bar                                 ] }; // / | 
-	key <TLDE> { [    Cyrillic_io,    Cyrillic_IO                                 ] }; // ё Ё 
+	key <AB01> { [    Cyrillic_ya,    Cyrillic_YA                                 ] }; // я Я
+	key <AB02> { [   Cyrillic_che,   Cyrillic_CHE                                 ] }; // ч Ч
+	key <AB03> { [    Cyrillic_es,    Cyrillic_ES                                 ] }; // с С
+	key <AB04> { [    Cyrillic_em,    Cyrillic_EM                                 ] }; // м М
+	key <AB05> { [     Cyrillic_i,     Cyrillic_I                                 ] }; // и И
+	key <AB06> { [    Cyrillic_te,    Cyrillic_TE                                 ] }; // т Т
+	key <AB07> { [      0x10004e3,      0x10004e2                                 ] }; // ӣ Ӣ
+	key <AB08> { [    Cyrillic_be,    Cyrillic_BE                                 ] }; // б Б
+	key <AB09> { [    Cyrillic_yu,    Cyrillic_YU                                 ] }; // ю Ю
+	key <AB10> { [         period,          comma                                 ] }; // . ,
+	key <AC01> { [    Cyrillic_ef,    Cyrillic_EF                                 ] }; // ф Ф
+	key <AC02> { [      0x10004b7,      0x10004b6                                 ] }; // ҷ Ҷ
+	key <AC03> { [    Cyrillic_ve,    Cyrillic_VE                                 ] }; // в В
+	key <AC04> { [     Cyrillic_a,     Cyrillic_A                                 ] }; // а А
+	key <AC05> { [    Cyrillic_pe,    Cyrillic_PE                                 ] }; // п П
+	key <AC06> { [    Cyrillic_er,    Cyrillic_ER                                 ] }; // р Р
+	key <AC07> { [     Cyrillic_o,     Cyrillic_O                                 ] }; // о О
+	key <AC08> { [    Cyrillic_el,    Cyrillic_EL                                 ] }; // л Л
+	key <AC09> { [    Cyrillic_de,    Cyrillic_DE                                 ] }; // д Д
+	key <AC10> { [   Cyrillic_zhe,   Cyrillic_ZHE                                 ] }; // ж Ж
+	key <AC11> { [     Cyrillic_e,     Cyrillic_E                                 ] }; // э Э
+	key <AD01> { [ Cyrillic_shorti, Cyrillic_SHORTI                               ] }; // й Й
+	key <AD02> { [      0x100049b,      0x100049a                                 ] }; // қ Қ
+	key <AD03> { [     Cyrillic_u,     Cyrillic_U                                 ] }; // у У
+	key <AD04> { [    Cyrillic_ka,    Cyrillic_KA                                 ] }; // к К
+	key <AD05> { [    Cyrillic_ie,    Cyrillic_IE                                 ] }; // е Е
+	key <AD06> { [    Cyrillic_en,    Cyrillic_EN                                 ] }; // н Н
+	key <AD07> { [   Cyrillic_ghe,   Cyrillic_GHE                                 ] }; // г Г
+	key <AD08> { [   Cyrillic_sha,   Cyrillic_SHA                                 ] }; // ш Ш
+	key <AD09> { [      0x10004b3,      0x10004b2                                 ] }; // ҳ Ҳ
+	key <AD10> { [    Cyrillic_ze,    Cyrillic_ZE                                 ] }; // з З
+	key <AD11> { [    Cyrillic_ha,    Cyrillic_HA                                 ] }; // х Х
+	key <AD12> { [ Cyrillic_hardsign, Cyrillic_HARDSIGN                           ] }; // ъ Ъ
+	key <AE01> { [              1,         exclam,      0x10000a7                 ] }; // 1 ! §
+	key <AE02> { [              2,       quotedbl,      0x10000ab,      0x10000bb ] }; // 2 " « »
+	key <AE03> { [              3,     numerosign                                 ] }; // 3 №
+	key <AE04> { [              4,      semicolon                                 ] }; // 4 ;
+	key <AE05> { [              5,        percent                                 ] }; // 5 %
+	key <AE06> { [              6,          colon,      0x1002013                 ] }; // 6 : –
+	key <AE07> { [              7,       question,      ampersand                 ] }; // 7 ? &
+	key <AE08> { [              8,       asterisk                                 ] }; // 8 *
+	key <AE09> { [              9,      parenleft                                 ] }; // 9 (
+	key <AE10> { [              0,     parenright,      0x10000b0                 ] }; // 0 ) °
+	key <AE11> { [      0x1000493,      0x1000492,          minus,     underscore ] }; // ғ Ғ - _
+	key <AE12> { [      0x10004ef,      0x10004ee,          equal,           plus ] }; // ӯ Ӯ = +
+	key <BKSL> { [      backslash,          slash                                 ] }; // \ /
+	key <LSGT> { [          slash,            bar                                 ] }; // / |
+	key <TLDE> { [    Cyrillic_io,    Cyrillic_IO                                 ] }; // ё Ё
 };
 
 // --------------------------------------------------------------------
@@ -85,52 +85,52 @@ xkb_symbols "legacy"
 	include "kpdl(comma)"
 	include "level3(ralt_switch)"
 
-	key <AB01> { [    Cyrillic_ya,    Cyrillic_YA                                 ] }; // я Я 
-	key <AB02> { [   Cyrillic_che,   Cyrillic_CHE,      0x10004b7,      0x10004b6 ] }; // ч Ч ҷ Ҷ 
-	key <AB03> { [    Cyrillic_es,    Cyrillic_ES                                 ] }; // с С 
-	key <AB04> { [    Cyrillic_em,    Cyrillic_EM                                 ] }; // м М 
-	key <AB05> { [     Cyrillic_i,     Cyrillic_I,      0x10004e3,      0x10004e2 ] }; // и И ӣ Ӣ 
-	key <AB06> { [    Cyrillic_te,    Cyrillic_TE                                 ] }; // т Т 
-	key <AB07> { [ Cyrillic_softsign, Cyrillic_SOFTSIGN                           ] }; // ь Ь 
-	key <AB08> { [    Cyrillic_be,    Cyrillic_BE                                 ] }; // б Б 
-	key <AB09> { [    Cyrillic_yu,    Cyrillic_YU                                 ] }; // ю Ю 
-	key <AB10> { [         period,          comma                                 ] }; // . , 
-	key <AC01> { [    Cyrillic_ef,    Cyrillic_EF                                 ] }; // ф Ф 
-	key <AC02> { [  Cyrillic_yeru,  Cyrillic_YERU                                 ] }; // ы Ы 
-	key <AC03> { [    Cyrillic_ve,    Cyrillic_VE                                 ] }; // в В 
-	key <AC04> { [     Cyrillic_a,     Cyrillic_A                                 ] }; // а А 
-	key <AC05> { [    Cyrillic_pe,    Cyrillic_PE                                 ] }; // п П 
-	key <AC06> { [    Cyrillic_er,    Cyrillic_ER                                 ] }; // р Р 
-	key <AC07> { [     Cyrillic_o,     Cyrillic_O                                 ] }; // о О 
-	key <AC08> { [    Cyrillic_el,    Cyrillic_EL                                 ] }; // л Л 
-	key <AC09> { [    Cyrillic_de,    Cyrillic_DE                                 ] }; // д Д 
-	key <AC10> { [   Cyrillic_zhe,   Cyrillic_ZHE                                 ] }; // ж Ж 
-	key <AC11> { [     Cyrillic_e,     Cyrillic_E                                 ] }; // э Э 
-	key <AD01> { [ Cyrillic_shorti, Cyrillic_SHORTI                               ] }; // й Й 
-	key <AD02> { [   Cyrillic_tse,   Cyrillic_TSE                                 ] }; // ц Ц 
-	key <AD03> { [     Cyrillic_u,     Cyrillic_U,      0x10004ef,      0x10004ee ] }; // у У ӯ Ӯ 
-	key <AD04> { [    Cyrillic_ka,    Cyrillic_KA,      0x100049b,      0x100049a ] }; // к К қ Қ 
-	key <AD05> { [    Cyrillic_ie,    Cyrillic_IE                                 ] }; // е Е 
-	key <AD06> { [    Cyrillic_en,    Cyrillic_EN                                 ] }; // н Н 
-	key <AD07> { [   Cyrillic_ghe,   Cyrillic_GHE,      0x1000493,      0x1000492 ] }; // г Г ғ Ғ 
-	key <AD08> { [   Cyrillic_sha,   Cyrillic_SHA                                 ] }; // ш Ш 
-	key <AD09> { [ Cyrillic_shcha, Cyrillic_SHCHA                                 ] }; // щ Щ 
-	key <AD10> { [    Cyrillic_ze,    Cyrillic_ZE                                 ] }; // з З 
-	key <AD11> { [    Cyrillic_ha,    Cyrillic_HA,      0x10004b3,      0x10004b2 ] }; // х Х ҳ Ҳ 
-	key <AD12> { [ Cyrillic_hardsign, Cyrillic_HARDSIGN                           ] }; // ъ Ъ 
-	key <AE01> { [              1,         exclam,      0x10000a7                 ] }; // 1 ! § 
-	key <AE02> { [              2,       quotedbl,      0x10000ab,      0x10000bb ] }; // 2 " « » 
-	key <AE03> { [              3,     numerosign                                 ] }; // 3 № 
-	key <AE04> { [              4,      semicolon                                 ] }; // 4 ; 
-	key <AE05> { [              5,        percent                                 ] }; // 5 % 
-	key <AE06> { [              6,          colon,      0x1002013                 ] }; // 6 : – 
-	key <AE07> { [              7,       question,      ampersand                 ] }; // 7 ? & 
-	key <AE08> { [              8,       asterisk                                 ] }; // 8 * 
-	key <AE09> { [              9,      parenleft                                 ] }; // 9 ( 
-	key <AE10> { [              0,     parenright                                 ] }; // 0 ) 
-	key <AE11> { [          minus,     underscore                                 ] }; // - _ 
-	key <AE12> { [          equal,           plus                                 ] }; // = + 
-	key <BKSL> { [      backslash,          slash                                 ] }; // \ / 
-	key <LSGT> { [          slash,            bar                                 ] }; // / | 
-	key <TLDE> { [    Cyrillic_io,    Cyrillic_IO                                 ] }; // ё Ё 
+	key <AB01> { [    Cyrillic_ya,    Cyrillic_YA                                 ] }; // я Я
+	key <AB02> { [   Cyrillic_che,   Cyrillic_CHE,      0x10004b7,      0x10004b6 ] }; // ч Ч ҷ Ҷ
+	key <AB03> { [    Cyrillic_es,    Cyrillic_ES                                 ] }; // с С
+	key <AB04> { [    Cyrillic_em,    Cyrillic_EM                                 ] }; // м М
+	key <AB05> { [     Cyrillic_i,     Cyrillic_I,      0x10004e3,      0x10004e2 ] }; // и И ӣ Ӣ
+	key <AB06> { [    Cyrillic_te,    Cyrillic_TE                                 ] }; // т Т
+	key <AB07> { [ Cyrillic_softsign, Cyrillic_SOFTSIGN                           ] }; // ь Ь
+	key <AB08> { [    Cyrillic_be,    Cyrillic_BE                                 ] }; // б Б
+	key <AB09> { [    Cyrillic_yu,    Cyrillic_YU                                 ] }; // ю Ю
+	key <AB10> { [         period,          comma                                 ] }; // . ,
+	key <AC01> { [    Cyrillic_ef,    Cyrillic_EF                                 ] }; // ф Ф
+	key <AC02> { [  Cyrillic_yeru,  Cyrillic_YERU                                 ] }; // ы Ы
+	key <AC03> { [    Cyrillic_ve,    Cyrillic_VE                                 ] }; // в В
+	key <AC04> { [     Cyrillic_a,     Cyrillic_A                                 ] }; // а А
+	key <AC05> { [    Cyrillic_pe,    Cyrillic_PE                                 ] }; // п П
+	key <AC06> { [    Cyrillic_er,    Cyrillic_ER                                 ] }; // р Р
+	key <AC07> { [     Cyrillic_o,     Cyrillic_O                                 ] }; // о О
+	key <AC08> { [    Cyrillic_el,    Cyrillic_EL                                 ] }; // л Л
+	key <AC09> { [    Cyrillic_de,    Cyrillic_DE                                 ] }; // д Д
+	key <AC10> { [   Cyrillic_zhe,   Cyrillic_ZHE                                 ] }; // ж Ж
+	key <AC11> { [     Cyrillic_e,     Cyrillic_E                                 ] }; // э Э
+	key <AD01> { [ Cyrillic_shorti, Cyrillic_SHORTI                               ] }; // й Й
+	key <AD02> { [   Cyrillic_tse,   Cyrillic_TSE                                 ] }; // ц Ц
+	key <AD03> { [     Cyrillic_u,     Cyrillic_U,      0x10004ef,      0x10004ee ] }; // у У ӯ Ӯ
+	key <AD04> { [    Cyrillic_ka,    Cyrillic_KA,      0x100049b,      0x100049a ] }; // к К қ Қ
+	key <AD05> { [    Cyrillic_ie,    Cyrillic_IE                                 ] }; // е Е
+	key <AD06> { [    Cyrillic_en,    Cyrillic_EN                                 ] }; // н Н
+	key <AD07> { [   Cyrillic_ghe,   Cyrillic_GHE,      0x1000493,      0x1000492 ] }; // г Г ғ Ғ
+	key <AD08> { [   Cyrillic_sha,   Cyrillic_SHA                                 ] }; // ш Ш
+	key <AD09> { [ Cyrillic_shcha, Cyrillic_SHCHA                                 ] }; // щ Щ
+	key <AD10> { [    Cyrillic_ze,    Cyrillic_ZE                                 ] }; // з З
+	key <AD11> { [    Cyrillic_ha,    Cyrillic_HA,      0x10004b3,      0x10004b2 ] }; // х Х ҳ Ҳ
+	key <AD12> { [ Cyrillic_hardsign, Cyrillic_HARDSIGN                           ] }; // ъ Ъ
+	key <AE01> { [              1,         exclam,      0x10000a7                 ] }; // 1 ! §
+	key <AE02> { [              2,       quotedbl,      0x10000ab,      0x10000bb ] }; // 2 " « »
+	key <AE03> { [              3,     numerosign                                 ] }; // 3 №
+	key <AE04> { [              4,      semicolon                                 ] }; // 4 ;
+	key <AE05> { [              5,        percent                                 ] }; // 5 %
+	key <AE06> { [              6,          colon,      0x1002013                 ] }; // 6 : –
+	key <AE07> { [              7,       question,      ampersand                 ] }; // 7 ? &
+	key <AE08> { [              8,       asterisk                                 ] }; // 8 *
+	key <AE09> { [              9,      parenleft                                 ] }; // 9 (
+	key <AE10> { [              0,     parenright                                 ] }; // 0 )
+	key <AE11> { [          minus,     underscore                                 ] }; // - _
+	key <AE12> { [          equal,           plus                                 ] }; // = +
+	key <BKSL> { [      backslash,          slash                                 ] }; // \ /
+	key <LSGT> { [          slash,            bar                                 ] }; // / |
+	key <TLDE> { [    Cyrillic_io,    Cyrillic_IO                                 ] }; // ё Ё
 };
diff --git a/xorg-server/xkeyboard-config/symbols/tm b/xorg-server/xkeyboard-config/symbols/tm
index 8d84f9a85..e861b35c3 100644
--- a/xorg-server/xkeyboard-config/symbols/tm
+++ b/xorg-server/xkeyboard-config/symbols/tm
@@ -4,7 +4,7 @@
 default  partial
 xkb_symbols "basic" {
     name[Group1]="Turkmen";
-    
+
     include "us"
     key <TLDE> {	[    zcaron, 	Zcaron,		grave,	asciitilde	]	};
 
diff --git a/xorg-server/xkeyboard-config/symbols/ua b/xorg-server/xkeyboard-config/symbols/ua
index e286f4835..9aea09e05 100644
--- a/xorg-server/xkeyboard-config/symbols/ua
+++ b/xorg-server/xkeyboard-config/symbols/ua
@@ -8,7 +8,7 @@
 default  partial alphanumeric_keys
 xkb_symbols "unicode" {
     include "ua(winkeys)"
- 
+
     name[Group1]= "Ukrainian";
 
     key <TLDE> {    [           U2019, 	apostrophe,    U0301,   asciitilde     ]       };	// Apostrophe and Stress symbol
@@ -43,7 +43,7 @@ xkb_symbols "unicode" {
     include "level3(ralt_switch)"
 };
 
-partial alphanumeric_keys 
+partial alphanumeric_keys
 xkb_symbols "legacy" {
 
     name[Group1]= "Ukrainian (legacy)";
@@ -105,7 +105,7 @@ xkb_symbols "legacy" {
 partial alphanumeric_keys
 xkb_symbols "winkeys" {
     include "ua(legacy)"
- 
+
     name[Group1]= "Ukrainian (WinKeys)";
 
     key <AE03> {        [               3,      numerosign      ]       };
@@ -149,7 +149,7 @@ xkb_symbols "typewriter" {
 partial alphanumeric_keys
 xkb_symbols "phonetic" {
   include "ua(legacy)"
-  
+
   name[Group1]= "Ukrainian (phonetic)";
 
   key <LatQ> {   [ Cyrillic_ya,       Cyrillic_YA         ]    };
diff --git a/xorg-server/xkeyboard-config/symbols/us b/xorg-server/xkeyboard-config/symbols/us
index 0eff07539..4948a6345 100644
--- a/xorg-server/xkeyboard-config/symbols/us
+++ b/xorg-server/xkeyboard-config/symbols/us
@@ -425,7 +425,7 @@ xkb_symbols "dvorak-l" {
 
 partial alphanumeric_keys
 xkb_symbols "dvorak-r" {
-    
+
     include "us(dvorak)"
     name[Group1]= "English (right handed Dvorak)";
 
@@ -726,7 +726,7 @@ xkb_symbols "mac" {
 
     include "level3(ralt_switch)"
 };
- 
+
 // Colemak symbols for xkb on X.Org Server 7.x
 // 2006-01-01 Shai Coleman, http://colemak.com/
 
@@ -894,11 +894,11 @@ xkb_symbols "classmate-intl" {
 			oslash,			Ooblique	] };
     key <KPAD> { [ 	KP_Add,     		KP_Add,
 			paragraph,		degree          ] };
-   
+
     key <KP0>  { [	KP_Insert,		KP_0,
 			mu,			mu	] };
     key <KPDL> { [	KP_Delete,		KP_Decimal,
-			dead_abovedot,		dead_caron	] }; 
+			dead_abovedot,		dead_caron	] };
     key <KPDV> { [ 	KP_Divide,   		KP_Divide,
 			questiondown,		dead_hook       ] };
 
@@ -927,9 +927,9 @@ xkb_symbols "classmate-alt-intl" {
 
     key <KPAD> { [ 	KP_Add,     		KP_Add,
 			dead_ogonek,		dead_diaeresis   ] };
-    
+
     key <KPDL> { [	KP_Delete,		KP_Decimal,
-			dead_abovedot,		dead_circumflex	] }; 
+			dead_abovedot,		dead_circumflex	] };
     key <KPDV> { [ 	KP_Divide,   		KP_Divide,
 			dead_hook,		dead_hook       ] };
 
@@ -975,11 +975,11 @@ xkb_symbols "classmate-altgr-intl" {
 			oslash,			Ooblique	] };
     key <KPAD> { [ 	KP_Add,     		KP_Add,
 			paragraph,		degree          ] };
-   
+
     key <KP0>  { [	KP_Insert,		KP_0,
 			mu,			mu	] };
     key <KPDL> { [	KP_Delete,		KP_Decimal,
-			dead_abovedot,		dead_caron	] }; 
+			dead_abovedot,		dead_caron	] };
     key <KPDV> { [ 	KP_Divide,   		KP_Divide,
 			questiondown,		dead_hook       ] };
 
@@ -1399,7 +1399,7 @@ xkb_symbols "cz_sk_de" {
     key <AE10>	{ [    0,   parenright, eacute,	    Eacute	] };
     key <AE11>	{ [minus,   underscore, ssharp,     0x1001E9E	] };
     key <AE12>	{ [equal,	  plus, dead_acute, dead_caron  ] };
-    
+
     key <AD03>	{ [         e,          E,     EuroSign,     Eacute ]	};
 
     key <AD11>	{ [bracketleft, braceleft,   udiaeresis,   Udiaeresis ]	};
@@ -1514,7 +1514,7 @@ xkb_symbols "alt-intl-unicode" {
 
 };
 
-partial alphanumeric_keys  
+partial alphanumeric_keys
 xkb_symbols "ats" {
 
     include "us"
@@ -1551,19 +1551,19 @@ xkb_symbols "crd" {
 
   name[Group1]= "Coeur d'Alene Salish";
 
-  key <AD02> { [         w,           W, U02B7, U02B7 ] }; 
-  key <AE07> { [         7,   ampersand, U0294        ] }; 
-  key <AD01> { [         q,           Q, U221A        ] }; 
-  key <AB04> { [         v,           V, U0259        ] }; 
-  key <BKSL> { [ backslash,         bar, U026B        ] }; 
-  key <AD03> { [         e,           E, U025B        ] }; 
-  key <AD08> { [         i,           I, U026A        ] }; 
-  key <AC07> { [         j,           J, U01F0        ] }; 
-  key <AE06> { [         6, asciicircum, U0295        ] }; 
-  key <AC02> { [         s,           S, U0161        ] }; 
-  key <AB03> { [         c,           C, U010D        ] }; 
-  key <AD09> { [         o,           O, U0254        ] }; 
-  key <AB09> { [    period,     greater, U0323        ] }; 
+  key <AD02> { [         w,           W, U02B7, U02B7 ] };
+  key <AE07> { [         7,   ampersand, U0294        ] };
+  key <AD01> { [         q,           Q, U221A        ] };
+  key <AB04> { [         v,           V, U0259        ] };
+  key <BKSL> { [ backslash,         bar, U026B        ] };
+  key <AD03> { [         e,           E, U025B        ] };
+  key <AD08> { [         i,           I, U026A        ] };
+  key <AC07> { [         j,           J, U01F0        ] };
+  key <AE06> { [         6, asciicircum, U0295        ] };
+  key <AC02> { [         s,           S, U0161        ] };
+  key <AB03> { [         c,           C, U010D        ] };
+  key <AD09> { [         o,           O, U0254        ] };
+  key <AB09> { [    period,     greater, U0323        ] };
 
   include "level3(ralt_switch)"
   include "compose(rctrl)"
diff --git a/xorg-server/xkeyboard-config/symbols/uz b/xorg-server/xkeyboard-config/symbols/uz
index e88741b73..d76e3c9b9 100644
--- a/xorg-server/xkeyboard-config/symbols/uz
+++ b/xorg-server/xkeyboard-config/symbols/uz
@@ -6,17 +6,17 @@
 //
 // Jun 2, 2003. Mashrab Kuvatov <kmashrab@uni-bremen.de>
 //
-// Created based on Russian standard keyboard. AEN <aen@logic.ru> 
-// The following symbols of Russian standard keyboard were replaced:
+// Created based on the Russian standard keyboard. AEN <aen@logic.ru>
+// The following symbols of the Russian standard keyboard were replaced:
 // minus (key <AE11>) with Byelorussian_shortu (U045e),
-// equal (key <AE12>) with Cyrillic_ka_descender (U049b)
-// Cyrillic_ha (key <AD11>) with Cyrillic_ghe_bar (U0493)
-// Cyrillic_hardsign (key <AD12>) with Cyrillic_ha_descender (U04b3)
-// The following symbols of Russian standard keyboard were moved:
-// Cyrillic_ze       to key <AC02> (english 's'), 
-// Cyrillic_sha      to key <AD08> (english 'i'),
-// Cyrillic_ha       to key <AD09> (english 'o'),
-// Cyrillic_hardsign to key <AD10> (english 'p'). 
+// equal (key <AE12>) with Cyrillic_ka_descender (U049b),
+// Cyrillic_ha (key <AD11>) with Cyrillic_ghe_bar (U0493),
+// Cyrillic_hardsign (key <AD12>) with Cyrillic_ha_descender (U04b3).
+// The following symbols of the Russian standard keyboard were moved:
+// Cyrillic_ze       to key <AC02> (English 's'),
+// Cyrillic_sha      to key <AD08> (English 'i'),
+// Cyrillic_ha       to key <AD09> (English 'o'),
+// Cyrillic_hardsign to key <AD10> (English 'p').
 //
 // Feb 25, 2007. Mashrab Kuvatov <kmashrab@uni-bremen.de>
 //
@@ -28,62 +28,61 @@
 // Latin variant is somewhat experimental, since there is no
 // official standard for it. It is a copy of "us" layout, where
 // apostrophe is replaced with U02BB.
-// 
 
 default  partial alphanumeric_keys
 xkb_symbols "cyrillic" {
 
     name[Group1]= "Uzbek";
 
-    key	<AE01> {	[		1,	    exclam 	]	};
-    key	<AE02> {	[		2,        quotedbl	]	};
-    key	<AE03> {	[		3,      numerosign	]	};
-    key	<AE04> {	[		4,       semicolon 	]	};
-    key	<AE05> {	[		5,	   percent 	]	};
+    key	<AE01> {	[		1,	    exclam	]	};
+    key	<AE02> {	[		2,	  quotedbl	]	};
+    key	<AE03> {	[		3,	numerosign	]	};
+    key	<AE04> {	[		4,	 semicolon	]	};
+    key	<AE05> {	[		5,	   percent	]	};
     key	<AE06> {	[		6,	     colon	]	};
     key	<AE07> {	[		7,	  question	]	};
     key	<AE08> {	[		8,	  asterisk	]	};
     key	<AE09> {	[		9,	 parenleft	]	};
     key	<AE10> {	[		0,	parenright	]	};
-    key	<BKSL> {	[	backslash,             bar	]	};
+    key	<BKSL> {	[	backslash,	       bar	]	};
     key	<AB10> {	[	   period,	     comma	]	};
-    key	<LSGT> {        [           slash,             bar      ]       };
+    key	<LSGT> {	[	    slash,	       bar	]	};
 
     key.type[group1]="ALPHABETIC";
 
-    key	<AE11> {	[Cyrillic_ghe_bar, Cyrillic_GHE_bar     ]	};
+    key	<AE11> {	[Cyrillic_ghe_bar, Cyrillic_GHE_bar	]	};
     key	<AE12> {	[Cyrillic_ha_descender, Cyrillic_HA_descender ]	};
     key	<TLDE> {	[     Cyrillic_io,     Cyrillic_IO	]	};
     key	<AD01> {	[ Cyrillic_shorti, Cyrillic_SHORTI	]	};
     key	<AD02> {	[    Cyrillic_tse,    Cyrillic_TSE	]	};
-    key	<AD03> {	[      Cyrillic_u,	Cyrillic_U	]	};
+    key	<AD03> {	[      Cyrillic_u,      Cyrillic_U	]	};
     key	<AD04> {	[     Cyrillic_ka,     Cyrillic_KA	]	};
     key	<AD05> {	[     Cyrillic_ie,     Cyrillic_IE	]	};
     key	<AD06> {	[     Cyrillic_en,     Cyrillic_EN	]	};
     key	<AD07> {	[    Cyrillic_ghe,    Cyrillic_GHE	]	};
     key	<AD08> {	[    Cyrillic_sha,    Cyrillic_SHA	]	};
     key	<AD09> {	[ Byelorussian_shortu, Byelorussian_SHORTU ]	};
-    key	<AD10> {	[     Cyrillic_ze,     Cyrillic_ZE      ]	};
-    key	<AD11> {	[     Cyrillic_ha,     Cyrillic_HA      ]	};
-    key	<AD12> {	[Cyrillic_hardsign,Cyrillic_HARDSIGN ]	};
+    key	<AD10> {	[     Cyrillic_ze,     Cyrillic_ZE	]	};
+    key	<AD11> {	[     Cyrillic_ha,     Cyrillic_HA	]	};
+    key	<AD12> {	[Cyrillic_hardsign, Cyrillic_HARDSIGN ]	};
     key	<AC01> {	[     Cyrillic_ef,     Cyrillic_EF	]	};
     key	<AC02> {	[Cyrillic_ka_descender, Cyrillic_KA_descender ]	};
     key	<AC03> {	[     Cyrillic_ve,     Cyrillic_VE	]	};
-    key	<AC04> {	[      Cyrillic_a,	Cyrillic_A	]	};
+    key	<AC04> {	[      Cyrillic_a,      Cyrillic_A	]	};
     key	<AC05> {	[     Cyrillic_pe,     Cyrillic_PE	]	};
     key	<AC06> {	[     Cyrillic_er,     Cyrillic_ER	]	};
-    key	<AC07> {	[      Cyrillic_o,	Cyrillic_O	]	};
+    key	<AC07> {	[      Cyrillic_o,      Cyrillic_O	]	};
     key	<AC08> {	[     Cyrillic_el,     Cyrillic_EL	]	};
     key	<AC09> {	[     Cyrillic_de,     Cyrillic_DE	]	};
     key	<AC10> {	[    Cyrillic_zhe,    Cyrillic_ZHE	]	};
-    key	<AC11> {	[      Cyrillic_e,	Cyrillic_E	]	};
+    key	<AC11> {	[      Cyrillic_e,      Cyrillic_E	]	};
     key	<AB01> {	[     Cyrillic_ya,     Cyrillic_YA	]	};
     key	<AB02> {	[    Cyrillic_che,    Cyrillic_CHE	]	};
     key	<AB03> {	[     Cyrillic_es,     Cyrillic_ES	]	};
     key	<AB04> {	[     Cyrillic_em,     Cyrillic_EM	]	};
     key	<AB06> {	[     Cyrillic_te,     Cyrillic_TE	]	};
-    key	<AB05> {	[      Cyrillic_i,	Cyrillic_I	]	};
-    key	<AB07> {	[Cyrillic_softsign,Cyrillic_SOFTSIGN	]	};
+    key	<AB05> {	[      Cyrillic_i,      Cyrillic_I	]	};
+    key	<AB07> {	[Cyrillic_softsign, Cyrillic_SOFTSIGN	]	};
     key	<AB08> {	[     Cyrillic_be,     Cyrillic_BE	]	};
     key	<AB09> {	[     Cyrillic_yu,     Cyrillic_YU	]	};
 };
diff --git a/xorg-server/xkeyboard-config/symbols/za b/xorg-server/xkeyboard-config/symbols/za
index 75f6d9a27..aba979196 100644
--- a/xorg-server/xkeyboard-config/symbols/za
+++ b/xorg-server/xkeyboard-config/symbols/za
@@ -1,42 +1,42 @@
-// based on the Latvian and GB keyboard maps
+// Based on the Latvian and GB keyboard maps.
 
 default  partial alphanumeric_keys modifier_keys
 xkb_symbols "basic" {
 
-    // Describes the differences between an en_US 
-    // keyboard and a South African layout with 
-    // dead keys. By Dwayne Bailey (dwayne@translate.org.za) 
+    // Describes the differences between an en_US layout
+    // and a South African layout with dead keys.
+    // By Dwayne Bailey (dwayne@translate.org.za).
 
     include "latin"
 
     name[Group1]="English (South Africa)";
 
-    key <TLDE>  { [     grave,  asciitilde,  dead_grave ] };
-    key <AE02>	{ [         2,         at,      yen ]	};
-    key <AE03>	{ [         3,  numbersign,     sterling ]	};
-    key <AE04>	{ [         4,     dollar,        dollar ]	};
-    key <AE05>	{ [         5,     percent,     EuroSign ]	};
-    key <AE06>  { [         6, asciicircum, dead_circumflex ] };
-
-    key <AD03>	{ [         e,          E,  ediaeresis,  Ediaeresis ]	};
-    key <AD04>	{ [         r,          R,  ecircumflex,  Ecircumflex ]	};
-    key <AD05>	{ [         t,          T,  U1e71,  U1e70 ]	};
-    key <AD06>	{ [         y,          Y,  ucircumflex,  Ucircumflex ]	};
-    key <AD07>	{ [         u,          U,  udiaeresis,  Udiaeresis ]	};
-    key <AD08>	{ [         i,          I,   idiaeresis,   Idiaeresis ]	};
-    key <AD09>	{ [         o,          O,  odiaeresis,  Odiaeresis ]	};
-    key <AD10>	{ [         p,          P,  ocircumflex,  Ocircumflex ]	};
-
-    key <AC01>	{ [         a,          A,  adiaeresis, Adiaeresis ]	};
-    key <AC02>	{ [         s,          S,       scaron,       Scaron ]	};
-    key <AC03>	{ [         d,          D,  U1e13,  U1e12 ]	};
-    key <AC09>	{ [         l,          L,  U1e3d,  U1e3c ]	};
-    key <AC10>  { [ semicolon,      colon,  dead_diaeresis ] };
-    key <AC11>  { [apostrophe,   quotedbl,  dead_acute ] };
-
-    key <AB06>	{ [         n,          N,  U1e4b,  U1e4a ]	};
-    key <AB07>	{ [         m,          M,  U1e45,  U1e44 ]	};
-    key <AB09>  { [    period,    greater, dead_abovedot ] };
+    key <TLDE>  { [     grave, asciitilde,  dead_grave                ] };
+    key <AE02>  { [         2,         at,         yen                ] };
+    key <AE03>  { [         3, numbersign,    sterling                ] };
+    key <AE04>  { [         4,     dollar,      dollar                ] };
+    key <AE05>  { [         5,    percent,    EuroSign                ] };
+    key <AE06>  { [         6,asciicircum, dead_circumflex            ] };
+
+    key <AD03>  { [         e,          E,  ediaeresis,    Ediaeresis ] };
+    key <AD04>  { [         r,          R, ecircumflex,   Ecircumflex ] };
+    key <AD05>  { [         t,          T,       U1e71,         U1e70 ] };
+    key <AD06>  { [         y,          Y, ucircumflex,   Ucircumflex ] };
+    key <AD07>  { [         u,          U,  udiaeresis,    Udiaeresis ] };
+    key <AD08>  { [         i,          I,  idiaeresis,    Idiaeresis ] };
+    key <AD09>  { [         o,          O,  odiaeresis,    Odiaeresis ] };
+    key <AD10>  { [         p,          P, ocircumflex,   Ocircumflex ] };
+
+    key <AC01>  { [         a,          A,  adiaeresis,    Adiaeresis ] };
+    key <AC02>  { [         s,          S,      scaron,        Scaron ] };
+    key <AC03>  { [         d,          D,       U1e13,         U1e12 ] };
+    key <AC09>  { [         l,          L,       U1e3d,         U1e3c ] };
+    key <AC10>  { [ semicolon,      colon, dead_diaeresis             ] };
+    key <AC11>  { [apostrophe,   quotedbl,  dead_acute                ] };
+
+    key <AB06>  { [         n,          N,       U1e4b,         U1e4a ] };
+    key <AB07>  { [         m,          M,       U1e45,         U1e44 ] };
+    key <AB09>  { [    period,    greater, dead_abovedot              ] };
 
     include "level3(ralt_switch)"
 };