mi: remove 'register' keywords.

25 files changed, 556 insertions, 556 deletions

diff --git a/mi/miarc.c b/mi/miarc.c
index 2b3a0cbbc..8b6d8c0a9 100644
--- a/mi/miarc.c
+++ b/mi/miarc.c
@@ -246,7 +246,7 @@ typedef struct _miPolyArc {
 static CARD32 gcvals[6];
 
 static void fillSpans(DrawablePtr pDrawable, GCPtr pGC);
-static void newFinalSpan(int y, register int xmin, register int xmax);
+static void newFinalSpan(int y, int xmin, int xmax);
 static void drawArc(xArc *tarc, int l, int a0, int a1, miArcFacePtr right,
 		    miArcFacePtr left);
 static void drawZeroArc(DrawablePtr pDraw, GCPtr pGC, xArc *tarc, int lw,
@@ -284,7 +284,7 @@ miArcSegment(
 {
     int l = pGC->lineWidth;
     int a0, a1, startAngle, endAngle;
-    miArcFacePtr	temp;
+    miArcFacePtr temp;
 
     if (!l)
 	l = 1;
@@ -432,8 +432,8 @@ static RESTYPE cacheType;
 /*ARGSUSED*/
 int
 miFreeArcCache (data, id)
-    pointer	    data;
-    XID		    id;
+    pointer data;
+    XID	    id;
 {
     int k;
     arcCacheRec *cent;
@@ -461,11 +461,11 @@ miComputeCircleSpans(
     xArc *parc,
     miArcSpanData *spdata)
 {
-    register miArcSpan *span;
+    miArcSpan *span;
     int doinner;
-    register int x, y, e;
+    int x, y, e;
     int xk, yk, xm, ym, dx, dy;
-    register int slw, inslw;
+    int slw, inslw;
     int inx = 0, iny, ine = 0;
     int inxk = 0, inyk = 0, inxm = 0, inym = 0;
 
@@ -529,7 +529,7 @@ miComputeEllipseSpans(
     xArc *parc,
     miArcSpanData *spdata)
 {
-    register miArcSpan *span;
+    miArcSpan *span;
     double w, h, r, xorg;
     double Hs, Hf, WH, K, Vk, Nk, Fk, Vr, N, Nc, Z, rs;
     double A, T, b, d, x, y, t, inx, outx = 0.0, hepp, hepm;
@@ -859,13 +859,13 @@ tailX(
 
 static miArcSpanData *
 miComputeWideEllipse(
-    int		   lw,
-    register xArc *parc,
-    Bool	  *mustFree)
+    int  lw,
+    xArc *parc,
+    Bool *mustFree)
 {
-    register miArcSpanData *spdata;
-    register arcCacheRec *cent, *lruent;
-    register int k;
+    miArcSpanData *spdata;
+    arcCacheRec *cent, *lruent;
+    int k;
     arcCacheRec fakeent;
 
     if (!lw)
@@ -943,14 +943,14 @@ miFillWideEllipse(
     xArc	*parc)
 {
     DDXPointPtr points;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
     int *widths;
-    register int *wids;
+    int *wids;
     miArcSpanData *spdata;
     Bool mustFree;
-    register miArcSpan *span;
-    register int xorg, yorgu, yorgl;
-    register int n;
+    miArcSpan *span;
+    int xorg, yorgu, yorgl;
+    int n;
 
     yorgu = parc->height + pGC->lineWidth;
     n = (sizeof(int) * 2) * yorgu;
@@ -1077,20 +1077,20 @@ miPolyArc(pDraw, pGC, narcs, parcs)
     int		narcs;
     xArc	*parcs;
 {
-    register int		i;
-    xArc			*parc;
-    int				xMin, xMax, yMin, yMax;
-    int				pixmapWidth = 0, pixmapHeight = 0;
-    int				xOrg = 0, yOrg = 0;
-    int				width;
-    Bool			fTricky;
-    DrawablePtr			pDrawTo;
-    CARD32			fg, bg;
-    GCPtr			pGCTo;
-    miPolyArcPtr		polyArcs;
-    int				cap[2], join[2];
-    int				iphase;
-    int				halfWidth;
+    int		i;
+    xArc	*parc;
+    int		xMin, xMax, yMin, yMax;
+    int		pixmapWidth = 0, pixmapHeight = 0;
+    int		xOrg = 0, yOrg = 0;
+    int		width;
+    Bool	fTricky;
+    DrawablePtr	pDrawTo;
+    CARD32	fg, bg;
+    GCPtr	pGCTo;
+    miPolyArcPtr polyArcs;
+    int		cap[2], join[2];
+    int		iphase;
+    int		halfWidth;
 
     width = pGC->lineWidth;
     if(width == 0 && pGC->lineStyle == LineSolid)
@@ -3139,9 +3139,9 @@ static struct finalSpanChunk	*chunks;
 struct finalSpan *
 realAllocSpan ()
 {
-	register struct finalSpanChunk	*newChunk;
-	register struct finalSpan	*span;
-	register int			i;
+	struct finalSpanChunk	*newChunk;
+	struct finalSpan	*span;
+	int			i;
 
 	newChunk = (struct finalSpanChunk *) xalloc (sizeof (struct finalSpanChunk));
 	if (!newChunk)
@@ -3179,14 +3179,14 @@ fillSpans (
     DrawablePtr	pDrawable,
     GCPtr	pGC)
 {
-	register struct finalSpan	*span;
-	register DDXPointPtr		xSpan;
-	register int			*xWidth;
-	register int			i;
-	register struct finalSpan	**f;
-	register int			spany;
-	DDXPointPtr			xSpans;
-	int				*xWidths;
+	struct finalSpan	*span;
+	DDXPointPtr		xSpan;
+	int			*xWidth;
+	int			i;
+	struct finalSpan	**f;
+	int			spany;
+	DDXPointPtr		xSpans;
+	int			*xWidths;
 
 	if (nspans == 0)
 		return;
@@ -3280,13 +3280,13 @@ realFindSpan (int y)
 static void
 newFinalSpan (
     int		y,
-    register int	xmin,
-    register int	xmax)
+    int	xmin,
+    int	xmax)
 {
-	register struct finalSpan	*x;
-	register struct finalSpan	**f;
-	struct finalSpan		*oldx;
-	struct finalSpan		*prev;
+	struct finalSpan	*x;
+	struct finalSpan	**f;
+	struct finalSpan	*oldx;
+	struct finalSpan	*prev;
 
 	f = findSpan (y);
 	if (!f)
diff --git a/mi/mibitblt.c b/mi/mibitblt.c
index bf0e29ac0..e4b14078f 100644
--- a/mi/mibitblt.c
+++ b/mi/mibitblt.c
@@ -76,12 +76,12 @@ extern int ffs(int);
 _X_EXPORT RegionPtr
 miCopyArea(pSrcDrawable, pDstDrawable,
 	    pGC, xIn, yIn, widthSrc, heightSrc, xOut, yOut)
-    register DrawablePtr 	pSrcDrawable;
-    register DrawablePtr 	pDstDrawable;
-    GCPtr 			pGC;
-    int 			xIn, yIn;
-    int 			widthSrc, heightSrc;
-    int 			xOut, yOut;
+    DrawablePtr 	pSrcDrawable;
+    DrawablePtr 	pDstDrawable;
+    GCPtr 		pGC;
+    int 		xIn, yIn;
+    int 		widthSrc, heightSrc;
+    int 		xOut, yOut;
 {
     DDXPointPtr		ppt, pptFirst;
     unsigned int	*pwidthFirst, *pwidth, *pbits;
diff --git a/mi/mibstore.c b/mi/mibstore.c
index 6653c2345..70839ce31 100644
--- a/mi/mibstore.c
+++ b/mi/mibstore.c
@@ -152,11 +152,11 @@ static void	    miBSClearBackingRegion(WindowPtr pWin, RegionPtr pRgn);
 
 #define copyData(src,dst,n,morecopy) \
 { \
-    register short *srcCopy = (short *)(src); \
-    register short *dstCopy = (short *)(dst); \
-    register int i; \
-    register int bsx = pBackingStore->x; \
-    register int bsy = pBackingStore->y; \
+    short *srcCopy = (short *)(src); \
+    short *dstCopy = (short *)(dst); \
+    int i; \
+    int bsx = pBackingStore->x; \
+    int bsy = pBackingStore->y; \
     for (i = n; --i >= 0; ) \
     { \
 	*dstCopy++ = *srcCopy++ - bsx; \
@@ -1010,7 +1010,7 @@ miBSSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted)
     DrawablePtr		pDrawable;
     GCPtr		pGC;
     char		*psrc;
-    register DDXPointPtr ppt;
+    DDXPointPtr 	ppt;
     int			*pwidth;
     int			nspans;
     int			fSorted;
@@ -1150,8 +1150,8 @@ miBSDoCopy(
     }	    	  	*boxes;	    /* Array of box/drawable pairs covering
 				     * source box. */
     int  	  	*sequence;  /* Sequence of boxes to move */
-    register int  	i, j, k, l, y;
-    register BoxPtr	pBox;
+    int  		i, j, k, l, y;
+    BoxPtr		pBox;
     int	    	  	dx, dy, nrects;
     Bool    	  	graphicsExposures;
     CopyPlaneProcPtr  	pixCopyProc;
@@ -1591,7 +1591,7 @@ static RegionPtr
 miBSCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane)
     DrawablePtr	  pSrc;
     DrawablePtr	  pDst;
-    register GC   *pGC;
+    GC  	 *pGC;
     int     	  srcx,
 		  srcy;
     int     	  w,
@@ -1901,9 +1901,9 @@ miBSPolyArc(pDrawable, pGC, narcs, parcs)
 static void
 miBSFillPolygon(pDrawable, pGC, shape, mode, count, pPts)
     DrawablePtr		pDrawable;
-    register GCPtr	pGC;
+    GCPtr		pGC;
     int			shape, mode;
-    register int	count;
+    int			count;
     DDXPointPtr		pPts;
 {
     DDXPointPtr	pPtsCopy;
@@ -2546,8 +2546,8 @@ static void
 miBSAllocate(pWin)
     WindowPtr 	  pWin;
 {
-    register miBSWindowPtr  pBackingStore;
-    register ScreenPtr 	    pScreen;
+    miBSWindowPtr  	pBackingStore;
+    ScreenPtr 	   	pScreen;
 	
     if (pWin->drawable.pScreen->backingStoreSupport == NotUseful)
 	return;
@@ -2648,7 +2648,7 @@ miBSFree(pWin)
     WindowPtr pWin;
 {
     miBSWindowPtr 	pBackingStore;
-    register ScreenPtr	pScreen;
+    ScreenPtr		pScreen;
 
     pScreen = pWin->drawable.pScreen;
 
@@ -2792,9 +2792,9 @@ miResizeBackingStore(
  */
 static void
 miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
-    register WindowPtr pWin;
-    RegionPtr 	       pObscured;
-    int		       dx, dy;
+    WindowPtr		pWin;
+    RegionPtr		pObscured;
+    int			dx, dy;
 {
     miBSWindowPtr 	pBackingStore;
     ScreenPtr	  	pScreen;
@@ -2899,14 +2899,14 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
  */
 static RegionPtr
 miBSRestoreAreas(pWin, prgnExposed)
-    register WindowPtr pWin;
+    WindowPtr pWin;
     RegionPtr prgnExposed;
 {
     PixmapPtr pBackingPixmap;
     miBSWindowPtr pBackingStore;
     RegionPtr prgnSaved;
     RegionPtr prgnRestored;
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     RegionPtr exposures = prgnExposed;
 
     pScreen = pWin->drawable.pScreen;
@@ -3097,15 +3097,15 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
     int     	  oldx;		/* old window position */
     int     	  oldy;
 {
-    register miBSWindowPtr 	pBackingStore;
-    register RegionPtr 	    	pSavedRegion;
-    register RegionPtr 	    	newSaved, doomed;
-    register ScreenPtr		pScreen;
-    BoxRec			extents;
-    int     	  scrdx;	/* bit translation distance on screen */
-    int     	  scrdy;
-    int		  dx;		/* distance window moved  on screen */
-    int		  dy;
+    miBSWindowPtr 	pBackingStore;
+    RegionPtr 	    	pSavedRegion;
+    RegionPtr 	    	newSaved, doomed;
+    ScreenPtr		pScreen;
+    BoxRec		extents;
+    int 		scrdx;	/* bit translation distance on screen */
+    int     	  	scrdy;
+    int			dx;		/* distance window moved  on screen */
+    int			dy;
 
     pScreen = pWin->drawable.pScreen;
     pBackingStore = (miBSWindowPtr)(pWin->backStorage);
@@ -3815,9 +3815,9 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
     miBSWindowPtr	pBackingStore;
     CopyPlaneProcPtr 	copyProc;
     GCPtr		pScratchGC;
-    register BoxPtr	pBox;
-    register int  	i;
-    register int  	dx, dy;
+    BoxPtr		pBox;
+    int  		i;
+    int  		dx, dy;
     BITS32		gcMask;
 
     if (!REGION_NOTEMPTY(pGC->pScreen, prgnExposed))
diff --git a/mi/micmap.c b/mi/micmap.c
index 987affe96..977c587a0 100644
--- a/mi/micmap.c
+++ b/mi/micmap.c
@@ -125,8 +125,8 @@ miResolveColor(unsigned short *pred, unsigned short *pgreen,
 _X_EXPORT Bool
 miInitializeColormap(ColormapPtr pmap)
 {
-    register unsigned i;
-    register VisualPtr pVisual;
+    unsigned i;
+    VisualPtr pVisual;
     unsigned lim, maxent, shift;
 
     pVisual = pmap->pVisual;
@@ -211,13 +211,13 @@ _X_EXPORT int
 miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs,
 			xColorItem *outdefs)
 {
-    register int    red, green, blue;
-    int		    maxred, maxgreen, maxblue;
-    int		    stepred, stepgreen, stepblue;
-    VisualPtr	    pVisual;
-    register int    pixel;
-    register int    nresult;
-    register int    i;
+    int	        red, green, blue;
+    int	        maxred, maxgreen, maxblue;
+    int	        stepred, stepgreen, stepblue;
+    VisualPtr   pVisual;
+    int         pixel;
+    int         nresult;
+    int         i;
 
     pVisual = pmap->pVisual;
 
diff --git a/mi/miexpose.c b/mi/miexpose.c
index 1ca5fc965..df04bd291 100644
--- a/mi/miexpose.c
+++ b/mi/miexpose.c
@@ -130,15 +130,15 @@ exposing is done by the backing store's GraphicsExpose function, of course.
 _X_EXPORT RegionPtr
 miHandleExposures(pSrcDrawable, pDstDrawable,
 		  pGC, srcx, srcy, width, height, dstx, dsty, plane)
-    register DrawablePtr	pSrcDrawable;
-    register DrawablePtr	pDstDrawable;
+    DrawablePtr			pSrcDrawable;
+    DrawablePtr			pDstDrawable;
     GCPtr 			pGC;
     int 			srcx, srcy;
     int 			width, height;
     int 			dstx, dsty;
     unsigned long		plane;
 {
-    register ScreenPtr pscr;
+    ScreenPtr pscr;
     RegionPtr prgnSrcClip;	/* drawable-relative source clip */
     RegionRec rgnSrcRec;
     RegionPtr prgnDstClip;	/* drawable-relative dest clip */
@@ -387,9 +387,9 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
     if (pRgn && !REGION_NIL(pRgn))
     {
         xEvent *pEvent;
-	register xEvent *pe;
-	register BoxPtr pBox;
-	register int i;
+	xEvent *pe;
+	BoxPtr pBox;
+	int i;
 	int numRects;
 
 	numRects = REGION_NUM_RECTS(pRgn);
@@ -431,12 +431,12 @@ void
 miSendExposures(pWin, pRgn, dx, dy)
     WindowPtr pWin;
     RegionPtr pRgn;
-    register int dx, dy;
+    int dx, dy;
 {
-    register BoxPtr pBox;
+    BoxPtr pBox;
     int numRects;
-    register xEvent *pEvent, *pe;
-    register int i;
+    xEvent *pEvent, *pe;
+    int i;
 
     pBox = REGION_RECTS(pRgn);
     numRects = REGION_NUM_RECTS(pRgn);
@@ -493,7 +493,7 @@ miSendExposures(pWin, pRgn, dx, dy)
 _X_EXPORT void 
 miWindowExposures(pWin, prgn, other_exposed)
     WindowPtr pWin;
-    register RegionPtr prgn, other_exposed;
+    RegionPtr prgn, other_exposed;
 {
     RegionPtr   exposures = prgn;
     if (pWin->backStorage && prgn)
@@ -629,7 +629,7 @@ tossGC (
 
 _X_EXPORT void
 miPaintWindow(pWin, prgn, what)
-register WindowPtr pWin;
+WindowPtr pWin;
 RegionPtr prgn;
 int what;
 {
@@ -657,10 +657,10 @@ int what;
     BoxRec box;
     WindowPtr	pBgWin;
     GCPtr pGC;
-    register int i;
-    register BoxPtr pbox;
-    register ScreenPtr pScreen = pWin->drawable.pScreen;
-    register xRectangle *prect;
+    int i;
+    BoxPtr pbox;
+    ScreenPtr pScreen = pWin->drawable.pScreen;
+    xRectangle *prect;
     int numRects;
 
     gcmask = 0;
diff --git a/mi/mifillarc.c b/mi/mifillarc.c
index 66063166a..46c073851 100644
--- a/mi/mifillarc.c
+++ b/mi/mifillarc.c
@@ -54,8 +54,8 @@ Author:  Bob Scheifler, MIT X Consortium
 
 _X_EXPORT void
 miFillArcSetup(arc, info)
-    register xArc *arc;
-    register miFillArcRec *info;
+    xArc *arc;
+    miFillArcRec *info;
 {
     info->y = arc->height >> 1;
     info->dy = arc->height & 1;
@@ -109,8 +109,8 @@ miFillArcSetup(arc, info)
 
 void
 miFillArcDSetup(arc, info)
-    register xArc *arc;
-    register miFillArcDRec *info;
+    xArc *arc;
+    miFillArcDRec *info;
 {
     /* h^2 * (2x - 2xorg)^2 = w^2 * h^2 - w^2 * (2y - 2yorg)^2 */
     /* even: xorg = yorg = 0   odd:  xorg = .5, yorg = -.5 */
@@ -141,13 +141,13 @@ miFillArcDSetup(arc, info)
 
 static void
 miGetArcEdge(
-	     register xArc *arc,
-	     register miSliceEdgePtr edge,
+	     xArc *arc,
+	     miSliceEdgePtr edge,
 	     int k,
 	     Bool top, 
 	     Bool left )
 {
-    register int xady, y;
+    int xady, y;
 
     y = arc->height >> 1;
     if (!(arc->width & 1))
@@ -271,13 +271,13 @@ miEllipseAngleToSlope (angle, width, height, dxp, dyp, d_dxp, d_dyp)
 
 static void
 miGetPieEdge(
-	     register xArc *arc,
-	     register int angle,
-	     register miSliceEdgePtr edge,
+	     xArc *arc,
+	     int angle,
+	     miSliceEdgePtr edge,
 	     Bool top, 
 	     Bool left )
 {
-    register int k;
+    int k;
     int	dx, dy;
 
     miEllipseAngleToSlope (angle, arc->width, arc->height, &dx, &dy, 0, 0);
@@ -316,11 +316,11 @@ miGetPieEdge(
 
 _X_EXPORT void
 miFillArcSliceSetup(arc, slice, pGC)
-    register xArc *arc;
-    register miArcSliceRec *slice;
+    xArc *arc;
+    miArcSliceRec *slice;
     GCPtr pGC;
 {
-    register int angle1, angle2;
+    int angle1, angle2;
 
     angle1 = arc->angle1;
     if (arc->angle2 < 0)
@@ -550,14 +550,14 @@ miFillEllipseI(
 	       GCPtr pGC,
 	       xArc *arc )
 {
-    register int x, y, e;
+    int x, y, e;
     int yk, xk, ym, xm, dx, dy, xorg, yorg;
     int slw;
     miFillArcRec info;
     DDXPointPtr points;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
     int *widths;
-    register int *wids;
+    int *wids;
 
     points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height);
     if (!points)
@@ -593,14 +593,14 @@ miFillEllipseD(
 	       GCPtr pGC,
 	       xArc *arc )
 {
-    register int x, y;
+    int x, y;
     int xorg, yorg, dx, dy, slw;
     double e, yk, xk, ym, xm;
     miFillArcDRec info;
     DDXPointPtr points;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
     int *widths;
-    register int *wids;
+    int *wids;
 
     points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height);
     if (!points)
@@ -659,14 +659,14 @@ miFillArcSliceI(
 		xArc *arc )
 {
     int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
-    register int x, y, e;
+    int x, y, e;
     miFillArcRec info;
     miArcSliceRec slice;
     int ya, xl, xr, xc;
     DDXPointPtr points;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
     int *widths;
-    register int *wids;
+    int *wids;
 
     miFillArcSetup(arc, &info);
     miFillArcSliceSetup(arc, &slice, pGC);
@@ -721,16 +721,16 @@ miFillArcSliceD(
 		GCPtr pGC,
 		xArc *arc )
 {
-    register int x, y;
+    int x, y;
     int dx, dy, xorg, yorg, slw;
     double e, yk, xk, ym, xm;
     miFillArcDRec info;
     miArcSliceRec slice;
     int ya, xl, xr, xc;
     DDXPointPtr points;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
     int *widths;
-    register int *wids;
+    int *wids;
 
     miFillArcDSetup(arc, &info);
     miFillArcSliceSetup(arc, &slice, pGC);
@@ -790,8 +790,8 @@ miPolyFillArc(pDraw, pGC, narcs, parcs)
     int		narcs;
     xArc	*parcs;
 {
-    register int i;
-    register xArc *arc;
+    int i;
+    xArc *arc;
 
     for(i = narcs, arc = parcs; --i >= 0; arc++)
     {
diff --git a/mi/mifillrct.c b/mi/mifillrct.c
index 78e89d69c..ca7e86445 100644
--- a/mi/mifillrct.c
+++ b/mi/mifillrct.c
@@ -74,16 +74,16 @@ miPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
     xRectangle	*prectInit;  	/* Pointer to first rectangle to fill */
 {
     int i;
-    register int	height;
-    register int	width;
-    register xRectangle *prect; 
-    int			xorg;
-    register int	yorg;
-    int			maxheight;
-    DDXPointPtr		pptFirst;
-    register DDXPointPtr ppt;
-    int			*pwFirst;
-    register int 	*pw;
+    int	height;
+    int	width;
+    xRectangle *prect; 
+    int	xorg;
+    int	yorg;
+    int	maxheight;
+    DDXPointPtr	pptFirst;
+    DDXPointPtr ppt;
+    int	*pwFirst;
+    int *pw;
 
     if (pGC->miTranslate)
     {
diff --git a/mi/mifpolycon.c b/mi/mifpolycon.c
index 57229f639..7bc1bb278 100644
--- a/mi/mifpolycon.c
+++ b/mi/mifpolycon.c
@@ -55,7 +55,7 @@ SOFTWARE.
 #include "pixmapstr.h"
 #include "mifpoly.h"
 
-static int GetFPolyYBounds(register SppPointPtr pts, int n, double yFtrans,
+static int GetFPolyYBounds(SppPointPtr pts, int n, double yFtrans,
 			   int *by, int *ty);
 
 #ifdef ICEILTEMPDECL
@@ -101,7 +101,7 @@ miFillSppPoly(dst, pgc, count, ptsIn, xTrans, yTrans, xFtrans, yFtrans)
     			*width,
     			*FirstWidth,    /* output buffer */
     	 		*Marked;	/* set if this vertex has been used */
-    register int	left, right,	/* indices to first endpoints */
+    int			left, right,	/* indices to first endpoints */
     			nextleft,
                  	nextright;	/* indices to second endpoints */
     DDXPointPtr 	ptsOut,
@@ -251,13 +251,13 @@ miFillSppPoly(dst, pgc, count, ptsIn, xTrans, yTrans, xFtrans, yFtrans)
 static
 int
 GetFPolyYBounds(
-    register SppPointPtr	pts,
+    SppPointPtr			pts,
     int 			n,
     double			yFtrans,
     int 			*by,
     int				*ty)
 {
-    register SppPointPtr	ptMin;
+    SppPointPtr			ptMin;
     double 			ymin, ymax;
     SppPointPtr			ptsStart = pts;
 
diff --git a/mi/miglblt.c b/mi/miglblt.c
index db299a8ae..4db3eb62f 100644
--- a/mi/miglblt.c
+++ b/mi/miglblt.c
@@ -92,18 +92,18 @@ miPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
 {
     int width, height;
     PixmapPtr pPixmap;
-    int nbyLine;			/* bytes per line of padded pixmap */
+    int nbyLine;		/* bytes per line of padded pixmap */
     FontPtr pfont;
     GCPtr pGCtmp;
-    register int i;
-    register int j;
-    unsigned char *pbits;		/* buffer for PutImage */
-    register unsigned char *pb;		/* temp pointer into buffer */
-    register CharInfoPtr pci;		/* currect char info */
-    register unsigned char *pglyph;	/* pointer bits in glyph */
-    int gWidth, gHeight;		/* width and height of glyph */
-    register int nbyGlyphWidth;		/* bytes per scanline of glyph */
-    int nbyPadGlyph;			/* server padded line of glyph */
+    int i;
+    int j;
+    unsigned char *pbits;	/* buffer for PutImage */
+    unsigned char *pb;		/* temp pointer into buffer */
+    CharInfoPtr pci;		/* currect char info */
+    unsigned char *pglyph;	/* pointer bits in glyph */
+    int gWidth, gHeight;	/* width and height of glyph */
+    int nbyGlyphWidth;		/* bytes per scanline of glyph */
+    int nbyPadGlyph;		/* server padded line of glyph */
 
     XID gcvals[3];
 
diff --git a/mi/miline.h b/mi/miline.h
index 7028485f0..b97b8cf9d 100644
--- a/mi/miline.h
+++ b/mi/miline.h
@@ -109,7 +109,7 @@ extern void miSetZeroLineBias(
 }
   
 #define SWAPINT(i, j) \
-{  register int _t = i;  i = j;  j = _t; }
+{  int _t = i;  i = j;  j = _t; }
 
 #define SWAPPT(i, j) \
 {  DDXPointRec _t; _t = i;  i = j; j = _t; }
diff --git a/mi/mioverlay.c b/mi/mioverlay.c
index c02ea2dc5..5724a6fed 100644
--- a/mi/mioverlay.c
+++ b/mi/mioverlay.c
@@ -1019,7 +1019,7 @@ miOverlayMoveWindow(
 static void 
 miOverlayWindowExposures(
     WindowPtr pWin,
-    register RegionPtr prgn,
+    RegionPtr prgn,
     RegionPtr other_exposed
 ){
     RegionPtr   exposures = prgn;
@@ -1106,7 +1106,7 @@ miOverlayRecomputeExposures (
     WindowPtr	pWin,
     pointer	value 
 ){
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     miOverlayTwoRegions	*pValid = (miOverlayTwoRegions*)value;
     miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
 
@@ -1161,10 +1161,10 @@ miOverlayResizeWindow(
     DDXPointRec oldpt;
     RegionPtr oldRegion = NULL, oldRegion2 = NULL;
     WindowPtr pFirstChange;
-    register WindowPtr pChild;
+    WindowPtr pChild;
     RegionPtr	gravitate[StaticGravity + 1];
     RegionPtr	gravitate2[StaticGravity + 1];
-    register unsigned g;
+    unsigned 	g;
     int		nx, ny;		/* destination x,y */
     int		newx, newy;	/* new inner window position */
     RegionPtr	pRegion = NULL;
@@ -1669,7 +1669,7 @@ miOverlayChangeBorderWidth(
     unsigned int width
 ){
     int oldwidth;
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     Bool WasViewable = (Bool)(pWin->viewable);
     Bool HadBorder;
 #ifdef DO_SAVE_UNDERS
diff --git a/mi/mipoly.c b/mi/mipoly.c
index b514b5ed2..ea0406f88 100644
--- a/mi/mipoly.c
+++ b/mi/mipoly.c
@@ -70,14 +70,14 @@ SOFTWARE.
 _X_EXPORT void
 miFillPolygon(dst, pgc, shape, mode, count, pPts)
     DrawablePtr		dst;
-    register GCPtr	pgc;
+    GCPtr		pgc;
     int			shape, mode;
-    register int	count;
+    int			count;
     DDXPointPtr		pPts;
 {
     int			i;
-    register int	xorg, yorg;
-    register DDXPointPtr ppt;
+    int			xorg, yorg;
+    DDXPointPtr 	ppt;
 
     if (count == 0)
 	return;
diff --git a/mi/mipolycon.c b/mi/mipolycon.c
index b5ab89364..e2d666e51 100644
--- a/mi/mipolycon.c
+++ b/mi/mipolycon.c
@@ -78,9 +78,9 @@ miFillConvexPoly(dst, pgc, count, ptsIn)
     int		count;                /* number of points        */
     DDXPointPtr ptsIn;                /* the points              */
 {
-    register int xl = 0, xr = 0; /* x vals of left and right edges */
-    register int dl = 0, dr = 0; /* decision variables             */
-    register int ml = 0, m1l = 0;/* left edge slope and slope+1    */
+    int xl = 0, xr = 0; /* x vals of left and right edges */
+    int dl = 0, dr = 0; /* decision variables             */
+    int ml = 0, m1l = 0;/* left edge slope and slope+1    */
     int mr = 0, m1r = 0;         /* right edge slope and slope+1   */
     int incr1l = 0, incr2l = 0;  /* left edge error increments     */
     int incr1r = 0, incr2r = 0;  /* right edge error increments    */
@@ -221,7 +221,7 @@ miFillConvexPoly(dst, pgc, count, ptsIn)
 static int
 getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty)
 {
-    register DDXPointPtr ptMin;
+    DDXPointPtr ptMin;
     int ymin, ymax;
     DDXPointPtr ptsStart = pts;
 
diff --git a/mi/mipolygen.c b/mi/mipolygen.c
index 34da21f9e..0d2ecc430 100644
--- a/mi/mipolygen.c
+++ b/mi/mipolygen.c
@@ -72,12 +72,12 @@ miFillGeneralPoly(dst, pgc, count, ptsIn)
     int		count;              /* number of points        */
     DDXPointPtr ptsIn;              /* the points              */
 {
-    register EdgeTableEntry *pAET;  /* the Active Edge Table   */
-    register int y;                 /* the current scanline    */
-    register int nPts = 0;          /* number of pts in buffer */
-    register EdgeTableEntry *pWETE; /* Winding Edge Table      */
-    register ScanLineList *pSLL;    /* Current ScanLineList    */
-    register DDXPointPtr ptsOut;      /* ptr to output buffers   */
+    EdgeTableEntry *pAET;  /* the Active Edge Table   */
+    int y;                 /* the current scanline    */
+    int nPts = 0;          /* number of pts in buffer */
+    EdgeTableEntry *pWETE; /* Winding Edge Table      */
+    ScanLineList *pSLL;    /* Current ScanLineList    */
+    DDXPointPtr ptsOut;      /* ptr to output buffers   */
     int *width;
     DDXPointRec FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
     int FirstWidth[NUMPTSTOBUFFER];
diff --git a/mi/mipolypnt.c b/mi/mipolypnt.c
index 245bda317..afe3f724a 100644
--- a/mi/mipolypnt.c
+++ b/mi/mipolypnt.c
@@ -70,7 +70,7 @@ miPolyPoint(pDrawable, pGC, mode, npt, pptInit)
     XID			fsOld, fsNew;
     int			*pwidthInit, *pwidth;
     int			i;
-    register xPoint 	*ppt;
+    xPoint 		*ppt;
 
     /* make pointlist origin relative */
     if (mode == CoordModePrevious)
diff --git a/mi/mipolyutil.c b/mi/mipolyutil.c
index 5443ba5c3..fe72e557f 100644
--- a/mi/mipolyutil.c
+++ b/mi/mipolyutil.c
@@ -81,8 +81,8 @@ miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
     ScanLineListBlock **SLLBlock;
     int *iSLLBlock;
 {
-    register EdgeTableEntry *start, *prev;
-    register ScanLineList *pSLL, *pPrevSLL;
+    EdgeTableEntry *start, *prev;
+    ScanLineList *pSLL, *pPrevSLL;
     ScanLineListBlock *tmpSLLBlock;
 
     /*
@@ -166,15 +166,15 @@ miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
 
 Bool
 miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
-    register int count;
-    register DDXPointPtr pts;
+    int count;
+    DDXPointPtr pts;
     EdgeTable *ET;
     EdgeTableEntry *AET;
-    register EdgeTableEntry *pETEs;
+    EdgeTableEntry *pETEs;
     ScanLineListBlock   *pSLLBlock;
 {
-    register DDXPointPtr top, bottom;
-    register DDXPointPtr PrevPt, CurrPt;
+    DDXPointPtr top, bottom;
+    DDXPointPtr PrevPt, CurrPt;
     int iSLLBlock = 0;
 
     int dy;
@@ -262,10 +262,10 @@ miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
 
 void
 miloadAET(AET, ETEs)
-    register EdgeTableEntry *AET, *ETEs;
+    EdgeTableEntry *AET, *ETEs;
 {
-    register EdgeTableEntry *pPrevAET;
-    register EdgeTableEntry *tmp;
+    EdgeTableEntry *pPrevAET;
+    EdgeTableEntry *tmp;
 
     pPrevAET = AET;
     AET = AET->next;
@@ -310,11 +310,11 @@ miloadAET(AET, ETEs)
  */
 void
 micomputeWAET(AET)
-    register EdgeTableEntry *AET;
+    EdgeTableEntry *AET;
 {
-    register EdgeTableEntry *pWETE;
-    register int inside = 1;
-    register int isInside = 0;
+    EdgeTableEntry *pWETE;
+    int inside = 1;
+    int isInside = 0;
 
     AET->nextWETE = (EdgeTableEntry *)NULL;
     pWETE = AET;
@@ -349,12 +349,12 @@ micomputeWAET(AET)
 
 int
 miInsertionSort(AET)
-    register EdgeTableEntry *AET;
+    EdgeTableEntry *AET;
 {
-    register EdgeTableEntry *pETEchase;
-    register EdgeTableEntry *pETEinsert;
-    register EdgeTableEntry *pETEchaseBackTMP;
-    register int changed = 0;
+    EdgeTableEntry *pETEchase;
+    EdgeTableEntry *pETEinsert;
+    EdgeTableEntry *pETEchaseBackTMP;
+    int changed = 0;
 
     AET = AET->next;
     while (AET) 
@@ -386,9 +386,9 @@ miInsertionSort(AET)
  */
 void
 miFreeStorage(pSLLBlock)
-    register ScanLineListBlock   *pSLLBlock;
+    ScanLineListBlock   *pSLLBlock;
 {
-    register ScanLineListBlock   *tmpSLLBlock;
+    ScanLineListBlock   *tmpSLLBlock;
 
     while (pSLLBlock) 
     {
diff --git a/mi/mipushpxl.c b/mi/mipushpxl.c
index 6526aa02b..3695f30da 100644
--- a/mi/mipushpxl.c
+++ b/mi/mipushpxl.c
@@ -85,11 +85,11 @@ miPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
     int		dx, dy, xOrg, yOrg;
 {
     int		h, dxDivPPW, ibEnd;
-    MiBits *pwLineStart;
-    register MiBits	*pw, *pwEnd;
-    register MiBits msk;
-    register int ib, w;
-    register int ipt;		/* index into above arrays */
+    MiBits 	*pwLineStart;
+    MiBits	*pw, *pwEnd;
+    MiBits 	msk;
+    int 	ib, w;
+    int 	ipt;		/* index into above arrays */
     Bool 	fInBox;
     DDXPointRec	pt[NPT], ptThisLine;
     int		width[NPT];
diff --git a/mi/miregion.c b/mi/miregion.c
index 0db46dcf5..542209982 100644
--- a/mi/miregion.c
+++ b/mi/miregion.c
@@ -228,7 +228,7 @@ miPrintRegion(rgn)
     RegionPtr rgn;
 {
     int num, size;
-    register int i;
+    int i;
     BoxPtr rects;
 
     num = REGION_NUM_RECTS(rgn);
@@ -275,7 +275,7 @@ Bool
 miValidRegion(reg)
     RegionPtr reg;
 {
-    register int i, numRects;
+    int i, numRects;
 
     if ((reg->extents.x1 > reg->extents.x2) ||
 	(reg->extents.y1 > reg->extents.y2))
@@ -289,7 +289,7 @@ miValidRegion(reg)
 	return (!reg->data);
     else
     {
-	register BoxPtr pboxP, pboxN;
+	BoxPtr pboxP, pboxN;
 	BoxRec box;
 
 	pboxP = REGION_RECTS(reg);
@@ -331,7 +331,7 @@ miRegionCreate(rect, size)
     BoxPtr rect;
     int size;
 {
-    register RegionPtr pReg;
+    RegionPtr pReg;
    
     pReg = (RegionPtr)xalloc(sizeof(RegionRec));
     if (!pReg)
@@ -414,7 +414,7 @@ miRegionBreak (pReg)
 
 _X_EXPORT Bool
 miRectAlloc(
-    register RegionPtr pRgn,
+    RegionPtr pRgn,
     int n)
 {
     RegDataPtr	data;
@@ -455,8 +455,8 @@ miRectAlloc(
 
 _X_EXPORT Bool
 miRegionCopy(dst, src)
-    register RegionPtr dst;
-    register RegionPtr src;
+    RegionPtr dst;
+    RegionPtr src;
 {
     good(dst);
     good(src);
@@ -508,14 +508,14 @@ miRegionCopy(dst, src)
  */
 INLINE static int
 miCoalesce (
-    register RegionPtr	pReg,	    	/* Region to coalesce		     */
+    RegionPtr	pReg,	    	/* Region to coalesce		     */
     int	    	  	prevStart,  	/* Index of start of previous band   */
     int	    	  	curStart)   	/* Index of start of current band    */
 {
-    register BoxPtr	pPrevBox;   	/* Current box in previous band	     */
-    register BoxPtr	pCurBox;    	/* Current box in current band       */
-    register int  	numRects;	/* Number rectangles in both bands   */
-    register int	y2;		/* Bottom of current band	     */
+    BoxPtr	pPrevBox;   	/* Current box in previous band	     */
+    BoxPtr	pCurBox;    	/* Current box in current band       */
+    int  	numRects;	/* Number rectangles in both bands   */
+    int		y2;		/* Bottom of current band	     */
     /*
      * Figure out how many rectangles are in the band.
      */
@@ -592,14 +592,14 @@ miCoalesce (
 
 INLINE static Bool
 miAppendNonO (
-    register RegionPtr	pReg,
-    register BoxPtr	r,
-    BoxPtr  	  	rEnd,
-    register int  	y1,
-    register int  	y2)
+    RegionPtr	pReg,
+    BoxPtr	r,
+    BoxPtr  	rEnd,
+    int  	y1,
+    int  	y2)
 {
-    register BoxPtr	pNextRect;
-    register int	newRects;
+    BoxPtr	pNextRect;
+    int		newRects;
 
     newRects = rEnd - r;
 
@@ -691,25 +691,25 @@ miRegionOp(
 					    /* in region 2 ? */
     Bool	    *pOverlap)
 {
-    register BoxPtr r1;			    /* Pointer into first region     */
-    register BoxPtr r2;			    /* Pointer into 2d region	     */
-    BoxPtr	    r1End;		    /* End of 1st region	     */
-    BoxPtr	    r2End;		    /* End of 2d region		     */
-    short	    ybot;		    /* Bottom of intersection	     */
-    short	    ytop;		    /* Top of intersection	     */
-    RegDataPtr	    oldData;		    /* Old data for newReg	     */
-    int		    prevBand;		    /* Index of start of
-					     * previous band in newReg       */
-    int		    curBand;		    /* Index of start of current
-					     * band in newReg		     */
-    register BoxPtr r1BandEnd;		    /* End of current band in r1     */
-    register BoxPtr r2BandEnd;		    /* End of current band in r2     */
-    short	    top;		    /* Top of non-overlapping band   */
-    short	    bot;		    /* Bottom of non-overlapping band*/
-    register int    r1y1;		    /* Temps for r1->y1 and r2->y1   */
-    register int    r2y1;
-    int		    newSize;
-    int		    numRects;
+    BoxPtr 	r1;		    /* Pointer into first region     */
+    BoxPtr 	r2;		    /* Pointer into 2d region	     */
+    BoxPtr	r1End;		    /* End of 1st region	     */
+    BoxPtr	r2End;		    /* End of 2d region		     */
+    short	ybot;		    /* Bottom of intersection	     */
+    short	ytop;		    /* Top of intersection	     */
+    RegDataPtr	oldData;	    /* Old data for newReg	     */
+    int		prevBand;	    /* Index of start of
+				     * previous band in newReg       */
+    int		curBand;	    /* Index of start of current
+				     * band in newReg		     */
+    BoxPtr  	r1BandEnd;	    /* End of current band in r1     */
+    BoxPtr  	r2BandEnd;	    /* End of current band in r2     */
+    short   	top;		    /* Top of non-overlapping band   */
+    short   	bot;	    	    /* Bottom of non-overlapping band*/
+    int     	r1y1;	    	    /* Temps for r1->y1 and r2->y1   */
+    int     	r2y1;
+    int	    	newSize;
+    int	    	numRects;
 
     /*
      * Break any region computed from a broken region
@@ -915,9 +915,9 @@ miRegionOp(
  */
 void
 miSetExtents (pReg)
-    register RegionPtr pReg;
+    RegionPtr pReg;
 {
-    register BoxPtr pBox, pBoxEnd;
+    BoxPtr pBox, pBoxEnd;
 
     if (!pReg->data)
 	return;
@@ -974,18 +974,18 @@ miSetExtents (pReg)
 /*ARGSUSED*/
 static Bool
 miIntersectO (
-    register RegionPtr	pReg,
-    register BoxPtr	r1,
+    RegionPtr	pReg,
+    BoxPtr	r1,
     BoxPtr  	  	r1End,
-    register BoxPtr	r2,
+    BoxPtr	r2,
     BoxPtr  	  	r2End,
     short    	  	y1,
     short    	  	y2,
     Bool		*pOverlap)
 {
-    register int  	x1;
-    register int  	x2;
-    register BoxPtr	pNextRect;
+    int  	x1;
+    int  	x2;
+    BoxPtr	pNextRect;
 
     pNextRect = REGION_TOP(pReg);
 
@@ -1022,9 +1022,9 @@ miIntersectO (
 
 _X_EXPORT Bool
 miIntersect(newReg, reg1, reg2)
-    register RegionPtr 	newReg;     /* destination Region */
-    register RegionPtr 	reg1;
-    register RegionPtr	reg2;       /* source regions     */
+    RegionPtr 	newReg;     /* destination Region */
+    RegionPtr 	reg1;
+    RegionPtr	reg2;       /* source regions     */
 {
     good(reg1);
     good(reg2);
@@ -1117,18 +1117,18 @@ miIntersect(newReg, reg1, reg2)
  */
 static Bool
 miUnionO (
-    register RegionPtr	pReg,
-    register BoxPtr	r1,
-	     BoxPtr  	r1End,
-    register BoxPtr	r2,
-	     BoxPtr  	r2End,
-	     short	y1,
-	     short	y2,
-	     Bool	*pOverlap)
+    RegionPtr	pReg,
+    BoxPtr	r1,
+    BoxPtr  	r1End,
+    BoxPtr	r2,
+    BoxPtr  	r2End,
+    short	y1,
+    short	y2,
+    Bool	*pOverlap)
 {
-    register BoxPtr     pNextRect;
-    register int        x1;     /* left and right side of current union */
-    register int        x2;
+    BoxPtr     pNextRect;
+    int        x1;     /* left and right side of current union */
+    int        x2;
 
     assert (y1 < y2);
     assert(r1 != r1End && r2 != r2End);
@@ -1178,8 +1178,8 @@ miUnionO (
 _X_EXPORT Bool 
 miUnion(newReg, reg1, reg2)
     RegionPtr		newReg;                  /* destination Region */
-    register RegionPtr 	reg1;
-    register RegionPtr	reg2;             /* source regions     */
+    RegionPtr 	reg1;
+    RegionPtr	reg2;             /* source regions     */
 {
     Bool overlap; /* result ignored */
 
@@ -1276,8 +1276,8 @@ miUnion(newReg, reg1, reg2)
  */
 _X_EXPORT Bool
 miRegionAppend(dstrgn, rgn)
-    register RegionPtr dstrgn;
-    register RegionPtr rgn;
+    RegionPtr dstrgn;
+    RegionPtr rgn;
 {
     int numRects, dnumRects, size;
     BoxPtr new, old;
@@ -1307,7 +1307,7 @@ miRegionAppend(dstrgn, rgn)
 	dstrgn->extents = rgn->extents;
     else if (dstrgn->extents.x2 > dstrgn->extents.x1)
     {
-	register BoxPtr first, last;
+	BoxPtr first, last;
 
 	first = old;
 	last = REGION_BOXPTR(dstrgn) + (dnumRects - 1);
@@ -1371,13 +1371,13 @@ miRegionAppend(dstrgn, rgn)
 
 static void
 QuickSortRects(
-    register BoxRec     rects[],
-    register int        numRects)
+    BoxRec     rects[],
+    int        numRects)
 {
-    register int	y1;
-    register int	x1;
-    register int        i, j;
-    register BoxPtr     r;
+    int	y1;
+    int	x1;
+    int        i, j;
+    BoxPtr     r;
 
     /* Always called with numRects > 1 */
 
@@ -1472,17 +1472,17 @@ miRegionValidate(badreg, pOverlap)
 	int	    curBand;
     } RegionInfo;
 
-	     int	numRects;   /* Original numRects for badreg	    */
-	     RegionInfo *ri;	    /* Array of current regions		    */
-    	     int	numRI;      /* Number of entries used in ri	    */
-	     int	sizeRI;	    /* Number of entries available in ri    */
-	     int	i;	    /* Index into rects			    */
-    register int	j;	    /* Index into ri			    */
-    register RegionInfo *rit;       /* &ri[j]				    */
-    register RegionPtr  reg;        /* ri[j].reg			    */
-    register BoxPtr	box;	    /* Current box in rects		    */
-    register BoxPtr	riBox;      /* Last box in ri[j].reg		    */
-    register RegionPtr  hreg;       /* ri[j_half].reg			    */
+    int	numRects;   /* Original numRects for badreg	    */
+    RegionInfo *ri;	    /* Array of current regions		    */
+    int	numRI;      /* Number of entries used in ri	    */
+    int	sizeRI;	    /* Number of entries available in ri    */
+    int	i;	    /* Index into rects			    */
+    int	j;	    /* Index into ri			    */
+    RegionInfo *rit;       /* &ri[j]				    */
+    RegionPtr  reg;        /* ri[j].reg			    */
+    BoxPtr	box;	    /* Current box in rects		    */
+    BoxPtr	riBox;      /* Last box in ri[j].reg		    */
+    RegionPtr  hreg;       /* ri[j_half].reg			    */
     Bool		ret = TRUE;
 
     *pOverlap = FALSE;
@@ -1654,13 +1654,13 @@ bail:
 _X_EXPORT RegionPtr
 miRectsToRegion(nrects, prect, ctype)
     int			nrects;
-    register xRectangle	*prect;
+    xRectangle		*prect;
     int			ctype;
 {
-    register RegionPtr	pRgn;
-    register RegDataPtr	pData;
-    register BoxPtr	pBox;
-    register int        i;
+    RegionPtr		pRgn;
+    RegDataPtr		pData;
+    BoxPtr		pBox;
+    int        		i;
     int			x1, y1, x2, y2;
 
     pRgn = miRegionCreate(NullBox, 0);
@@ -1754,17 +1754,17 @@ miRectsToRegion(nrects, prect, ctype)
 /*ARGSUSED*/
 static Bool
 miSubtractO (
-    register RegionPtr	pReg,
-    register BoxPtr	r1,
-    BoxPtr  	  	r1End,
-    register BoxPtr	r2,
-    BoxPtr  	  	r2End,
-    register short  	y1,
-             short  	y2,
-    Bool		*pOverlap)
+    RegionPtr	pReg,
+    BoxPtr	r1,
+    BoxPtr  	r1End,
+    BoxPtr	r2,
+    BoxPtr  	r2End,
+    short  	y1,
+    short  	y2,
+    Bool	*pOverlap)
 {
-    register BoxPtr	pNextRect;
-    register int  	x1;
+    BoxPtr	pNextRect;
+    int  	x1;
 
     x1 = r1->x1;
     
@@ -1878,9 +1878,9 @@ miSubtractO (
  */
 _X_EXPORT Bool
 miSubtract(regD, regM, regS)
-    register RegionPtr	regD;               
-    register RegionPtr 	regM;
-    register RegionPtr	regS;          
+    RegionPtr	regD;               
+    RegionPtr 	regM;
+    RegionPtr	regS;          
 {
     Bool overlap; /* result ignored */
 
@@ -2003,15 +2003,15 @@ miInverse(newReg, reg1, invRect)
 
 _X_EXPORT int
 miRectIn(region, prect)
-    register RegionPtr  region;
-    register BoxPtr     prect;
+    RegionPtr  region;
+    BoxPtr     prect;
 {
-    register int	x;
-    register int	y;
-    register BoxPtr     pbox;
-    register BoxPtr     pboxEnd;
-    int			partIn, partOut;
-    int			numRects;
+    int		x;
+    int		y;
+    BoxPtr	pbox;
+    BoxPtr	pboxEnd;
+    int		partIn, partOut;
+    int		numRects;
 
     good(region);
     numRects = REGION_NUM_RECTS(region);
@@ -2099,13 +2099,13 @@ miRectIn(region, prect)
 
 _X_EXPORT void
 miTranslateRegion(pReg, x, y)
-    register RegionPtr pReg;
-    register int x;
-    register int y;
+    RegionPtr pReg;
+    int x;
+    int y;
 {
     int x1, x2, y1, y2;
-    register int nbox;
-    register BoxPtr pbox;
+    int nbox;
+    BoxPtr pbox;
 
     good(pReg);
     pReg->extents.x1 = x1 = pReg->extents.x1 + x;
@@ -2144,7 +2144,7 @@ miTranslateRegion(pReg, x, y)
 	pReg->extents.y2 = MAXSHORT;
     if (pReg->data && (nbox = pReg->data->numRects))
     {
-	register BoxPtr pboxout;
+	BoxPtr pboxout;
 
 	for (pboxout = pbox = REGION_BOXPTR(pReg); nbox--; pbox++)
 	{
@@ -2184,8 +2184,8 @@ miTranslateRegion(pReg, x, y)
 
 Bool
 miRegionDataCopy(
-    register RegionPtr dst,
-    register RegionPtr src)
+    RegionPtr dst,
+    RegionPtr src)
 {
     good(dst);
     good(src);
@@ -2226,11 +2226,11 @@ miRegionReset(pReg, pBox)
 
 _X_EXPORT Bool
 miPointInRegion(pReg, x, y, box)
-    register RegionPtr pReg;
-    register int x, y;
+    RegionPtr pReg;
+    int x, y;
     BoxPtr box;     /* "return" value */
 {
-    register BoxPtr pbox, pboxEnd;
+    BoxPtr pbox, pboxEnd;
     int numRects;
 
     good(pReg);
@@ -2294,8 +2294,8 @@ miRegionExtents(pReg)
 
 #define ExchangeSpans(a, b)				    \
 {							    \
-    DDXPointRec     tpt;				    \
-    register int    tw;					    \
+    DDXPointRec	tpt;				    	    \
+    int    	tw;					    \
 							    \
     tpt = spans[a]; spans[a] = spans[b]; spans[b] = tpt;    \
     tw = widths[a]; widths[a] = widths[b]; widths[b] = tw;  \
@@ -2307,13 +2307,13 @@ miRegionExtents(pReg)
 */
 
 static void QuickSortSpans(
-    register DDXPointRec    spans[],
-    register int	    widths[],
-    register int	    numSpans)
+    DDXPointRec spans[],
+    int	    	widths[],
+    int	    	numSpans)
 {
-    register int	    y;
-    register int	    i, j, m;
-    register DDXPointPtr    r;
+    int	    y;
+    int	    i, j, m;
+    DDXPointPtr    r;
 
     /* Always called with numSpans > 1 */
     /* Sorts only by y, doesn't bother to sort by x */
@@ -2323,7 +2323,7 @@ static void QuickSortSpans(
 	if (numSpans < 9)
 	{
 	    /* Do insertion sort */
-	    register int yprev;
+	    int yprev;
 
 	    yprev = spans[0].y;
 	    i = 1;
@@ -2412,18 +2412,18 @@ static void QuickSortSpans(
 
 _X_EXPORT int
 miClipSpans(
-    RegionPtr		    prgnDst,
-    register DDXPointPtr    ppt,
-    register int	    *pwidth,
-    int			    nspans,
-    register DDXPointPtr    pptNew,
-    int			    *pwidthNew,
-    int			    fSorted)
+    RegionPtr	prgnDst,
+    DDXPointPtr ppt,
+    int	    	*pwidth,
+    int		nspans,
+    DDXPointPtr	pptNew,
+    int		*pwidthNew,
+    int		fSorted)
 {
-    register DDXPointPtr pptLast;
-    int			*pwidthNewStart;	/* the vengeance of Xerox! */
-    register int	y, x1, x2;
-    register int	numRects;
+    DDXPointPtr pptLast;
+    int	*pwidthNewStart;	/* the vengeance of Xerox! */
+    int	y, x1, x2;
+    int	numRects;
 
     good(prgnDst);
     pptLast = ppt + nspans;
@@ -2435,7 +2435,7 @@ miClipSpans(
 	/* It doesn't pay much to make use of fSorted in this case, 
 	   so we lump everything together. */
 
-	register    int clipx1, clipx2, clipy1, clipy2;
+	int clipx1, clipx2, clipy1, clipy2;
 
 	clipx1 = prgnDst->extents.x1;
 	clipy1 = prgnDst->extents.y1;
@@ -2467,10 +2467,10 @@ miClipSpans(
     else if ((numRects = prgnDst->data->numRects))
     {
 	/* Have to clip against many boxes */
-	BoxPtr		pboxBandStart, pboxBandEnd;
-	register BoxPtr pbox;
-	register BoxPtr pboxLast;
-	register int	clipy1, clipy2;
+	BoxPtr pboxBandStart, pboxBandEnd;
+	BoxPtr pbox;
+	BoxPtr pboxLast;
+	int clipy1, clipy2;
 
 	/* In this case, taking advantage of sorted spans gains more than
 	   the sorting costs. */
@@ -2493,7 +2493,7 @@ miClipSpans(
 		x2 = x1 + *pwidth;
 		do
 		{ /* For each box in band */
-		    register int    newx1, newx2;
+		    int newx1, newx2;
 
 		    newx1 = x1;
 		    newx2 = x2;
@@ -2531,10 +2531,10 @@ _X_EXPORT int
 miFindMaxBand(prgn)
     RegionPtr prgn;
 {
-    register int nbox;
-    register BoxPtr pbox;
-    register int nThisBand;
-    register int nMaxBand = 0;
+    int nbox;
+    BoxPtr pbox;
+    int nThisBand;
+    int nMaxBand = 0;
     short yThisBand;
 
     good(prgn);
diff --git a/mi/miscrinit.c b/mi/miscrinit.c
index ac1b82336..7922cb66e 100644
--- a/mi/miscrinit.c
+++ b/mi/miscrinit.c
@@ -185,7 +185,7 @@ miCreateScreenResources(pScreen)
 
 Bool
 miScreenDevPrivateInit(pScreen, width, pbits)
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     int width;
     pointer pbits;
 {
@@ -207,7 +207,7 @@ miScreenDevPrivateInit(pScreen, width, pbits)
 _X_EXPORT Bool
 miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
 	     rootDepth, numDepths, depths, rootVisual, numVisuals, visuals)
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     pointer pbits;		/* pointer to screen bits */
     int xsize, ysize;		/* in pixels */
     int dpix, dpiy;		/* dots per inch */
diff --git a/mi/mispans.c b/mi/mispans.c
index 4c8b6d698..61d72e46c 100644
--- a/mi/mispans.c
+++ b/mi/mispans.c
@@ -188,8 +188,8 @@ void miAppendSpans(spanGroup, otherGroup, spans)
     SpanGroup	*otherGroup;
     Spans       *spans;
 {
-    register    int ymin, ymax;
-    register    int spansCount;
+    int ymin, ymax;
+    int spansCount;
 
     spansCount = spans->count;
     if (spansCount > 0) {
@@ -226,21 +226,21 @@ void miFreeSpanGroup(spanGroup)
 }
 
 static void QuickSortSpansX(
-    register DDXPointRec    points[],
-    register int	    widths[],
-    register int	    numSpans )
+    DDXPointRec points[],
+    int		widths[],
+    int		numSpans )
 {
-    register int	    x;
-    register int	    i, j, m;
-    register DDXPointPtr    r;
+    int	    		x;
+    int	    		i, j, m;
+    DDXPointPtr 	r;
 
 /* Always called with numSpans > 1 */
 /* Sorts only by x, as all y should be the same */
 
 #define ExchangeSpans(a, b)				    \
 {							    \
-    DDXPointRec     tpt;				    \
-    register int    tw;					    \
+    DDXPointRec 	tpt;				    \
+    int    		tw;				    \
 							    \
     tpt = points[a]; points[a] = points[b]; points[b] = tpt;    \
     tw = widths[a]; widths[a] = widths[b]; widths[b] = tw;  \
@@ -249,7 +249,7 @@ static void QuickSortSpansX(
     do {
 	if (numSpans < 9) {
 	    /* Do insertion sort */
-	    register int xprev;
+	    int xprev;
 
 	    xprev = points[0].x;
 	    i = 1;
@@ -313,14 +313,14 @@ static void QuickSortSpansX(
 
 
 static int UniquifySpansX(
-    Spans		    *spans,
-    register DDXPointRec    *newPoints,
-    register int	    *newWidths )
+    Spans	    	*spans,
+    DDXPointRec    	*newPoints,
+    int	    		*newWidths )
 {
-    register int newx1, newx2, oldpt, i, y;
-    register DDXPointRec    *oldPoints;
-    register int	    *oldWidths;
-    int			    *startNewWidths;
+    int 		newx1, newx2, oldpt, i, y;
+    DDXPointRec		*oldPoints;
+    int	    		*oldWidths;
+    int			*startNewWidths;
 
 /* Always called with numSpans > 1 */
 /* Uniquify the spans, and stash them into newPoints and newWidths.  Return the
@@ -384,16 +384,16 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
     GCPtr	pGC;
     SpanGroup   *spanGroup;
 {
-    register int    i;
-    register Spans  *spans;
-    register Spans  *yspans;
-    register int    *ysizes;
-    register int    ymin, ylength;
+    int    		i;
+    Spans  		*spans;
+    Spans  		*yspans;
+    int    		*ysizes;
+    int    		ymin, ylength;
 
     /* Outgoing spans for one big call to FillSpans */
-    register DDXPointPtr    points;
-    register int	    *widths;
-    register int	    count;
+    DDXPointPtr    	points;
+    int	    		*widths;
+    int	    		count;
 
     if (spanGroup->count == 0) return;
 
@@ -545,8 +545,8 @@ void miFillSpanGroup(pDraw, pGC, spanGroup)
     GCPtr	pGC;
     SpanGroup   *spanGroup;
 {
-    register int    i;
-    register Spans  *spans;
+    int    i;
+    Spans  *spans;
 
     for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) {
 	(*pGC->ops->FillSpans)
diff --git a/mi/misprite.c b/mi/misprite.c
index 286c7552a..c0560a4bb 100644
--- a/mi/misprite.c
+++ b/mi/misprite.c
@@ -320,11 +320,11 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
 
     if (pDrawable->type == DRAWABLE_WINDOW && pScreenPriv->isUp)
     {
-	register DDXPointPtr    pts;
-	register int    	*widths;
-	register int    	nPts;
-	register int    	xorg,
-				yorg;
+	DDXPointPtr    	pts;
+	int    		*widths;
+	int    		nPts;
+	int    		xorg,
+			yorg;
 
 	xorg = pDrawable->x;
 	yorg = pDrawable->y;
diff --git a/mi/mivaltree.c b/mi/mivaltree.c
index 0e5ed61e7..92ea0a8a9 100644
--- a/mi/mivaltree.c
+++ b/mi/mivaltree.c
@@ -112,13 +112,13 @@ miShapedWindowIn (pScreen, universe, bounding, rect, x, y)
     ScreenPtr	pScreen;
     RegionPtr	universe, bounding;
     BoxPtr	rect;
-    register int x, y;
+    int 	x, y;
 {
-    BoxRec  box;
-    register BoxPtr  boundBox;
-    int	    nbox;
-    Bool    someIn, someOut;
-    register int t, x1, y1, x2, y2;
+    BoxRec  	box;
+    BoxPtr	boundBox;
+    int		nbox;
+    Bool	someIn, someOut;
+    int 	t, x1, y1, x2, y2;
 
     nbox = REGION_NUM_RECTS (bounding);
     boundBox = REGION_RECTS (bounding);
@@ -202,16 +202,16 @@ miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,
  */
 static void
 miComputeClips (
-    register WindowPtr	pParent,
-    register ScreenPtr	pScreen,
-    register RegionPtr	universe,
+    WindowPtr	pParent,
+    ScreenPtr	pScreen,
+    RegionPtr	universe,
     VTKind		kind,
     RegionPtr		exposed ) /* for intermediate calculations */
 {
     int			dx,
 			dy;
     RegionRec		childUniverse;
-    register WindowPtr	pChild;
+    WindowPtr		pChild;
     int     	  	oldVis, newVis;
     BoxRec		borderSize;
     RegionRec		childUnion;
@@ -535,10 +535,10 @@ miComputeClips (
 
 static void
 miTreeObscured(
-    register WindowPtr pParent )
+    WindowPtr pParent )
 {
-    register WindowPtr pChild;
-    register int    oldVis;
+    WindowPtr 	pChild;
+    int    	oldVis;
 
     pChild = pParent;
     while (1)
@@ -609,8 +609,8 @@ miValidateTree (pParent, pChild, kind)
     RegionRec		childUnion; /* the space covered by borderSize for
 				     * all marked children */
     RegionRec		exposed;    /* For intermediate calculations */
-    register ScreenPtr	pScreen;
-    register WindowPtr	pWin;
+    ScreenPtr		pScreen;
+    WindowPtr		pWin;
     Bool		overlap;
     int			viewvals;
     Bool		forward;
diff --git a/mi/miwideline.c b/mi/miwideline.c
index d57c2eaa7..7f99aca51 100644
--- a/mi/miwideline.c
+++ b/mi/miwideline.c
@@ -56,10 +56,10 @@ from The Open Group.
 ICEILTEMPDECL
 #endif
 
-static void miLineArc(DrawablePtr pDraw, register GCPtr pGC,
+static void miLineArc(DrawablePtr pDraw, GCPtr pGC,
 		      unsigned long pixel, SpanDataPtr spanData,
-		      register LineFacePtr leftFace,
-		      register LineFacePtr rightFace,
+		      LineFacePtr leftFace,
+		      LineFacePtr rightFace,
 		      double xorg, double yorg, Bool isInt);
 
 
@@ -79,12 +79,12 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
     PolyEdgePtr	left, right;
     int		left_count, right_count;
 {
-    register int left_x = 0, left_e = 0;
+    int left_x = 0, left_e = 0;
     int	left_stepx = 0;
     int	left_signdx = 0;
     int	left_dy = 0, left_dx = 0;
 
-    register int right_x = 0, right_e = 0;
+    int right_x = 0, right_e = 0;
     int	right_stepx = 0;
     int	right_signdx = 0;
     int	right_dy = 0, right_dx = 0;
@@ -92,10 +92,10 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
     int	height = 0;
     int	left_height = 0, right_height = 0;
 
-    register DDXPointPtr ppt;
+    DDXPointPtr ppt;
     DDXPointPtr pptInit = NULL;
-    register int *pwidth;
-    int *pwidthInit = NULL;
+    int 	*pwidth;
+    int 	*pwidthInit = NULL;
     XID		oldPixel;
     int		xorg;
     Spans	spanRec;
@@ -203,8 +203,8 @@ miFillRectPolyHelper (
     int		w,
     int		h)
 {
-    register DDXPointPtr ppt;
-    register int *pwidth;
+    DDXPointPtr ppt;
+    int 	*pwidth;
     XID		oldPixel;
     Spans	spanRec;
     xRectangle  rect;
@@ -265,10 +265,10 @@ _X_EXPORT /* static */ int
 miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
     double	x0, y0;
     double	k;  /* x0 * dy - y0 * dx */
-    register int dx, dy;
+    int 	dx, dy;
     int		xi, yi;
     int		left;
-    register PolyEdgePtr edge;
+    PolyEdgePtr edge;
 {
     int	    x, y, e;
     int	    xady;
@@ -322,23 +322,23 @@ miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
 
 _X_EXPORT /* static */ int
 miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright, h)
-    register PolyVertexPtr vertices;
-    register PolySlopePtr  slopes;
-    int		    count;
-    int		    xi, yi;
-    PolyEdgePtr	    left, right;
-    int		    *pnleft, *pnright;
-    int		    *h;
+    PolyVertexPtr 	vertices;
+    PolySlopePtr	slopes;
+    int			count;
+    int		   	xi, yi;
+    PolyEdgePtr	    	left, right;
+    int		    	*pnleft, *pnright;
+    int		    	*h;
 {
-    int	    top, bottom;
-    double  miny, maxy;
-    register int i;
-    int	    j;
-    int	    clockwise;
-    int	    slopeoff;
-    register int s;
-    register int nright, nleft;
-    int	    y, lasty = 0, bottomy, topy = 0;
+    int 	top, bottom;
+    double 	miny, maxy;
+    int 	i;
+    int		j;
+    int		clockwise;
+    int		slopeoff;
+    int 	s;
+    int 	nright, nleft;
+    int	   	y, lasty = 0, bottomy, topy = 0;
 
     /* find the top of the polygon */
     maxy = miny = vertices[0].y;
@@ -467,12 +467,12 @@ miLineOnePoint (
 
 static void
 miLineJoin (
-    DrawablePtr	    pDrawable,
-    GCPtr	    pGC,
-    unsigned long   pixel,
-    SpanDataPtr	    spanData,
-    register LineFacePtr pLeft,
-    register LineFacePtr pRight)
+    DrawablePtr 	pDrawable,
+    GCPtr		pGC,
+    unsigned long	pixel,
+    SpanDataPtr		spanData,
+    LineFacePtr		pLeft,
+    LineFacePtr 	pRight)
 {
     double	    mx = 0, my = 0;
     double	    denom = 0.0;
@@ -624,9 +624,9 @@ miLineArcI (
     DDXPointPtr	    points,
     int		    *widths)
 {
-    register DDXPointPtr tpts, bpts;
-    register int *twids, *bwids;
-    register int x, y, e, ex, slw;
+    DDXPointPtr tpts, bpts;
+    int *twids, *bwids;
+    int x, y, e, ex, slw;
 
     tpts = points;
     twids = widths;
@@ -717,8 +717,8 @@ miLineArcD (
     int		    edgey2,
     Bool	    edgeleft2)
 {
-    register DDXPointPtr pts;
-    register int *wids;
+    DDXPointPtr pts;
+    int *wids;
     double radius, x0, y0, el, er, yk, xlk, xrk, k;
     int xbase, ybase, y, boty, xl, xr, xcl, xcr;
     int ymin, ymax;
@@ -875,8 +875,8 @@ miLineArcD (
 
 int
 miRoundJoinFace (face, edge, leftEdge)
-    register LineFacePtr face;
-    register PolyEdgePtr edge;
+    LineFacePtr face;
+    PolyEdgePtr edge;
     Bool	*leftEdge;
 {
     int	    y;
@@ -924,7 +924,7 @@ miRoundJoinFace (face, edge, leftEdge)
 
 _X_EXPORT void
 miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
-    register LineFacePtr pLeft, pRight;
+    LineFacePtr pLeft, pRight;
     PolyEdgePtr	edge1, edge2;
     int		*y1, *y2;
     Bool	*left1, *left2;
@@ -949,14 +949,14 @@ miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
 
 _X_EXPORT int
 miRoundCapClip (face, isInt, edge, leftEdge)
-    register LineFacePtr face;
+    LineFacePtr face;
     Bool	isInt;
-    register PolyEdgePtr edge;
+    PolyEdgePtr edge;
     Bool	*leftEdge;
 {
-    int	    y;
-    register int dx, dy;
-    double  xa, ya, k;
+    int		y;
+    int 	dx, dy;
+    double	xa, ya, k;
     Bool	left;
 
     dx = -face->dy;
@@ -999,15 +999,15 @@ miRoundCapClip (face, isInt, edge, leftEdge)
 
 static void
 miLineArc (
-    DrawablePtr	    pDraw,
-    register GCPtr  pGC,
-    unsigned long   pixel,
-    SpanDataPtr	    spanData,
-    register LineFacePtr leftFace,
-    register LineFacePtr rightFace,
-    double	    xorg,
-    double          yorg,
-    Bool	    isInt)
+    DrawablePtr		pDraw,
+    GCPtr  		pGC,
+    unsigned long	pixel,
+    SpanDataPtr		spanData,
+    LineFacePtr		leftFace,
+    LineFacePtr 	rightFace,
+    double	    	xorg,
+    double          	yorg,
+    Bool	    	isInt)
 {
     DDXPointPtr points;
     int *widths;
@@ -1116,14 +1116,14 @@ miLineArc (
 
 void
 miLineProjectingCap (pDrawable, pGC, pixel, spanData, face, isLeft, xorg, yorg, isInt)
-    DrawablePtr	    pDrawable;
-    register GCPtr  pGC;
-    unsigned long   pixel;
-    SpanDataPtr	    spanData;
-    register LineFacePtr face;
-    Bool	    isLeft;
-    double	    xorg, yorg;
-    Bool	    isInt;
+    DrawablePtr		pDrawable;
+    GCPtr  		pGC;
+    unsigned long	pixel;
+    SpanDataPtr		spanData;
+    LineFacePtr 	face;
+    Bool	    	isLeft;
+    double	    	xorg, yorg;
+    Bool	    	isInt;
 {
     int	xorgi = 0, yorgi = 0;
     int	lw;
@@ -1286,18 +1286,18 @@ miLineProjectingCap (pDrawable, pGC, pixel, spanData, face, isLeft, xorg, yorg,
 
 static void
 miWideSegment (
-    DrawablePtr	    pDrawable,
-    GCPtr	    pGC,
-    unsigned long   pixel,
-    SpanDataPtr	    spanData,
-    register int    x1,
-    register int    y1,
-    register int    x2,
-    register int    y2,
-    Bool	    projectLeft,
-    Bool	    projectRight,
-    register LineFacePtr leftFace,
-    register LineFacePtr rightFace)
+    DrawablePtr		pDrawable,
+    GCPtr		pGC,
+    unsigned long	pixel,
+    SpanDataPtr		spanData,
+    int    		x1,
+    int    		y1,
+    int    		x2,
+    int    		y2,
+    Bool		projectLeft,
+    Bool		projectRight,
+    LineFacePtr 	leftFace,
+    LineFacePtr 	rightFace)
 {
     double	l, L, r;
     double	xa, ya;
@@ -1508,7 +1508,7 @@ miWideSegment (
 
 SpanDataPtr
 miSetupSpanData (pGC, spanData, npt)
-    register GCPtr pGC;
+    GCPtr pGC;
     SpanDataPtr	spanData;
     int		npt;
 {
@@ -1552,21 +1552,21 @@ miCleanupSpanData (pDrawable, pGC, spanData)
 _X_EXPORT void
 miWideLine (pDrawable, pGC, mode, npt, pPts)
     DrawablePtr	pDrawable;
-    register GCPtr pGC;
+    GCPtr 	pGC;
     int		mode;
-    register int npt;
-    register DDXPointPtr pPts;
+    int 	npt;
+    DDXPointPtr pPts;
 {
-    int		    x1, y1, x2, y2;
-    SpanDataRec	    spanDataRec;
-    SpanDataPtr	    spanData;
-    unsigned long   pixel;
-    Bool	    projectLeft, projectRight;
-    LineFaceRec	    leftFace, rightFace, prevRightFace;
-    LineFaceRec	    firstFace;
-    register int    first;
-    Bool	    somethingDrawn = FALSE;
-    Bool	    selfJoin;
+    int		x1, y1, x2, y2;
+    SpanDataRec	spanDataRec;
+    SpanDataPtr	spanData;
+    long   	pixel;
+    Bool	projectLeft, projectRight;
+    LineFaceRec	leftFace, rightFace, prevRightFace;
+    LineFaceRec	firstFace;
+    int		first;
+    Bool	somethingDrawn = FALSE;
+    Bool	selfJoin;
 
     spanData = miSetupSpanData (pGC, &spanDataRec, npt);
     pixel = pGC->fgPixel;
@@ -1693,7 +1693,7 @@ miWideLine (pDrawable, pGC, mode, npt, pPts)
 static void
 miWideDashSegment (
     DrawablePtr	    pDrawable,
-    register GCPtr  pGC,
+    GCPtr  	    pGC,
     SpanDataPtr	    spanData,
     int		    *pDashOffset,
     int		    *pDashIndex,
@@ -2050,25 +2050,25 @@ miWideDashSegment (
 _X_EXPORT void
 miWideDash (pDrawable, pGC, mode, npt, pPts)
     DrawablePtr	pDrawable;
-    register GCPtr pGC;
+    GCPtr 	pGC;
     int		mode;
-    register int npt;
-    register DDXPointPtr pPts;
+    int 	npt;
+    DDXPointPtr pPts;
 {
-    int		    x1, y1, x2, y2;
-    unsigned long   pixel;
-    Bool	    projectLeft, projectRight;
-    LineFaceRec	    leftFace, rightFace, prevRightFace;
-    LineFaceRec	    firstFace;
-    int		    first;
-    int		    dashIndex, dashOffset;
-    register int    prevDashIndex;
-    SpanDataRec	    spanDataRec;
-    SpanDataPtr	    spanData;
-    Bool	    somethingDrawn = FALSE;
-    Bool	    selfJoin;
-    Bool	    endIsFg = FALSE, startIsFg = FALSE;
-    Bool            firstIsFg = FALSE, prevIsFg = FALSE;
+    int			x1, y1, x2, y2;
+    unsigned long	pixel;
+    Bool		projectLeft, projectRight;
+    LineFaceRec		leftFace, rightFace, prevRightFace;
+    LineFaceRec		firstFace;
+    int			first;
+    int			dashIndex, dashOffset;
+    int			prevDashIndex;
+    SpanDataRec		spanDataRec;
+    SpanDataPtr		spanData;
+    Bool		somethingDrawn = FALSE;
+    Bool		selfJoin;
+    Bool		endIsFg = FALSE, startIsFg = FALSE;
+    Bool		firstIsFg = FALSE, prevIsFg = FALSE;
 
 #if 0
     /* XXX backward compatibility */
diff --git a/mi/miwindow.c b/mi/miwindow.c
index cd6bb8df3..6ca2e1e38 100644
--- a/mi/miwindow.c
+++ b/mi/miwindow.c
@@ -160,12 +160,12 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
  */
 static Bool
 miCheckSubSaveUnder(
-    register WindowPtr	pParent,	/* Parent to check */
+    WindowPtr		pParent,	/* Parent to check */
     WindowPtr		pFirst,		/* first reconfigured window */
     RegionPtr		pRegion)	/* Initial area obscured by saveUnder */
 {
-    register WindowPtr	pChild;		/* Current child */
-    register ScreenPtr	pScreen;	/* Screen to use */
+    WindowPtr		pChild;		/* Current child */
+    ScreenPtr		pScreen;	/* Screen to use */
     RegionRec		SubRegion;	/* Area of children obscured */
     Bool		res = FALSE;	/* result */
     Bool		subInited=FALSE;/* SubRegion initialized */
@@ -268,12 +268,12 @@ miCheckSubSaveUnder(
  */
 Bool
 miChangeSaveUnder(pWin, first)
-    register WindowPtr	pWin;
+    WindowPtr		pWin;
     WindowPtr		first;		/* First window to check.
 					 * Used when pWin was restacked */
 {
     RegionRec	rgn;	/* Area obscured by saveUnder windows */
-    register ScreenPtr pScreen;
+    ScreenPtr 	pScreen;
     Bool	res;
 
     if (!deltaSaveUndersViewable && !numSaveUndersViewable)
@@ -309,7 +309,7 @@ miPostChangeSaveUnder(pWin, pFirst)
     WindowPtr		pWin;
     WindowPtr		pFirst;
 {
-    register WindowPtr pParent, pChild;
+    WindowPtr pParent, pChild;
     ChangeWindowAttributesProcPtr ChangeWindowAttributes;
 
     if (!(pParent = pWin->parent))
@@ -342,9 +342,9 @@ miPostChangeSaveUnder(pWin, pFirst)
 
 void
 miMarkWindow(pWin)
-    register WindowPtr pWin;
+    WindowPtr pWin;
 {
-    register ValidatePtr val;
+    ValidatePtr val;
 
     if (pWin->valdata)
 	return;
@@ -362,8 +362,8 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
     WindowPtr pFirst;
     WindowPtr *ppLayerWin;
 {
-    register BoxPtr box;
-    register WindowPtr pChild, pLast;
+    BoxPtr box;
+    WindowPtr pChild, pLast;
     Bool anyMarked = FALSE;
     MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow;
     ScreenPtr pScreen;
@@ -449,8 +449,8 @@ _X_EXPORT void
 miHandleValidateExposures(pWin)
     WindowPtr pWin;
 {
-    register WindowPtr pChild;
-    register ValidatePtr val;
+    WindowPtr pChild;
+    ValidatePtr val;
     ScreenPtr pScreen;
     WindowExposuresProcPtr WindowExposures;
 
@@ -487,7 +487,7 @@ miHandleValidateExposures(pWin)
 
 void
 miMoveWindow(pWin, x, y, pNextSib, kind)
-    register WindowPtr pWin;
+    WindowPtr pWin;
     int x,y;
     WindowPtr pNextSib;
     VTKind kind;
@@ -498,7 +498,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
     RegionPtr oldRegion = NULL;
     DDXPointRec oldpt;
     Bool anyMarked = FALSE;
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     WindowPtr windowToValidate;
 #ifdef DO_SAVE_UNDERS
     Bool dosave = FALSE;
@@ -576,10 +576,10 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
 
 static int
 miRecomputeExposures (
-    register WindowPtr	pWin,
+    WindowPtr	pWin,
     pointer		value) /* must conform to VisitWindowProcPtr */
 {
-    register ScreenPtr	pScreen;
+    ScreenPtr	pScreen;
     RegionPtr	pValid = (RegionPtr)value;
 
     if (pWin->valdata)
@@ -604,7 +604,7 @@ miRecomputeExposures (
 
 void
 miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
-    register WindowPtr pWin;
+    WindowPtr pWin;
     int x,y;
     unsigned int w, h;
     WindowPtr pSib;
@@ -620,11 +620,11 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
     DDXPointRec oldpt;
     RegionPtr oldRegion = NULL;
     Bool anyMarked = FALSE;
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     WindowPtr pFirstChange;
-    register WindowPtr pChild;
+    WindowPtr pChild;
     RegionPtr	gravitate[StaticGravity + 1];
-    register unsigned g;
+    unsigned g;
     int		nx, ny;		/* destination x,y */
     int		newx, newy;	/* new inner window position */
     RegionPtr	pRegion = NULL;
@@ -981,10 +981,10 @@ miGetLayerWindow(pWin)
 
 _X_EXPORT void
 miSetShape(pWin)
-    register WindowPtr	pWin;
+    WindowPtr	pWin;
 {
     Bool	WasViewable = (Bool)(pWin->viewable);
-    register ScreenPtr pScreen = pWin->drawable.pScreen;
+    ScreenPtr 	pScreen = pWin->drawable.pScreen;
     Bool	anyMarked = FALSE;
     RegionPtr	pOldClip = NULL, bsExposed;
 #ifdef DO_SAVE_UNDERS
@@ -1081,12 +1081,12 @@ miSetShape(pWin)
 
 _X_EXPORT void
 miChangeBorderWidth(pWin, width)
-    register WindowPtr pWin;
+    WindowPtr pWin;
     unsigned int width;
 {
     int oldwidth;
     Bool anyMarked = FALSE;
-    register ScreenPtr pScreen;
+    ScreenPtr pScreen;
     Bool WasViewable = (Bool)(pWin->viewable);
     Bool HadBorder;
 #ifdef DO_SAVE_UNDERS
diff --git a/mi/mizerarc.c b/mi/mizerarc.c
index 33e1acc19..f1adc9e2b 100644
--- a/mi/mizerarc.c
+++ b/mi/mizerarc.c
@@ -97,8 +97,8 @@ static miZeroArcPtRec oob = {65536, 65536, 0};
 
 _X_EXPORT Bool
 miZeroArcSetup(arc, info, ok360)
-    register xArc *arc;
-    register miZeroArcRec *info;
+    xArc *arc;
+    miZeroArcRec *info;
     Bool ok360;
 {
     int l;
@@ -404,11 +404,11 @@ miZeroArcSetup(arc, info, ok360)
 DDXPointPtr
 miZeroArcPts(arc, pts)
     xArc *arc;
-    register DDXPointPtr pts;
+    DDXPointPtr pts;
 {
     miZeroArcRec info;
-    register int x, y, a, b, d, mask;
-    register int k1, k3, dx, dy;
+    int x, y, a, b, d, mask;
+    int k1, k3, dx, dy;
     Bool do360;
 
     do360 = miZeroArcSetup(arc, &info, TRUE);
@@ -509,14 +509,14 @@ miZeroArcDashPts(
     GCPtr pGC,
     xArc *arc,
     DashInfo *dinfo,
-    register DDXPointPtr points,
+    DDXPointPtr points,
     int maxPts,
-    register DDXPointPtr *evenPts, 
-    register DDXPointPtr *oddPts )
+    DDXPointPtr *evenPts, 
+    DDXPointPtr *oddPts )
 {
     miZeroArcRec info;
-    register int x, y, a, b, d, mask;
-    register int k1, k3, dx, dy;
+    int x, y, a, b, d, mask;
+    int k1, k3, dx, dy;
     int dashRemaining;
     DDXPointPtr arcPts[4];
     DDXPointPtr startPts[5], endPts[5];
@@ -715,11 +715,11 @@ miZeroPolyArc(pDraw, pGC, narcs, parcs)
     xArc	*parcs;
 {
     int maxPts = 0;
-    register int n, maxw = 0;
-    register xArc *arc;
-    register int i;
+    int n, maxw = 0;
+    xArc *arc;
+    int i;
     DDXPointPtr points, pts, oddPts;
-    register DDXPointPtr pt;
+    DDXPointPtr pt;
     int numPts;
     Bool dospans;
     int *widths = NULL;