frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mi: remove 'register' keywords.

This commit is contained in:
Peter Hutterer 2007-03-09 14:16:23 +10:30
parent 63169ce52d
commit 4054834965
25 changed files with 556 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
mi/miarc.c
View File

@ -246,7 +246,7 @@ typedef struct _miPolyArc {
static CARD32 gcvals[6]; static CARD32 gcvals[6];
static void fillSpans(DrawablePtr pDrawable, GCPtr pGC); 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, static void drawArc(xArc *tarc, int l, int a0, int a1, miArcFacePtr right,
miArcFacePtr left); miArcFacePtr left);
static void drawZeroArc(DrawablePtr pDraw, GCPtr pGC, xArc *tarc, int lw, static void drawZeroArc(DrawablePtr pDraw, GCPtr pGC, xArc *tarc, int lw,
@ -461,11 +461,11 @@ miComputeCircleSpans(
xArc *parc, xArc *parc,
miArcSpanData *spdata) miArcSpanData *spdata)
{ {
register miArcSpan *span; miArcSpan *span;
int doinner; int doinner;
register int x, y, e; int x, y, e;
int xk, yk, xm, ym, dx, dy; int xk, yk, xm, ym, dx, dy;
register int slw, inslw; int slw, inslw;
int inx = 0, iny, ine = 0; int inx = 0, iny, ine = 0;
int inxk = 0, inyk = 0, inxm = 0, inym = 0; int inxk = 0, inyk = 0, inxm = 0, inym = 0;
@ -529,7 +529,7 @@ miComputeEllipseSpans(
xArc *parc, xArc *parc,
miArcSpanData *spdata) miArcSpanData *spdata)
{ {
register miArcSpan *span; miArcSpan *span;
double w, h, r, xorg; double w, h, r, xorg;
double Hs, Hf, WH, K, Vk, Nk, Fk, Vr, N, Nc, Z, rs; 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; double A, T, b, d, x, y, t, inx, outx = 0.0, hepp, hepm;
@ -860,12 +860,12 @@ tailX(
static miArcSpanData * static miArcSpanData *
miComputeWideEllipse( miComputeWideEllipse(
int lw, int lw,
register xArc *parc, xArc *parc,
Bool *mustFree) Bool *mustFree)
{ {
register miArcSpanData *spdata; miArcSpanData *spdata;
register arcCacheRec *cent, *lruent; arcCacheRec *cent, *lruent;
register int k; int k;
arcCacheRec fakeent; arcCacheRec fakeent;
if (!lw) if (!lw)
@ -943,14 +943,14 @@ miFillWideEllipse(
xArc *parc) xArc *parc)
{ {
DDXPointPtr points; DDXPointPtr points;
register DDXPointPtr pts; DDXPointPtr pts;
int *widths; int *widths;
register int *wids; int *wids;
miArcSpanData *spdata; miArcSpanData *spdata;
Bool mustFree; Bool mustFree;
register miArcSpan *span; miArcSpan *span;
register int xorg, yorgu, yorgl; int xorg, yorgu, yorgl;
register int n; int n;
yorgu = parc->height + pGC->lineWidth; yorgu = parc->height + pGC->lineWidth;
n = (sizeof(int) * 2) * yorgu; n = (sizeof(int) * 2) * yorgu;
@ -1077,7 +1077,7 @@ miPolyArc(pDraw, pGC, narcs, parcs)
int narcs; int narcs;
xArc *parcs; xArc *parcs;
{ {
register int i; int i;
xArc *parc; xArc *parc;
int xMin, xMax, yMin, yMax; int xMin, xMax, yMin, yMax;
int pixmapWidth = 0, pixmapHeight = 0; int pixmapWidth = 0, pixmapHeight = 0;
@ -3139,9 +3139,9 @@ static struct finalSpanChunk *chunks;
struct finalSpan * struct finalSpan *
realAllocSpan () realAllocSpan ()
{ {
register struct finalSpanChunk *newChunk; struct finalSpanChunk *newChunk;
register struct finalSpan *span; struct finalSpan *span;
register int i; int i;
newChunk = (struct finalSpanChunk *) xalloc (sizeof (struct finalSpanChunk)); newChunk = (struct finalSpanChunk *) xalloc (sizeof (struct finalSpanChunk));
if (!newChunk) if (!newChunk)
@ -3179,12 +3179,12 @@ fillSpans (
DrawablePtr pDrawable, DrawablePtr pDrawable,
GCPtr pGC) GCPtr pGC)
{ {
register struct finalSpan *span; struct finalSpan *span;
register DDXPointPtr xSpan; DDXPointPtr xSpan;
register int *xWidth; int *xWidth;
register int i; int i;
register struct finalSpan **f; struct finalSpan **f;
register int spany; int spany;
DDXPointPtr xSpans; DDXPointPtr xSpans;
int *xWidths; int *xWidths;
@ -3280,11 +3280,11 @@ realFindSpan (int y)
static void static void
newFinalSpan ( newFinalSpan (
int y, int y,
register int xmin, int xmin,
register int xmax) int xmax)
{ {
register struct finalSpan *x; struct finalSpan *x;
register struct finalSpan **f; struct finalSpan **f;
struct finalSpan *oldx; struct finalSpan *oldx;
struct finalSpan *prev; struct finalSpan *prev;

4
mi/mibitblt.c
View File

@ -76,8 +76,8 @@ extern int ffs(int);
_X_EXPORT RegionPtr _X_EXPORT RegionPtr
miCopyArea(pSrcDrawable, pDstDrawable, miCopyArea(pSrcDrawable, pDstDrawable,
pGC, xIn, yIn, widthSrc, heightSrc, xOut, yOut) pGC, xIn, yIn, widthSrc, heightSrc, xOut, yOut)
register DrawablePtr pSrcDrawable; DrawablePtr pSrcDrawable;
register DrawablePtr pDstDrawable; DrawablePtr pDstDrawable;
GCPtr pGC; GCPtr pGC;
int xIn, yIn; int xIn, yIn;
int widthSrc, heightSrc; int widthSrc, heightSrc;

48
mi/mibstore.c
View File

@ -152,11 +152,11 @@ static void miBSClearBackingRegion(WindowPtr pWin, RegionPtr pRgn);
#define copyData(src,dst,n,morecopy) \ #define copyData(src,dst,n,morecopy) \
{ \ { \
register short *srcCopy = (short *)(src); \ short *srcCopy = (short *)(src); \
register short *dstCopy = (short *)(dst); \ short *dstCopy = (short *)(dst); \
register int i; \ int i; \
register int bsx = pBackingStore->x; \ int bsx = pBackingStore->x; \
register int bsy = pBackingStore->y; \ int bsy = pBackingStore->y; \
for (i = n; --i >= 0; ) \ for (i = n; --i >= 0; ) \
{ \ { \
*dstCopy++ = *srcCopy++ - bsx; \ *dstCopy++ = *srcCopy++ - bsx; \
@ -1010,7 +1010,7 @@ miBSSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted)
DrawablePtr pDrawable; DrawablePtr pDrawable;
GCPtr pGC; GCPtr pGC;
char *psrc; char *psrc;
register DDXPointPtr ppt; DDXPointPtr ppt;
int *pwidth; int *pwidth;
int nspans; int nspans;
int fSorted; int fSorted;
@ -1150,8 +1150,8 @@ miBSDoCopy(
} *boxes; /* Array of box/drawable pairs covering } *boxes; /* Array of box/drawable pairs covering
* source box. */ * source box. */
int *sequence; /* Sequence of boxes to move */ int *sequence; /* Sequence of boxes to move */
register int i, j, k, l, y; int i, j, k, l, y;
register BoxPtr pBox; BoxPtr pBox;
int dx, dy, nrects; int dx, dy, nrects;
Bool graphicsExposures; Bool graphicsExposures;
CopyPlaneProcPtr pixCopyProc; CopyPlaneProcPtr pixCopyProc;
@ -1591,7 +1591,7 @@ static RegionPtr
miBSCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane) miBSCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane)
DrawablePtr pSrc; DrawablePtr pSrc;
DrawablePtr pDst; DrawablePtr pDst;
register GC *pGC; GC *pGC;
int srcx, int srcx,
srcy; srcy;
int w, int w,
@ -1901,9 +1901,9 @@ miBSPolyArc(pDrawable, pGC, narcs, parcs)
static void static void
miBSFillPolygon(pDrawable, pGC, shape, mode, count, pPts) miBSFillPolygon(pDrawable, pGC, shape, mode, count, pPts)
DrawablePtr pDrawable; DrawablePtr pDrawable;
register GCPtr pGC; GCPtr pGC;
int shape, mode; int shape, mode;
register int count; int count;
DDXPointPtr pPts; DDXPointPtr pPts;
{ {
DDXPointPtr pPtsCopy; DDXPointPtr pPtsCopy;
@ -2546,8 +2546,8 @@ static void
miBSAllocate(pWin) miBSAllocate(pWin)
WindowPtr pWin; WindowPtr pWin;
{ {
register miBSWindowPtr pBackingStore; miBSWindowPtr pBackingStore;
register ScreenPtr pScreen; ScreenPtr pScreen;
if (pWin->drawable.pScreen->backingStoreSupport == NotUseful) if (pWin->drawable.pScreen->backingStoreSupport == NotUseful)
return; return;
@ -2648,7 +2648,7 @@ miBSFree(pWin)
WindowPtr pWin; WindowPtr pWin;
{ {
miBSWindowPtr pBackingStore; miBSWindowPtr pBackingStore;
register ScreenPtr pScreen; ScreenPtr pScreen;
pScreen = pWin->drawable.pScreen; pScreen = pWin->drawable.pScreen;
@ -2792,7 +2792,7 @@ miResizeBackingStore(
*/ */
static void static void
miBSSaveDoomedAreas(pWin, pObscured, dx, dy) miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
register WindowPtr pWin; WindowPtr pWin;
RegionPtr pObscured; RegionPtr pObscured;
int dx, dy; int dx, dy;
{ {
@ -2899,14 +2899,14 @@ miBSSaveDoomedAreas(pWin, pObscured, dx, dy)
*/ */
static RegionPtr static RegionPtr
miBSRestoreAreas(pWin, prgnExposed) miBSRestoreAreas(pWin, prgnExposed)
register WindowPtr pWin; WindowPtr pWin;
RegionPtr prgnExposed; RegionPtr prgnExposed;
{ {
PixmapPtr pBackingPixmap; PixmapPtr pBackingPixmap;
miBSWindowPtr pBackingStore; miBSWindowPtr pBackingStore;
RegionPtr prgnSaved; RegionPtr prgnSaved;
RegionPtr prgnRestored; RegionPtr prgnRestored;
register ScreenPtr pScreen; ScreenPtr pScreen;
RegionPtr exposures = prgnExposed; RegionPtr exposures = prgnExposed;
pScreen = pWin->drawable.pScreen; pScreen = pWin->drawable.pScreen;
@ -3097,10 +3097,10 @@ miBSTranslateBackingStore(pWin, windx, windy, oldClip, oldx, oldy)
int oldx; /* old window position */ int oldx; /* old window position */
int oldy; int oldy;
{ {
register miBSWindowPtr pBackingStore; miBSWindowPtr pBackingStore;
register RegionPtr pSavedRegion; RegionPtr pSavedRegion;
register RegionPtr newSaved, doomed; RegionPtr newSaved, doomed;
register ScreenPtr pScreen; ScreenPtr pScreen;
BoxRec extents; BoxRec extents;
int scrdx; /* bit translation distance on screen */ int scrdx; /* bit translation distance on screen */
int scrdy; int scrdy;
@ -3815,9 +3815,9 @@ miBSExposeCopy (pSrc, pDst, pGC, prgnExposed, srcx, srcy, dstx, dsty, plane)
miBSWindowPtr pBackingStore; miBSWindowPtr pBackingStore;
CopyPlaneProcPtr copyProc; CopyPlaneProcPtr copyProc;
GCPtr pScratchGC; GCPtr pScratchGC;
register BoxPtr pBox; BoxPtr pBox;
register int i; int i;
register int dx, dy; int dx, dy;
BITS32 gcMask; BITS32 gcMask;
if (!REGION_NOTEMPTY(pGC->pScreen, prgnExposed)) if (!REGION_NOTEMPTY(pGC->pScreen, prgnExposed))

12
mi/micmap.c
View File

@ -125,8 +125,8 @@ miResolveColor(unsigned short *pred, unsigned short *pgreen,
_X_EXPORT Bool _X_EXPORT Bool
miInitializeColormap(ColormapPtr pmap) miInitializeColormap(ColormapPtr pmap)
{ {
register unsigned i; unsigned i;
register VisualPtr pVisual; VisualPtr pVisual;
unsigned lim, maxent, shift; unsigned lim, maxent, shift;
pVisual = pmap->pVisual; pVisual = pmap->pVisual;
@ -211,13 +211,13 @@ _X_EXPORT int
miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs, miExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs,
xColorItem *outdefs) xColorItem *outdefs)
{ {
register int red, green, blue; int red, green, blue;
int maxred, maxgreen, maxblue; int maxred, maxgreen, maxblue;
int stepred, stepgreen, stepblue; int stepred, stepgreen, stepblue;
VisualPtr pVisual; VisualPtr pVisual;
register int pixel; int pixel;
register int nresult; int nresult;
register int i; int i;
pVisual = pmap->pVisual; pVisual = pmap->pVisual;

32
mi/miexpose.c
View File

@ -130,15 +130,15 @@ exposing is done by the backing store's GraphicsExpose function, of course.
_X_EXPORT RegionPtr _X_EXPORT RegionPtr
miHandleExposures(pSrcDrawable, pDstDrawable, miHandleExposures(pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty, plane) pGC, srcx, srcy, width, height, dstx, dsty, plane)
register DrawablePtr pSrcDrawable; DrawablePtr pSrcDrawable;
register DrawablePtr pDstDrawable; DrawablePtr pDstDrawable;
GCPtr pGC; GCPtr pGC;
int srcx, srcy; int srcx, srcy;
int width, height; int width, height;
int dstx, dsty; int dstx, dsty;
unsigned long plane; unsigned long plane;
{ {
register ScreenPtr pscr; ScreenPtr pscr;
RegionPtr prgnSrcClip; /* drawable-relative source clip */ RegionPtr prgnSrcClip; /* drawable-relative source clip */
RegionRec rgnSrcRec; RegionRec rgnSrcRec;
RegionPtr prgnDstClip; /* drawable-relative dest clip */ RegionPtr prgnDstClip; /* drawable-relative dest clip */
@ -387,9 +387,9 @@ miSendGraphicsExpose (client, pRgn, drawable, major, minor)
if (pRgn && !REGION_NIL(pRgn)) if (pRgn && !REGION_NIL(pRgn))
{ {
xEvent *pEvent; xEvent *pEvent;
register xEvent *pe; xEvent *pe;
register BoxPtr pBox; BoxPtr pBox;
register int i; int i;
int numRects; int numRects;
numRects = REGION_NUM_RECTS(pRgn); numRects = REGION_NUM_RECTS(pRgn);
@ -431,12 +431,12 @@ void
miSendExposures(pWin, pRgn, dx, dy) miSendExposures(pWin, pRgn, dx, dy)
WindowPtr pWin; WindowPtr pWin;
RegionPtr pRgn; RegionPtr pRgn;
register int dx, dy; int dx, dy;
{ {
register BoxPtr pBox; BoxPtr pBox;
int numRects; int numRects;
register xEvent *pEvent, *pe; xEvent *pEvent, *pe;
register int i; int i;
pBox = REGION_RECTS(pRgn); pBox = REGION_RECTS(pRgn);
numRects = REGION_NUM_RECTS(pRgn); numRects = REGION_NUM_RECTS(pRgn);
@ -493,7 +493,7 @@ miSendExposures(pWin, pRgn, dx, dy)
_X_EXPORT void _X_EXPORT void
miWindowExposures(pWin, prgn, other_exposed) miWindowExposures(pWin, prgn, other_exposed)
WindowPtr pWin; WindowPtr pWin;
register RegionPtr prgn, other_exposed; RegionPtr prgn, other_exposed;
{ {
RegionPtr exposures = prgn; RegionPtr exposures = prgn;
if (pWin->backStorage && prgn) if (pWin->backStorage && prgn)
@ -629,7 +629,7 @@ tossGC (
_X_EXPORT void _X_EXPORT void
miPaintWindow(pWin, prgn, what) miPaintWindow(pWin, prgn, what)
register WindowPtr pWin; WindowPtr pWin;
RegionPtr prgn; RegionPtr prgn;
int what; int what;
{ {
@ -657,10 +657,10 @@ int what;
BoxRec box; BoxRec box;
WindowPtr pBgWin; WindowPtr pBgWin;
GCPtr pGC; GCPtr pGC;
register int i; int i;
register BoxPtr pbox; BoxPtr pbox;
register ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
register xRectangle *prect; xRectangle *prect;
int numRects; int numRects;
gcmask = 0; gcmask = 0;

56
mi/mifillarc.c
View File

@ -54,8 +54,8 @@ Author: Bob Scheifler, MIT X Consortium
_X_EXPORT void _X_EXPORT void
miFillArcSetup(arc, info) miFillArcSetup(arc, info)
register xArc *arc; xArc *arc;
register miFillArcRec *info; miFillArcRec *info;
{ {
info->y = arc->height >> 1; info->y = arc->height >> 1;
info->dy = arc->height & 1; info->dy = arc->height & 1;
@ -109,8 +109,8 @@ miFillArcSetup(arc, info)
void void
miFillArcDSetup(arc, info) miFillArcDSetup(arc, info)
register xArc *arc; xArc *arc;
register miFillArcDRec *info; miFillArcDRec *info;
{ {
/* h^2 * (2x - 2xorg)^2 = w^2 * h^2 - w^2 * (2y - 2yorg)^2 */ /* h^2 * (2x - 2xorg)^2 = w^2 * h^2 - w^2 * (2y - 2yorg)^2 */
/* even: xorg = yorg = 0 odd: xorg = .5, yorg = -.5 */ /* even: xorg = yorg = 0 odd: xorg = .5, yorg = -.5 */
@ -141,13 +141,13 @@ miFillArcDSetup(arc, info)
static void static void
miGetArcEdge( miGetArcEdge(
register xArc *arc, xArc *arc,
register miSliceEdgePtr edge, miSliceEdgePtr edge,
int k, int k,
Bool top, Bool top,
Bool left ) Bool left )
{ {
register int xady, y; int xady, y;
y = arc->height >> 1; y = arc->height >> 1;
if (!(arc->width & 1)) if (!(arc->width & 1))
@ -271,13 +271,13 @@ miEllipseAngleToSlope (angle, width, height, dxp, dyp, d_dxp, d_dyp)
static void static void
miGetPieEdge( miGetPieEdge(
register xArc *arc, xArc *arc,
register int angle, int angle,
register miSliceEdgePtr edge, miSliceEdgePtr edge,
Bool top, Bool top,
Bool left ) Bool left )
{ {
register int k; int k;
int dx, dy; int dx, dy;
miEllipseAngleToSlope (angle, arc->width, arc->height, &dx, &dy, 0, 0); miEllipseAngleToSlope (angle, arc->width, arc->height, &dx, &dy, 0, 0);
@ -316,11 +316,11 @@ miGetPieEdge(
_X_EXPORT void _X_EXPORT void
miFillArcSliceSetup(arc, slice, pGC) miFillArcSliceSetup(arc, slice, pGC)
register xArc *arc; xArc *arc;
register miArcSliceRec *slice; miArcSliceRec *slice;
GCPtr pGC; GCPtr pGC;
{ {
register int angle1, angle2; int angle1, angle2;
angle1 = arc->angle1; angle1 = arc->angle1;
if (arc->angle2 < 0) if (arc->angle2 < 0)
@ -550,14 +550,14 @@ miFillEllipseI(
GCPtr pGC, GCPtr pGC,
xArc *arc ) xArc *arc )
{ {
register int x, y, e; int x, y, e;
int yk, xk, ym, xm, dx, dy, xorg, yorg; int yk, xk, ym, xm, dx, dy, xorg, yorg;
int slw; int slw;
miFillArcRec info; miFillArcRec info;
DDXPointPtr points; DDXPointPtr points;
register DDXPointPtr pts; DDXPointPtr pts;
int *widths; int *widths;
register int *wids; int *wids;
points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height); points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height);
if (!points) if (!points)
@ -593,14 +593,14 @@ miFillEllipseD(
GCPtr pGC, GCPtr pGC,
xArc *arc ) xArc *arc )
{ {
register int x, y; int x, y;
int xorg, yorg, dx, dy, slw; int xorg, yorg, dx, dy, slw;
double e, yk, xk, ym, xm; double e, yk, xk, ym, xm;
miFillArcDRec info; miFillArcDRec info;
DDXPointPtr points; DDXPointPtr points;
register DDXPointPtr pts; DDXPointPtr pts;
int *widths; int *widths;
register int *wids; int *wids;
points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height); points = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * arc->height);
if (!points) if (!points)
@ -659,14 +659,14 @@ miFillArcSliceI(
xArc *arc ) xArc *arc )
{ {
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw; int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
register int x, y, e; int x, y, e;
miFillArcRec info; miFillArcRec info;
miArcSliceRec slice; miArcSliceRec slice;
int ya, xl, xr, xc; int ya, xl, xr, xc;
DDXPointPtr points; DDXPointPtr points;
register DDXPointPtr pts; DDXPointPtr pts;
int *widths; int *widths;
register int *wids; int *wids;
miFillArcSetup(arc, &info); miFillArcSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC); miFillArcSliceSetup(arc, &slice, pGC);
@ -721,16 +721,16 @@ miFillArcSliceD(
GCPtr pGC, GCPtr pGC,
xArc *arc ) xArc *arc )
{ {
register int x, y; int x, y;
int dx, dy, xorg, yorg, slw; int dx, dy, xorg, yorg, slw;
double e, yk, xk, ym, xm; double e, yk, xk, ym, xm;
miFillArcDRec info; miFillArcDRec info;
miArcSliceRec slice; miArcSliceRec slice;
int ya, xl, xr, xc; int ya, xl, xr, xc;
DDXPointPtr points; DDXPointPtr points;
register DDXPointPtr pts; DDXPointPtr pts;
int *widths; int *widths;
register int *wids; int *wids;
miFillArcDSetup(arc, &info); miFillArcDSetup(arc, &info);
miFillArcSliceSetup(arc, &slice, pGC); miFillArcSliceSetup(arc, &slice, pGC);
@ -790,8 +790,8 @@ miPolyFillArc(pDraw, pGC, narcs, parcs)
int narcs; int narcs;
xArc *parcs; xArc *parcs;
{ {
register int i; int i;
register xArc *arc; xArc *arc;
for(i = narcs, arc = parcs; --i >= 0; arc++) for(i = narcs, arc = parcs; --i >= 0; arc++)
{ {

12
mi/mifillrct.c
View File

@ -74,16 +74,16 @@ miPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
xRectangle *prectInit; /* Pointer to first rectangle to fill */ xRectangle *prectInit; /* Pointer to first rectangle to fill */
{ {
int i; int i;
register int height; int height;
register int width; int width;
register xRectangle *prect; xRectangle *prect;
int xorg; int xorg;
register int yorg; int yorg;
int maxheight; int maxheight;
DDXPointPtr pptFirst; DDXPointPtr pptFirst;
register DDXPointPtr ppt; DDXPointPtr ppt;
int *pwFirst; int *pwFirst;
register int *pw; int *pw;
if (pGC->miTranslate) if (pGC->miTranslate)
{ {

8
mi/mifpolycon.c
View File

@ -55,7 +55,7 @@ SOFTWARE.
#include "pixmapstr.h" #include "pixmapstr.h"
#include "mifpoly.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); int *by, int *ty);
#ifdef ICEILTEMPDECL #ifdef ICEILTEMPDECL
@ -101,7 +101,7 @@ miFillSppPoly(dst, pgc, count, ptsIn, xTrans, yTrans, xFtrans, yFtrans)
*width, *width,
*FirstWidth, /* output buffer */ *FirstWidth, /* output buffer */
*Marked; /* set if this vertex has been used */ *Marked; /* set if this vertex has been used */
register int left, right, /* indices to first endpoints */ int left, right, /* indices to first endpoints */
nextleft, nextleft,
nextright; /* indices to second endpoints */ nextright; /* indices to second endpoints */
DDXPointPtr ptsOut, DDXPointPtr ptsOut,
@ -251,13 +251,13 @@ miFillSppPoly(dst, pgc, count, ptsIn, xTrans, yTrans, xFtrans, yFtrans)
static static
int int
GetFPolyYBounds( GetFPolyYBounds(
register SppPointPtr pts, SppPointPtr pts,
int n, int n,
double yFtrans, double yFtrans,
int *by, int *by,
int *ty) int *ty)
{ {
register SppPointPtr ptMin; SppPointPtr ptMin;
double ymin, ymax; double ymin, ymax;
SppPointPtr ptsStart = pts; SppPointPtr ptsStart = pts;

12
mi/miglblt.c
View File

@ -95,14 +95,14 @@ miPolyGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
int nbyLine; /* bytes per line of padded pixmap */ int nbyLine; /* bytes per line of padded pixmap */
FontPtr pfont; FontPtr pfont;
GCPtr pGCtmp; GCPtr pGCtmp;
register int i; int i;
register int j; int j;
unsigned char *pbits; /* buffer for PutImage */ unsigned char *pbits; /* buffer for PutImage */
register unsigned char *pb; /* temp pointer into buffer */ unsigned char *pb; /* temp pointer into buffer */
register CharInfoPtr pci; /* currect char info */ CharInfoPtr pci; /* currect char info */
register unsigned char *pglyph; /* pointer bits in glyph */ unsigned char *pglyph; /* pointer bits in glyph */
int gWidth, gHeight; /* width and height of glyph */ int gWidth, gHeight; /* width and height of glyph */
register int nbyGlyphWidth; /* bytes per scanline of glyph */ int nbyGlyphWidth; /* bytes per scanline of glyph */
int nbyPadGlyph; /* server padded line of glyph */ int nbyPadGlyph; /* server padded line of glyph */
XID gcvals[3]; XID gcvals[3];

2
mi/miline.h
View File

@ -109,7 +109,7 @@ extern void miSetZeroLineBias(
} }
#define SWAPINT(i, j) \ #define SWAPINT(i, j) \
{ register int _t = i; i = j; j = _t; } { int _t = i; i = j; j = _t; }
#define SWAPPT(i, j) \ #define SWAPPT(i, j) \
{ DDXPointRec _t; _t = i; i = j; j = _t; } { DDXPointRec _t; _t = i; i = j; j = _t; }

10
mi/mioverlay.c
View File

@ -1019,7 +1019,7 @@ miOverlayMoveWindow(
static void static void
miOverlayWindowExposures( miOverlayWindowExposures(
WindowPtr pWin, WindowPtr pWin,
register RegionPtr prgn, RegionPtr prgn,
RegionPtr other_exposed RegionPtr other_exposed
){ ){
RegionPtr exposures = prgn; RegionPtr exposures = prgn;
@ -1106,7 +1106,7 @@ miOverlayRecomputeExposures (
WindowPtr pWin, WindowPtr pWin,
pointer value pointer value
){ ){
register ScreenPtr pScreen; ScreenPtr pScreen;
miOverlayTwoRegions *pValid = (miOverlayTwoRegions*)value; miOverlayTwoRegions *pValid = (miOverlayTwoRegions*)value;
miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin); miOverlayTreePtr pTree = MIOVERLAY_GET_WINDOW_TREE(pWin);
@ -1161,10 +1161,10 @@ miOverlayResizeWindow(
DDXPointRec oldpt; DDXPointRec oldpt;
RegionPtr oldRegion = NULL, oldRegion2 = NULL; RegionPtr oldRegion = NULL, oldRegion2 = NULL;
WindowPtr pFirstChange; WindowPtr pFirstChange;
register WindowPtr pChild; WindowPtr pChild;
RegionPtr gravitate[StaticGravity + 1]; RegionPtr gravitate[StaticGravity + 1];
RegionPtr gravitate2[StaticGravity + 1]; RegionPtr gravitate2[StaticGravity + 1];
register unsigned g; unsigned g;
int nx, ny; /* destination x,y */ int nx, ny; /* destination x,y */
int newx, newy; /* new inner window position */ int newx, newy; /* new inner window position */
RegionPtr pRegion = NULL; RegionPtr pRegion = NULL;
@ -1669,7 +1669,7 @@ miOverlayChangeBorderWidth(
unsigned int width unsigned int width
){ ){
int oldwidth; int oldwidth;
register ScreenPtr pScreen; ScreenPtr pScreen;
Bool WasViewable = (Bool)(pWin->viewable); Bool WasViewable = (Bool)(pWin->viewable);
Bool HadBorder; Bool HadBorder;
#ifdef DO_SAVE_UNDERS #ifdef DO_SAVE_UNDERS

8
mi/mipoly.c
View File

@ -70,14 +70,14 @@ SOFTWARE.
_X_EXPORT void _X_EXPORT void
miFillPolygon(dst, pgc, shape, mode, count, pPts) miFillPolygon(dst, pgc, shape, mode, count, pPts)
DrawablePtr dst; DrawablePtr dst;
register GCPtr pgc; GCPtr pgc;
int shape, mode; int shape, mode;
register int count; int count;
DDXPointPtr pPts; DDXPointPtr pPts;
{ {
int i; int i;
register int xorg, yorg; int xorg, yorg;
register DDXPointPtr ppt; DDXPointPtr ppt;
if (count == 0) if (count == 0)
return; return;

8
mi/mipolycon.c
View File

@ -78,9 +78,9 @@ miFillConvexPoly(dst, pgc, count, ptsIn)
int count; /* number of points */ int count; /* number of points */
DDXPointPtr ptsIn; /* the points */ DDXPointPtr ptsIn; /* the points */
{ {
register int xl = 0, xr = 0; /* x vals of left and right edges */ int xl = 0, xr = 0; /* x vals of left and right edges */
register int dl = 0, dr = 0; /* decision variables */ int dl = 0, dr = 0; /* decision variables */
register int ml = 0, m1l = 0;/* left edge slope and slope+1 */ int ml = 0, m1l = 0;/* left edge slope and slope+1 */
int mr = 0, m1r = 0; /* right 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 incr1l = 0, incr2l = 0; /* left edge error increments */
int incr1r = 0, incr2r = 0; /* right edge error increments */ int incr1r = 0, incr2r = 0; /* right edge error increments */
@ -221,7 +221,7 @@ miFillConvexPoly(dst, pgc, count, ptsIn)
static int static int
getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty) getPolyYBounds(DDXPointPtr pts, int n, int *by, int *ty)
{ {
register DDXPointPtr ptMin; DDXPointPtr ptMin;
int ymin, ymax; int ymin, ymax;
DDXPointPtr ptsStart = pts; DDXPointPtr ptsStart = pts;

12
mi/mipolygen.c
View File

@ -72,12 +72,12 @@ miFillGeneralPoly(dst, pgc, count, ptsIn)
int count; /* number of points */ int count; /* number of points */
DDXPointPtr ptsIn; /* the points */ DDXPointPtr ptsIn; /* the points */
{ {
register EdgeTableEntry *pAET; /* the Active Edge Table */ EdgeTableEntry *pAET; /* the Active Edge Table */
register int y; /* the current scanline */ int y; /* the current scanline */
register int nPts = 0; /* number of pts in buffer */ int nPts = 0; /* number of pts in buffer */
register EdgeTableEntry *pWETE; /* Winding Edge Table */ EdgeTableEntry *pWETE; /* Winding Edge Table */
register ScanLineList *pSLL; /* Current ScanLineList */ ScanLineList *pSLL; /* Current ScanLineList */
register DDXPointPtr ptsOut; /* ptr to output buffers */ DDXPointPtr ptsOut; /* ptr to output buffers */
int *width; int *width;
DDXPointRec FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */ DDXPointRec FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
int FirstWidth[NUMPTSTOBUFFER]; int FirstWidth[NUMPTSTOBUFFER];

2
mi/mipolypnt.c
View File

@ -70,7 +70,7 @@ miPolyPoint(pDrawable, pGC, mode, npt, pptInit)
XID fsOld, fsNew; XID fsOld, fsNew;
int *pwidthInit, *pwidth; int *pwidthInit, *pwidth;
int i; int i;
register xPoint *ppt; xPoint *ppt;
/* make pointlist origin relative */ /* make pointlist origin relative */
if (mode == CoordModePrevious) if (mode == CoordModePrevious)

42
mi/mipolyutil.c
View File

@ -81,8 +81,8 @@ miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
ScanLineListBlock **SLLBlock; ScanLineListBlock **SLLBlock;
int *iSLLBlock; int *iSLLBlock;
{ {
register EdgeTableEntry *start, *prev; EdgeTableEntry *start, *prev;
register ScanLineList *pSLL, *pPrevSLL; ScanLineList *pSLL, *pPrevSLL;
ScanLineListBlock *tmpSLLBlock; ScanLineListBlock *tmpSLLBlock;
/* /*
@ -166,15 +166,15 @@ miInsertEdgeInET(ET, ETE, scanline, SLLBlock, iSLLBlock)
Bool Bool
miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock) miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
register int count; int count;
register DDXPointPtr pts; DDXPointPtr pts;
EdgeTable *ET; EdgeTable *ET;
EdgeTableEntry *AET; EdgeTableEntry *AET;
register EdgeTableEntry *pETEs; EdgeTableEntry *pETEs;
ScanLineListBlock *pSLLBlock; ScanLineListBlock *pSLLBlock;
{ {
register DDXPointPtr top, bottom; DDXPointPtr top, bottom;
register DDXPointPtr PrevPt, CurrPt; DDXPointPtr PrevPt, CurrPt;
int iSLLBlock = 0; int iSLLBlock = 0;
int dy; int dy;
@ -262,10 +262,10 @@ miCreateETandAET(count, pts, ET, AET, pETEs, pSLLBlock)
void void
miloadAET(AET, ETEs) miloadAET(AET, ETEs)
register EdgeTableEntry *AET, *ETEs; EdgeTableEntry *AET, *ETEs;
{ {
register EdgeTableEntry *pPrevAET; EdgeTableEntry *pPrevAET;
register EdgeTableEntry *tmp; EdgeTableEntry *tmp;
pPrevAET = AET; pPrevAET = AET;
AET = AET->next; AET = AET->next;
@ -310,11 +310,11 @@ miloadAET(AET, ETEs)
*/ */
void void
micomputeWAET(AET) micomputeWAET(AET)
register EdgeTableEntry *AET; EdgeTableEntry *AET;
{ {
register EdgeTableEntry *pWETE; EdgeTableEntry *pWETE;
register int inside = 1; int inside = 1;
register int isInside = 0; int isInside = 0;
AET->nextWETE = (EdgeTableEntry *)NULL; AET->nextWETE = (EdgeTableEntry *)NULL;
pWETE = AET; pWETE = AET;
@ -349,12 +349,12 @@ micomputeWAET(AET)
int int
miInsertionSort(AET) miInsertionSort(AET)
register EdgeTableEntry *AET; EdgeTableEntry *AET;
{ {
register EdgeTableEntry *pETEchase; EdgeTableEntry *pETEchase;
register EdgeTableEntry *pETEinsert; EdgeTableEntry *pETEinsert;
register EdgeTableEntry *pETEchaseBackTMP; EdgeTableEntry *pETEchaseBackTMP;
register int changed = 0; int changed = 0;
AET = AET->next; AET = AET->next;
while (AET) while (AET)
@ -386,9 +386,9 @@ miInsertionSort(AET)
*/ */
void void
miFreeStorage(pSLLBlock) miFreeStorage(pSLLBlock)
register ScanLineListBlock *pSLLBlock; ScanLineListBlock *pSLLBlock;
{ {
register ScanLineListBlock *tmpSLLBlock; ScanLineListBlock *tmpSLLBlock;
while (pSLLBlock) while (pSLLBlock)
{ {

8
mi/mipushpxl.c
View File

@ -86,10 +86,10 @@ miPushPixels(pGC, pBitMap, pDrawable, dx, dy, xOrg, yOrg)
{ {
int h, dxDivPPW, ibEnd; int h, dxDivPPW, ibEnd;
MiBits *pwLineStart; MiBits *pwLineStart;
register MiBits *pw, *pwEnd; MiBits *pw, *pwEnd;
register MiBits msk; MiBits msk;
register int ib, w; int ib, w;
register int ipt; /* index into above arrays */ int ipt; /* index into above arrays */
Bool fInBox; Bool fInBox;
DDXPointRec pt[NPT], ptThisLine; DDXPointRec pt[NPT], ptThisLine;
int width[NPT]; int width[NPT];

224
mi/miregion.c
View File

@ -228,7 +228,7 @@ miPrintRegion(rgn)
RegionPtr rgn; RegionPtr rgn;
{ {
int num, size; int num, size;
register int i; int i;
BoxPtr rects; BoxPtr rects;
num = REGION_NUM_RECTS(rgn); num = REGION_NUM_RECTS(rgn);
@ -275,7 +275,7 @@ Bool
miValidRegion(reg) miValidRegion(reg)
RegionPtr reg; RegionPtr reg;
{ {
register int i, numRects; int i, numRects;
if ((reg->extents.x1 > reg->extents.x2) || if ((reg->extents.x1 > reg->extents.x2) ||
(reg->extents.y1 > reg->extents.y2)) (reg->extents.y1 > reg->extents.y2))
@ -289,7 +289,7 @@ miValidRegion(reg)
return (!reg->data); return (!reg->data);
else else
{ {
register BoxPtr pboxP, pboxN; BoxPtr pboxP, pboxN;
BoxRec box; BoxRec box;
pboxP = REGION_RECTS(reg); pboxP = REGION_RECTS(reg);
@ -331,7 +331,7 @@ miRegionCreate(rect, size)
BoxPtr rect; BoxPtr rect;
int size; int size;
{ {
register RegionPtr pReg; RegionPtr pReg;
pReg = (RegionPtr)xalloc(sizeof(RegionRec)); pReg = (RegionPtr)xalloc(sizeof(RegionRec));
if (!pReg) if (!pReg)
@ -414,7 +414,7 @@ miRegionBreak (pReg)
_X_EXPORT Bool _X_EXPORT Bool
miRectAlloc( miRectAlloc(
register RegionPtr pRgn, RegionPtr pRgn,
int n) int n)
{ {
RegDataPtr data; RegDataPtr data;
@ -455,8 +455,8 @@ miRectAlloc(
_X_EXPORT Bool _X_EXPORT Bool
miRegionCopy(dst, src) miRegionCopy(dst, src)
register RegionPtr dst; RegionPtr dst;
register RegionPtr src; RegionPtr src;
{ {
good(dst); good(dst);
good(src); good(src);
@ -508,14 +508,14 @@ miRegionCopy(dst, src)
*/ */
INLINE static int INLINE static int
miCoalesce ( miCoalesce (
register RegionPtr pReg, /* Region to coalesce */ RegionPtr pReg, /* Region to coalesce */
int prevStart, /* Index of start of previous band */ int prevStart, /* Index of start of previous band */
int curStart) /* Index of start of current band */ int curStart) /* Index of start of current band */
{ {
register BoxPtr pPrevBox; /* Current box in previous band */ BoxPtr pPrevBox; /* Current box in previous band */
register BoxPtr pCurBox; /* Current box in current band */ BoxPtr pCurBox; /* Current box in current band */
register int numRects; /* Number rectangles in both bands */ int numRects; /* Number rectangles in both bands */
register int y2; /* Bottom of current band */ int y2; /* Bottom of current band */
/* /*
* Figure out how many rectangles are in the band. * Figure out how many rectangles are in the band.
*/ */
@ -592,14 +592,14 @@ miCoalesce (
INLINE static Bool INLINE static Bool
miAppendNonO ( miAppendNonO (
register RegionPtr pReg, RegionPtr pReg,
register BoxPtr r, BoxPtr r,
BoxPtr rEnd, BoxPtr rEnd,
register int y1, int y1,
register int y2) int y2)
{ {
register BoxPtr pNextRect; BoxPtr pNextRect;
register int newRects; int newRects;
newRects = rEnd - r; newRects = rEnd - r;
@ -691,8 +691,8 @@ miRegionOp(
/* in region 2 ? */ /* in region 2 ? */
Bool *pOverlap) Bool *pOverlap)
{ {
register BoxPtr r1; /* Pointer into first region */ BoxPtr r1; /* Pointer into first region */
register BoxPtr r2; /* Pointer into 2d region */ BoxPtr r2; /* Pointer into 2d region */
BoxPtr r1End; /* End of 1st region */ BoxPtr r1End; /* End of 1st region */
BoxPtr r2End; /* End of 2d region */ BoxPtr r2End; /* End of 2d region */
short ybot; /* Bottom of intersection */ short ybot; /* Bottom of intersection */
@ -702,12 +702,12 @@ miRegionOp(
* previous band in newReg */ * previous band in newReg */
int curBand; /* Index of start of current int curBand; /* Index of start of current
* band in newReg */ * band in newReg */
register BoxPtr r1BandEnd; /* End of current band in r1 */ BoxPtr r1BandEnd; /* End of current band in r1 */
register BoxPtr r2BandEnd; /* End of current band in r2 */ BoxPtr r2BandEnd; /* End of current band in r2 */
short top; /* Top of non-overlapping band */ short top; /* Top of non-overlapping band */
short bot; /* Bottom of non-overlapping band*/ short bot; /* Bottom of non-overlapping band*/
register int r1y1; /* Temps for r1->y1 and r2->y1 */ int r1y1; /* Temps for r1->y1 and r2->y1 */
register int r2y1; int r2y1;
int newSize; int newSize;
int numRects; int numRects;
@ -915,9 +915,9 @@ miRegionOp(
*/ */
void void
miSetExtents (pReg) miSetExtents (pReg)
register RegionPtr pReg; RegionPtr pReg;
{ {
register BoxPtr pBox, pBoxEnd; BoxPtr pBox, pBoxEnd;
if (!pReg->data) if (!pReg->data)
return; return;
@ -974,18 +974,18 @@ miSetExtents (pReg)
/*ARGSUSED*/ /*ARGSUSED*/
static Bool static Bool
miIntersectO ( miIntersectO (
register RegionPtr pReg, RegionPtr pReg,
register BoxPtr r1, BoxPtr r1,
BoxPtr r1End, BoxPtr r1End,
register BoxPtr r2, BoxPtr r2,
BoxPtr r2End, BoxPtr r2End,
short y1, short y1,
short y2, short y2,
Bool *pOverlap) Bool *pOverlap)
{ {
register int x1; int x1;
register int x2; int x2;
register BoxPtr pNextRect; BoxPtr pNextRect;
pNextRect = REGION_TOP(pReg); pNextRect = REGION_TOP(pReg);
@ -1022,9 +1022,9 @@ miIntersectO (
_X_EXPORT Bool _X_EXPORT Bool
miIntersect(newReg, reg1, reg2) miIntersect(newReg, reg1, reg2)
register RegionPtr newReg; /* destination Region */ RegionPtr newReg; /* destination Region */
register RegionPtr reg1; RegionPtr reg1;
register RegionPtr reg2; /* source regions */ RegionPtr reg2; /* source regions */
{ {
good(reg1); good(reg1);
good(reg2); good(reg2);
@ -1117,18 +1117,18 @@ miIntersect(newReg, reg1, reg2)
*/ */
static Bool static Bool
miUnionO ( miUnionO (
register RegionPtr pReg, RegionPtr pReg,
register BoxPtr r1, BoxPtr r1,
BoxPtr r1End, BoxPtr r1End,
register BoxPtr r2, BoxPtr r2,
BoxPtr r2End, BoxPtr r2End,
short y1, short y1,
short y2, short y2,
Bool *pOverlap) Bool *pOverlap)
{ {
register BoxPtr pNextRect; BoxPtr pNextRect;
register int x1; /* left and right side of current union */ int x1; /* left and right side of current union */
register int x2; int x2;
assert (y1 < y2); assert (y1 < y2);
assert(r1 != r1End && r2 != r2End); assert(r1 != r1End && r2 != r2End);
@ -1178,8 +1178,8 @@ miUnionO (
_X_EXPORT Bool _X_EXPORT Bool
miUnion(newReg, reg1, reg2) miUnion(newReg, reg1, reg2)
RegionPtr newReg; /* destination Region */ RegionPtr newReg; /* destination Region */
register RegionPtr reg1; RegionPtr reg1;
register RegionPtr reg2; /* source regions */ RegionPtr reg2; /* source regions */
{ {
Bool overlap; /* result ignored */ Bool overlap; /* result ignored */
@ -1276,8 +1276,8 @@ miUnion(newReg, reg1, reg2)
*/ */
_X_EXPORT Bool _X_EXPORT Bool
miRegionAppend(dstrgn, rgn) miRegionAppend(dstrgn, rgn)
register RegionPtr dstrgn; RegionPtr dstrgn;
register RegionPtr rgn; RegionPtr rgn;
{ {
int numRects, dnumRects, size; int numRects, dnumRects, size;
BoxPtr new, old; BoxPtr new, old;
@ -1307,7 +1307,7 @@ miRegionAppend(dstrgn, rgn)
dstrgn->extents = rgn->extents; dstrgn->extents = rgn->extents;
else if (dstrgn->extents.x2 > dstrgn->extents.x1) else if (dstrgn->extents.x2 > dstrgn->extents.x1)
{ {
register BoxPtr first, last; BoxPtr first, last;
first = old; first = old;
last = REGION_BOXPTR(dstrgn) + (dnumRects - 1); last = REGION_BOXPTR(dstrgn) + (dnumRects - 1);
@ -1371,13 +1371,13 @@ miRegionAppend(dstrgn, rgn)
static void static void
QuickSortRects( QuickSortRects(
register BoxRec rects[], BoxRec rects[],
register int numRects) int numRects)
{ {
register int y1; int y1;
register int x1; int x1;
register int i, j; int i, j;
register BoxPtr r; BoxPtr r;
/* Always called with numRects > 1 */ /* Always called with numRects > 1 */
@ -1477,12 +1477,12 @@ miRegionValidate(badreg, pOverlap)
int numRI; /* Number of entries used in ri */ int numRI; /* Number of entries used in ri */
int sizeRI; /* Number of entries available in ri */ int sizeRI; /* Number of entries available in ri */
int i; /* Index into rects */ int i; /* Index into rects */
register int j; /* Index into ri */ int j; /* Index into ri */
register RegionInfo *rit; /* &ri[j] */ RegionInfo *rit; /* &ri[j] */
register RegionPtr reg; /* ri[j].reg */ RegionPtr reg; /* ri[j].reg */
register BoxPtr box; /* Current box in rects */ BoxPtr box; /* Current box in rects */
register BoxPtr riBox; /* Last box in ri[j].reg */ BoxPtr riBox; /* Last box in ri[j].reg */
register RegionPtr hreg; /* ri[j_half].reg */ RegionPtr hreg; /* ri[j_half].reg */
Bool ret = TRUE; Bool ret = TRUE;
*pOverlap = FALSE; *pOverlap = FALSE;
@ -1654,13 +1654,13 @@ bail:
_X_EXPORT RegionPtr _X_EXPORT RegionPtr
miRectsToRegion(nrects, prect, ctype) miRectsToRegion(nrects, prect, ctype)
int nrects; int nrects;
register xRectangle *prect; xRectangle *prect;
int ctype; int ctype;
{ {
register RegionPtr pRgn; RegionPtr pRgn;
register RegDataPtr pData; RegDataPtr pData;
register BoxPtr pBox; BoxPtr pBox;
register int i; int i;
int x1, y1, x2, y2; int x1, y1, x2, y2;
pRgn = miRegionCreate(NullBox, 0); pRgn = miRegionCreate(NullBox, 0);
@ -1754,17 +1754,17 @@ miRectsToRegion(nrects, prect, ctype)
/*ARGSUSED*/ /*ARGSUSED*/
static Bool static Bool
miSubtractO ( miSubtractO (
register RegionPtr pReg, RegionPtr pReg,
register BoxPtr r1, BoxPtr r1,
BoxPtr r1End, BoxPtr r1End,
register BoxPtr r2, BoxPtr r2,
BoxPtr r2End, BoxPtr r2End,
register short y1, short y1,
short y2, short y2,
Bool *pOverlap) Bool *pOverlap)
{ {
register BoxPtr pNextRect; BoxPtr pNextRect;
register int x1; int x1;
x1 = r1->x1; x1 = r1->x1;
@ -1878,9 +1878,9 @@ miSubtractO (
*/ */
_X_EXPORT Bool _X_EXPORT Bool
miSubtract(regD, regM, regS) miSubtract(regD, regM, regS)
register RegionPtr regD; RegionPtr regD;
register RegionPtr regM; RegionPtr regM;
register RegionPtr regS; RegionPtr regS;
{ {
Bool overlap; /* result ignored */ Bool overlap; /* result ignored */
@ -2003,13 +2003,13 @@ miInverse(newReg, reg1, invRect)
_X_EXPORT int _X_EXPORT int
miRectIn(region, prect) miRectIn(region, prect)
register RegionPtr region; RegionPtr region;
register BoxPtr prect; BoxPtr prect;
{ {
register int x; int x;
register int y; int y;
register BoxPtr pbox; BoxPtr pbox;
register BoxPtr pboxEnd; BoxPtr pboxEnd;
int partIn, partOut; int partIn, partOut;
int numRects; int numRects;
@ -2099,13 +2099,13 @@ miRectIn(region, prect)
_X_EXPORT void _X_EXPORT void
miTranslateRegion(pReg, x, y) miTranslateRegion(pReg, x, y)
register RegionPtr pReg; RegionPtr pReg;
register int x; int x;
register int y; int y;
{ {
int x1, x2, y1, y2; int x1, x2, y1, y2;
register int nbox; int nbox;
register BoxPtr pbox; BoxPtr pbox;
good(pReg); good(pReg);
pReg->extents.x1 = x1 = pReg->extents.x1 + x; pReg->extents.x1 = x1 = pReg->extents.x1 + x;
@ -2144,7 +2144,7 @@ miTranslateRegion(pReg, x, y)
pReg->extents.y2 = MAXSHORT; pReg->extents.y2 = MAXSHORT;
if (pReg->data && (nbox = pReg->data->numRects)) if (pReg->data && (nbox = pReg->data->numRects))
{ {
register BoxPtr pboxout; BoxPtr pboxout;
for (pboxout = pbox = REGION_BOXPTR(pReg); nbox--; pbox++) for (pboxout = pbox = REGION_BOXPTR(pReg); nbox--; pbox++)
{ {
@ -2184,8 +2184,8 @@ miTranslateRegion(pReg, x, y)
Bool Bool
miRegionDataCopy( miRegionDataCopy(
register RegionPtr dst, RegionPtr dst,
register RegionPtr src) RegionPtr src)
{ {
good(dst); good(dst);
good(src); good(src);
@ -2226,11 +2226,11 @@ miRegionReset(pReg, pBox)
_X_EXPORT Bool _X_EXPORT Bool
miPointInRegion(pReg, x, y, box) miPointInRegion(pReg, x, y, box)
register RegionPtr pReg; RegionPtr pReg;
register int x, y; int x, y;
BoxPtr box; /* "return" value */ BoxPtr box; /* "return" value */
{ {
register BoxPtr pbox, pboxEnd; BoxPtr pbox, pboxEnd;
int numRects; int numRects;
good(pReg); good(pReg);
@ -2295,7 +2295,7 @@ miRegionExtents(pReg)
#define ExchangeSpans(a, b) \ #define ExchangeSpans(a, b) \
{ \ { \
DDXPointRec tpt; \ DDXPointRec tpt; \
register int tw; \ int tw; \
\ \
tpt = spans[a]; spans[a] = spans[b]; spans[b] = tpt; \ tpt = spans[a]; spans[a] = spans[b]; spans[b] = tpt; \
tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \ tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \
@ -2307,13 +2307,13 @@ miRegionExtents(pReg)
*/ */
static void QuickSortSpans( static void QuickSortSpans(
register DDXPointRec spans[], DDXPointRec spans[],
register int widths[], int widths[],
register int numSpans) int numSpans)
{ {
register int y; int y;
register int i, j, m; int i, j, m;
register DDXPointPtr r; DDXPointPtr r;
/* Always called with numSpans > 1 */ /* Always called with numSpans > 1 */
/* Sorts only by y, doesn't bother to sort by x */ /* Sorts only by y, doesn't bother to sort by x */
@ -2323,7 +2323,7 @@ static void QuickSortSpans(
if (numSpans < 9) if (numSpans < 9)
{ {
/* Do insertion sort */ /* Do insertion sort */
register int yprev; int yprev;
yprev = spans[0].y; yprev = spans[0].y;
i = 1; i = 1;
@ -2413,17 +2413,17 @@ static void QuickSortSpans(
_X_EXPORT int _X_EXPORT int
miClipSpans( miClipSpans(
RegionPtr prgnDst, RegionPtr prgnDst,
register DDXPointPtr ppt, DDXPointPtr ppt,
register int *pwidth, int *pwidth,
int nspans, int nspans,
register DDXPointPtr pptNew, DDXPointPtr pptNew,
int *pwidthNew, int *pwidthNew,
int fSorted) int fSorted)
{ {
register DDXPointPtr pptLast; DDXPointPtr pptLast;
int *pwidthNewStart; /* the vengeance of Xerox! */ int *pwidthNewStart; /* the vengeance of Xerox! */
register int y, x1, x2; int y, x1, x2;
register int numRects; int numRects;
good(prgnDst); good(prgnDst);
pptLast = ppt + nspans; pptLast = ppt + nspans;
@ -2435,7 +2435,7 @@ miClipSpans(
/* It doesn't pay much to make use of fSorted in this case, /* It doesn't pay much to make use of fSorted in this case,
so we lump everything together. */ so we lump everything together. */
register int clipx1, clipx2, clipy1, clipy2; int clipx1, clipx2, clipy1, clipy2;
clipx1 = prgnDst->extents.x1; clipx1 = prgnDst->extents.x1;
clipy1 = prgnDst->extents.y1; clipy1 = prgnDst->extents.y1;
@ -2468,9 +2468,9 @@ miClipSpans(
{ {
/* Have to clip against many boxes */ /* Have to clip against many boxes */
BoxPtr pboxBandStart, pboxBandEnd; BoxPtr pboxBandStart, pboxBandEnd;
register BoxPtr pbox; BoxPtr pbox;
register BoxPtr pboxLast; BoxPtr pboxLast;
register int clipy1, clipy2; int clipy1, clipy2;
/* In this case, taking advantage of sorted spans gains more than /* In this case, taking advantage of sorted spans gains more than
the sorting costs. */ the sorting costs. */
@ -2493,7 +2493,7 @@ miClipSpans(
x2 = x1 + *pwidth; x2 = x1 + *pwidth;
do do
{ /* For each box in band */ { /* For each box in band */
register int newx1, newx2; int newx1, newx2;
newx1 = x1; newx1 = x1;
newx2 = x2; newx2 = x2;
@ -2531,10 +2531,10 @@ _X_EXPORT int
miFindMaxBand(prgn) miFindMaxBand(prgn)
RegionPtr prgn; RegionPtr prgn;
{ {
register int nbox; int nbox;
register BoxPtr pbox; BoxPtr pbox;
register int nThisBand; int nThisBand;
register int nMaxBand = 0; int nMaxBand = 0;
short yThisBand; short yThisBand;
good(prgn); good(prgn);

4
mi/miscrinit.c
View File

@ -185,7 +185,7 @@ miCreateScreenResources(pScreen)
Bool Bool
miScreenDevPrivateInit(pScreen, width, pbits) miScreenDevPrivateInit(pScreen, width, pbits)
register ScreenPtr pScreen; ScreenPtr pScreen;
int width; int width;
pointer pbits; pointer pbits;
{ {
@ -207,7 +207,7 @@ miScreenDevPrivateInit(pScreen, width, pbits)
_X_EXPORT Bool _X_EXPORT Bool
miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width, miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
rootDepth, numDepths, depths, rootVisual, numVisuals, visuals) rootDepth, numDepths, depths, rootVisual, numVisuals, visuals)
register ScreenPtr pScreen; ScreenPtr pScreen;
pointer pbits; /* pointer to screen bits */ pointer pbits; /* pointer to screen bits */
int xsize, ysize; /* in pixels */ int xsize, ysize; /* in pixels */
int dpix, dpiy; /* dots per inch */ int dpix, dpiy; /* dots per inch */

50
mi/mispans.c
View File

@ -188,8 +188,8 @@ void miAppendSpans(spanGroup, otherGroup, spans)
SpanGroup *otherGroup; SpanGroup *otherGroup;
Spans *spans; Spans *spans;
{ {
register int ymin, ymax; int ymin, ymax;
register int spansCount; int spansCount;
spansCount = spans->count; spansCount = spans->count;
if (spansCount > 0) { if (spansCount > 0) {
@ -226,13 +226,13 @@ void miFreeSpanGroup(spanGroup)
} }
static void QuickSortSpansX( static void QuickSortSpansX(
register DDXPointRec points[], DDXPointRec points[],
register int widths[], int widths[],
register int numSpans ) int numSpans )
{ {
register int x; int x;
register int i, j, m; int i, j, m;
register DDXPointPtr r; DDXPointPtr r;
/* Always called with numSpans > 1 */ /* Always called with numSpans > 1 */
/* Sorts only by x, as all y should be the same */ /* Sorts only by x, as all y should be the same */
@ -240,7 +240,7 @@ static void QuickSortSpansX(
#define ExchangeSpans(a, b) \ #define ExchangeSpans(a, b) \
{ \ { \
DDXPointRec tpt; \ DDXPointRec tpt; \
register int tw; \ int tw; \
\ \
tpt = points[a]; points[a] = points[b]; points[b] = tpt; \ tpt = points[a]; points[a] = points[b]; points[b] = tpt; \
tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \ tw = widths[a]; widths[a] = widths[b]; widths[b] = tw; \
@ -249,7 +249,7 @@ static void QuickSortSpansX(
do { do {
if (numSpans < 9) { if (numSpans < 9) {
/* Do insertion sort */ /* Do insertion sort */
register int xprev; int xprev;
xprev = points[0].x; xprev = points[0].x;
i = 1; i = 1;
@ -314,12 +314,12 @@ static void QuickSortSpansX(
static int UniquifySpansX( static int UniquifySpansX(
Spans *spans, Spans *spans,
register DDXPointRec *newPoints, DDXPointRec *newPoints,
register int *newWidths ) int *newWidths )
{ {
register int newx1, newx2, oldpt, i, y; int newx1, newx2, oldpt, i, y;
register DDXPointRec *oldPoints; DDXPointRec *oldPoints;
register int *oldWidths; int *oldWidths;
int *startNewWidths; int *startNewWidths;
/* Always called with numSpans > 1 */ /* Always called with numSpans > 1 */
@ -384,16 +384,16 @@ void miFillUniqueSpanGroup(pDraw, pGC, spanGroup)
GCPtr pGC; GCPtr pGC;
SpanGroup *spanGroup; SpanGroup *spanGroup;
{ {
register int i; int i;
register Spans *spans; Spans *spans;
register Spans *yspans; Spans *yspans;
register int *ysizes; int *ysizes;
register int ymin, ylength; int ymin, ylength;
/* Outgoing spans for one big call to FillSpans */ /* Outgoing spans for one big call to FillSpans */
register DDXPointPtr points; DDXPointPtr points;
register int *widths; int *widths;
register int count; int count;
if (spanGroup->count == 0) return; if (spanGroup->count == 0) return;
@ -545,8 +545,8 @@ void miFillSpanGroup(pDraw, pGC, spanGroup)
GCPtr pGC; GCPtr pGC;
SpanGroup *spanGroup; SpanGroup *spanGroup;
{ {
register int i; int i;
register Spans *spans; Spans *spans;
for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) { for (i = 0, spans = spanGroup->group; i != spanGroup->count; i++, spans++) {
(*pGC->ops->FillSpans) (*pGC->ops->FillSpans)

8
mi/misprite.c
View File

@ -320,10 +320,10 @@ miSpriteGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart)
if (pDrawable->type == DRAWABLE_WINDOW && pScreenPriv->isUp) if (pDrawable->type == DRAWABLE_WINDOW && pScreenPriv->isUp)
{ {
register DDXPointPtr pts; DDXPointPtr pts;
register int *widths; int *widths;
register int nPts; int nPts;
register int xorg, int xorg,
yorg; yorg;
xorg = pDrawable->x; xorg = pDrawable->x;

24
mi/mivaltree.c
View File

@ -112,13 +112,13 @@ miShapedWindowIn (pScreen, universe, bounding, rect, x, y)
ScreenPtr pScreen; ScreenPtr pScreen;
RegionPtr universe, bounding; RegionPtr universe, bounding;
BoxPtr rect; BoxPtr rect;
register int x, y; int x, y;
{ {
BoxRec box; BoxRec box;
register BoxPtr boundBox; BoxPtr boundBox;
int nbox; int nbox;
Bool someIn, someOut; Bool someIn, someOut;
register int t, x1, y1, x2, y2; int t, x1, y1, x2, y2;
nbox = REGION_NUM_RECTS (bounding); nbox = REGION_NUM_RECTS (bounding);
boundBox = REGION_RECTS (bounding); boundBox = REGION_RECTS (bounding);
@ -202,16 +202,16 @@ miRegisterRedirectBorderClipProc (SetRedirectBorderClipProcPtr setBorderClip,
*/ */
static void static void
miComputeClips ( miComputeClips (
register WindowPtr pParent, WindowPtr pParent,
register ScreenPtr pScreen, ScreenPtr pScreen,
register RegionPtr universe, RegionPtr universe,
VTKind kind, VTKind kind,
RegionPtr exposed ) /* for intermediate calculations */ RegionPtr exposed ) /* for intermediate calculations */
{ {
int dx, int dx,
dy; dy;
RegionRec childUniverse; RegionRec childUniverse;
register WindowPtr pChild; WindowPtr pChild;
int oldVis, newVis; int oldVis, newVis;
BoxRec borderSize; BoxRec borderSize;
RegionRec childUnion; RegionRec childUnion;
@ -535,10 +535,10 @@ miComputeClips (
static void static void
miTreeObscured( miTreeObscured(
register WindowPtr pParent ) WindowPtr pParent )
{ {
register WindowPtr pChild; WindowPtr pChild;
register int oldVis; int oldVis;
pChild = pParent; pChild = pParent;
while (1) while (1)
@ -609,8 +609,8 @@ miValidateTree (pParent, pChild, kind)
RegionRec childUnion; /* the space covered by borderSize for RegionRec childUnion; /* the space covered by borderSize for
* all marked children */ * all marked children */
RegionRec exposed; /* For intermediate calculations */ RegionRec exposed; /* For intermediate calculations */
register ScreenPtr pScreen; ScreenPtr pScreen;
register WindowPtr pWin; WindowPtr pWin;
Bool overlap; Bool overlap;
int viewvals; int viewvals;
Bool forward; Bool forward;

102
mi/miwideline.c
View File

@ -56,10 +56,10 @@ from The Open Group.
ICEILTEMPDECL ICEILTEMPDECL
#endif #endif
static void miLineArc(DrawablePtr pDraw, register GCPtr pGC, static void miLineArc(DrawablePtr pDraw, GCPtr pGC,
unsigned long pixel, SpanDataPtr spanData, unsigned long pixel, SpanDataPtr spanData,
register LineFacePtr leftFace, LineFacePtr leftFace,
register LineFacePtr rightFace, LineFacePtr rightFace,
double xorg, double yorg, Bool isInt); double xorg, double yorg, Bool isInt);
@ -79,12 +79,12 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
PolyEdgePtr left, right; PolyEdgePtr left, right;
int left_count, right_count; 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_stepx = 0;
int left_signdx = 0; int left_signdx = 0;
int left_dy = 0, left_dx = 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_stepx = 0;
int right_signdx = 0; int right_signdx = 0;
int right_dy = 0, right_dx = 0; int right_dy = 0, right_dx = 0;
@ -92,9 +92,9 @@ miFillPolyHelper (pDrawable, pGC, pixel, spanData, y, overall_height,
int height = 0; int height = 0;
int left_height = 0, right_height = 0; int left_height = 0, right_height = 0;
register DDXPointPtr ppt; DDXPointPtr ppt;
DDXPointPtr pptInit = NULL; DDXPointPtr pptInit = NULL;
register int *pwidth; int *pwidth;
int *pwidthInit = NULL; int *pwidthInit = NULL;
XID oldPixel; XID oldPixel;
int xorg; int xorg;
@ -203,8 +203,8 @@ miFillRectPolyHelper (
int w, int w,
int h) int h)
{ {
register DDXPointPtr ppt; DDXPointPtr ppt;
register int *pwidth; int *pwidth;
XID oldPixel; XID oldPixel;
Spans spanRec; Spans spanRec;
xRectangle rect; xRectangle rect;
@ -265,10 +265,10 @@ _X_EXPORT /* static */ int
miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge) miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
double x0, y0; double x0, y0;
double k; /* x0 * dy - y0 * dx */ double k; /* x0 * dy - y0 * dx */
register int dx, dy; int dx, dy;
int xi, yi; int xi, yi;
int left; int left;
register PolyEdgePtr edge; PolyEdgePtr edge;
{ {
int x, y, e; int x, y, e;
int xady; int xady;
@ -322,8 +322,8 @@ miPolyBuildEdge (x0, y0, k, dx, dy, xi, yi, left, edge)
_X_EXPORT /* static */ int _X_EXPORT /* static */ int
miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright, h) miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright, h)
register PolyVertexPtr vertices; PolyVertexPtr vertices;
register PolySlopePtr slopes; PolySlopePtr slopes;
int count; int count;
int xi, yi; int xi, yi;
PolyEdgePtr left, right; PolyEdgePtr left, right;
@ -332,12 +332,12 @@ miPolyBuildPoly (vertices, slopes, count, xi, yi, left, right, pnleft, pnright,
{ {
int top, bottom; int top, bottom;
double miny, maxy; double miny, maxy;
register int i; int i;
int j; int j;
int clockwise; int clockwise;
int slopeoff; int slopeoff;
register int s; int s;
register int nright, nleft; int nright, nleft;
int y, lasty = 0, bottomy, topy = 0; int y, lasty = 0, bottomy, topy = 0;
/* find the top of the polygon */ /* find the top of the polygon */
@ -471,8 +471,8 @@ miLineJoin (
GCPtr pGC, GCPtr pGC,
unsigned long pixel, unsigned long pixel,
SpanDataPtr spanData, SpanDataPtr spanData,
register LineFacePtr pLeft, LineFacePtr pLeft,
register LineFacePtr pRight) LineFacePtr pRight)
{ {
double mx = 0, my = 0; double mx = 0, my = 0;
double denom = 0.0; double denom = 0.0;
@ -624,9 +624,9 @@ miLineArcI (
DDXPointPtr points, DDXPointPtr points,
int *widths) int *widths)
{ {
register DDXPointPtr tpts, bpts; DDXPointPtr tpts, bpts;
register int *twids, *bwids; int *twids, *bwids;
register int x, y, e, ex, slw; int x, y, e, ex, slw;
tpts = points; tpts = points;
twids = widths; twids = widths;
@ -717,8 +717,8 @@ miLineArcD (
int edgey2, int edgey2,
Bool edgeleft2) Bool edgeleft2)
{ {
register DDXPointPtr pts; DDXPointPtr pts;
register int *wids; int *wids;
double radius, x0, y0, el, er, yk, xlk, xrk, k; double radius, x0, y0, el, er, yk, xlk, xrk, k;
int xbase, ybase, y, boty, xl, xr, xcl, xcr; int xbase, ybase, y, boty, xl, xr, xcl, xcr;
int ymin, ymax; int ymin, ymax;
@ -875,8 +875,8 @@ miLineArcD (
int int
miRoundJoinFace (face, edge, leftEdge) miRoundJoinFace (face, edge, leftEdge)
register LineFacePtr face; LineFacePtr face;
register PolyEdgePtr edge; PolyEdgePtr edge;
Bool *leftEdge; Bool *leftEdge;
{ {
int y; int y;
@ -924,7 +924,7 @@ miRoundJoinFace (face, edge, leftEdge)
_X_EXPORT void _X_EXPORT void
miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2) miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
register LineFacePtr pLeft, pRight; LineFacePtr pLeft, pRight;
PolyEdgePtr edge1, edge2; PolyEdgePtr edge1, edge2;
int *y1, *y2; int *y1, *y2;
Bool *left1, *left2; Bool *left1, *left2;
@ -949,13 +949,13 @@ miRoundJoinClip (pLeft, pRight, edge1, edge2, y1, y2, left1, left2)
_X_EXPORT int _X_EXPORT int
miRoundCapClip (face, isInt, edge, leftEdge) miRoundCapClip (face, isInt, edge, leftEdge)
register LineFacePtr face; LineFacePtr face;
Bool isInt; Bool isInt;
register PolyEdgePtr edge; PolyEdgePtr edge;
Bool *leftEdge; Bool *leftEdge;
{ {
int y; int y;
register int dx, dy; int dx, dy;
double xa, ya, k; double xa, ya, k;
Bool left; Bool left;
@ -1000,11 +1000,11 @@ miRoundCapClip (face, isInt, edge, leftEdge)
static void static void
miLineArc ( miLineArc (
DrawablePtr pDraw, DrawablePtr pDraw,
register GCPtr pGC, GCPtr pGC,
unsigned long pixel, unsigned long pixel,
SpanDataPtr spanData, SpanDataPtr spanData,
register LineFacePtr leftFace, LineFacePtr leftFace,
register LineFacePtr rightFace, LineFacePtr rightFace,
double xorg, double xorg,
double yorg, double yorg,
Bool isInt) Bool isInt)
@ -1117,10 +1117,10 @@ miLineArc (
void void
miLineProjectingCap (pDrawable, pGC, pixel, spanData, face, isLeft, xorg, yorg, isInt) miLineProjectingCap (pDrawable, pGC, pixel, spanData, face, isLeft, xorg, yorg, isInt)
DrawablePtr pDrawable; DrawablePtr pDrawable;
register GCPtr pGC; GCPtr pGC;
unsigned long pixel; unsigned long pixel;
SpanDataPtr spanData; SpanDataPtr spanData;
register LineFacePtr face; LineFacePtr face;
Bool isLeft; Bool isLeft;
double xorg, yorg; double xorg, yorg;
Bool isInt; Bool isInt;
@ -1290,14 +1290,14 @@ miWideSegment (
GCPtr pGC, GCPtr pGC,
unsigned long pixel, unsigned long pixel,
SpanDataPtr spanData, SpanDataPtr spanData,
register int x1, int x1,
register int y1, int y1,
register int x2, int x2,
register int y2, int y2,
Bool projectLeft, Bool projectLeft,
Bool projectRight, Bool projectRight,
register LineFacePtr leftFace, LineFacePtr leftFace,
register LineFacePtr rightFace) LineFacePtr rightFace)
{ {
double l, L, r; double l, L, r;
double xa, ya; double xa, ya;
@ -1508,7 +1508,7 @@ miWideSegment (
SpanDataPtr SpanDataPtr
miSetupSpanData (pGC, spanData, npt) miSetupSpanData (pGC, spanData, npt)
register GCPtr pGC; GCPtr pGC;
SpanDataPtr spanData; SpanDataPtr spanData;
int npt; int npt;
{ {
@ -1552,19 +1552,19 @@ miCleanupSpanData (pDrawable, pGC, spanData)
_X_EXPORT void _X_EXPORT void
miWideLine (pDrawable, pGC, mode, npt, pPts) miWideLine (pDrawable, pGC, mode, npt, pPts)
DrawablePtr pDrawable; DrawablePtr pDrawable;
register GCPtr pGC; GCPtr pGC;
int mode; int mode;
register int npt; int npt;
register DDXPointPtr pPts; DDXPointPtr pPts;
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
SpanDataRec spanDataRec; SpanDataRec spanDataRec;
SpanDataPtr spanData; SpanDataPtr spanData;
unsigned long pixel; long pixel;
Bool projectLeft, projectRight; Bool projectLeft, projectRight;
LineFaceRec leftFace, rightFace, prevRightFace; LineFaceRec leftFace, rightFace, prevRightFace;
LineFaceRec firstFace; LineFaceRec firstFace;
register int first; int first;
Bool somethingDrawn = FALSE; Bool somethingDrawn = FALSE;
Bool selfJoin; Bool selfJoin;
@ -1693,7 +1693,7 @@ miWideLine (pDrawable, pGC, mode, npt, pPts)
static void static void
miWideDashSegment ( miWideDashSegment (
DrawablePtr pDrawable, DrawablePtr pDrawable,
register GCPtr pGC, GCPtr pGC,
SpanDataPtr spanData, SpanDataPtr spanData,
int *pDashOffset, int *pDashOffset,
int *pDashIndex, int *pDashIndex,
@ -2050,10 +2050,10 @@ miWideDashSegment (
_X_EXPORT void _X_EXPORT void
miWideDash (pDrawable, pGC, mode, npt, pPts) miWideDash (pDrawable, pGC, mode, npt, pPts)
DrawablePtr pDrawable; DrawablePtr pDrawable;
register GCPtr pGC; GCPtr pGC;
int mode; int mode;
register int npt; int npt;
register DDXPointPtr pPts; DDXPointPtr pPts;
{ {
int x1, y1, x2, y2; int x1, y1, x2, y2;
unsigned long pixel; unsigned long pixel;
@ -2062,7 +2062,7 @@ miWideDash (pDrawable, pGC, mode, npt, pPts)
LineFaceRec firstFace; LineFaceRec firstFace;
int first; int first;
int dashIndex, dashOffset; int dashIndex, dashOffset;
register int prevDashIndex; int prevDashIndex;
SpanDataRec spanDataRec; SpanDataRec spanDataRec;
SpanDataPtr spanData; SpanDataPtr spanData;
Bool somethingDrawn = FALSE; Bool somethingDrawn = FALSE;

48
mi/miwindow.c
View File

@ -160,12 +160,12 @@ miClearToBackground(pWin, x, y, w, h, generateExposures)
*/ */
static Bool static Bool
miCheckSubSaveUnder( miCheckSubSaveUnder(
register WindowPtr pParent, /* Parent to check */ WindowPtr pParent, /* Parent to check */
WindowPtr pFirst, /* first reconfigured window */ WindowPtr pFirst, /* first reconfigured window */
RegionPtr pRegion) /* Initial area obscured by saveUnder */ RegionPtr pRegion) /* Initial area obscured by saveUnder */
{ {
register WindowPtr pChild; /* Current child */ WindowPtr pChild; /* Current child */
register ScreenPtr pScreen; /* Screen to use */ ScreenPtr pScreen; /* Screen to use */
RegionRec SubRegion; /* Area of children obscured */ RegionRec SubRegion; /* Area of children obscured */
Bool res = FALSE; /* result */ Bool res = FALSE; /* result */
Bool subInited=FALSE;/* SubRegion initialized */ Bool subInited=FALSE;/* SubRegion initialized */
@ -268,12 +268,12 @@ miCheckSubSaveUnder(
*/ */
Bool Bool
miChangeSaveUnder(pWin, first) miChangeSaveUnder(pWin, first)
register WindowPtr pWin; WindowPtr pWin;
WindowPtr first; /* First window to check. WindowPtr first; /* First window to check.
* Used when pWin was restacked */ * Used when pWin was restacked */
{ {
RegionRec rgn; /* Area obscured by saveUnder windows */ RegionRec rgn; /* Area obscured by saveUnder windows */
register ScreenPtr pScreen; ScreenPtr pScreen;
Bool res; Bool res;
if (!deltaSaveUndersViewable && !numSaveUndersViewable) if (!deltaSaveUndersViewable && !numSaveUndersViewable)
@ -309,7 +309,7 @@ miPostChangeSaveUnder(pWin, pFirst)
WindowPtr pWin; WindowPtr pWin;
WindowPtr pFirst; WindowPtr pFirst;
{ {
register WindowPtr pParent, pChild; WindowPtr pParent, pChild;
ChangeWindowAttributesProcPtr ChangeWindowAttributes; ChangeWindowAttributesProcPtr ChangeWindowAttributes;
if (!(pParent = pWin->parent)) if (!(pParent = pWin->parent))
@ -342,9 +342,9 @@ miPostChangeSaveUnder(pWin, pFirst)
void void
miMarkWindow(pWin) miMarkWindow(pWin)
register WindowPtr pWin; WindowPtr pWin;
{ {
register ValidatePtr val; ValidatePtr val;
if (pWin->valdata) if (pWin->valdata)
return; return;
@ -362,8 +362,8 @@ miMarkOverlappedWindows(pWin, pFirst, ppLayerWin)
WindowPtr pFirst; WindowPtr pFirst;
WindowPtr *ppLayerWin; WindowPtr *ppLayerWin;
{ {
register BoxPtr box; BoxPtr box;
register WindowPtr pChild, pLast; WindowPtr pChild, pLast;
Bool anyMarked = FALSE; Bool anyMarked = FALSE;
MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow; MarkWindowProcPtr MarkWindow = pWin->drawable.pScreen->MarkWindow;
ScreenPtr pScreen; ScreenPtr pScreen;
@ -449,8 +449,8 @@ _X_EXPORT void
miHandleValidateExposures(pWin) miHandleValidateExposures(pWin)
WindowPtr pWin; WindowPtr pWin;
{ {
register WindowPtr pChild; WindowPtr pChild;
register ValidatePtr val; ValidatePtr val;
ScreenPtr pScreen; ScreenPtr pScreen;
WindowExposuresProcPtr WindowExposures; WindowExposuresProcPtr WindowExposures;
@ -487,7 +487,7 @@ miHandleValidateExposures(pWin)
void void
miMoveWindow(pWin, x, y, pNextSib, kind) miMoveWindow(pWin, x, y, pNextSib, kind)
register WindowPtr pWin; WindowPtr pWin;
int x,y; int x,y;
WindowPtr pNextSib; WindowPtr pNextSib;
VTKind kind; VTKind kind;
@ -498,7 +498,7 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
RegionPtr oldRegion = NULL; RegionPtr oldRegion = NULL;
DDXPointRec oldpt; DDXPointRec oldpt;
Bool anyMarked = FALSE; Bool anyMarked = FALSE;
register ScreenPtr pScreen; ScreenPtr pScreen;
WindowPtr windowToValidate; WindowPtr windowToValidate;
#ifdef DO_SAVE_UNDERS #ifdef DO_SAVE_UNDERS
Bool dosave = FALSE; Bool dosave = FALSE;
@ -576,10 +576,10 @@ miMoveWindow(pWin, x, y, pNextSib, kind)
static int static int
miRecomputeExposures ( miRecomputeExposures (
register WindowPtr pWin, WindowPtr pWin,
pointer value) /* must conform to VisitWindowProcPtr */ pointer value) /* must conform to VisitWindowProcPtr */
{ {
register ScreenPtr pScreen; ScreenPtr pScreen;
RegionPtr pValid = (RegionPtr)value; RegionPtr pValid = (RegionPtr)value;
if (pWin->valdata) if (pWin->valdata)
@ -604,7 +604,7 @@ miRecomputeExposures (
void void
miSlideAndSizeWindow(pWin, x, y, w, h, pSib) miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
register WindowPtr pWin; WindowPtr pWin;
int x,y; int x,y;
unsigned int w, h; unsigned int w, h;
WindowPtr pSib; WindowPtr pSib;
@ -620,11 +620,11 @@ miSlideAndSizeWindow(pWin, x, y, w, h, pSib)
DDXPointRec oldpt; DDXPointRec oldpt;
RegionPtr oldRegion = NULL; RegionPtr oldRegion = NULL;
Bool anyMarked = FALSE; Bool anyMarked = FALSE;
register ScreenPtr pScreen; ScreenPtr pScreen;
WindowPtr pFirstChange; WindowPtr pFirstChange;
register WindowPtr pChild; WindowPtr pChild;
RegionPtr gravitate[StaticGravity + 1]; RegionPtr gravitate[StaticGravity + 1];
register unsigned g; unsigned g;
int nx, ny; /* destination x,y */ int nx, ny; /* destination x,y */
int newx, newy; /* new inner window position */ int newx, newy; /* new inner window position */
RegionPtr pRegion = NULL; RegionPtr pRegion = NULL;
@ -981,10 +981,10 @@ miGetLayerWindow(pWin)
_X_EXPORT void _X_EXPORT void
miSetShape(pWin) miSetShape(pWin)
register WindowPtr pWin; WindowPtr pWin;
{ {
Bool WasViewable = (Bool)(pWin->viewable); Bool WasViewable = (Bool)(pWin->viewable);
register ScreenPtr pScreen = pWin->drawable.pScreen; ScreenPtr pScreen = pWin->drawable.pScreen;
Bool anyMarked = FALSE; Bool anyMarked = FALSE;
RegionPtr pOldClip = NULL, bsExposed; RegionPtr pOldClip = NULL, bsExposed;
#ifdef DO_SAVE_UNDERS #ifdef DO_SAVE_UNDERS
@ -1081,12 +1081,12 @@ miSetShape(pWin)
_X_EXPORT void _X_EXPORT void
miChangeBorderWidth(pWin, width) miChangeBorderWidth(pWin, width)
register WindowPtr pWin; WindowPtr pWin;
unsigned int width; unsigned int width;
{ {
int oldwidth; int oldwidth;
Bool anyMarked = FALSE; Bool anyMarked = FALSE;
register ScreenPtr pScreen; ScreenPtr pScreen;
Bool WasViewable = (Bool)(pWin->viewable); Bool WasViewable = (Bool)(pWin->viewable);
Bool HadBorder; Bool HadBorder;
#ifdef DO_SAVE_UNDERS #ifdef DO_SAVE_UNDERS

28
mi/mizerarc.c
View File

@ -97,8 +97,8 @@ static miZeroArcPtRec oob = {65536, 65536, 0};
_X_EXPORT Bool _X_EXPORT Bool
miZeroArcSetup(arc, info, ok360) miZeroArcSetup(arc, info, ok360)
register xArc *arc; xArc *arc;
register miZeroArcRec *info; miZeroArcRec *info;
Bool ok360; Bool ok360;
{ {
int l; int l;
@ -404,11 +404,11 @@ miZeroArcSetup(arc, info, ok360)
DDXPointPtr DDXPointPtr
miZeroArcPts(arc, pts) miZeroArcPts(arc, pts)
xArc *arc; xArc *arc;
register DDXPointPtr pts; DDXPointPtr pts;
{ {
miZeroArcRec info; miZeroArcRec info;
register int x, y, a, b, d, mask; int x, y, a, b, d, mask;
register int k1, k3, dx, dy; int k1, k3, dx, dy;
Bool do360; Bool do360;
do360 = miZeroArcSetup(arc, &info, TRUE); do360 = miZeroArcSetup(arc, &info, TRUE);
@ -509,14 +509,14 @@ miZeroArcDashPts(
GCPtr pGC, GCPtr pGC,
xArc *arc, xArc *arc,
DashInfo *dinfo, DashInfo *dinfo,
register DDXPointPtr points, DDXPointPtr points,
int maxPts, int maxPts,
register DDXPointPtr *evenPts, DDXPointPtr *evenPts,
register DDXPointPtr *oddPts ) DDXPointPtr *oddPts )
{ {
miZeroArcRec info; miZeroArcRec info;
register int x, y, a, b, d, mask; int x, y, a, b, d, mask;
register int k1, k3, dx, dy; int k1, k3, dx, dy;
int dashRemaining; int dashRemaining;
DDXPointPtr arcPts[4]; DDXPointPtr arcPts[4];
DDXPointPtr startPts[5], endPts[5]; DDXPointPtr startPts[5], endPts[5];
@ -715,11 +715,11 @@ miZeroPolyArc(pDraw, pGC, narcs, parcs)
xArc *parcs; xArc *parcs;
{ {
int maxPts = 0; int maxPts = 0;
register int n, maxw = 0; int n, maxw = 0;
register xArc *arc; xArc *arc;
register int i; int i;
DDXPointPtr points, pts, oddPts; DDXPointPtr points, pts, oddPts;
register DDXPointPtr pt; DDXPointPtr pt;
int numPts; int numPts;
Bool dospans; Bool dospans;
int *widths = NULL; int *widths = NULL;