Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 1187 insertions, 1279 deletions

diff --git a/xorg-server/dix/dixfonts.c b/xorg-server/dix/dixfonts.c
index efc3c09ce..eb2c98c4b 100644
--- a/xorg-server/dix/dixfonts.c
+++ b/xorg-server/dix/dixfonts.c
@@ -74,14 +74,14 @@ extern pointer fosNaturalParams;
 extern FontPtr defaultFont;
 
 static FontPathElementPtr *font_path_elements = (FontPathElementPtr *) 0;
-static int  num_fpes = 0;
+static int num_fpes = 0;
 static FPEFunctions *fpe_functions = (FPEFunctions *) 0;
-static int  num_fpe_types = 0;
+static int num_fpe_types = 0;
 
 static unsigned char *font_path_string;
 
-static int  num_slept_fpes = 0;
-static int  size_slept_fpes = 0;
+static int num_slept_fpes = 0;
+static int size_slept_fpes = 0;
 static FontPathElementPtr *slept_fpes = (FontPathElementPtr *) 0;
 static FontPatternCachePtr patternCache;
 
@@ -90,29 +90,29 @@ FontToXError(int err)
 {
     switch (err) {
     case Successful:
-	return Success;
+        return Success;
     case AllocError:
-	return BadAlloc;
+        return BadAlloc;
     case BadFontName:
-	return BadName;
+        return BadName;
     case BadFontPath:
-    case BadFontFormat:	/* is there something better? */
+    case BadFontFormat:        /* is there something better? */
     case BadCharRange:
-	return BadValue;
+        return BadValue;
     default:
-	return err;
+        return err;
     }
 }
 
 static int
 LoadGlyphs(ClientPtr client, FontPtr pfont, unsigned nchars, int item_size,
-	   unsigned char *data)
+           unsigned char *data)
 {
     if (fpe_functions[pfont->fpe->type].load_glyphs)
-	return (*fpe_functions[pfont->fpe->type].load_glyphs)
-	    (client, pfont, 0, nchars, item_size, data);
+        return (*fpe_functions[pfont->fpe->type].load_glyphs)
+            (client, pfont, 0, nchars, item_size, data);
     else
-	return Successful;
+        return Successful;
 }
 
 /*
@@ -121,21 +121,21 @@ LoadGlyphs(ClientPtr client, FontPtr pfont, unsigned nchars, int item_size,
 Bool
 SetDefaultFont(char *defaultfontname)
 {
-    int         err;
-    FontPtr     pf;
-    XID         fid;
+    int err;
+    FontPtr pf;
+    XID fid;
     static FontPtr last_pf;
 
     fid = FakeClientID(0);
     err = OpenFont(serverClient, fid, FontLoadAll | FontOpenSync,
-		   (unsigned) strlen(defaultfontname), defaultfontname);
+                   (unsigned) strlen(defaultfontname), defaultfontname);
     if (err != Success)
-	return FALSE;
-    err = dixLookupResourceByType((pointer *)&pf, fid, RT_FONT, serverClient,
-				  DixReadAccess);
+        return FALSE;
+    err = dixLookupResourceByType((pointer *) &pf, fid, RT_FONT, serverClient,
+                                  DixReadAccess);
     if (err == Success) last_pf = pf;
     if (last_pf == (FontPtr) NULL)
-	return FALSE;
+        return FALSE;
     defaultFont = last_pf;
     return TRUE;
 }
@@ -152,22 +152,22 @@ SetDefaultFont(char *defaultfontname)
 void
 QueueFontWakeup(FontPathElementPtr fpe)
 {
-    int         i;
+    int i;
     FontPathElementPtr *new;
 
     for (i = 0; i < num_slept_fpes; i++) {
-	if (slept_fpes[i] == fpe) {
-	    return;
-	}
+        if (slept_fpes[i] == fpe) {
+            return;
+        }
     }
     if (num_slept_fpes == size_slept_fpes) {
-	new = (FontPathElementPtr *)
-	    realloc(slept_fpes,
-		     sizeof(FontPathElementPtr) * (size_slept_fpes + 4));
-	if (!new)
-	    return;
-	slept_fpes = new;
-	size_slept_fpes += 4;
+        new = (FontPathElementPtr *)
+            realloc(slept_fpes,
+                    sizeof(FontPathElementPtr) * (size_slept_fpes + 4));
+        if (!new)
+            return;
+        slept_fpes = new;
+        size_slept_fpes += 4;
     }
     slept_fpes[num_slept_fpes] = fpe;
     num_slept_fpes++;
@@ -176,32 +176,31 @@ QueueFontWakeup(FontPathElementPtr fpe)
 void
 RemoveFontWakeup(FontPathElementPtr fpe)
 {
-    int         i,
-                j;
+    int i, j;
 
     for (i = 0; i < num_slept_fpes; i++) {
-	if (slept_fpes[i] == fpe) {
-	    for (j = i; j < num_slept_fpes; j++) {
-		slept_fpes[j] = slept_fpes[j + 1];
-	    }
-	    num_slept_fpes--;
-	    return;
-	}
+        if (slept_fpes[i] == fpe) {
+            for (j = i; j < num_slept_fpes; j++) {
+                slept_fpes[j] = slept_fpes[j + 1];
+            }
+            num_slept_fpes--;
+            return;
+        }
     }
 }
 
 void
 FontWakeup(pointer data, int count, pointer LastSelectMask)
 {
-    int         i;
+    int i;
     FontPathElementPtr fpe;
 
     if (count < 0)
-	return;
+        return;
     /* wake up any fpe's that may be waiting for information */
     for (i = 0; i < num_slept_fpes; i++) {
-	fpe = slept_fpes[i];
-	(void) (*fpe_functions[fpe->type].wakeup_fpe) (fpe, LastSelectMask);
+        fpe = slept_fpes[i];
+        (void) (*fpe_functions[fpe->type].wakeup_fpe) (fpe, LastSelectMask);
     }
 }
 
@@ -213,227 +212,212 @@ UseFPE(FontPathElementPtr fpe)
 }
 
 static void
-FreeFPE (FontPathElementPtr fpe)
+FreeFPE(FontPathElementPtr fpe)
 {
     fpe->refcount--;
     if (fpe->refcount == 0) {
-	(*fpe_functions[fpe->type].free_fpe) (fpe);
-	free(fpe->name);
-	free(fpe);
+        (*fpe_functions[fpe->type].free_fpe) (fpe);
+        free(fpe->name);
+        free(fpe);
     }
 }
 
 static Bool
 doOpenFont(ClientPtr client, OFclosurePtr c)
 {
-    FontPtr     pfont = NullFont;
+    FontPtr pfont = NullFont;
     FontPathElementPtr fpe = NULL;
-    ScreenPtr   pScr;
-    int         err = Successful;
-    int         i;
-    char       *alias,
-               *newname;
-    int         newlen;
-    int		aliascount = 20;
-    Bool	fromDispatch = c->from_dispatch;
-    Bool        finished = FALSE;
+    ScreenPtr pScr;
+    int err = Successful;
+    int i;
+    char *alias, *newname;
+    int newlen;
+    int aliascount = 20;
+    Bool fromDispatch = c->from_dispatch;
+    Bool finished = FALSE;
     /*
      * Decide at runtime what FontFormat to use.
      */
-    Mask FontFormat = 
-
-	((screenInfo.imageByteOrder == LSBFirst) ?
-	    BitmapFormatByteOrderLSB : BitmapFormatByteOrderMSB) |
-
-	((screenInfo.bitmapBitOrder == LSBFirst) ?
-	    BitmapFormatBitOrderLSB : BitmapFormatBitOrderMSB) |
-
-	BitmapFormatImageRectMin |
-
+    Mask FontFormat =
+        ((screenInfo.imageByteOrder == LSBFirst) ?
+         BitmapFormatByteOrderLSB : BitmapFormatByteOrderMSB) |
+        ((screenInfo.bitmapBitOrder == LSBFirst) ?
+         BitmapFormatBitOrderLSB : BitmapFormatBitOrderMSB) |
+        BitmapFormatImageRectMin |
 #if GLYPHPADBYTES == 1
-	BitmapFormatScanlinePad8 |
+        BitmapFormatScanlinePad8 |
 #endif
-
 #if GLYPHPADBYTES == 2
-	BitmapFormatScanlinePad16 |
+        BitmapFormatScanlinePad16 |
 #endif
-
 #if GLYPHPADBYTES == 4
-	BitmapFormatScanlinePad32 |
+        BitmapFormatScanlinePad32 |
 #endif
-
 #if GLYPHPADBYTES == 8
-	BitmapFormatScanlinePad64 |
+        BitmapFormatScanlinePad64 |
 #endif
-
-	BitmapFormatScanlineUnit8;
+        BitmapFormatScanlineUnit8;
 
     c->from_dispatch = FALSE;
 
-    if (client->clientGone)
-    {
-	if (c->current_fpe < c->num_fpes)
-	{
-	    fpe = c->fpe_list[c->current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	}
-	err = Successful;
-	goto bail;
+    if (client->clientGone) {
+        if (c->current_fpe < c->num_fpes) {
+            fpe = c->fpe_list[c->current_fpe];
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+        }
+        err = Successful;
+        goto bail;
     }
     while (c->current_fpe < c->num_fpes) {
-	fpe = c->fpe_list[c->current_fpe];
-	err = (*fpe_functions[fpe->type].open_font)
-	    ((pointer) client, fpe, c->flags,
-	     c->fontname, c->fnamelen, FontFormat,
-	     BitmapFormatMaskByte |
-	     BitmapFormatMaskBit |
-	     BitmapFormatMaskImageRectangle |
-	     BitmapFormatMaskScanLinePad |
-	     BitmapFormatMaskScanLineUnit,
-	     c->fontid, &pfont, &alias,
-	     c->non_cachable_font && c->non_cachable_font->fpe == fpe ?
-		 c->non_cachable_font :
-		 (FontPtr)0);
-
-	if (err == FontNameAlias && alias) {
-	    newlen = strlen(alias);
-	    newname = (char *) realloc(c->fontname, newlen);
-	    if (!newname) {
-		err = AllocError;
-		break;
-	    }
-	    memmove(newname, alias, newlen);
-	    c->fontname = newname;
-	    c->fnamelen = newlen;
-	    c->current_fpe = 0;
-	    if (--aliascount <= 0) {
-		/* We've tried resolving this alias 20 times, we're
- 		 * probably stuck in an infinite loop of aliases pointing
- 		 * to each other - time to take emergency exit!
- 		 */
- 		err = BadImplementation;
-		break;
-	    }
-	    continue;
-	}
-	if (err == BadFontName) {
-	    c->current_fpe++;
-	    continue;
-	}
-	if (err == Suspended) {
-	    if (!ClientIsAsleep(client))
-		ClientSleep(client, (ClientSleepProcPtr)doOpenFont, c);
-	    else
-		goto xinerama_sleep;
-	    return TRUE;
-	}
-	break;
+        fpe = c->fpe_list[c->current_fpe];
+        err = (*fpe_functions[fpe->type].open_font)
+            ((pointer) client, fpe, c->flags,
+             c->fontname, c->fnamelen, FontFormat,
+             BitmapFormatMaskByte |
+             BitmapFormatMaskBit |
+             BitmapFormatMaskImageRectangle |
+             BitmapFormatMaskScanLinePad |
+             BitmapFormatMaskScanLineUnit,
+             c->fontid, &pfont, &alias,
+             c->non_cachable_font && c->non_cachable_font->fpe == fpe ?
+             c->non_cachable_font : (FontPtr) 0);
+
+        if (err == FontNameAlias && alias) {
+            newlen = strlen(alias);
+            newname = (char *) realloc(c->fontname, newlen);
+            if (!newname) {
+                err = AllocError;
+                break;
+            }
+            memmove(newname, alias, newlen);
+            c->fontname = newname;
+            c->fnamelen = newlen;
+            c->current_fpe = 0;
+            if (--aliascount <= 0) {
+                /* We've tried resolving this alias 20 times, we're
+                 * probably stuck in an infinite loop of aliases pointing
+                 * to each other - time to take emergency exit!
+                 */
+                err = BadImplementation;
+                break;
+            }
+            continue;
+        }
+        if (err == BadFontName) {
+            c->current_fpe++;
+            continue;
+        }
+        if (err == Suspended) {
+            if (!ClientIsAsleep(client))
+                ClientSleep(client, (ClientSleepProcPtr) doOpenFont, c);
+            else
+                goto xinerama_sleep;
+            return TRUE;
+        }
+        break;
     }
 
     if (err != Successful)
-	goto bail;
+        goto bail;
     if (!pfont) {
-	err = BadFontName;
-	goto bail;
+        err = BadFontName;
+        goto bail;
     }
     /* check values for firstCol, lastCol, firstRow, and lastRow */
     if (pfont->info.firstCol > pfont->info.lastCol ||
-       pfont->info.firstRow > pfont->info.lastRow ||
-       pfont->info.lastCol - pfont->info.firstCol > 255) {
-       err = AllocError;
-       goto bail;
+        pfont->info.firstRow > pfont->info.lastRow ||
+        pfont->info.lastCol - pfont->info.firstCol > 255) {
+        err = AllocError;
+        goto bail;
     }
     if (!pfont->fpe)
-	pfont->fpe = fpe;
+        pfont->fpe = fpe;
     pfont->refcnt++;
     if (pfont->refcnt == 1) {
-	UseFPE(pfont->fpe);
-	for (i = 0; i < screenInfo.numScreens; i++) {
-	    pScr = screenInfo.screens[i];
-	    if (pScr->RealizeFont)
-	    {
-		if (!(*pScr->RealizeFont) (pScr, pfont))
-		{
-		    CloseFont (pfont, (Font) 0);
-		    err = AllocError;
-		    goto bail;
-		}
-	    }
-	}
+        UseFPE(pfont->fpe);
+        for (i = 0; i < screenInfo.numScreens; i++) {
+            pScr = screenInfo.screens[i];
+            if (pScr->RealizeFont) {
+                if (!(*pScr->RealizeFont) (pScr, pfont)) {
+                    CloseFont(pfont, (Font) 0);
+                    err = AllocError;
+                    goto bail;
+                }
+            }
+        }
     }
     if (!AddResource(c->fontid, RT_FONT, (pointer) pfont)) {
-	err = AllocError;
-	goto bail;
+        err = AllocError;
+        goto bail;
     }
     if (patternCache && pfont != c->non_cachable_font)
-	CacheFontPattern(patternCache, c->origFontName, c->origFontNameLen,
-			 pfont);
-bail:
+        CacheFontPattern(patternCache, c->origFontName, c->origFontNameLen,
+                         pfont);
+ bail:
     if (err != Successful && c->client != serverClient) {
-	SendErrorToClient(c->client, X_OpenFont, 0,
-			  c->fontid, FontToXError(err));
+        SendErrorToClient(c->client, X_OpenFont, 0,
+                          c->fontid, FontToXError(err));
     }
     ClientWakeup(c->client);
     finished = TRUE;
-xinerama_sleep:
+ xinerama_sleep:
     if (finished || fromDispatch) {
-	for (i = 0; i < c->num_fpes; i++) {
-	    FreeFPE(c->fpe_list[i]);
-	}
-	free(c->fpe_list);
-	free(c->fontname);
-	free(c);
+        for (i = 0; i < c->num_fpes; i++) {
+            FreeFPE(c->fpe_list[i]);
+        }
+        free(c->fpe_list);
+        free(c->fontname);
+        free(c);
     }
     return TRUE;
 }
 
 int
-OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontname)
+OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname,
+         char *pfontname)
 {
     OFclosurePtr c;
-    int         i;
-    FontPtr     cached = (FontPtr)0;
+    int i;
+    FontPtr cached = (FontPtr) 0;
 
     if (!lenfname || lenfname > XLFDMAXFONTNAMELEN)
-	return BadName;
-    if (patternCache)
-    {
+        return BadName;
+    if (patternCache) {
 
-    /*
-    ** Check name cache.  If we find a cached version of this font that
-    ** is cachable, immediately satisfy the request with it.  If we find
-    ** a cached version of this font that is non-cachable, we do not
-    ** satisfy the request with it.  Instead, we pass the FontPtr to the
-    ** FPE's open_font code (the fontfile FPE in turn passes the
-    ** information to the rasterizer; the fserve FPE ignores it).
-    **
-    ** Presumably, the font is marked non-cachable because the FPE has
-    ** put some licensing restrictions on it.  If the FPE, using
-    ** whatever logic it relies on, determines that it is willing to
-    ** share this existing font with the client, then it has the option
-    ** to return the FontPtr we passed it as the newly-opened font.
-    ** This allows the FPE to exercise its licensing logic without
-    ** having to create another instance of a font that already exists.
-    */
-
-	cached = FindCachedFontPattern(patternCache, pfontname, lenfname);
-	if (cached && cached->info.cachable)
-	{
-	    if (!AddResource(fid, RT_FONT, (pointer) cached))
-		return BadAlloc;
-	    cached->refcnt++;
-	    return Success;
-	}
+        /*
+         ** Check name cache.  If we find a cached version of this font that
+         ** is cachable, immediately satisfy the request with it.  If we find
+         ** a cached version of this font that is non-cachable, we do not
+         ** satisfy the request with it.  Instead, we pass the FontPtr to the
+         ** FPE's open_font code (the fontfile FPE in turn passes the
+         ** information to the rasterizer; the fserve FPE ignores it).
+         **
+         ** Presumably, the font is marked non-cachable because the FPE has
+         ** put some licensing restrictions on it.  If the FPE, using
+         ** whatever logic it relies on, determines that it is willing to
+         ** share this existing font with the client, then it has the option
+         ** to return the FontPtr we passed it as the newly-opened font.
+         ** This allows the FPE to exercise its licensing logic without
+         ** having to create another instance of a font that already exists.
+         */
+
+        cached = FindCachedFontPattern(patternCache, pfontname, lenfname);
+        if (cached && cached->info.cachable) {
+            if (!AddResource(fid, RT_FONT, (pointer) cached))
+                return BadAlloc;
+            cached->refcnt++;
+            return Success;
+        }
     }
     c = malloc(sizeof(OFclosureRec));
     if (!c)
-	return BadAlloc;
+        return BadAlloc;
     c->fontname = malloc(lenfname);
     c->origFontName = pfontname;
     c->origFontNameLen = lenfname;
     if (!c->fontname) {
-	free(c);
-	return BadAlloc;
+        free(c);
+        return BadAlloc;
     }
     /*
      * copy the current FPE list, so that if it gets changed by another client
@@ -441,14 +425,14 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
      */
     c->fpe_list = malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	free(c->fontname);
-	free(c);
-	return BadAlloc;
+        free(c->fontname);
+        free(c);
+        return BadAlloc;
     }
     memmove(c->fontname, pfontname, lenfname);
     for (i = 0; i < num_fpes; i++) {
-	c->fpe_list[i] = font_path_elements[i];
-	UseFPE(c->fpe_list[i]);
+        c->fpe_list[i] = font_path_elements[i];
+        UseFPE(c->fpe_list[i]);
     }
     c->client = client;
     c->fontid = fid;
@@ -471,38 +455,37 @@ OpenFont(ClientPtr client, XID fid, Mask flags, unsigned lenfname, char *pfontna
 int
 CloseFont(pointer value, XID fid)
 {
-    int         nscr;
-    ScreenPtr   pscr;
+    int nscr;
+    ScreenPtr pscr;
     FontPathElementPtr fpe;
-    FontPtr     pfont = (FontPtr)value;
+    FontPtr pfont = (FontPtr) value;
 
     if (pfont == NullFont)
-	return Success;
+        return Success;
     if (--pfont->refcnt == 0) {
-	if (patternCache)
-	    RemoveCachedFontPattern (patternCache, pfont);
-	/*
-	 * since the last reference is gone, ask each screen to free any
-	 * storage it may have allocated locally for it.
-	 */
-	for (nscr = 0; nscr < screenInfo.numScreens; nscr++) {
-	    pscr = screenInfo.screens[nscr];
-	    if (pscr->UnrealizeFont)
-		(*pscr->UnrealizeFont) (pscr, pfont);
-	}
-	if (pfont == defaultFont)
-	    defaultFont = NULL;
+        if (patternCache)
+            RemoveCachedFontPattern(patternCache, pfont);
+        /*
+         * since the last reference is gone, ask each screen to free any
+         * storage it may have allocated locally for it.
+         */
+        for (nscr = 0; nscr < screenInfo.numScreens; nscr++) {
+            pscr = screenInfo.screens[nscr];
+            if (pscr->UnrealizeFont)
+                (*pscr->UnrealizeFont) (pscr, pfont);
+        }
+        if (pfont == defaultFont)
+            defaultFont = NULL;
 #ifdef XF86BIGFONT
-	XF86BigfontFreeFontShm(pfont);
+        XF86BigfontFreeFontShm(pfont);
 #endif
-	fpe = pfont->fpe;
-	(*fpe_functions[fpe->type].close_font) (fpe, pfont);
-	FreeFPE(fpe);
+        fpe = pfont->fpe;
+        (*fpe_functions[fpe->type].close_font) (fpe, pfont);
+        FreeFPE(fpe);
     }
     return Success;
 }
 
-
 /***====================================================================***/
 
 /**
@@ -512,19 +495,17 @@ CloseFont(pointer value, XID fid)
  *  \param pReply caller must allocate this storage
   */
 void
-QueryFont(FontPtr pFont, xQueryFontReply *pReply, int nProtoCCIStructs)
+QueryFont(FontPtr pFont, xQueryFontReply * pReply, int nProtoCCIStructs)
 {
-    FontPropPtr      pFP;
-    int              r,
-                     c,
-                     i;
-    xFontProp       *prFP;
-    xCharInfo       *prCI;
-    xCharInfo       *charInfos[256];
-    unsigned char    chars[512];
-    int              ninfos;
-    unsigned long    ncols;
-    unsigned long    count;
+    FontPropPtr pFP;
+    int r, c, i;
+    xFontProp *prFP;
+    xCharInfo *prCI;
+    xCharInfo *charInfos[256];
+    unsigned char chars[512];
+    int ninfos;
+    unsigned long ncols;
+    unsigned long count;
 
     /* pr->length set in dispatch */
     pReply->minCharOrByte2 = pFont->info.firstCol;
@@ -544,31 +525,29 @@ QueryFont(FontPtr pFont, xQueryFontReply *pReply, int nProtoCCIStructs)
     pReply->nCharInfos = nProtoCCIStructs;
 
     for (i = 0, pFP = pFont->info.props, prFP = (xFontProp *) (&pReply[1]);
-	    i < pFont->info.nprops;
-	    i++, pFP++, prFP++) {
-	prFP->name = pFP->name;
-	prFP->value = pFP->value;
+         i < pFont->info.nprops; i++, pFP++, prFP++) {
+        prFP->name = pFP->name;
+        prFP->value = pFP->value;
     }
 
     ninfos = 0;
     ncols = (unsigned long) (pFont->info.lastCol - pFont->info.firstCol + 1);
     prCI = (xCharInfo *) (prFP);
     for (r = pFont->info.firstRow;
-	    ninfos < nProtoCCIStructs && r <= (int)pFont->info.lastRow;
-	    r++) {
-	i = 0;
-	for (c = pFont->info.firstCol; c <= (int)pFont->info.lastCol; c++) {
-	    chars[i++] = r;
-	    chars[i++] = c;
-	}
-	(*pFont->get_metrics) (pFont, ncols, chars, 
-				TwoD16Bit, &count, charInfos);
-	i = 0;
-	for (i = 0; i < (int) count && ninfos < nProtoCCIStructs; i++) {
-	    *prCI = *charInfos[i];
-	    prCI++;
-	    ninfos++;
-	}
+         ninfos < nProtoCCIStructs && r <= (int) pFont->info.lastRow; r++) {
+        i = 0;
+        for (c = pFont->info.firstCol; c <= (int) pFont->info.lastCol; c++) {
+            chars[i++] = r;
+            chars[i++] = c;
+        }
+        (*pFont->get_metrics) (pFont, ncols, chars,
+                               TwoD16Bit, &count, charInfos);
+        i = 0;
+        for (i = 0; i < (int) count && ninfos < nProtoCCIStructs; i++) {
+            *prCI = *charInfos[i];
+            prCI++;
+            ninfos++;
+        }
     }
     return;
 }
@@ -577,215 +556,206 @@ static Bool
 doListFontsAndAliases(ClientPtr client, LFclosurePtr c)
 {
     FontPathElementPtr fpe;
-    int         err = Successful;
+    int err = Successful;
     FontNamesPtr names = NULL;
-    char       *name, *resolved=NULL;
-    int         namelen, resolvedlen;
-    int		nnames;
-    int         stringLens;
-    int         i;
+    char *name, *resolved = NULL;
+    int namelen, resolvedlen;
+    int nnames;
+    int stringLens;
+    int i;
     xListFontsReply reply;
-    char	*bufptr;
-    char	*bufferStart;
-    int		aliascount = 0;
-    Bool	fromDispatch = c->from_dispatch;
-    Bool	finished = FALSE;
+    char *bufptr;
+    char *bufferStart;
+    int aliascount = 0;
+    Bool fromDispatch = c->from_dispatch;
+    Bool finished = FALSE;
 
     c->from_dispatch = FALSE;
 
-    if (client->clientGone)
-    {
-	if (c->current.current_fpe < c->num_fpes)
-	{
-	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	}
-	err = Successful;
-	goto bail;
+    if (client->clientGone) {
+        if (c->current.current_fpe < c->num_fpes) {
+            fpe = c->fpe_list[c->current.current_fpe];
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+        }
+        err = Successful;
+        goto bail;
     }
 
     if (!c->current.patlen)
-	goto finish;
+        goto finish;
 
     while (c->current.current_fpe < c->num_fpes) {
-	fpe = c->fpe_list[c->current.current_fpe];
-	err = Successful;
-
-	if (!fpe_functions[fpe->type].start_list_fonts_and_aliases)
-	{
-	    /* This FPE doesn't support/require list_fonts_and_aliases */
-
-	    err = (*fpe_functions[fpe->type].list_fonts)
-		((pointer) c->client, fpe, c->current.pattern,
-		 c->current.patlen, c->current.max_names - c->names->nnames,
-		 c->names);
-
-	    if (err == Suspended) {
-		if (!ClientIsAsleep(client))
-		    ClientSleep(client,
-				(ClientSleepProcPtr)doListFontsAndAliases,
-				c);
-		else
-		    goto xinerama_sleep;
-		return TRUE;
-	    }
-
-	    err = BadFontName;
-	}
-	else
-	{
-	    /* Start of list_fonts_and_aliases functionality.  Modeled
-	       after list_fonts_with_info in that it resolves aliases,
-	       except that the information collected from FPEs is just
-	       names, not font info.  Each list_next_font_or_alias()
-	       returns either a name into name/namelen or an alias into
-	       name/namelen and its target name into resolved/resolvedlen.
-	       The code at this level then resolves the alias by polling
-	       the FPEs.  */
-
-	    if (!c->current.list_started) {
-		err = (*fpe_functions[fpe->type].start_list_fonts_and_aliases)
-		    ((pointer) c->client, fpe, c->current.pattern,
-		     c->current.patlen, c->current.max_names - c->names->nnames,
-		     &c->current.private);
-		if (err == Suspended) {
-		    if (!ClientIsAsleep(client))
-			ClientSleep(client,
-				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    c);
-		    else
-			goto xinerama_sleep;
-		    return TRUE;
-		}
-		if (err == Successful)
-		    c->current.list_started = TRUE;
-	    }
-	    if (err == Successful) {
-		char    *tmpname;
-		name = 0;
-		err = (*fpe_functions[fpe->type].list_next_font_or_alias)
-		    ((pointer) c->client, fpe, &name, &namelen, &tmpname,
-		     &resolvedlen, c->current.private);
-		if (err == Suspended) {
-		    if (!ClientIsAsleep(client))
-			ClientSleep(client,
-				    (ClientSleepProcPtr)doListFontsAndAliases,
-				    c);
-		    else
-			goto xinerama_sleep;
-		    return TRUE;
-		}
-		if (err == FontNameAlias) {
-		    free(resolved);
-		    resolved = malloc(resolvedlen + 1);
-		    if (resolved)
-			memmove(resolved, tmpname, resolvedlen + 1);
-		}
-	    }
-
-	    if (err == Successful)
-	    {
-		if (c->haveSaved)
-		{
-		    if (c->savedName)
-			(void)AddFontNamesName(c->names, c->savedName,
-					       c->savedNameLen);
-		}
-		else
-		    (void)AddFontNamesName(c->names, name, namelen);
-	    }
-
-	    /*
-	     * When we get an alias back, save our state and reset back to
-	     * the start of the FPE looking for the specified name.  As
-	     * soon as a real font is found for the alias, pop back to the
-	     * old state
-	     */
-	    else if (err == FontNameAlias) {
-		char	tmp_pattern[XLFDMAXFONTNAMELEN];
-		/*
-		 * when an alias recurses, we need to give
-		 * the last FPE a chance to clean up; so we call
-		 * it again, and assume that the error returned
-		 * is BadFontName, indicating the alias resolution
-		 * is complete.
-		 */
-		memmove(tmp_pattern, resolved, resolvedlen);
-		if (c->haveSaved)
-		{
-		    char    *tmpname;
-		    int     tmpnamelen;
-
-		    tmpname = 0;
-		    (void) (*fpe_functions[fpe->type].list_next_font_or_alias)
-			((pointer) c->client, fpe, &tmpname, &tmpnamelen,
-			 &tmpname, &tmpnamelen, c->current.private);
-		    if (--aliascount <= 0)
-		    {
-			err = BadFontName;
-			goto ContBadFontName;
-		    }
-		}
-		else
-		{
-		    c->saved = c->current;
-		    c->haveSaved = TRUE;
-		    free(c->savedName);
-		    c->savedName = malloc(namelen + 1);
-		    if (c->savedName)
-			memmove(c->savedName, name, namelen + 1);
-		    c->savedNameLen = namelen;
-		    aliascount = 20;
-		}
-		memmove(c->current.pattern, tmp_pattern, resolvedlen);
-		c->current.patlen = resolvedlen;
-		c->current.max_names = c->names->nnames + 1;
-		c->current.current_fpe = -1;
-		c->current.private = 0;
-		err = BadFontName;
-	    }
-	}
-	/*
-	 * At the end of this FPE, step to the next.  If we've finished
-	 * processing an alias, pop state back. If we've collected enough
-	 * font names, quit.
-	 */
-	if (err == BadFontName) {
-	  ContBadFontName: ;
-	    c->current.list_started = FALSE;
-	    c->current.current_fpe++;
-	    err = Successful;
-	    if (c->haveSaved)
-	    {
-		if (c->names->nnames == c->current.max_names ||
-			c->current.current_fpe == c->num_fpes) {
-		    c->haveSaved = FALSE;
-		    c->current = c->saved;
-		    /* Give the saved namelist a chance to clean itself up */
-		    continue;
-		}
-	    }
-	    if (c->names->nnames == c->current.max_names)
-		break;
-	}
+        fpe = c->fpe_list[c->current.current_fpe];
+        err = Successful;
+
+        if (!fpe_functions[fpe->type].start_list_fonts_and_aliases) {
+            /* This FPE doesn't support/require list_fonts_and_aliases */
+
+            err = (*fpe_functions[fpe->type].list_fonts)
+                ((pointer) c->client, fpe, c->current.pattern,
+                 c->current.patlen, c->current.max_names - c->names->nnames,
+                 c->names);
+
+            if (err == Suspended) {
+                if (!ClientIsAsleep(client))
+                    ClientSleep(client,
+                                (ClientSleepProcPtr) doListFontsAndAliases, c);
+                else
+                    goto xinerama_sleep;
+                return TRUE;
+            }
+
+            err = BadFontName;
+        }
+        else {
+            /* Start of list_fonts_and_aliases functionality.  Modeled
+               after list_fonts_with_info in that it resolves aliases,
+               except that the information collected from FPEs is just
+               names, not font info.  Each list_next_font_or_alias()
+               returns either a name into name/namelen or an alias into
+               name/namelen and its target name into resolved/resolvedlen.
+               The code at this level then resolves the alias by polling
+               the FPEs.  */
+
+            if (!c->current.list_started) {
+                err = (*fpe_functions[fpe->type].start_list_fonts_and_aliases)
+                    ((pointer) c->client, fpe, c->current.pattern,
+                     c->current.patlen, c->current.max_names - c->names->nnames,
+                     &c->current.private);
+                if (err == Suspended) {
+                    if (!ClientIsAsleep(client))
+                        ClientSleep(client,
+                                    (ClientSleepProcPtr) doListFontsAndAliases,
+                                    c);
+                    else
+                        goto xinerama_sleep;
+                    return TRUE;
+                }
+                if (err == Successful)
+                    c->current.list_started = TRUE;
+            }
+            if (err == Successful) {
+                char *tmpname;
+
+                name = 0;
+                err = (*fpe_functions[fpe->type].list_next_font_or_alias)
+                    ((pointer) c->client, fpe, &name, &namelen, &tmpname,
+                     &resolvedlen, c->current.private);
+                if (err == Suspended) {
+                    if (!ClientIsAsleep(client))
+                        ClientSleep(client,
+                                    (ClientSleepProcPtr) doListFontsAndAliases,
+                                    c);
+                    else
+                        goto xinerama_sleep;
+                    return TRUE;
+                }
+                if (err == FontNameAlias) {
+                    free(resolved);
+                    resolved = malloc(resolvedlen + 1);
+                    if (resolved)
+                        memmove(resolved, tmpname, resolvedlen + 1);
+                }
+            }
+
+            if (err == Successful) {
+                if (c->haveSaved) {
+                    if (c->savedName)
+                        (void) AddFontNamesName(c->names, c->savedName,
+                                                c->savedNameLen);
+                }
+                else
+                    (void) AddFontNamesName(c->names, name, namelen);
+            }
+
+            /*
+             * When we get an alias back, save our state and reset back to
+             * the start of the FPE looking for the specified name.  As
+             * soon as a real font is found for the alias, pop back to the
+             * old state
+             */
+            else if (err == FontNameAlias) {
+                char tmp_pattern[XLFDMAXFONTNAMELEN];
+
+                /*
+                 * when an alias recurses, we need to give
+                 * the last FPE a chance to clean up; so we call
+                 * it again, and assume that the error returned
+                 * is BadFontName, indicating the alias resolution
+                 * is complete.
+                 */
+                memmove(tmp_pattern, resolved, resolvedlen);
+                if (c->haveSaved) {
+                    char *tmpname;
+                    int tmpnamelen;
+
+                    tmpname = 0;
+                    (void) (*fpe_functions[fpe->type].list_next_font_or_alias)
+                        ((pointer) c->client, fpe, &tmpname, &tmpnamelen,
+                         &tmpname, &tmpnamelen, c->current.private);
+                    if (--aliascount <= 0) {
+                        err = BadFontName;
+                        goto ContBadFontName;
+                    }
+                }
+                else {
+                    c->saved = c->current;
+                    c->haveSaved = TRUE;
+                    free(c->savedName);
+                    c->savedName = malloc(namelen + 1);
+                    if (c->savedName)
+                        memmove(c->savedName, name, namelen + 1);
+                    c->savedNameLen = namelen;
+                    aliascount = 20;
+                }
+                memmove(c->current.pattern, tmp_pattern, resolvedlen);
+                c->current.patlen = resolvedlen;
+                c->current.max_names = c->names->nnames + 1;
+                c->current.current_fpe = -1;
+                c->current.private = 0;
+                err = BadFontName;
+            }
+        }
+        /*
+         * At the end of this FPE, step to the next.  If we've finished
+         * processing an alias, pop state back. If we've collected enough
+         * font names, quit.
+         */
+        if (err == BadFontName) {
+ ContBadFontName:;
+            c->current.list_started = FALSE;
+            c->current.current_fpe++;
+            err = Successful;
+            if (c->haveSaved) {
+                if (c->names->nnames == c->current.max_names ||
+                    c->current.current_fpe == c->num_fpes) {
+                    c->haveSaved = FALSE;
+                    c->current = c->saved;
+                    /* Give the saved namelist a chance to clean itself up */
+                    continue;
+                }
+            }
+            if (c->names->nnames == c->current.max_names)
+                break;
+        }
     }
 
     /*
      * send the reply
      */
     if (err != Successful) {
-	SendErrorToClient(client, X_ListFonts, 0, 0, FontToXError(err));
-	goto bail;
+        SendErrorToClient(client, X_ListFonts, 0, 0, FontToXError(err));
+        goto bail;
     }
 
-finish:
+ finish:
 
     names = c->names;
     nnames = names->nnames;
     client = c->client;
     stringLens = 0;
     for (i = 0; i < nnames; i++)
-	stringLens += (names->length[i] <= 255) ? names->length[i] : 0;
+        stringLens += (names->length[i] <= 255) ? names->length[i] : 0;
 
     memset(&reply, 0, sizeof(xListFontsReply));
     reply.type = X_Reply;
@@ -796,22 +766,21 @@ finish:
     bufptr = bufferStart = malloc(reply.length << 2);
 
     if (!bufptr && reply.length) {
-	SendErrorToClient(client, X_ListFonts, 0, 0, BadAlloc);
-	goto bail;
+        SendErrorToClient(client, X_ListFonts, 0, 0, BadAlloc);
+        goto bail;
     }
     /*
      * since WriteToClient long word aligns things, copy to temp buffer and
      * write all at once
      */
     for (i = 0; i < nnames; i++) {
-	if (names->length[i] > 255)
-	    reply.nFonts--;
-	else
-	{
-	    *bufptr++ = names->length[i];
-	    memmove( bufptr, names->names[i], names->length[i]);
-	    bufptr += names->length[i];
-	}
+        if (names->length[i] > 255)
+            reply.nFonts--;
+        else {
+            *bufptr++ = names->length[i];
+            memmove(bufptr, names->names[i], names->length[i]);
+            bufptr += names->length[i];
+        }
     }
     nnames = reply.nFonts;
     reply.length = bytes_to_int32(stringLens + nnames);
@@ -820,27 +789,27 @@ finish:
     (void) WriteToClient(client, stringLens + nnames, bufferStart);
     free(bufferStart);
 
-bail:
+ bail:
     ClientWakeup(client);
     finished = TRUE;
-xinerama_sleep:
+ xinerama_sleep:
     if (finished || fromDispatch) {
-	for (i = 0; i < c->num_fpes; i++)
-	    FreeFPE(c->fpe_list[i]);
-	free(c->fpe_list);
-	free(c->savedName);
-	FreeFontNames(names);
-	free(c);
+        for (i = 0; i < c->num_fpes; i++)
+            FreeFPE(c->fpe_list[i]);
+        free(c->fpe_list);
+        free(c->savedName);
+        FreeFontNames(names);
+        free(c);
     }
     free(resolved);
     return TRUE;
 }
 
 int
-ListFonts(ClientPtr client, unsigned char *pattern, unsigned length, 
+ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
           unsigned max_names)
 {
-    int         i;
+    int i;
     LFclosurePtr c;
 
     /* 
@@ -850,30 +819,29 @@ ListFonts(ClientPtr client, unsigned char *pattern, unsigned length,
      * a list containing zero fontnames.
      */
     if (length > XLFDMAXFONTNAMELEN)
-	return BadAlloc;
+        return BadAlloc;
 
     i = XaceHook(XACE_SERVER_ACCESS, client, DixGetAttrAccess);
     if (i != Success)
-	return i;
+        return i;
 
     if (!(c = malloc(sizeof *c)))
-	return BadAlloc;
+        return BadAlloc;
     c->fpe_list = malloc(sizeof(FontPathElementPtr) * num_fpes);
     if (!c->fpe_list) {
-	free(c);
-	return BadAlloc;
+        free(c);
+        return BadAlloc;
     }
     c->names = MakeFontNamesRecord(max_names < 100 ? max_names : 100);
-    if (!c->names)
-    {
-	free(c->fpe_list);
-	free(c);
-	return BadAlloc;
+    if (!c->names) {
+        free(c->fpe_list);
+        free(c);
+        return BadAlloc;
     }
-    memmove( c->current.pattern, pattern, length);
+    memmove(c->current.pattern, pattern, length);
     for (i = 0; i < num_fpes; i++) {
-	c->fpe_list[i] = font_path_elements[i];
-	UseFPE(c->fpe_list[i]);
+        c->fpe_list[i] = font_path_elements[i];
+        UseFPE(c->fpe_list[i]);
     }
     c->client = client;
     c->num_fpes = num_fpes;
@@ -893,235 +861,214 @@ int
 doListFontsWithInfo(ClientPtr client, LFWIclosurePtr c)
 {
     FontPathElementPtr fpe;
-    int         err = Successful;
-    char       *name;
-    Bool        fromDispatch = c->from_dispatch;
-    Bool        finished = FALSE;
-    int         namelen;
-    int         numFonts;
-    FontInfoRec fontInfo,
-               *pFontInfo;
+    int err = Successful;
+    char *name;
+    Bool fromDispatch = c->from_dispatch;
+    Bool finished = FALSE;
+    int namelen;
+    int numFonts;
+    FontInfoRec fontInfo, *pFontInfo;
     xListFontsWithInfoReply *reply;
-    int         length;
-    xFontProp  *pFP;
-    int         i;
-    int		aliascount = 0;
+    int length;
+    xFontProp *pFP;
+    int i;
+    int aliascount = 0;
     xListFontsWithInfoReply finalReply;
 
     c->from_dispatch = FALSE;
 
-    if (client->clientGone)
-    {
-	if (c->current.current_fpe < c->num_fpes)
- 	{
-	    fpe = c->fpe_list[c->current.current_fpe];
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	}
-	err = Successful;
-	goto bail;
+    if (client->clientGone) {
+        if (c->current.current_fpe < c->num_fpes) {
+            fpe = c->fpe_list[c->current.current_fpe];
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+        }
+        err = Successful;
+        goto bail;
     }
     client->pSwapReplyFunc = ReplySwapVector[X_ListFontsWithInfo];
     if (!c->current.patlen)
-	goto finish;
-    while (c->current.current_fpe < c->num_fpes)
-    {
-	fpe = c->fpe_list[c->current.current_fpe];
-	err = Successful;
-	if (!c->current.list_started)
- 	{
-	    err = (*fpe_functions[fpe->type].start_list_fonts_with_info)
-		(client, fpe, c->current.pattern, c->current.patlen,
-		 c->current.max_names, &c->current.private);
-	    if (err == Suspended)
- 	    {
-		if (!ClientIsAsleep(client))
-		    ClientSleep(client,
-				(ClientSleepProcPtr)doListFontsWithInfo, c);
-		else
-		    goto xinerama_sleep;
-		return TRUE;
-	    }
-	    if (err == Successful)
-		c->current.list_started = TRUE;
-	}
-	if (err == Successful)
- 	{
-	    name = 0;
-	    pFontInfo = &fontInfo;
-	    err = (*fpe_functions[fpe->type].list_next_font_with_info)
-		(client, fpe, &name, &namelen, &pFontInfo,
-		 &numFonts, c->current.private);
-	    if (err == Suspended)
- 	    {
-		if (!ClientIsAsleep(client))
-		    ClientSleep(client,
-				(ClientSleepProcPtr)doListFontsWithInfo, c);
-		else
-		    goto xinerama_sleep;
-		return TRUE;
-	    }
-	}
-	/*
-	 * When we get an alias back, save our state and reset back to the
-	 * start of the FPE looking for the specified name.  As soon as a real
-	 * font is found for the alias, pop back to the old state
-	 */
-	if (err == FontNameAlias)
- 	{
-	    /*
-	     * when an alias recurses, we need to give
-	     * the last FPE a chance to clean up; so we call
-	     * it again, and assume that the error returned
-	     * is BadFontName, indicating the alias resolution
-	     * is complete.
-	     */
-	    if (c->haveSaved)
-	    {
-		char	*tmpname;
-		int	tmpnamelen;
-		FontInfoPtr tmpFontInfo;
-
-	    	tmpname = 0;
-	    	tmpFontInfo = &fontInfo;
-	    	(void) (*fpe_functions[fpe->type].list_next_font_with_info)
-		    (client, fpe, &tmpname, &tmpnamelen, &tmpFontInfo,
-		     &numFonts, c->current.private);
-		if (--aliascount <= 0)
-		{
-		    err = BadFontName;
-		    goto ContBadFontName;
-		}
-	    }
-	    else
-	    {
-		c->saved = c->current;
-		c->haveSaved = TRUE;
-		c->savedNumFonts = numFonts;
-		free(c->savedName);
-		c->savedName = malloc(namelen + 1);
-		if (c->savedName)
-		  memmove(c->savedName, name, namelen + 1);
-		aliascount = 20;
-	    }
-	    memmove(c->current.pattern, name, namelen);
-	    c->current.patlen = namelen;
-	    c->current.max_names = 1;
-	    c->current.current_fpe = 0;
-	    c->current.private = 0;
-	    c->current.list_started = FALSE;
-	}
-	/*
-	 * At the end of this FPE, step to the next.  If we've finished
-	 * processing an alias, pop state back.  If we've sent enough font
-	 * names, quit.  Always wait for BadFontName to let the FPE
-	 * have a chance to clean up.
-	 */
-	else if (err == BadFontName)
- 	{
-	  ContBadFontName: ;
-	    c->current.list_started = FALSE;
-	    c->current.current_fpe++;
-	    err = Successful;
-	    if (c->haveSaved)
- 	    {
-		if (c->current.max_names == 0 ||
-			c->current.current_fpe == c->num_fpes)
- 		{
-		    c->haveSaved = FALSE;
-		    c->saved.max_names -= (1 - c->current.max_names);
-		    c->current = c->saved;
-		}
-	    }
-	    else if (c->current.max_names == 0)
-		break;
-	}
- 	else if (err == Successful)
- 	{
-	    length = sizeof(*reply) + pFontInfo->nprops * sizeof(xFontProp);
-	    reply = c->reply;
-	    if (c->length < length)
- 	    {
-		reply = (xListFontsWithInfoReply *) realloc(c->reply, length);
-		if (!reply)
- 		{
-		    err = AllocError;
-		    break;
-		}
-		memset((char*)reply + c->length, 0, length - c->length);
-		c->reply = reply;
-		c->length = length;
-	    }
-	    if (c->haveSaved)
- 	    {
-		numFonts = c->savedNumFonts;
-		name = c->savedName;
-		namelen = strlen(name);
-	    }
-	    reply->type = X_Reply;
-	    reply->length = bytes_to_int32(sizeof *reply - sizeof(xGenericReply) +
-			     pFontInfo->nprops * sizeof(xFontProp) +
-			     namelen);
-	    reply->sequenceNumber = client->sequence;
-	    reply->nameLength = namelen;
-	    reply->minBounds = pFontInfo->ink_minbounds;
-	    reply->maxBounds = pFontInfo->ink_maxbounds;
-	    reply->minCharOrByte2 = pFontInfo->firstCol;
-	    reply->maxCharOrByte2 = pFontInfo->lastCol;
-	    reply->defaultChar = pFontInfo->defaultCh;
-	    reply->nFontProps = pFontInfo->nprops;
-	    reply->drawDirection = pFontInfo->drawDirection;
-	    reply->minByte1 = pFontInfo->firstRow;
-	    reply->maxByte1 = pFontInfo->lastRow;
-	    reply->allCharsExist = pFontInfo->allExist;
-	    reply->fontAscent = pFontInfo->fontAscent;
-	    reply->fontDescent = pFontInfo->fontDescent;
-	    reply->nReplies = numFonts;
-	    pFP = (xFontProp *) (reply + 1);
-	    for (i = 0; i < pFontInfo->nprops; i++)
- 	    {
-		pFP->name = pFontInfo->props[i].name;
-		pFP->value = pFontInfo->props[i].value;
-		pFP++;
-	    }
-	    WriteSwappedDataToClient(client, length, reply);
-	    (void) WriteToClient(client, namelen, name);
-	    if (pFontInfo == &fontInfo)
- 	    {
-		free(fontInfo.props);
-		free(fontInfo.isStringProp);
-	    }
-	    --c->current.max_names;
-	}
-    }
-finish:
+        goto finish;
+    while (c->current.current_fpe < c->num_fpes) {
+        fpe = c->fpe_list[c->current.current_fpe];
+        err = Successful;
+        if (!c->current.list_started) {
+            err = (*fpe_functions[fpe->type].start_list_fonts_with_info)
+                (client, fpe, c->current.pattern, c->current.patlen,
+                 c->current.max_names, &c->current.private);
+            if (err == Suspended) {
+                if (!ClientIsAsleep(client))
+                    ClientSleep(client,
+                                (ClientSleepProcPtr) doListFontsWithInfo, c);
+                else
+                    goto xinerama_sleep;
+                return TRUE;
+            }
+            if (err == Successful)
+                c->current.list_started = TRUE;
+        }
+        if (err == Successful) {
+            name = 0;
+            pFontInfo = &fontInfo;
+            err = (*fpe_functions[fpe->type].list_next_font_with_info)
+                (client, fpe, &name, &namelen, &pFontInfo,
+                 &numFonts, c->current.private);
+            if (err == Suspended) {
+                if (!ClientIsAsleep(client))
+                    ClientSleep(client,
+                                (ClientSleepProcPtr) doListFontsWithInfo, c);
+                else
+                    goto xinerama_sleep;
+                return TRUE;
+            }
+        }
+        /*
+         * When we get an alias back, save our state and reset back to the
+         * start of the FPE looking for the specified name.  As soon as a real
+         * font is found for the alias, pop back to the old state
+         */
+        if (err == FontNameAlias) {
+            /*
+             * when an alias recurses, we need to give
+             * the last FPE a chance to clean up; so we call
+             * it again, and assume that the error returned
+             * is BadFontName, indicating the alias resolution
+             * is complete.
+             */
+            if (c->haveSaved) {
+                char *tmpname;
+                int tmpnamelen;
+                FontInfoPtr tmpFontInfo;
+
+                tmpname = 0;
+                tmpFontInfo = &fontInfo;
+                (void) (*fpe_functions[fpe->type].list_next_font_with_info)
+                    (client, fpe, &tmpname, &tmpnamelen, &tmpFontInfo,
+                     &numFonts, c->current.private);
+                if (--aliascount <= 0) {
+                    err = BadFontName;
+                    goto ContBadFontName;
+                }
+            }
+            else {
+                c->saved = c->current;
+                c->haveSaved = TRUE;
+                c->savedNumFonts = numFonts;
+                free(c->savedName);
+                c->savedName = malloc(namelen + 1);
+                if (c->savedName)
+                    memmove(c->savedName, name, namelen + 1);
+                aliascount = 20;
+            }
+            memmove(c->current.pattern, name, namelen);
+            c->current.patlen = namelen;
+            c->current.max_names = 1;
+            c->current.current_fpe = 0;
+            c->current.private = 0;
+            c->current.list_started = FALSE;
+        }
+        /*
+         * At the end of this FPE, step to the next.  If we've finished
+         * processing an alias, pop state back.  If we've sent enough font
+         * names, quit.  Always wait for BadFontName to let the FPE
+         * have a chance to clean up.
+         */
+        else if (err == BadFontName) {
+ ContBadFontName:;
+            c->current.list_started = FALSE;
+            c->current.current_fpe++;
+            err = Successful;
+            if (c->haveSaved) {
+                if (c->current.max_names == 0 ||
+                    c->current.current_fpe == c->num_fpes) {
+                    c->haveSaved = FALSE;
+                    c->saved.max_names -= (1 - c->current.max_names);
+                    c->current = c->saved;
+                }
+            }
+            else if (c->current.max_names == 0)
+                break;
+        }
+        else if (err == Successful) {
+            length = sizeof(*reply) + pFontInfo->nprops * sizeof(xFontProp);
+            reply = c->reply;
+            if (c->length < length) {
+                reply = (xListFontsWithInfoReply *) realloc(c->reply, length);
+                if (!reply) {
+                    err = AllocError;
+                    break;
+                }
+                memset((char *) reply + c->length, 0, length - c->length);
+                c->reply = reply;
+                c->length = length;
+            }
+            if (c->haveSaved) {
+                numFonts = c->savedNumFonts;
+                name = c->savedName;
+                namelen = strlen(name);
+            }
+            reply->type = X_Reply;
+            reply->length =
+                bytes_to_int32(sizeof *reply - sizeof(xGenericReply) +
+                               pFontInfo->nprops * sizeof(xFontProp) + namelen);
+            reply->sequenceNumber = client->sequence;
+            reply->nameLength = namelen;
+            reply->minBounds = pFontInfo->ink_minbounds;
+            reply->maxBounds = pFontInfo->ink_maxbounds;
+            reply->minCharOrByte2 = pFontInfo->firstCol;
+            reply->maxCharOrByte2 = pFontInfo->lastCol;
+            reply->defaultChar = pFontInfo->defaultCh;
+            reply->nFontProps = pFontInfo->nprops;
+            reply->drawDirection = pFontInfo->drawDirection;
+            reply->minByte1 = pFontInfo->firstRow;
+            reply->maxByte1 = pFontInfo->lastRow;
+            reply->allCharsExist = pFontInfo->allExist;
+            reply->fontAscent = pFontInfo->fontAscent;
+            reply->fontDescent = pFontInfo->fontDescent;
+            reply->nReplies = numFonts;
+            pFP = (xFontProp *) (reply + 1);
+            for (i = 0; i < pFontInfo->nprops; i++) {
+                pFP->name = pFontInfo->props[i].name;
+                pFP->value = pFontInfo->props[i].value;
+                pFP++;
+            }
+            WriteSwappedDataToClient(client, length, reply);
+            (void) WriteToClient(client, namelen, name);
+            if (pFontInfo == &fontInfo) {
+                free(fontInfo.props);
+                free(fontInfo.isStringProp);
+            }
+            --c->current.max_names;
+        }
+    }
+ finish:
     length = sizeof(xListFontsWithInfoReply);
     memset((char *) &finalReply, 0, sizeof(xListFontsWithInfoReply));
     finalReply.type = X_Reply;
     finalReply.sequenceNumber = client->sequence;
     finalReply.length = bytes_to_int32(sizeof(xListFontsWithInfoReply)
-		     - sizeof(xGenericReply));
+                                       - sizeof(xGenericReply));
     WriteSwappedDataToClient(client, length, &finalReply);
-bail:
+ bail:
     ClientWakeup(client);
     finished = TRUE;
-xinerama_sleep:
+ xinerama_sleep:
     if (finished || fromDispatch) {
-	for (i = 0; i < c->num_fpes; i++)
-	    FreeFPE(c->fpe_list[i]);
-	free(c->reply);
-	free(c->fpe_list);
-	free(c->savedName);
-	free(c);
+        for (i = 0; i < c->num_fpes; i++)
+            FreeFPE(c->fpe_list[i]);
+        free(c->reply);
+        free(c->fpe_list);
+        free(c->savedName);
+        free(c);
     }
     return TRUE;
 }
 
 int
-StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern, 
+StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
                        int max_names)
 {
-    int		    i;
-    LFWIclosurePtr  c;
+    int i;
+    LFWIclosurePtr c;
 
     /* 
      * The right error to return here would be BadName, however the
@@ -1130,25 +1077,23 @@ StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
      * a list containing zero fontnames.
      */
     if (length > XLFDMAXFONTNAMELEN)
-	return BadAlloc;
+        return BadAlloc;
 
     i = XaceHook(XACE_SERVER_ACCESS, client, DixGetAttrAccess);
     if (i != Success)
-	return i;
+        return i;
 
     if (!(c = malloc(sizeof *c)))
-	goto badAlloc;
+        goto badAlloc;
     c->fpe_list = malloc(sizeof(FontPathElementPtr) * num_fpes);
-    if (!c->fpe_list)
-    {
-	free(c);
-	goto badAlloc;
+    if (!c->fpe_list) {
+        free(c);
+        goto badAlloc;
     }
     memmove(c->current.pattern, pattern, length);
-    for (i = 0; i < num_fpes; i++)
-    {
-	c->fpe_list[i] = font_path_elements[i];
-	UseFPE(c->fpe_list[i]);
+    for (i = 0; i < num_fpes; i++) {
+        c->fpe_list[i] = font_path_elements[i];
+        UseFPE(c->fpe_list[i]);
     }
     c->client = client;
     c->num_fpes = num_fpes;
@@ -1165,20 +1110,21 @@ StartListFontsWithInfo(ClientPtr client, int length, unsigned char *pattern,
     c->savedName = 0;
     doListFontsWithInfo(client, c);
     return Success;
-badAlloc:
+ badAlloc:
     return BadAlloc;
 }
 
 #define TextEltHeader 2
 #define FontShiftSize 5
 static ChangeGCVal clearGC[] = { NullPixmap };
+
 #define clearGCmask (GCClipMask)
 
 int
 doPolyText(ClientPtr client, PTclosurePtr c)
 {
     FontPtr pFont = c->pGC->font, oldpFont;
-    int err = Success, lgerr;	/* err is in X error, not font error, space */
+    int err = Success, lgerr;   /* err is in X error, not font error, space */
     enum { NEVER_SLEPT, START_SLEEP, SLEEPING } client_state = NEVER_SLEPT;
     FontPathElementPtr fpe;
     GC *origGC = NULL;
@@ -1188,270 +1134,261 @@ doPolyText(ClientPtr client, PTclosurePtr c)
 
     c->from_dispatch = FALSE;
 
-    if (client->clientGone)
-    {
-	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-
-	if (ClientIsAsleep(client))
-	{
-	    /* Client has died, but we cannot bail out right now.  We
-	       need to clean up after the work we did when going to
-	       sleep.  Setting the drawable pointer to 0 makes this
-	       happen without any attempts to render or perform other
-	       unnecessary activities.  */
-	    c->pDraw = (DrawablePtr)0;
-	}
-	else
-	{
-	    err = Success;
-	    goto bail;
-	}
+    if (client->clientGone) {
+        fpe = c->pGC->font->fpe;
+        (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+
+        if (ClientIsAsleep(client)) {
+            /* Client has died, but we cannot bail out right now.  We
+               need to clean up after the work we did when going to
+               sleep.  Setting the drawable pointer to 0 makes this
+               happen without any attempts to render or perform other
+               unnecessary activities.  */
+            c->pDraw = (DrawablePtr) 0;
+        }
+        else {
+            err = Success;
+            goto bail;
+        }
     }
 
     /* Make sure our drawable hasn't disappeared while we slept. */
-    if (ClientIsAsleep(client) && c->pDraw)
-    {
-	DrawablePtr pDraw;
-	dixLookupDrawable(&pDraw, c->did, client, 0, DixWriteAccess);
-	if (c->pDraw != pDraw) {
-	    /* Our drawable has disappeared.  Treat like client died... ask
-	       the FPE code to clean up after client and avoid further
-	       rendering while we clean up after ourself.  */
-	    fpe = c->pGC->font->fpe;
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	    c->pDraw = (DrawablePtr)0;
-	}
+    if (ClientIsAsleep(client) && c->pDraw) {
+        DrawablePtr pDraw;
+
+        dixLookupDrawable(&pDraw, c->did, client, 0, DixWriteAccess);
+        if (c->pDraw != pDraw) {
+            /* Our drawable has disappeared.  Treat like client died... ask
+               the FPE code to clean up after client and avoid further
+               rendering while we clean up after ourself.  */
+            fpe = c->pGC->font->fpe;
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+            c->pDraw = (DrawablePtr) 0;
+        }
     }
 
     client_state = ClientIsAsleep(client) ? SLEEPING : NEVER_SLEPT;
 
-    while (c->endReq - c->pElt > TextEltHeader)
-    {
-	if (*c->pElt == FontChange)
-        {
-	    Font fid;
-	    if (c->endReq - c->pElt < FontShiftSize)
-	    {
-		 err = BadLength;
-		 goto bail;
-	    }
-
-	    oldpFont = pFont;
-
-	    fid =  ((Font)*(c->pElt+4))		/* big-endian */
-		 | ((Font)*(c->pElt+3)) << 8
-		 | ((Font)*(c->pElt+2)) << 16
-		 | ((Font)*(c->pElt+1)) << 24;
-	    err = dixLookupResourceByType((pointer *)&pFont, fid, RT_FONT,
-					  client, DixUseAccess);
-	    if (err != Success)
-	    {
-		/* restore pFont for step 4 (described below) */
-		pFont = oldpFont;
-
-		/* If we're in START_SLEEP mode, the following step
-		   shortens the request...  in the unlikely event that
-		   the fid somehow becomes valid before we come through
-		   again to actually execute the polytext, which would
-		   then mess up our refcounting scheme badly.  */
-		c->err = err;
-		c->endReq = c->pElt;
-
-		goto bail;
-	    }
-
-	    /* Step 3 (described below) on our new font */
-	    if (client_state == START_SLEEP)
-		pFont->refcnt++;
-	    else
-	    {
-		if (pFont != c->pGC->font && c->pDraw)
-		{
-		    ChangeGCVal val;
-		    val.ptr = pFont;
-		    ChangeGC(NullClient, c->pGC, GCFont, &val);
-		    ValidateGC(c->pDraw, c->pGC);
-		}
-
-		/* Undo the refcnt++ we performed when going to sleep */
-		if (client_state == SLEEPING)
-		    (void)CloseFont(c->pGC->font, (Font)0);
-	    }
-	    c->pElt += FontShiftSize;
-	}
-	else	/* print a string */
-	{
-	    unsigned char *pNextElt;
-	    pNextElt = c->pElt + TextEltHeader + (*c->pElt) * itemSize;
-	    if ( pNextElt > c->endReq)
-	    {
-		err = BadLength;
-		goto bail;
-	    }
-	    if (client_state == START_SLEEP)
-	    {
-		c->pElt = pNextElt;
-		continue;
-	    }
-	    if (c->pDraw)
-	    {
-		lgerr = LoadGlyphs(client, c->pGC->font, *c->pElt, itemSize,
-				   c->pElt + TextEltHeader);
-	    }
-	    else lgerr = Successful;
-
-	    if (lgerr == Suspended)
-	    {
-		if (!ClientIsAsleep(client)) {
-		    int len;
-		    GC *pGC;
-		    PTclosurePtr new_closure;
-
-    /*  We're putting the client to sleep.  We need to do a few things
-	to ensure successful and atomic-appearing execution of the
-	remainder of the request.  First, copy the remainder of the
-	request into a safe malloc'd area.  Second, create a scratch GC
-	to use for the remainder of the request.  Third, mark all fonts
-	referenced in the remainder of the request to prevent their
-	deallocation.  Fourth, make the original GC look like the
-	request has completed...  set its font to the final font value
-	from this request.  These GC manipulations are for the unlikely
-	(but possible) event that some other client is using the GC.
-	Steps 3 and 4 are performed by running this procedure through
-	the remainder of the request in a special no-render mode
-	indicated by client_state = START_SLEEP.  */
-
-		    /* Step 1 */
-		    /* Allocate a malloc'd closure structure to replace
-		       the local one we were passed */
-		    new_closure = malloc(sizeof(PTclosureRec));
-		    if (!new_closure)
-		    {
-			err = BadAlloc;
-			goto bail;
-		    }
-		    *new_closure = *c;
-
-		    len = new_closure->endReq - new_closure->pElt;
-		    new_closure->data = malloc(len);
-		    if (!new_closure->data)
-		    {
-			free(new_closure);
-			err = BadAlloc;
-			goto bail;
-		    }
-		    memmove(new_closure->data, new_closure->pElt, len);
-		    new_closure->pElt = new_closure->data;
-		    new_closure->endReq = new_closure->pElt + len;
-
-		    /* Step 2 */
-
-		    pGC = GetScratchGC(new_closure->pGC->depth, new_closure->pGC->pScreen);
-		    if (!pGC)
-		    {
-			free(new_closure->data);
-			free(new_closure);
-			err = BadAlloc;
-			goto bail;
-		    }
-		    if ((err = CopyGC(new_closure->pGC, pGC, GCFunction |
-				      GCPlaneMask | GCForeground |
-				      GCBackground | GCFillStyle |
-				      GCTile | GCStipple |
-				      GCTileStipXOrigin |
-				      GCTileStipYOrigin | GCFont |
-				      GCSubwindowMode | GCClipXOrigin |
-				      GCClipYOrigin | GCClipMask)) !=
-				      Success)
-		    {
-			FreeScratchGC(pGC);
-			free(new_closure->data);
-			free(new_closure);
-			err = BadAlloc;
-			goto bail;
-		    }
-		    c = new_closure;
-		    origGC = c->pGC;
-		    c->pGC = pGC;
-		    ValidateGC(c->pDraw, c->pGC);
-
-		    ClientSleep(client, (ClientSleepProcPtr)doPolyText, c);
-
-		    /* Set up to perform steps 3 and 4 */
-		    client_state = START_SLEEP;
-		    continue;	/* on to steps 3 and 4 */
-		}
-		else
-		    goto xinerama_sleep;
-		return TRUE;
-	    }
-	    else if (lgerr != Successful)
-	    {
-		err = FontToXError(lgerr);
-		goto bail;
-	    }
-	    if (c->pDraw)
-	    {
-		c->xorg += *((INT8 *)(c->pElt + 1));	/* must be signed */
-		if (c->reqType == X_PolyText8)
-		    c->xorg = (* c->pGC->ops->PolyText8)(c->pDraw, c->pGC, c->xorg, c->yorg,
-			*c->pElt, (char *) (c->pElt + TextEltHeader));
-		else
-		    c->xorg = (* c->pGC->ops->PolyText16)(c->pDraw, c->pGC, c->xorg, c->yorg,
-			*c->pElt, (unsigned short *) (c->pElt + TextEltHeader));
-	    }
-	    c->pElt = pNextElt;
-	}
-    }
-
-bail:
-
-    if (client_state == START_SLEEP)
-    {
-	/* Step 4 */
-	if (pFont != origGC->font)
-	{
-	    ChangeGCVal val;
-	    val.ptr = pFont;
-	    ChangeGC(NullClient, origGC, GCFont, &val);
-	    ValidateGC(c->pDraw, origGC);
-	}
-
-	/* restore pElt pointer for execution of remainder of the request */
-	c->pElt = c->data;
-	return TRUE;
-    }
-
-    if (c->err != Success) err = c->err;
+    while (c->endReq - c->pElt > TextEltHeader) {
+        if (*c->pElt == FontChange) {
+            Font fid;
+
+            if (c->endReq - c->pElt < FontShiftSize) {
+                err = BadLength;
+                goto bail;
+            }
+
+            oldpFont = pFont;
+
+            fid = ((Font) *(c->pElt + 4))       /* big-endian */
+                |((Font) *(c->pElt + 3)) << 8
+                | ((Font) *(c->pElt + 2)) << 16 | ((Font) *(c->pElt + 1)) << 24;
+            err = dixLookupResourceByType((pointer *) &pFont, fid, RT_FONT,
+                                          client, DixUseAccess);
+            if (err != Success) {
+                /* restore pFont for step 4 (described below) */
+                pFont = oldpFont;
+
+                /* If we're in START_SLEEP mode, the following step
+                   shortens the request...  in the unlikely event that
+                   the fid somehow becomes valid before we come through
+                   again to actually execute the polytext, which would
+                   then mess up our refcounting scheme badly.  */
+                c->err = err;
+                c->endReq = c->pElt;
+
+                goto bail;
+            }
+
+            /* Step 3 (described below) on our new font */
+            if (client_state == START_SLEEP)
+                pFont->refcnt++;
+            else {
+                if (pFont != c->pGC->font && c->pDraw) {
+                    ChangeGCVal val;
+
+                    val.ptr = pFont;
+                    ChangeGC(NullClient, c->pGC, GCFont, &val);
+                    ValidateGC(c->pDraw, c->pGC);
+                }
+
+                /* Undo the refcnt++ we performed when going to sleep */
+                if (client_state == SLEEPING)
+                    (void) CloseFont(c->pGC->font, (Font) 0);
+            }
+            c->pElt += FontShiftSize;
+        }
+        else {                  /* print a string */
+
+            unsigned char *pNextElt;
+
+            pNextElt = c->pElt + TextEltHeader + (*c->pElt) * itemSize;
+            if (pNextElt > c->endReq) {
+                err = BadLength;
+                goto bail;
+            }
+            if (client_state == START_SLEEP) {
+                c->pElt = pNextElt;
+                continue;
+            }
+            if (c->pDraw) {
+                lgerr = LoadGlyphs(client, c->pGC->font, *c->pElt, itemSize,
+                                   c->pElt + TextEltHeader);
+            }
+            else
+                lgerr = Successful;
+
+            if (lgerr == Suspended) {
+                if (!ClientIsAsleep(client)) {
+                    int len;
+                    GC *pGC;
+                    PTclosurePtr new_closure;
+
+                    /*  We're putting the client to sleep.  We need to do a few things
+                       to ensure successful and atomic-appearing execution of the
+                       remainder of the request.  First, copy the remainder of the
+                       request into a safe malloc'd area.  Second, create a scratch GC
+                       to use for the remainder of the request.  Third, mark all fonts
+                       referenced in the remainder of the request to prevent their
+                       deallocation.  Fourth, make the original GC look like the
+                       request has completed...  set its font to the final font value
+                       from this request.  These GC manipulations are for the unlikely
+                       (but possible) event that some other client is using the GC.
+                       Steps 3 and 4 are performed by running this procedure through
+                       the remainder of the request in a special no-render mode
+                       indicated by client_state = START_SLEEP.  */
+
+                    /* Step 1 */
+                    /* Allocate a malloc'd closure structure to replace
+                       the local one we were passed */
+                    new_closure = malloc(sizeof(PTclosureRec));
+                    if (!new_closure) {
+                        err = BadAlloc;
+                        goto bail;
+                    }
+                    *new_closure = *c;
+
+                    len = new_closure->endReq - new_closure->pElt;
+                    new_closure->data = malloc(len);
+                    if (!new_closure->data) {
+                        free(new_closure);
+                        err = BadAlloc;
+                        goto bail;
+                    }
+                    memmove(new_closure->data, new_closure->pElt, len);
+                    new_closure->pElt = new_closure->data;
+                    new_closure->endReq = new_closure->pElt + len;
+
+                    /* Step 2 */
+
+                    pGC =
+                        GetScratchGC(new_closure->pGC->depth,
+                                     new_closure->pGC->pScreen);
+                    if (!pGC) {
+                        free(new_closure->data);
+                        free(new_closure);
+                        err = BadAlloc;
+                        goto bail;
+                    }
+                    if ((err = CopyGC(new_closure->pGC, pGC, GCFunction |
+                                      GCPlaneMask | GCForeground |
+                                      GCBackground | GCFillStyle |
+                                      GCTile | GCStipple |
+                                      GCTileStipXOrigin |
+                                      GCTileStipYOrigin | GCFont |
+                                      GCSubwindowMode | GCClipXOrigin |
+                                      GCClipYOrigin | GCClipMask)) != Success) {
+                        FreeScratchGC(pGC);
+                        free(new_closure->data);
+                        free(new_closure);
+                        err = BadAlloc;
+                        goto bail;
+                    }
+                    c = new_closure;
+                    origGC = c->pGC;
+                    c->pGC = pGC;
+                    ValidateGC(c->pDraw, c->pGC);
+
+                    ClientSleep(client, (ClientSleepProcPtr) doPolyText, c);
+
+                    /* Set up to perform steps 3 and 4 */
+                    client_state = START_SLEEP;
+                    continue;   /* on to steps 3 and 4 */
+                }
+                else
+                    goto xinerama_sleep;
+                return TRUE;
+            }
+            else if (lgerr != Successful) {
+                err = FontToXError(lgerr);
+                goto bail;
+            }
+            if (c->pDraw) {
+                c->xorg += *((INT8 *) (c->pElt + 1));   /* must be signed */
+                if (c->reqType == X_PolyText8)
+                    c->xorg =
+                        (*c->pGC->ops->PolyText8) (c->pDraw, c->pGC, c->xorg,
+                                                   c->yorg, *c->pElt,
+                                                   (char *) (c->pElt +
+                                                             TextEltHeader));
+                else
+                    c->xorg =
+                        (*c->pGC->ops->PolyText16) (c->pDraw, c->pGC, c->xorg,
+                                                    c->yorg, *c->pElt,
+                                                    (unsigned short *) (c->
+                                                                        pElt +
+                                                                        TextEltHeader));
+            }
+            c->pElt = pNextElt;
+        }
+    }
+
+ bail:
+
+    if (client_state == START_SLEEP) {
+        /* Step 4 */
+        if (pFont != origGC->font) {
+            ChangeGCVal val;
+
+            val.ptr = pFont;
+            ChangeGC(NullClient, origGC, GCFont, &val);
+            ValidateGC(c->pDraw, origGC);
+        }
+
+        /* restore pElt pointer for execution of remainder of the request */
+        c->pElt = c->data;
+        return TRUE;
+    }
+
+    if (c->err != Success)
+        err = c->err;
     if (err != Success && c->client != serverClient) {
 #ifdef PANORAMIX
         if (noPanoramiXExtension || !c->pGC->pScreen->myNum)
 #endif
-	    SendErrorToClient(c->client, c->reqType, 0, 0, err);
-    }
-    if (ClientIsAsleep(client))
-    {
-	ClientWakeup(c->client);
-	finished = TRUE;
-xinerama_sleep:
-	if (finished || fromDispatch) {
-	    ChangeGC(NullClient, c->pGC, clearGCmask, clearGC);
-
-	    /* Unreference the font from the scratch GC */
-	    CloseFont(c->pGC->font, (Font)0);
-	    c->pGC->font = NullFont;
-
-	    FreeScratchGC(c->pGC);
-	    free(c->data);
-	    free(c);
-	}
+            SendErrorToClient(c->client, c->reqType, 0, 0, err);
+    }
+    if (ClientIsAsleep(client)) {
+        ClientWakeup(c->client);
+        finished = TRUE;
+ xinerama_sleep:
+        if (finished || fromDispatch) {
+            ChangeGC(NullClient, c->pGC, clearGCmask, clearGC);
+
+            /* Unreference the font from the scratch GC */
+            CloseFont(c->pGC->font, (Font) 0);
+            c->pGC->font = NullFont;
+
+            FreeScratchGC(c->pGC);
+            free(c->data);
+            free(c);
+        }
     }
     return TRUE;
 }
 
 int
-PolyText(ClientPtr client, DrawablePtr pDraw, GC *pGC, unsigned char *pElt, 
+PolyText(ClientPtr client, DrawablePtr pDraw, GC * pGC, unsigned char *pElt,
          unsigned char *endReq, int xorg, int yorg, int reqType, XID did)
 {
     PTclosureRec local_closure;
@@ -1471,14 +1408,13 @@ PolyText(ClientPtr client, DrawablePtr pDraw, GC *pGC, unsigned char *pElt,
     return Success;
 }
 
-
 #undef TextEltHeader
 #undef FontShiftSize
 
 int
 doImageText(ClientPtr client, ITclosurePtr c)
 {
-    int err = Success, lgerr;	/* err is in X error, not font error, space */
+    int err = Success, lgerr;   /* err is in X error, not font error, space */
     FontPathElementPtr fpe;
     int itemSize = c->reqType == X_ImageText8 ? 1 : 2;
     Bool fromDispatch = c->from_dispatch;
@@ -1486,133 +1422,124 @@ doImageText(ClientPtr client, ITclosurePtr c)
 
     c->from_dispatch = FALSE;
 
-    if (client->clientGone)
-    {
-	fpe = c->pGC->font->fpe;
-	(*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	err = Success;
-	goto bail;
+    if (client->clientGone) {
+        fpe = c->pGC->font->fpe;
+        (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+        err = Success;
+        goto bail;
     }
 
     /* Make sure our drawable hasn't disappeared while we slept. */
-    if (ClientIsAsleep(client) && c->pDraw)
-    {
-	DrawablePtr pDraw;
-	dixLookupDrawable(&pDraw, c->did, client, 0, DixWriteAccess);
-	if (c->pDraw != pDraw) {
-	    /* Our drawable has disappeared.  Treat like client died... ask
-	       the FPE code to clean up after client. */
-	    fpe = c->pGC->font->fpe;
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
-	    err = Success;
-	    goto bail;
-	}
+    if (ClientIsAsleep(client) && c->pDraw) {
+        DrawablePtr pDraw;
+
+        dixLookupDrawable(&pDraw, c->did, client, 0, DixWriteAccess);
+        if (c->pDraw != pDraw) {
+            /* Our drawable has disappeared.  Treat like client died... ask
+               the FPE code to clean up after client. */
+            fpe = c->pGC->font->fpe;
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+            err = Success;
+            goto bail;
+        }
     }
 
     lgerr = LoadGlyphs(client, c->pGC->font, c->nChars, itemSize, c->data);
-    if (lgerr == Suspended)
-    {
+    if (lgerr == Suspended) {
         if (!ClientIsAsleep(client)) {
-	    GC *pGC;
-	    unsigned char *data;
-	    ITclosurePtr new_closure;
-
-	    /* We're putting the client to sleep.  We need to
-	       save some state.  Similar problem to that handled
-	       in doPolyText, but much simpler because the
-	       request structure is much simpler. */
-
-	    new_closure = malloc(sizeof(ITclosureRec));
-	    if (!new_closure)
-	    {
-		err = BadAlloc;
-		goto bail;
-	    }
-	    *new_closure = *c;
-	    c = new_closure;
-
-	    data = malloc(c->nChars * itemSize);
-	    if (!data)
-	    {
-		free(c);
-		err = BadAlloc;
-		goto bail;
-	    }
-	    memmove(data, c->data, c->nChars * itemSize);
-	    c->data = data;
-
-	    pGC = GetScratchGC(c->pGC->depth, c->pGC->pScreen);
-	    if (!pGC)
-	    {
-		free(c->data);
-		free(c);
-		err = BadAlloc;
-		goto bail;
-	    }
-	    if ((err = CopyGC(c->pGC, pGC, GCFunction | GCPlaneMask |
-			      GCForeground | GCBackground | GCFillStyle |
-			      GCTile | GCStipple | GCTileStipXOrigin |
-			      GCTileStipYOrigin | GCFont |
-			      GCSubwindowMode | GCClipXOrigin |
-			      GCClipYOrigin | GCClipMask)) != Success)
-	    {
-		FreeScratchGC(pGC);
-		free(c->data);
-		free(c);
-		err = BadAlloc;
-		goto bail;
-	    }
-	    c->pGC = pGC;
-	    ValidateGC(c->pDraw, c->pGC);
-
-            ClientSleep(client, (ClientSleepProcPtr)doImageText, c);
+            GC *pGC;
+            unsigned char *data;
+            ITclosurePtr new_closure;
+
+            /* We're putting the client to sleep.  We need to
+               save some state.  Similar problem to that handled
+               in doPolyText, but much simpler because the
+               request structure is much simpler. */
+
+            new_closure = malloc(sizeof(ITclosureRec));
+            if (!new_closure) {
+                err = BadAlloc;
+                goto bail;
+            }
+            *new_closure = *c;
+            c = new_closure;
+
+            data = malloc(c->nChars * itemSize);
+            if (!data) {
+                free(c);
+                err = BadAlloc;
+                goto bail;
+            }
+            memmove(data, c->data, c->nChars * itemSize);
+            c->data = data;
+
+            pGC = GetScratchGC(c->pGC->depth, c->pGC->pScreen);
+            if (!pGC) {
+                free(c->data);
+                free(c);
+                err = BadAlloc;
+                goto bail;
+            }
+            if ((err = CopyGC(c->pGC, pGC, GCFunction | GCPlaneMask |
+                              GCForeground | GCBackground | GCFillStyle |
+                              GCTile | GCStipple | GCTileStipXOrigin |
+                              GCTileStipYOrigin | GCFont |
+                              GCSubwindowMode | GCClipXOrigin |
+                              GCClipYOrigin | GCClipMask)) != Success) {
+                FreeScratchGC(pGC);
+                free(c->data);
+                free(c);
+                err = BadAlloc;
+                goto bail;
+            }
+            c->pGC = pGC;
+            ValidateGC(c->pDraw, c->pGC);
+
+            ClientSleep(client, (ClientSleepProcPtr) doImageText, c);
         }
-	else
-	    goto xinerama_sleep;
+        else
+            goto xinerama_sleep;
         return TRUE;
     }
-    else if (lgerr != Successful)
-    {
+    else if (lgerr != Successful) {
         err = FontToXError(lgerr);
         goto bail;
     }
-    if (c->pDraw)
-    {
-	if (c->reqType == X_ImageText8)
-	    (* c->pGC->ops->ImageText8)(c->pDraw, c->pGC, c->xorg, c->yorg,
-		c->nChars, (char *) c->data);
-	else
-	    (* c->pGC->ops->ImageText16)(c->pDraw, c->pGC, c->xorg, c->yorg,
-		c->nChars, (unsigned short *) c->data);
+    if (c->pDraw) {
+        if (c->reqType == X_ImageText8)
+            (*c->pGC->ops->ImageText8) (c->pDraw, c->pGC, c->xorg, c->yorg,
+                                        c->nChars, (char *) c->data);
+        else
+            (*c->pGC->ops->ImageText16) (c->pDraw, c->pGC, c->xorg, c->yorg,
+                                         c->nChars, (unsigned short *) c->data);
     }
 
-bail:
+ bail:
 
     if (err != Success && c->client != serverClient) {
-	SendErrorToClient(c->client, c->reqType, 0, 0, err);
-    }
-    if (ClientIsAsleep(client))
-    {
-	ClientWakeup(c->client);
-	finished = TRUE;
-xinerama_sleep:
-	if (finished || fromDispatch) {
-	    ChangeGC(NullClient, c->pGC, clearGCmask, clearGC);
-
-	    /* Unreference the font from the scratch GC */
-	    CloseFont(c->pGC->font, (Font)0);
-	    c->pGC->font = NullFont;
-
-	    FreeScratchGC(c->pGC);
-	    free(c->data);
-	    free(c);
-	}
+        SendErrorToClient(c->client, c->reqType, 0, 0, err);
+    }
+    if (ClientIsAsleep(client)) {
+        ClientWakeup(c->client);
+        finished = TRUE;
+ xinerama_sleep:
+        if (finished || fromDispatch) {
+            ChangeGC(NullClient, c->pGC, clearGCmask, clearGC);
+
+            /* Unreference the font from the scratch GC */
+            CloseFont(c->pGC->font, (Font) 0);
+            c->pGC->font = NullFont;
+
+            FreeScratchGC(c->pGC);
+            free(c->data);
+            free(c);
+        }
     }
     return TRUE;
 }
 
 int
-ImageText(ClientPtr client, DrawablePtr pDraw, GC *pGC, int nChars, 
+ImageText(ClientPtr client, DrawablePtr pDraw, GC * pGC, int nChars,
           unsigned char *data, int xorg, int yorg, int reqType, XID did)
 {
     ITclosureRec local_closure;
@@ -1631,168 +1558,157 @@ ImageText(ClientPtr client, DrawablePtr pDraw, GC *pGC, int nChars,
     return Success;
 }
 
-
 /* does the necessary magic to figure out the fpe type */
 static int
 DetermineFPEType(char *pathname)
 {
-    int         i;
+    int i;
 
     for (i = 0; i < num_fpe_types; i++) {
-	if ((*fpe_functions[i].name_check) (pathname))
-	    return i;
+        if ((*fpe_functions[i].name_check) (pathname))
+            return i;
     }
     return -1;
 }
 
-
 static void
-FreeFontPath(FontPathElementPtr *list, int n, Bool force)
+FreeFontPath(FontPathElementPtr * list, int n, Bool force)
 {
-    int         i;
+    int i;
 
     for (i = 0; i < n; i++) {
-	if (force) {
-	    /* Sanity check that all refcounts will be 0 by the time
-	       we get to the end of the list. */
-	    int found = 1;	/* the first reference is us */
-	    int j;
-	    for (j = i+1; j < n; j++) {
-		if (list[j] == list[i])
-		    found++;
-	    }
-	    if (list[i]->refcount != found) {
-		list[i]->refcount = found; /* ensure it will get freed */
-	    }
-	}
-	FreeFPE(list[i]);
+        if (force) {
+            /* Sanity check that all refcounts will be 0 by the time
+               we get to the end of the list. */
+            int found = 1;      /* the first reference is us */
+            int j;
+
+            for (j = i + 1; j < n; j++) {
+                if (list[j] == list[i])
+                    found++;
+            }
+            if (list[i]->refcount != found) {
+                list[i]->refcount = found;      /* ensure it will get freed */
+            }
+        }
+        FreeFPE(list[i]);
     }
     free(list);
 }
 
 static FontPathElementPtr
-find_existing_fpe(FontPathElementPtr *list, int num, unsigned char *name, int len)
+find_existing_fpe(FontPathElementPtr * list, int num, unsigned char *name,
+                  int len)
 {
     FontPathElementPtr fpe;
-    int         i;
+    int i;
 
     for (i = 0; i < num; i++) {
-	fpe = list[i];
-	if (fpe->name_length == len && memcmp(name, fpe->name, len) == 0)
-	    return fpe;
+        fpe = list[i];
+        if (fpe->name_length == len && memcmp(name, fpe->name, len) == 0)
+            return fpe;
     }
     return (FontPathElementPtr) 0;
 }
 
-
 static int
 SetFontPathElements(int npaths, unsigned char *paths, int *bad, Bool persist)
 {
-    int         i, err = 0;
-    int         valid_paths = 0;
+    int i, err = 0;
+    int valid_paths = 0;
     unsigned int len;
     unsigned char *cp = paths;
     FontPathElementPtr fpe = NULL, *fplist;
 
     fplist = malloc(sizeof(FontPathElementPtr) * npaths);
     if (!fplist) {
-	*bad = 0;
-	return BadAlloc;
+        *bad = 0;
+        return BadAlloc;
     }
     for (i = 0; i < num_fpe_types; i++) {
-	if (fpe_functions[i].set_path_hook)
-	    (*fpe_functions[i].set_path_hook) ();
-    }
-    for (i = 0; i < npaths; i++) 
-    {
-	len = (unsigned int) (*cp++);
-
-	if (len == 0) 
-	{
-	    if (persist)
-		ErrorF("[dix] Removing empty element from the valid list of fontpaths\n");
-	    err = BadValue;
-	}
-	else
-	{
-	    /* if it's already in our active list, just reset it */
-	    /*
-	     * note that this can miss FPE's in limbo -- may be worth catching
-	     * them, though it'd muck up refcounting
-	     */
-	    fpe = find_existing_fpe(font_path_elements, num_fpes, cp, len);
-	    if (fpe) 
-	    {
-		err = (*fpe_functions[fpe->type].reset_fpe) (fpe);
-		if (err == Successful) 
-		{
-		    UseFPE(fpe);/* since it'll be decref'd later when freed
-				 * from the old list */
-		}
-		else
-		    fpe = 0;
-	    }
-	    /* if error or can't do it, act like it's a new one */
-	    if (!fpe)
-	    {
-		fpe = malloc(sizeof(FontPathElementRec));
-		if (!fpe) 
-		{
-		    err = BadAlloc;
-		    goto bail;
-		}
-		fpe->name = malloc(len + 1);
-		if (!fpe->name) 
-		{
-		    free(fpe);
-		    err = BadAlloc;
-		    goto bail;
-		}
-		fpe->refcount = 1;
-    
-		strncpy(fpe->name, (char *) cp, (int) len);
-		fpe->name[len] = '\0';
-		fpe->name_length = len;
-		fpe->type = DetermineFPEType(fpe->name);
-		if (fpe->type == -1)
-		    err = BadValue;
-		else
-		    err = (*fpe_functions[fpe->type].init_fpe) (fpe);
-		if (err != Successful)
-		{
-		    if (persist)
-		    {
-			ErrorF("[dix] Could not init font path element %s, removing from list!\n",
-			       fpe->name);
-		    }
-		    free(fpe->name);
-		    free(fpe);
-		}
-	    }
-	}
-	if (err != Successful)
-	{
-	    if (!persist)
-		goto bail;
-	}
-	else
-	{
-	    fplist[valid_paths++] = fpe;
-	}
-	cp += len;
+        if (fpe_functions[i].set_path_hook)
+            (*fpe_functions[i].set_path_hook) ();
+    }
+    for (i = 0; i < npaths; i++) {
+        len = (unsigned int) (*cp++);
+
+        if (len == 0) {
+            if (persist)
+                ErrorF
+                    ("[dix] Removing empty element from the valid list of fontpaths\n");
+            err = BadValue;
+        }
+        else {
+            /* if it's already in our active list, just reset it */
+            /*
+             * note that this can miss FPE's in limbo -- may be worth catching
+             * them, though it'd muck up refcounting
+             */
+            fpe = find_existing_fpe(font_path_elements, num_fpes, cp, len);
+            if (fpe) {
+                err = (*fpe_functions[fpe->type].reset_fpe) (fpe);
+                if (err == Successful) {
+                    UseFPE(fpe);        /* since it'll be decref'd later when freed
+                                         * from the old list */
+                }
+                else
+                    fpe = 0;
+            }
+            /* if error or can't do it, act like it's a new one */
+            if (!fpe) {
+                fpe = malloc(sizeof(FontPathElementRec));
+                if (!fpe) {
+                    err = BadAlloc;
+                    goto bail;
+                }
+                fpe->name = malloc(len + 1);
+                if (!fpe->name) {
+                    free(fpe);
+                    err = BadAlloc;
+                    goto bail;
+                }
+                fpe->refcount = 1;
+
+                strncpy(fpe->name, (char *) cp, (int) len);
+                fpe->name[len] = '\0';
+                fpe->name_length = len;
+                fpe->type = DetermineFPEType(fpe->name);
+                if (fpe->type == -1)
+                    err = BadValue;
+                else
+                    err = (*fpe_functions[fpe->type].init_fpe) (fpe);
+                if (err != Successful) {
+                    if (persist) {
+                        ErrorF
+                            ("[dix] Could not init font path element %s, removing from list!\n",
+                             fpe->name);
+                    }
+                    free(fpe->name);
+                    free(fpe);
+                }
+            }
+        }
+        if (err != Successful) {
+            if (!persist)
+                goto bail;
+        }
+        else {
+            fplist[valid_paths++] = fpe;
+        }
+        cp += len;
     }
 
     FreeFontPath(font_path_elements, num_fpes, FALSE);
     font_path_elements = fplist;
     if (patternCache)
-	EmptyFontPatternCache(patternCache);
+        EmptyFontPatternCache(patternCache);
     num_fpes = valid_paths;
 
     return Success;
-bail:
+ bail:
     *bad = i;
     while (--valid_paths >= 0)
-	FreeFPE(fplist[valid_paths]);
+        FreeFPE(fplist[valid_paths]);
     free(fplist);
     return FontToXError(err);
 }
@@ -1801,16 +1717,19 @@ int
 SetFontPath(ClientPtr client, int npaths, unsigned char *paths)
 {
     int err = XaceHook(XACE_SERVER_ACCESS, client, DixManageAccess);
+
     if (err != Success)
-	return err;
+        return err;
 
     if (npaths == 0) {
-	if (SetDefaultFontPath(defaultFontPath) != Success)
-	    return BadValue;
-    } else {
-	int bad;
-	err = SetFontPathElements(npaths, paths, &bad, FALSE);
-	client->errorValue = bad;
+        if (SetDefaultFontPath(defaultFontPath) != Success)
+            return BadValue;
+    }
+    else {
+        int bad;
+
+        err = SetFontPathElements(npaths, paths, &bad, FALSE);
+        client->errorValue = bad;
     }
     return err;
 }
@@ -1818,36 +1737,28 @@ SetFontPath(ClientPtr client, int npaths, unsigned char *paths)
 int
 SetDefaultFontPath(char *path)
 {
-    char       *temp_path,
-               *start,
-               *end;
-    unsigned char *cp,
-               *pp,
-               *nump,
-               *newpath;
-    int         num = 1,
-                len,
-                err,
-                size = 0,
-                bad;
+    char *temp_path, *start, *end;
+    unsigned char *cp, *pp, *nump, *newpath;
+    int num = 1, len, err, size = 0, bad;
 
     /* ensure temp_path contains "built-ins" */
     start = path;
     while (1) {
-	start = strstr(start, "built-ins");
-	if (start == NULL)
-	    break;
-	end = start + strlen("built-ins");
-	if ((start == path || start[-1] == ',') && (!*end || *end == ','))
-	    break;
-	start = end;
+        start = strstr(start, "built-ins");
+        if (start == NULL)
+            break;
+        end = start + strlen("built-ins");
+        if ((start == path || start[-1] == ',') && (!*end || *end == ','))
+            break;
+        start = end;
     }
     if (!start) {
-	if (asprintf(&temp_path, "%s%sbuilt-ins", path, *path ? "," : "")
-	    == -1)
-	    temp_path = NULL;
-    } else {
-	temp_path = strdup(path);
+        if (asprintf(&temp_path, "%s%sbuilt-ins", path, *path ? "," : "")
+            == -1)
+            temp_path = NULL;
+    }
+    else {
+        temp_path = strdup(path);
     }
     if (!temp_path)
         return BadAlloc;
@@ -1856,22 +1767,23 @@ SetDefaultFontPath(char *path)
     len = strlen(temp_path) + 1;
     nump = cp = newpath = malloc(len);
     if (!newpath) {
-	free(temp_path);
-	return BadAlloc;
+        free(temp_path);
+        return BadAlloc;
     }
     pp = (unsigned char *) temp_path;
     cp++;
     while (*pp) {
-	if (*pp == ',') {
-	    *nump = (unsigned char) size;
-	    nump = cp++;
-	    pp++;
-	    num++;
-	    size = 0;
-	} else {
-	    *cp++ = *pp++;
-	    size++;
-	}
+        if (*pp == ',') {
+            *nump = (unsigned char) size;
+            nump = cp++;
+            pp++;
+            num++;
+            size = 0;
+        }
+        else {
+            *cp++ = *pp++;
+            size++;
+        }
     }
     *nump = (unsigned char) size;
 
@@ -1886,32 +1798,32 @@ SetDefaultFontPath(char *path)
 int
 GetFontPath(ClientPtr client, int *count, int *length, unsigned char **result)
 {
-    int			i;
-    unsigned char       *c;
-    int			len;
-    FontPathElementPtr	fpe;
+    int i;
+    unsigned char *c;
+    int len;
+    FontPathElementPtr fpe;
 
     i = XaceHook(XACE_SERVER_ACCESS, client, DixGetAttrAccess);
     if (i != Success)
-	return i;
+        return i;
 
     len = 0;
     for (i = 0; i < num_fpes; i++) {
-	fpe = font_path_elements[i];
-	len += fpe->name_length + 1;
+        fpe = font_path_elements[i];
+        len += fpe->name_length + 1;
     }
     font_path_string = (unsigned char *) realloc(font_path_string, len);
     if (!font_path_string)
-	return BadAlloc;
+        return BadAlloc;
 
     c = font_path_string;
     *length = 0;
     for (i = 0; i < num_fpes; i++) {
-	fpe = font_path_elements[i];
-	*c = fpe->name_length;
-	*length += *c++;
-	memmove(c, fpe->name, fpe->name_length);
-	c += fpe->name_length;
+        fpe = font_path_elements[i];
+        *c = fpe->name_length;
+        *length += *c++;
+        memmove(c, fpe->name, fpe->name_length);
+        c += fpe->name_length;
     }
     *count = num_fpes;
     *result = font_path_string;
@@ -1921,19 +1833,18 @@ GetFontPath(ClientPtr client, int *count, int *length, unsigned char **result)
 void
 DeleteClientFontStuff(ClientPtr client)
 {
-    int			i;
-    FontPathElementPtr	fpe;
+    int i;
+    FontPathElementPtr fpe;
 
-    for (i = 0; i < num_fpes; i++)
-    {
-	fpe = font_path_elements[i];
-	if (fpe_functions[fpe->type].client_died)
-	    (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
+    for (i = 0; i < num_fpes; i++) {
+        fpe = font_path_elements[i];
+        if (fpe_functions[fpe->type].client_died)
+            (*fpe_functions[fpe->type].client_died) ((pointer) client, fpe);
     }
 }
 
 void
-InitFonts (void)
+InitFonts(void)
 {
     patternCache = MakeFontPatternCache();
 
@@ -1941,17 +1852,16 @@ InitFonts (void)
 }
 
 int
-GetDefaultPointSize (void)
+GetDefaultPointSize(void)
 {
     return 120;
 }
 
-
 FontResolutionPtr
-GetClientResolutions (int *num)
+GetClientResolutions(int *num)
 {
     static struct _FontResolution res;
-    ScreenPtr   pScreen;
+    ScreenPtr pScreen;
 
     pScreen = screenInfo.screens[0];
     res.x_resolution = (pScreen->width * 25.4) / pScreen->mmWidth;
@@ -1960,14 +1870,14 @@ GetClientResolutions (int *num)
      so that we can match them from scalable fonts
      */
     if (res.x_resolution < 88)
-	res.x_resolution = 75;
+        res.x_resolution = 75;
     else
-	res.x_resolution = 100;
+        res.x_resolution = 100;
     res.y_resolution = (pScreen->height * 25.4) / pScreen->mmHeight;
     if (res.y_resolution < 88)
-	res.y_resolution = 75;
+        res.y_resolution = 75;
     else
-	res.y_resolution = 100;
+        res.y_resolution = 100;
     res.point_size = 120;
     *num = 1;
     return &res;
@@ -1980,29 +1890,28 @@ GetClientResolutions (int *num)
  */
 
 int
-RegisterFPEFunctions(NameCheckFunc name_func, 
-		     InitFpeFunc init_func, 
-		     FreeFpeFunc free_func, 
-		     ResetFpeFunc reset_func, 
-		     OpenFontFunc open_func, 
-		     CloseFontFunc close_func, 
-		     ListFontsFunc list_func, 
-		     StartLfwiFunc start_lfwi_func, 
-		     NextLfwiFunc next_lfwi_func, 
-		     WakeupFpeFunc wakeup_func, 
-		     ClientDiedFunc client_died, 
-		     LoadGlyphsFunc load_glyphs, 
-		     StartLaFunc start_list_alias_func, 
-		     NextLaFunc next_list_alias_func, 
-		     SetPathFunc set_path_func)
+RegisterFPEFunctions(NameCheckFunc name_func,
+                     InitFpeFunc init_func,
+                     FreeFpeFunc free_func,
+                     ResetFpeFunc reset_func,
+                     OpenFontFunc open_func,
+                     CloseFontFunc close_func,
+                     ListFontsFunc list_func,
+                     StartLfwiFunc start_lfwi_func,
+                     NextLfwiFunc next_lfwi_func,
+                     WakeupFpeFunc wakeup_func,
+                     ClientDiedFunc client_died,
+                     LoadGlyphsFunc load_glyphs,
+                     StartLaFunc start_list_alias_func,
+                     NextLaFunc next_list_alias_func, SetPathFunc set_path_func)
 {
     FPEFunctions *new;
 
     /* grow the list */
     new = (FPEFunctions *) realloc(fpe_functions,
-				 (num_fpe_types + 1) * sizeof(FPEFunctions));
+                                   (num_fpe_types + 1) * sizeof(FPEFunctions));
     if (!new)
-	return -1;
+        return -1;
     fpe_functions = new;
 
     fpe_functions[num_fpe_types].name_check = name_func;
@@ -2010,19 +1919,16 @@ RegisterFPEFunctions(NameCheckFunc name_func,
     fpe_functions[num_fpe_types].close_font = close_func;
     fpe_functions[num_fpe_types].wakeup_fpe = wakeup_func;
     fpe_functions[num_fpe_types].list_fonts = list_func;
-    fpe_functions[num_fpe_types].start_list_fonts_with_info =
-	start_lfwi_func;
-    fpe_functions[num_fpe_types].list_next_font_with_info =
-	next_lfwi_func;
+    fpe_functions[num_fpe_types].start_list_fonts_with_info = start_lfwi_func;
+    fpe_functions[num_fpe_types].list_next_font_with_info = next_lfwi_func;
     fpe_functions[num_fpe_types].init_fpe = init_func;
     fpe_functions[num_fpe_types].free_fpe = free_func;
     fpe_functions[num_fpe_types].reset_fpe = reset_func;
     fpe_functions[num_fpe_types].client_died = client_died;
     fpe_functions[num_fpe_types].load_glyphs = load_glyphs;
     fpe_functions[num_fpe_types].start_list_fonts_and_aliases =
-	start_list_alias_func;
-    fpe_functions[num_fpe_types].list_next_font_or_alias =
-	next_list_alias_func;
+        start_list_alias_func;
+    fpe_functions[num_fpe_types].list_next_font_or_alias = next_list_alias_func;
     fpe_functions[num_fpe_types].set_path_hook = set_path_func;
 
     return num_fpe_types++;
@@ -2032,8 +1938,8 @@ void
 FreeFonts(void)
 {
     if (patternCache) {
-	FreeFontPatternCache(patternCache);
-	patternCache = 0;
+        FreeFontPatternCache(patternCache);
+        patternCache = 0;
     }
     FreeFontPath(font_path_elements, num_fpes, TRUE);
     font_path_elements = 0;
@@ -2049,8 +1955,9 @@ FontPtr
 find_old_font(XID id)
 {
     pointer pFont;
+
     dixLookupResourceByType(&pFont, id, RT_NONE, serverClient, DixReadAccess);
-    return (FontPtr)pFont;
+    return (FontPtr) pFont;
 }
 
 Font
@@ -2077,7 +1984,7 @@ client_auth_generation(ClientPtr client)
     return 0;
 }
 
-static int  fs_handlers_installed = 0;
+static int fs_handlers_installed = 0;
 static unsigned int last_server_gen;
 
 int
@@ -2085,28 +1992,29 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
 {
     /* if server has reset, make sure the b&w handlers are reinstalled */
     if (last_server_gen < serverGeneration) {
-	last_server_gen = serverGeneration;
-	fs_handlers_installed = 0;
+        last_server_gen = serverGeneration;
+        fs_handlers_installed = 0;
     }
     if (fs_handlers_installed == 0) {
-	if (!RegisterBlockAndWakeupHandlers(block_handler,
-					    FontWakeup, (pointer) 0))
-	    return AllocError;
-	fs_handlers_installed++;
+        if (!RegisterBlockAndWakeupHandlers(block_handler,
+                                            FontWakeup, (pointer) 0))
+            return AllocError;
+        fs_handlers_installed++;
     }
     QueueFontWakeup(fpe);
     return Successful;
 }
 
 void
-remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bool all)
+remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler,
+                   Bool all)
 {
     if (all) {
-	/* remove the handlers if no one else is using them */
-	if (--fs_handlers_installed == 0) {
-	    RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
-					 (pointer) 0);
-	}
+        /* remove the handlers if no one else is using them */
+        if (--fs_handlers_installed == 0) {
+            RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
+                                         (pointer) 0);
+        }
     }
     RemoveFontWakeup(fpe);
 }