SwallowOS/xserver_xsdl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace X-allocation functions with their C89 counterparts

Browse Source 
The only remaining X-functions used in server are XNF*, the rest is converted to
plain alloc/calloc/realloc/free/strdup.

X* functions are still exported from server and x* macros are still defined in
header file, so both ABI and API are not affected by this change.

Signed-off-by: Mikhail Gusarov <dottedmag@dottedmag.net>
Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Mikhail Gusarov
2010-05-06 01:44:06 +07:00
parent 96c7ab27c3
commit 3f3ff971ec
345 changed files with 3011 additions and 3011 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
mi/miarc.c
View File

@@ -800,7 +800,7 @@ miComputeWideEllipse(int lw, xArc *parc)
if (!lw)
lw = 1;
k = (parc->height >> 1) + ((lw - 1) >> 1);
spdata = xalloc(sizeof(miArcSpanData) + sizeof(miArcSpan) * (k + 2));
spdata = malloc(sizeof(miArcSpanData) + sizeof(miArcSpan) * (k + 2));
if (!spdata)
return NULL;
spdata->spans = (miArcSpan *)(spdata + 1);
@@ -831,14 +831,14 @@ miFillWideEllipse(
yorgu = parc->height + pGC->lineWidth;
n = (sizeof(int) * 2) * yorgu;
widths = xalloc(n + (sizeof(DDXPointRec) * 2) * yorgu);
widths = malloc(n + (sizeof(DDXPointRec) * 2) * yorgu);
if (!widths)
return;
points = (DDXPointPtr)((char *)widths + n);
spdata = miComputeWideEllipse((int)pGC->lineWidth, parc);
if (!spdata)
{
xfree(widths);
free(widths);
return;
}
pts = points;
@@ -927,10 +927,10 @@ miFillWideEllipse(
wids += 2;
}
}
xfree(spdata);
free(spdata);
(*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
xfree(widths);
free(widths);
}
/*
@@ -1266,7 +1266,7 @@ miArcJoin(DrawablePtr pDraw, GCPtr pGC, miArcFacePtr pLeft,
arc.height = width;
arc.angle1 = -miDatan2 (corner.y - center.y, corner.x - center.x);
arc.angle2 = a;
pArcPts = xalloc (3 * sizeof (SppPointRec));
pArcPts = malloc(3 * sizeof (SppPointRec));
if (!pArcPts)
return;
pArcPts[0].x = otherCorner.x;
@@ -1282,7 +1282,7 @@ miArcJoin(DrawablePtr pDraw, GCPtr pGC, miArcFacePtr pLeft,
* rest of the line */
miFillSppPoly(pDraw, pGC, cpt, pArcPts, xOrg, yOrg, xFtrans, yFtrans);
}
xfree(pArcPts);
free(pArcPts);
return;
case JoinMiter:
/*
@@ -1413,7 +1413,7 @@ miRoundCap(
* rest of the line */
miFillSppPoly(pDraw, pGC, cpt, pArcPts, -xOrg, -yOrg, xFtrans, yFtrans);
}
xfree(pArcPts);
free(pArcPts);
}
/*
@@ -1511,10 +1511,10 @@ miDatan2 (double dy, double dx)
* This procedure allocates the space necessary to fit the arc points.
* Sometimes it's convenient for those points to be at the end of an existing
* array. (For example, if we want to leave a spare point to make sectors
* instead of segments.) So we pass in the xalloc()ed chunk that contains the
* instead of segments.) So we pass in the malloc()ed chunk that contains the
* array and an index saying where we should start stashing the points.
* If there isn't an array already, we just pass in a null pointer and
* count on xrealloc() to handle the null pointer correctly.
* count on realloc() to handle the null pointer correctly.
*/
static int
miGetArcPts(
@@ -1561,7 +1561,7 @@ miGetArcPts(
count++;
cdt = 2 * miDcos(dt);
if (!(poly = (SppPointPtr) xrealloc((pointer)*ppPts,
if (!(poly = (SppPointPtr) realloc((pointer)*ppPts,
(cpt + count) * sizeof(SppPointRec))))
return(0);
*ppPts = poly;
@@ -1624,7 +1624,7 @@ addCap (
if (*ncapsp == *sizep)
{
newsize = *sizep + ADD_REALLOC_STEP;
cap = (miArcCapPtr) xrealloc (*capsp,
cap = (miArcCapPtr) realloc(*capsp,
newsize * sizeof (**capsp));
if (!cap)
return;
@@ -1655,7 +1655,7 @@ addJoin (
if (*njoinsp == *sizep)
{
newsize = *sizep + ADD_REALLOC_STEP;
join = (miArcJoinPtr) xrealloc (*joinsp,
join = (miArcJoinPtr) realloc(*joinsp,
newsize * sizeof (**joinsp));
if (!join)
return;
@@ -1685,7 +1685,7 @@ addArc (
if (*narcsp == *sizep)
{
newsize = *sizep + ADD_REALLOC_STEP;
arc = (miArcDataPtr) xrealloc (*arcsp,
arc = (miArcDataPtr) realloc(*arcsp,
newsize * sizeof (**arcsp));
if (!arc)
return NULL;
@@ -1710,13 +1710,13 @@ miFreeArcs(
iphase--)
{
if (arcs[iphase].narcs > 0)
xfree(arcs[iphase].arcs);
free(arcs[iphase].arcs);
if (arcs[iphase].njoins > 0)
xfree(arcs[iphase].joins);
free(arcs[iphase].joins);
if (arcs[iphase].ncaps > 0)
xfree(arcs[iphase].caps);
free(arcs[iphase].caps);
}
xfree(arcs);
free(arcs);
}
/*
@@ -1800,13 +1800,13 @@ miComputeArcs (
isDoubleDash = (pGC->lineStyle == LineDoubleDash);
dashOffset = pGC->dashOffset;
data = xalloc (narcs * sizeof (struct arcData));
data = malloc(narcs * sizeof (struct arcData));
if (!data)
return NULL;
arcs = xalloc (sizeof (*arcs) * (isDoubleDash ? 2 : 1));
arcs = malloc(sizeof (*arcs) * (isDoubleDash ? 2 : 1));
if (!arcs)
{
xfree(data);
free(data);
return NULL;
}
for (i = 0; i < narcs; i++) {
@@ -2155,11 +2155,11 @@ miComputeArcs (
arcs[iphase].arcs[arcs[iphase].narcs-1].cap =
arcs[iphase].ncaps;
}
xfree(data);
free(data);
return arcs;
arcfail:
miFreeArcs(arcs, pGC);
xfree(data);
free(data);
return NULL;
}
@@ -3016,7 +3016,7 @@ realAllocSpan (void)
struct finalSpan *span;
int i;
newChunk = xalloc (sizeof (struct finalSpanChunk));
newChunk = malloc(sizeof (struct finalSpanChunk));
if (!newChunk)
return (struct finalSpan *) NULL;
newChunk->next = chunks;
@@ -3039,11 +3039,11 @@ disposeFinalSpans (void)
for (chunk = chunks; chunk; chunk = next) {
next = chunk->next;
xfree (chunk);
free(chunk);
}
chunks = 0;
freeFinalSpans = 0;
xfree(finalSpans);
free(finalSpans);
finalSpans = 0;
}
@@ -3063,8 +3063,8 @@ fillSpans (
if (nspans == 0)
return;
xSpan = xSpans = xalloc (nspans * sizeof (DDXPointRec));
xWidth = xWidths = xalloc (nspans * sizeof (int));
xSpan = xSpans = malloc(nspans * sizeof (DDXPointRec));
xWidth = xWidths = malloc(nspans * sizeof (int));
if (xSpans && xWidths)
{
i = 0;
@@ -3084,9 +3084,9 @@ fillSpans (
}
disposeFinalSpans ();
if (xSpans)
xfree (xSpans);
free(xSpans);
if (xWidths)
xfree (xWidths);
free(xWidths);
finalMiny = 0;
finalMaxy = -1;
finalSize = 0;
@@ -3121,7 +3121,7 @@ realFindSpan (int y)
else
change = SPAN_REALLOC;
newSize = finalSize + change;
newSpans = xalloc(newSize * sizeof (struct finalSpan *));
newSpans = malloc(newSize * sizeof (struct finalSpan *));
if (!newSpans)
return NULL;
newMiny = finalMiny;
@@ -3134,7 +3134,7 @@ realFindSpan (int y)
memmove(((char *) newSpans) + (finalMiny-newMiny) * sizeof (struct finalSpan *),
(char *) finalSpans,
finalSize * sizeof (struct finalSpan *));
xfree (finalSpans);
free(finalSpans);
}
if ((i = finalMiny - newMiny) > 0)
bzero ((char *)newSpans, i * sizeof (struct finalSpan *));
@@ -3477,7 +3477,7 @@ drawArc (
left->counterClock = temp;
}
}
xfree(spdata);
free(spdata);
}
static void

50
mi/mibitblt.c
View File

@@ -143,19 +143,19 @@ miCopyArea(DrawablePtr pSrcDrawable,
dsty += pDstDrawable->y;
}
pptFirst = ppt = xalloc(heightSrc * sizeof(DDXPointRec));
pwidthFirst = pwidth = xalloc(heightSrc * sizeof(unsigned int));
pptFirst = ppt = malloc(heightSrc * sizeof(DDXPointRec));
pwidthFirst = pwidth = malloc(heightSrc * sizeof(unsigned int));
numRects = REGION_NUM_RECTS(prgnSrcClip);
boxes = REGION_RECTS(prgnSrcClip);
ordering = xalloc(numRects * sizeof(unsigned int));
ordering = malloc(numRects * sizeof(unsigned int));
if(!pptFirst || !pwidthFirst || !ordering)
{
if (ordering)
xfree(ordering);
free(ordering);
if (pwidthFirst)
xfree(pwidthFirst);
free(pwidthFirst);
if (pptFirst)
xfree(pptFirst);
free(pptFirst);
return NULL;
}
@@ -235,7 +235,7 @@ miCopyArea(DrawablePtr pSrcDrawable,
ppt++->y = y++;
*pwidth++ = width;
}
pbits = xalloc(height * PixmapBytePad(width, pSrcDrawable->depth));
pbits = malloc(height * PixmapBytePad(width, pSrcDrawable->depth));
if (pbits)
{
(*pSrcDrawable->pScreen->GetSpans)(pSrcDrawable, width, pptFirst,
@@ -253,7 +253,7 @@ miCopyArea(DrawablePtr pSrcDrawable,
(*pGC->ops->SetSpans)(pDstDrawable, pGC, (char *)pbits, pptFirst,
(int *)pwidthFirst, height, TRUE);
xfree(pbits);
free(pbits);
}
}
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, xIn, yIn,
@@ -261,9 +261,9 @@ miCopyArea(DrawablePtr pSrcDrawable,
if(realSrcClip)
REGION_DESTROY(pGC->pScreen, prgnSrcClip);
xfree(ordering);
xfree(pwidthFirst);
xfree(pptFirst);
free(ordering);
free(pwidthFirst);
free(pptFirst);
return prgnExposed;
}
@@ -313,7 +313,7 @@ miGetPlane(
sy += pDraw->y;
widthInBytes = BitmapBytePad(w);
if(!result)
result = xcalloc(h, widthInBytes);
result = calloc(h, widthInBytes);
if (!result)
return NULL;
bitsPerPixel = pDraw->bitsPerPixel;
@@ -429,12 +429,12 @@ miOpqStipDrawable(DrawablePtr pDraw, GCPtr pGC, RegionPtr prgnSrc,
dixChangeGC(NullClient, pGCT, GCBackground, NULL, gcv);
ValidateGC((DrawablePtr)pPixmap, pGCT);
miClearDrawable((DrawablePtr)pPixmap, pGCT);
ppt = pptFirst = xalloc(h * sizeof(DDXPointRec));
pwidth = pwidthFirst = xalloc(h * sizeof(int));
ppt = pptFirst = malloc(h * sizeof(DDXPointRec));
pwidth = pwidthFirst = malloc(h * sizeof(int));
if(!pptFirst || !pwidthFirst)
{
if (pwidthFirst) xfree(pwidthFirst);
if (pptFirst) xfree(pptFirst);
if (pwidthFirst) free(pwidthFirst);
if (pptFirst) free(pptFirst);
FreeScratchGC(pGCT);
return;
}
@@ -460,8 +460,8 @@ miOpqStipDrawable(DrawablePtr pDraw, GCPtr pGC, RegionPtr prgnSrc,
(*pGCT->ops->SetSpans)((DrawablePtr)pPixmap, pGCT, (char *)pbits,
pptFirst, pwidthFirst, h, TRUE);
xfree(pwidthFirst);
xfree(pptFirst);
free(pwidthFirst);
free(pptFirst);
/* Save current values from the client GC */
@@ -614,7 +614,7 @@ miCopyPlane( DrawablePtr pSrcDrawable,
miOpqStipDrawable(pDstDrawable, pGC, prgnSrc, ptile, 0,
box.x2 - box.x1, box.y2 - box.y1,
dstx + box.x1 - srcx, dsty + box.y1 - srcy);
xfree(ptile);
free(ptile);
}
}
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
@@ -798,14 +798,14 @@ miPutImage( DrawablePtr pDraw, GCPtr pGC, int depth,
break;
case ZPixmap:
ppt = pptFirst = xalloc(h * sizeof(DDXPointRec));
pwidth = pwidthFirst = xalloc(h * sizeof(int));
ppt = pptFirst = malloc(h * sizeof(DDXPointRec));
pwidth = pwidthFirst = malloc(h * sizeof(int));
if(!pptFirst || !pwidthFirst)
{
if (pwidthFirst)
xfree(pwidthFirst);
free(pwidthFirst);
if (pptFirst)
xfree(pptFirst);
free(pptFirst);
return;
}
if (pGC->miTranslate)
@@ -824,8 +824,8 @@ miPutImage( DrawablePtr pDraw, GCPtr pGC, int depth,
(*pGC->ops->SetSpans)(pDraw, pGC, (char *)pImage, pptFirst,
pwidthFirst, h, TRUE);
xfree(pwidthFirst);
xfree(pptFirst);
free(pwidthFirst);
free(pptFirst);
break;
}
}

24
mi/micmap.c
View File

@@ -380,7 +380,7 @@ miClearVisualTypes(void)
while ((v = miVisuals)) {
miVisuals = v->next;
xfree(v);
free(v);
}
}
@@ -393,7 +393,7 @@ miSetVisualTypesAndMasks(int depth, int visuals, int bitsPerRGB,
miVisualsPtr new, *prev, v;
int count;
new = xalloc (sizeof *new);
new = malloc(sizeof *new);
if (!new)
return FALSE;
if (!redMask || !greenMask || !blueMask)
@@ -534,14 +534,14 @@ miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
ndepth++;
nvisual += visuals->count;
}
depth = xalloc (ndepth * sizeof (DepthRec));
visual = xalloc (nvisual * sizeof (VisualRec));
preferredCVCs = xalloc(ndepth * sizeof(int));
depth = malloc(ndepth * sizeof (DepthRec));
visual = malloc(nvisual * sizeof (VisualRec));
preferredCVCs = malloc(ndepth * sizeof(int));
if (!depth || !visual || !preferredCVCs)
{
xfree (depth);
xfree (visual);
xfree (preferredCVCs);
free(depth);
free(visual);
free(preferredCVCs);
return FALSE;
}
*depthp = depth;
@@ -560,9 +560,9 @@ miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
vid = NULL;
if (nvtype)
{
vid = xalloc (nvtype * sizeof (VisualID));
vid = malloc(nvtype * sizeof (VisualID));
if (!vid) {
xfree(preferredCVCs);
free(preferredCVCs);
return FALSE;
}
}
@@ -604,7 +604,7 @@ miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
vid++;
visual++;
}
xfree (visuals);
free(visuals);
}
miVisuals = NULL;
visual = *visualp;
@@ -660,7 +660,7 @@ miInitVisuals(VisualPtr *visualp, DepthPtr *depthp, int *nvisualp,
}
*rootDepthp = depth[i].depth;
*defaultVisp = depth[i].vids[j];
xfree(preferredCVCs);
free(preferredCVCs);
return TRUE;
}

10
mi/micopy.c
View File

@@ -68,7 +68,7 @@ miCopyRegion (DrawablePtr pSrcDrawable,
if (nbox > 1)
{
/* keep ordering in each band, reverse order of bands */
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
pboxNew1 = (BoxPtr)malloc(sizeof(BoxRec) * nbox);
if(!pboxNew1)
return;
pboxBase = pboxNext = pbox+nbox-1;
@@ -105,11 +105,11 @@ miCopyRegion (DrawablePtr pSrcDrawable,
if (nbox > 1)
{
/* reverse order of rects in each band */
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
pboxNew2 = (BoxPtr)malloc(sizeof(BoxRec) * nbox);
if(!pboxNew2)
{
if (pboxNew1)
xfree(pboxNew1);
free(pboxNew1);
return;
}
pboxBase = pboxNext = pbox;
@@ -144,9 +144,9 @@ miCopyRegion (DrawablePtr pSrcDrawable,
reverse, upsidedown, bitPlane, closure);
if (pboxNew1)
xfree (pboxNew1);
free(pboxNew1);
if (pboxNew2)
xfree (pboxNew2);
free(pboxNew2);
}
RegionPtr

26
mi/midispcur.c
View File

@@ -140,7 +140,7 @@ miDCInitialize (ScreenPtr pScreen, miPointerScreenFuncPtr screenFuncs)
{
miDCScreenPtr pScreenPriv;
pScreenPriv = xalloc (sizeof (miDCScreenRec));
pScreenPriv = malloc(sizeof (miDCScreenRec));
if (!pScreenPriv)
return FALSE;
@@ -152,7 +152,7 @@ miDCInitialize (ScreenPtr pScreen, miPointerScreenFuncPtr screenFuncs)
if (!miSpriteInitialize (pScreen, &miDCFuncs, screenFuncs))
{
xfree ((pointer) pScreenPriv);
free((pointer) pScreenPriv);
return FALSE;
}
return TRUE;
@@ -166,7 +166,7 @@ miDCCloseScreen (int index, ScreenPtr pScreen)
pScreenPriv = (miDCScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
miDCScreenKey);
pScreen->CloseScreen = pScreenPriv->CloseScreen;
xfree ((pointer) pScreenPriv);
free((pointer) pScreenPriv);
return (*pScreen->CloseScreen) (index, pScreen);
}
@@ -224,7 +224,7 @@ miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
GCPtr pGC;
XID gcvals[3];
pPriv = xalloc (sizeof (miDCCursorRec));
pPriv = malloc(sizeof (miDCCursorRec));
if (!pPriv)
return NULL;
#ifdef ARGB_CURSOR
@@ -237,7 +237,7 @@ miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
if (!pFormat)
{
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
@@ -248,14 +248,14 @@ miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap)
{
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
pGC = GetScratchGC (32, pScreen);
if (!pGC)
{
(*pScreen->DestroyPixmap) (pPixmap);
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
ValidateGC (&pPixmap->drawable, pGC);
@@ -269,7 +269,7 @@ miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
(*pScreen->DestroyPixmap) (pPixmap);
if (!pPriv->pPicture)
{
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
dixSetPrivate(&pCursor->bits->devPrivates, CursorScreenKey(pScreen), pPriv);
@@ -280,14 +280,14 @@ miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
pPriv->sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1, 0);
if (!pPriv->sourceBits)
{
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
pPriv->maskBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1, 0);
if (!pPriv->maskBits)
{
(*pScreen->DestroyPixmap) (pPriv->sourceBits);
xfree ((pointer) pPriv);
free((pointer) pPriv);
return NULL;
}
dixSetPrivate(&pCursor->bits->devPrivates, CursorScreenKey(pScreen), pPriv);
@@ -346,7 +346,7 @@ miDCUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor)
if (pPriv->pPicture)
FreePicture (pPriv->pPicture, 0);
#endif
xfree ((pointer) pPriv);
free((pointer) pPriv);
dixSetPrivate(&pCursor->bits->devPrivates, CursorScreenKey(pScreen), NULL);
}
return TRUE;
@@ -780,7 +780,7 @@ miDCDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
{
pScreen = screenInfo.screens[i];
pBuffer = xalloc(sizeof(miDCBufferRec));
pBuffer = malloc(sizeof(miDCBufferRec));
if (!pBuffer)
goto failure;
@@ -866,7 +866,7 @@ miDCDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
if (pBuffer->pSave) (*pScreen->DestroyPixmap)(pBuffer->pSave);
if (pBuffer->pTemp) (*pScreen->DestroyPixmap)(pBuffer->pTemp);
xfree(pBuffer);
free(pBuffer);
dixSetPrivate(&pDev->devPrivates, miDCSpriteKey + pScreen->myNum, NULL);
}
}

4
mi/mieq.c
View File

@@ -191,7 +191,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
if (evt->evlen < evlen)
{
evt->evlen = evlen;
evt->event = xrealloc(evt->event, evt->evlen);
evt->event = realloc(evt->event, evt->evlen);
if (!evt->event)
{
ErrorF("[mi] Running out of memory. Tossing event.\n");
@@ -439,7 +439,7 @@ mieqProcessInputEvents(void)
evlen = e->events->evlen;
if(evlen > event_size)
event = xrealloc(event, evlen);
event = realloc(event, evlen);
if (!event)
FatalError("[mi] No memory left for event processing.\n");

16
mi/miexpose.c
View File

@@ -358,7 +358,7 @@ miSendGraphicsExpose (ClientPtr client, RegionPtr pRgn, XID drawable,
numRects = REGION_NUM_RECTS(pRgn);
pBox = REGION_RECTS(pRgn);
if(!(pEvent = xalloc(numRects * sizeof(xEvent))))
if(!(pEvent = malloc(numRects * sizeof(xEvent))))
return;
pe = pEvent;
@@ -376,7 +376,7 @@ miSendGraphicsExpose (ClientPtr client, RegionPtr pRgn, XID drawable,
}
TryClientEvents(client, NULL, pEvent, numRects,
(Mask)0, NoEventMask, NullGrab);
xfree(pEvent);
free(pEvent);
}
else
{
@@ -402,7 +402,7 @@ miSendExposures( WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
pBox = REGION_RECTS(pRgn);
numRects = REGION_NUM_RECTS(pRgn);
if(!(pEvent = xcalloc(1, numRects * sizeof(xEvent))))
if(!(pEvent = calloc(1, numRects * sizeof(xEvent))))
return;
for (i=numRects, pe = pEvent; --i >= 0; pe++, pBox++)
@@ -432,7 +432,7 @@ miSendExposures( WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
win = PanoramiXFindIDByScrnum(XRT_WINDOW,
pWin->drawable.id, scrnum);
if(!win) {
xfree(pEvent);
free(pEvent);
return;
}
realWin = win->info[0].id;
@@ -449,7 +449,7 @@ miSendExposures( WindowPtr pWin, RegionPtr pRgn, int dx, int dy)
DeliverEvents(pWin, pEvent, numRects, NullWindow);
xfree(pEvent);
free(pEvent);
}
void
@@ -646,14 +646,14 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
gcmask |= GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin;
}
prect = xalloc(REGION_NUM_RECTS(prgn) * sizeof(xRectangle));
prect = malloc(REGION_NUM_RECTS(prgn) * sizeof(xRectangle));
if (!prect)
return;
pGC = GetScratchGC(drawable->depth, drawable->pScreen);
if (!pGC)
{
xfree(prect);
free(prect);
return;
}
@@ -671,7 +671,7 @@ miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
}
prect -= numRects;
(*pGC->ops->PolyFillRect)(drawable, pGC, numRects, prect);
xfree(prect);
free(prect);
FreeScratchGC(pGC);
}

40
mi/mifillarc.c
View File

@@ -546,13 +546,13 @@ miFillEllipseI(
int *widths;
int *wids;
points = xalloc(sizeof(DDXPointRec) * arc->height);
points = malloc(sizeof(DDXPointRec) * arc->height);
if (!points)
return;
widths = xalloc(sizeof(int) * arc->height);
widths = malloc(sizeof(int) * arc->height);
if (!widths)
{
xfree(points);
free(points);
return;
}
miFillArcSetup(arc, &info);
@@ -570,8 +570,8 @@ miFillEllipseI(
ADDSPANS();
}
(*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
xfree(widths);
xfree(points);
free(widths);
free(points);
}
static void
@@ -589,13 +589,13 @@ miFillEllipseD(
int *widths;
int *wids;
points = xalloc(sizeof(DDXPointRec) * arc->height);
points = malloc(sizeof(DDXPointRec) * arc->height);
if (!points)
return;
widths = xalloc(sizeof(int) * arc->height);
widths = malloc(sizeof(int) * arc->height);
if (!widths)
{
xfree(points);
free(points);
return;
}
miFillArcDSetup(arc, &info);
@@ -613,8 +613,8 @@ miFillEllipseD(
ADDSPANS();
}
(*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
xfree(widths);
xfree(points);
free(widths);
free(points);
}
#define ADDSPAN(l,r) \
@@ -661,13 +661,13 @@ miFillArcSliceI(
slw = arc->height;
if (slice.flip_top || slice.flip_bot)
slw += (arc->height >> 1) + 1;
points = xalloc(sizeof(DDXPointRec) * slw);
points = malloc(sizeof(DDXPointRec) * slw);
if (!points)
return;
widths = xalloc(sizeof(int) * slw);
widths = malloc(sizeof(int) * slw);
if (!widths)
{
xfree(points);
free(points);
return;
}
if (pGC->miTranslate)
@@ -698,8 +698,8 @@ miFillArcSliceI(
}
}
(*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
xfree(widths);
xfree(points);
free(widths);
free(points);
}
static void
@@ -725,13 +725,13 @@ miFillArcSliceD(
slw = arc->height;
if (slice.flip_top || slice.flip_bot)
slw += (arc->height >> 1) + 1;
points = xalloc(sizeof(DDXPointRec) * slw);
points = malloc(sizeof(DDXPointRec) * slw);
if (!points)
return;
widths = xalloc(sizeof(int) * slw);
widths = malloc(sizeof(int) * slw);
if (!widths)
{
xfree(points);
free(points);
return;
}
if (pGC->miTranslate)
@@ -762,8 +762,8 @@ miFillArcSliceD(
}
}
(*pGC->ops->FillSpans)(pDraw, pGC, pts - points, points, widths, FALSE);
xfree(widths);
xfree(points);
free(widths);
free(points);
}
/* MIPOLYFILLARC -- The public entry for the PolyFillArc request.

12
mi/mifillrct.c
View File

@@ -107,12 +107,12 @@ miPolyFillRect(
maxheight = max(maxheight, prect->height);
}
pptFirst = xalloc(maxheight * sizeof(DDXPointRec));
pwFirst = xalloc(maxheight * sizeof(int));
pptFirst = malloc(maxheight * sizeof(DDXPointRec));
pwFirst = malloc(maxheight * sizeof(int));
if(!pptFirst || !pwFirst)
{
if (pwFirst) xfree(pwFirst);
if (pptFirst) xfree(pptFirst);
if (pwFirst) free(pwFirst);
if (pptFirst) free(pptFirst);
return;
}
@@ -138,6 +138,6 @@ miPolyFillRect(
1);
prect++;
}
xfree(pwFirst);
xfree(pptFirst);
free(pwFirst);
free(pptFirst);
}

18
mi/mifpolycon.c
View File

@@ -116,15 +116,15 @@ miFillSppPoly(
y = ymax - ymin + 1;
if ((count < 3) || (y <= 0))
return;
ptsOut = FirstPoint = xalloc(sizeof(DDXPointRec) * y);
width = FirstWidth = xalloc(sizeof(int) * y);
Marked = xalloc(sizeof(int) * count);
ptsOut = FirstPoint = malloc(sizeof(DDXPointRec) * y);
width = FirstWidth = malloc(sizeof(int) * y);
Marked = malloc(sizeof(int) * count);
if(!ptsOut || !width || !Marked)
{
if (Marked) xfree(Marked);
if (width) xfree(width);
if (ptsOut) xfree(ptsOut);
if (Marked) free(Marked);
if (width) free(width);
if (ptsOut) free(ptsOut);
return;
}
@@ -238,9 +238,9 @@ miFillSppPoly(
/* Finally, fill the spans we've collected */
(*pgc->ops->FillSpans)(dst, pgc,
ptsOut-FirstPoint, FirstPoint, FirstWidth, 1);
xfree(Marked);
xfree(FirstWidth);
xfree(FirstPoint);
free(Marked);
free(FirstWidth);
free(FirstPoint);
}

2
mi/migc.c
View File

@@ -95,7 +95,7 @@ miChangeClip( GCPtr pGC, int type, pointer pvalue, int nrects)
pGC->clientClip = (pointer) RECTS_TO_REGION(pGC->pScreen, nrects,
(xRectangle *) pvalue,
type);
xfree(pvalue);
free(pvalue);
}
pGC->clientClipType = (type != CT_NONE && pGC->clientClip) ? CT_REGION : CT_NONE;
pGC->stateChanges |= GCClipMask;

4
mi/miglblt.c
View File

@@ -141,7 +141,7 @@ miPolyGlyphBlt(
DoChangeGC(pGCtmp, GCFunction|GCForeground|GCBackground, gcvals, 0);
nbyLine = BitmapBytePad(width);
pbits = xalloc(height*nbyLine);
pbits = malloc(height*nbyLine);
if (!pbits)
{
(*pDrawable->pScreen->DestroyPixmap)(pPixmap);
@@ -192,7 +192,7 @@ miPolyGlyphBlt(
x += pci->metrics.characterWidth;
}
(*pDrawable->pScreen->DestroyPixmap)(pPixmap);
xfree(pbits);
free(pbits);
FreeScratchGC(pGCtmp);
}

14
mi/mioverlay.c
View File

@@ -115,7 +115,7 @@ miInitOverlay(
if(!dixRequestPrivate(miOverlayWindowKey, sizeof(miOverlayWindowRec)))
return FALSE;
if(!(pScreenPriv = xalloc(sizeof(miOverlayScreenRec))))
if(!(pScreenPriv = malloc(sizeof(miOverlayScreenRec))))
return FALSE;
dixSetPrivate(&pScreen->devPrivates, miOverlayScreenKey, pScreenPriv);
@@ -166,7 +166,7 @@ miOverlayCloseScreen(int i, ScreenPtr pScreen)
pScreen->UnrealizeWindow = pScreenPriv->UnrealizeWindow;
pScreen->RealizeWindow = pScreenPriv->RealizeWindow;
xfree(pScreenPriv);
free(pScreenPriv);
return (*pScreen->CloseScreen)(i, pScreen);
}
@@ -184,7 +184,7 @@ miOverlayCreateWindow(WindowPtr pWin)
pWinPriv->tree = NULL;
if(!pWin->parent || !((*pScreenPriv->InOverlay)(pWin))) {
if(!(pTree = (miOverlayTreePtr)xcalloc(1, sizeof(miOverlayTreeRec))))
if(!(pTree = (miOverlayTreePtr)calloc(1, sizeof(miOverlayTreeRec))))
return FALSE;
}
@@ -212,7 +212,7 @@ miOverlayCreateWindow(WindowPtr pWin)
REGION_INIT(pScreen, &(pTree->borderClip), &fullBox, 1);
REGION_INIT(pScreen, &(pTree->clipList), &fullBox, 1);
}
} else xfree(pTree);
} else free(pTree);
}
return TRUE;
@@ -240,7 +240,7 @@ miOverlayDestroyWindow(WindowPtr pWin)
REGION_UNINIT(pScreen, &(pTree->borderClip));
REGION_UNINIT(pScreen, &(pTree->clipList));
xfree(pTree);
free(pTree);
}
if(pScreenPriv->DestroyWindow) {
@@ -861,7 +861,7 @@ miOverlayHandleExposures(WindowPtr pWin)
(*WindowExposures)(pTree->pWin,&mival->exposed,NullRegion);
REGION_UNINIT(pScreen, &mival->exposed);
}
xfree(mival);
free(mival);
pTree->valdata = NULL;
if (pTree->firstChild) {
pTree = pTree->firstChild;
@@ -899,7 +899,7 @@ miOverlayHandleExposures(WindowPtr pWin)
}
REGION_UNINIT(pScreen, &val->after.borderExposed);
REGION_UNINIT(pScreen, &val->after.exposed);
xfree(val);
free(val);
pChild->valdata = NULL;
if (pChild->firstChild)
{

10
mi/mipointer.c
View File

@@ -88,7 +88,7 @@ miPointerInitialize (ScreenPtr pScreen,
{
miPointerScreenPtr pScreenPriv;
pScreenPriv = xalloc (sizeof (miPointerScreenRec));
pScreenPriv = malloc(sizeof (miPointerScreenRec));
if (!pScreenPriv)
return FALSE;
pScreenPriv->spriteFuncs = spriteFuncs;
@@ -154,7 +154,7 @@ miPointerCloseScreen (int index, ScreenPtr pScreen)
#endif
pScreen->CloseScreen = pScreenPriv->CloseScreen;
xfree ((pointer) pScreenPriv);
free((pointer) pScreenPriv);
FreeEventList(events, GetMaximumEventsNum());
events = NULL;
return (*pScreen->CloseScreen) (index, pScreen);
@@ -252,7 +252,7 @@ miPointerDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
miPointerPtr pPointer;
SetupScreen (pScreen);
pPointer = xalloc(sizeof(miPointerRec));
pPointer = malloc(sizeof(miPointerRec));
if (!pPointer)
return FALSE;
@@ -270,7 +270,7 @@ miPointerDeviceInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
if (!((*pScreenPriv->spriteFuncs->DeviceCursorInitialize)(pDev, pScreen)))
{
xfree(pPointer);
free(pPointer);
return FALSE;
}
@@ -290,7 +290,7 @@ miPointerDeviceCleanup(DeviceIntPtr pDev, ScreenPtr pScreen)
return;
(*pScreenPriv->spriteFuncs->DeviceCursorCleanup)(pDev, pScreen);
xfree(dixLookupPrivate(&pDev->devPrivates, miPointerPrivKey));
free(dixLookupPrivate(&pDev->devPrivates, miPointerPrivKey));
dixSetPrivate(&pDev->devPrivates, miPointerPrivKey, NULL);
}

16
mi/mipolycon.c
View File

@@ -105,12 +105,12 @@ miFillConvexPoly(
dy = ymax - ymin + 1;
if ((count < 3) || (dy < 0))
return(TRUE);
ptsOut = FirstPoint = xalloc(sizeof(DDXPointRec)*dy);
width = FirstWidth = xalloc(sizeof(int) * dy);
ptsOut = FirstPoint = malloc(sizeof(DDXPointRec)*dy);
width = FirstWidth = malloc(sizeof(int) * dy);
if(!FirstPoint || !FirstWidth)
{
if (FirstWidth) xfree(FirstWidth);
if (FirstPoint) xfree(FirstPoint);
if (FirstWidth) free(FirstWidth);
if (FirstPoint) free(FirstPoint);
return(FALSE);
}
@@ -175,8 +175,8 @@ miFillConvexPoly(
/* in case we're called with non-convex polygon */
if(i < 0)
{
xfree(FirstWidth);
xfree(FirstPoint);
free(FirstWidth);
free(FirstPoint);
return(TRUE);
}
while (i-- > 0)
@@ -210,8 +210,8 @@ miFillConvexPoly(
(*pgc->ops->FillSpans)(dst, pgc,
ptsOut-FirstPoint,FirstPoint,FirstWidth,
1);
xfree(FirstWidth);
xfree(FirstPoint);
free(FirstWidth);
free(FirstPoint);
return(TRUE);
}

6
mi/mipolygen.c
View File

@@ -92,13 +92,13 @@ miFillGeneralPoly(
if (count < 3)
return(TRUE);
if(!(pETEs = xalloc(sizeof(EdgeTableEntry) * count)))
if(!(pETEs = malloc(sizeof(EdgeTableEntry) * count)))
return(FALSE);
ptsOut = FirstPoint;
width = FirstWidth;
if (!miCreateETandAET(count, ptsIn, &ET, &AET, pETEs, &SLLBlock))
{
xfree(pETEs);
free(pETEs);
return(FALSE);
}
pSLL = ET.scanlines.next;
@@ -224,7 +224,7 @@ miFillGeneralPoly(
* Get any spans that we missed by buffering
*/
(*pgc->ops->FillSpans)(dst, pgc, nPts, FirstPoint, FirstWidth, 1);
xfree(pETEs);
free(pETEs);
miFreeStorage(SLLBlock.next);
return(TRUE);
}

2
mi/mipolypnt.c
View File

@@ -120,6 +120,6 @@ miPolyPoint(
DoChangeGC(pGC, GCFillStyle, &fsOld, 0);
ValidateGC(pDrawable, pGC);
}
xfree(pwidthInit);
free(pwidthInit);
}

4
mi/mipolyrect.c
View File

@@ -90,7 +90,7 @@ miPolyRectangle(DrawablePtr pDraw, GCPtr pGC, int nrects, xRectangle *pRects)
offset2 = pGC->lineWidth;
offset1 = offset2 >> 1;
offset3 = offset2 - offset1;
tmp = xalloc(ntmp * sizeof (xRectangle));
tmp = malloc(ntmp * sizeof (xRectangle));
if (!tmp)
return;
t = tmp;
@@ -158,7 +158,7 @@ miPolyRectangle(DrawablePtr pDraw, GCPtr pGC, int nrects, xRectangle *pRects)
}
}
(*pGC->ops->PolyFillRect) (pDraw, pGC, t - tmp, tmp);
xfree ((pointer) tmp);
free((pointer) tmp);
}
else
{

4
mi/mipolyutil.c
View File

@@ -99,7 +99,7 @@ miInsertEdgeInET(EdgeTable *ET, EdgeTableEntry *ETE, int scanline,
{
if (*iSLLBlock > SLLSPERBLOCK-1)
{
tmpSLLBlock = xalloc(sizeof(ScanLineListBlock));
tmpSLLBlock = malloc(sizeof(ScanLineListBlock));
if (!tmpSLLBlock)
return FALSE;
(*SLLBlock)->next = tmpSLLBlock;
@@ -379,7 +379,7 @@ miFreeStorage(ScanLineListBlock *pSLLBlock)
while (pSLLBlock)
{
tmpSLLBlock = pSLLBlock->next;
xfree(pSLLBlock);
free(pSLLBlock);
pSLLBlock = tmpSLLBlock;
}
}

4
mi/mipushpxl.c
View File

@@ -123,7 +123,7 @@ miPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable,
LONG2CHARSDIFFORDER((MiBits)(-1) >> 1);
#endif
pwLineStart = xalloc(BitmapBytePad(dx));
pwLineStart = malloc(BitmapBytePad(dx));
if (!pwLineStart)
return;
ipt = 0;
@@ -262,7 +262,7 @@ miPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDrawable,
}
}
}
xfree(pwLineStart);
free(pwLineStart);
/* Flush any remaining spans */
if (ipt)
{

24
mi/miregion.c
View File

@@ -171,8 +171,8 @@ Equipment Corporation.
((r1)->y1 <= (r2)->y1) && \
((r1)->y2 >= (r2)->y2) )
#define xallocData(n) xalloc(REGION_SZOF(n))
#define xfreeData(reg) if ((reg)->data && (reg)->data->size) xfree((reg)->data)
#define xallocData(n) malloc(REGION_SZOF(n))
#define xfreeData(reg) if ((reg)->data && (reg)->data->size) free((reg)->data)
#define RECTALLOC_BAIL(pReg,n,bail) \
if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
@@ -209,7 +209,7 @@ if (!(pReg)->data || (((pReg)->data->numRects + (n)) > (pReg)->data->size)) \
if (((numRects) < ((reg)->data->size >> 1)) && ((reg)->data->size > 50)) \
{ \
RegDataPtr NewData; \
NewData = (RegDataPtr)xrealloc((reg)->data, REGION_SZOF(numRects)); \
NewData = (RegDataPtr)realloc((reg)->data, REGION_SZOF(numRects)); \
if (NewData) \
{ \
NewData->size = (numRects); \
@@ -241,7 +241,7 @@ miRegionCreate(BoxPtr rect, int size)
{
RegionPtr pReg;
pReg = (RegionPtr)xalloc(sizeof(RegionRec));
pReg = (RegionPtr)malloc(sizeof(RegionRec));
if (!pReg)
return &miBrokenRegion;
@@ -255,7 +255,7 @@ miRegionDestroy(RegionPtr pReg)
{
pixman_region_fini (pReg);
if (pReg != &miBrokenRegion)
xfree(pReg);
free(pReg);
}
void
@@ -389,7 +389,7 @@ miRectAlloc(RegionPtr pRgn, int n)
n = 250;
}
n += pRgn->data->numRects;
data = (RegDataPtr)xrealloc(pRgn->data, REGION_SZOF(n));
data = (RegDataPtr)realloc(pRgn->data, REGION_SZOF(n));
if (!data)
return miRegionBreak (pRgn);
pRgn->data = data;
@@ -797,7 +797,7 @@ miRegionOp(
}
if (oldData)
xfree(oldData);
free(oldData);
if (!(numRects = newReg->data->numRects))
{
@@ -1269,7 +1269,7 @@ miRegionValidate(RegionPtr badreg, Bool *pOverlap)
/* Set up the first region to be the first rectangle in badreg */
/* Note that step 2 code will never overflow the ri[0].reg rects array */
ri = (RegionInfo *) xalloc(4 * sizeof(RegionInfo));
ri = (RegionInfo *) malloc(4 * sizeof(RegionInfo));
if (!ri)
return miRegionBreak (badreg);
sizeRI = 4;
@@ -1333,7 +1333,7 @@ miRegionValidate(RegionPtr badreg, Bool *pOverlap)
{
/* Oops, allocate space for new region information */
sizeRI <<= 1;
rit = (RegionInfo *) xrealloc(ri, sizeRI * sizeof(RegionInfo));
rit = (RegionInfo *) realloc(ri, sizeRI * sizeof(RegionInfo));
if (!rit)
goto bail;
ri = rit;
@@ -1389,13 +1389,13 @@ NextRect: ;
numRI -= half;
}
*badreg = ri[0].reg;
xfree(ri);
free(ri);
good(badreg);
return ret;
bail:
for (i = 0; i < numRI; i++)
xfreeData(&ri[i].reg);
xfree (ri);
free(ri);
return miRegionBreak (badreg);
}
@@ -1473,7 +1473,7 @@ miRectsToRegion(int nrects, xRectangle *prect, int ctype)
}
else
{
xfree (pData);
free(pData);
}
return pRgn;
}

4
mi/miscrinit.c
View File

@@ -166,7 +166,7 @@ miCreateScreenResources(ScreenPtr pScreen)
{
value = pScrInitParms->pbits;
}
xfree(pScreen->devPrivate); /* freeing miScreenInitParmsRec */
free(pScreen->devPrivate); /* freeing miScreenInitParmsRec */
pScreen->devPrivate = value; /* pPixmap or pbits */
return TRUE;
}
@@ -180,7 +180,7 @@ miScreenDevPrivateInit(ScreenPtr pScreen, int width, pointer pbits)
* to the screen, until CreateScreenResources can put them in the
* screen pixmap.
*/
pScrInitParms = xalloc(sizeof(miScreenInitParmsRec));
pScrInitParms = malloc(sizeof(miScreenInitParmsRec));
if (!pScrInitParms)
return FALSE;
pScrInitParms->pbits = pbits;

72
mi/mispans.c
View File

@@ -150,12 +150,12 @@ static void miSubtractSpans (SpanGroup *spanGroup, Spans *sub)
int *newwid;
#define EXTRA 8
newPt = (DDXPointPtr) xrealloc (spans->points, (spans->count + EXTRA) * sizeof (DDXPointRec));
newPt = (DDXPointPtr) realloc(spans->points, (spans->count + EXTRA) * sizeof (DDXPointRec));
if (!newPt)
break;
spansPt = newPt + (spansPt - spans->points);
spans->points = newPt;
newwid = (int *) xrealloc (spans->widths, (spans->count + EXTRA) * sizeof (int));
newwid = (int *) realloc(spans->widths, (spans->count + EXTRA) * sizeof (int));
if (!newwid)
break;
spansWid = newwid + (spansWid - spans->widths);
@@ -190,7 +190,7 @@ void miAppendSpans(SpanGroup *spanGroup, SpanGroup *otherGroup, Spans *spans)
if (spanGroup->size == spanGroup->count) {
spanGroup->size = (spanGroup->size + 8) * 2;
spanGroup->group = (Spans *)
xrealloc(spanGroup->group, sizeof(Spans) * spanGroup->size);
realloc(spanGroup->group, sizeof(Spans) * spanGroup->size);
}
spanGroup->group[spanGroup->count] = *spans;
@@ -208,14 +208,14 @@ void miAppendSpans(SpanGroup *spanGroup, SpanGroup *otherGroup, Spans *spans)
}
else
{
xfree (spans->points);
xfree (spans->widths);
free(spans->points);
free(spans->widths);
}
} /* AppendSpans */
void miFreeSpanGroup(SpanGroup *spanGroup)
{
if (spanGroup->group != NULL) xfree(spanGroup->group);
if (spanGroup->group != NULL) free(spanGroup->group);
}
static void QuickSortSpansX(
@@ -366,8 +366,8 @@ miDisposeSpanGroup (SpanGroup *spanGroup)
for (i = 0; i < spanGroup->count; i++)
{
spans = spanGroup->group + i;
xfree (spans->points);
xfree (spans->widths);
free(spans->points);
free(spans->widths);
}
}
@@ -391,8 +391,8 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
spans = spanGroup->group;
(*pGC->ops->FillSpans)
(pDraw, pGC, spans->count, spans->points, spans->widths, TRUE);
xfree(spans->points);
xfree(spans->widths);
free(spans->points);
free(spans->widths);
}
else
{
@@ -405,15 +405,15 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
ylength = spanGroup->ymax - ymin + 1;
/* Allocate Spans for y buckets */
yspans = xalloc(ylength * sizeof(Spans));
ysizes = xalloc(ylength * sizeof (int));
yspans = malloc(ylength * sizeof(Spans));
ysizes = malloc(ylength * sizeof (int));
if (!yspans || !ysizes)
{
if (yspans)
xfree (yspans);
free(yspans);
if (ysizes)
xfree (ysizes);
free(ysizes);
miDisposeSpanGroup (spanGroup);
return;
}
@@ -443,10 +443,10 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
DDXPointPtr newpoints;
int *newwidths;
ysizes[index] = (ysizes[index] + 8) * 2;
newpoints = (DDXPointPtr) xrealloc(
newpoints = (DDXPointPtr) realloc(
newspans->points,
ysizes[index] * sizeof(DDXPointRec));
newwidths = (int *) xrealloc(
newwidths = (int *) realloc(
newspans->widths,
ysizes[index] * sizeof(int));
if (!newpoints || !newwidths)
@@ -455,11 +455,11 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
for (i = 0; i < ylength; i++)
{
xfree (yspans[i].points);
xfree (yspans[i].widths);
free(yspans[i].points);
free(yspans[i].widths);
}
xfree (yspans);
xfree (ysizes);
free(yspans);
free(ysizes);
miDisposeSpanGroup (spanGroup);
return;
}
@@ -472,30 +472,30 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
} /* if y value of span in range */
} /* for j through spans */
count += spans->count;
xfree(spans->points);
free(spans->points);
spans->points = NULL;
xfree(spans->widths);
free(spans->widths);
spans->widths = NULL;
} /* for i thorough Spans */
/* Now sort by x and uniquify each bucket into the final array */
points = xalloc(count * sizeof(DDXPointRec));
widths = xalloc(count * sizeof(int));
points = malloc(count * sizeof(DDXPointRec));
widths = malloc(count * sizeof(int));
if (!points || !widths)
{
int i;
for (i = 0; i < ylength; i++)
{
xfree (yspans[i].points);
xfree (yspans[i].widths);
free(yspans[i].points);
free(yspans[i].widths);
}
xfree (yspans);
xfree (ysizes);
free(yspans);
free(ysizes);
if (points)
xfree (points);
free(points);
if (widths)
xfree (widths);
free(widths);
return;
}
count = 0;
@@ -511,16 +511,16 @@ void miFillUniqueSpanGroup(DrawablePtr pDraw, GCPtr pGC, SpanGroup *spanGroup)
widths[count] = yspans[i].widths[0];
count++;
}
xfree(yspans[i].points);
xfree(yspans[i].widths);
free(yspans[i].points);
free(yspans[i].widths);
}
}
(*pGC->ops->FillSpans) (pDraw, pGC, count, points, widths, TRUE);
xfree(points);
xfree(widths);
xfree(yspans);
xfree(ysizes); /* use (DE)xalloc for these? */
free(points);
free(widths);
free(yspans);
free(ysizes); /* use (DE)xalloc for these? */
}
spanGroup->count = 0;

10
mi/misprite.c
View File

@@ -298,7 +298,7 @@ miSpriteInitialize (ScreenPtr pScreen,
if (!DamageSetup (pScreen))
return FALSE;
pScreenPriv = xalloc (sizeof (miSpriteScreenRec));
pScreenPriv = malloc(sizeof (miSpriteScreenRec));
if (!pScreenPriv)
return FALSE;
@@ -311,7 +311,7 @@ miSpriteInitialize (ScreenPtr pScreen,
if (!miPointerInitialize (pScreen, &miSpritePointerFuncs, screenFuncs,TRUE))
{
xfree (pScreenPriv);
free(pScreenPriv);
return FALSE;
}
for (pVisual = pScreen->visuals;
@@ -386,7 +386,7 @@ miSpriteCloseScreen (int i, ScreenPtr pScreen)
DamageDestroy (pScreenPriv->pDamage);
xfree (pScreenPriv);
free(pScreenPriv);
return (*pScreen->CloseScreen) (i, pScreen);
}
@@ -926,7 +926,7 @@ miSpriteDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
pScreenPriv = dixLookupPrivate(&pScreen->devPrivates, miSpriteScreenKey);
pCursorInfo = xalloc(sizeof(miCursorInfoRec));
pCursorInfo = malloc(sizeof(miCursorInfoRec));
if (!pCursorInfo)
return FALSE;
@@ -943,7 +943,7 @@ miSpriteDeviceCursorInitialize(DeviceIntPtr pDev, ScreenPtr pScreen)
ret = (*pScreenPriv->funcs->DeviceCursorInitialize)(pDev, pScreen);
if (!ret)
{
xfree(pCursorInfo);
free(pCursorInfo);
pCursorInfo = NULL;
}
dixSetPrivate(&pDev->devPrivates, miSpriteDevPrivatesKey, pCursorInfo);

38
mi/miwideline.c
View File

@@ -122,13 +122,13 @@ miFillPolyHelper (DrawablePtr pDrawable, GCPtr pGC, unsigned long pixel,
if (!spanData)
{
pptInit = xalloc (overall_height * sizeof(*ppt));
pptInit = malloc(overall_height * sizeof(*ppt));
if (!pptInit)
return;
pwidthInit = xalloc (overall_height * sizeof(*pwidth));
pwidthInit = malloc(overall_height * sizeof(*pwidth));
if (!pwidthInit)
{
xfree (pptInit);
free(pptInit);
return;
}
ppt = pptInit;
@@ -143,13 +143,13 @@ miFillPolyHelper (DrawablePtr pDrawable, GCPtr pGC, unsigned long pixel,
}
else
{
spanRec.points = xalloc (overall_height * sizeof (*ppt));
spanRec.points = malloc(overall_height * sizeof (*ppt));
if (!spanRec.points)
return;
spanRec.widths = xalloc (overall_height * sizeof (int));
spanRec.widths = malloc(overall_height * sizeof (int));
if (!spanRec.widths)
{
xfree (spanRec.points);
free(spanRec.points);
return;
}
ppt = spanRec.points;
@@ -229,8 +229,8 @@ miFillPolyHelper (DrawablePtr pDrawable, GCPtr pGC, unsigned long pixel,
if (!spanData)
{
(*pGC->ops->FillSpans) (pDrawable, pGC, ppt - pptInit, pptInit, pwidthInit, TRUE);
xfree (pwidthInit);
xfree (pptInit);
free(pwidthInit);
free(pptInit);
if (pixel != oldPixel)
{
DoChangeGC (pGC, GCForeground, &oldPixel, FALSE);
@@ -283,13 +283,13 @@ miFillRectPolyHelper (
}
else
{
spanRec.points = xalloc (h * sizeof (*ppt));
spanRec.points = malloc(h * sizeof (*ppt));
if (!spanRec.points)
return;
spanRec.widths = xalloc (h * sizeof (int));
spanRec.widths = malloc(h * sizeof (int));
if (!spanRec.widths)
{
xfree (spanRec.points);
free(spanRec.points);
return;
}
ppt = spanRec.points;
@@ -1107,13 +1107,13 @@ miLineArc (
}
if (!spanData)
{
points = xalloc(sizeof(DDXPointRec) * pGC->lineWidth);
points = malloc(sizeof(DDXPointRec) * pGC->lineWidth);
if (!points)
return;
widths = xalloc(sizeof(int) * pGC->lineWidth);
widths = malloc(sizeof(int) * pGC->lineWidth);
if (!widths)
{
xfree(points);
free(points);
return;
}
oldPixel = pGC->fgPixel;
@@ -1126,13 +1126,13 @@ miLineArc (
}
else
{
points = xalloc (pGC->lineWidth * sizeof (DDXPointRec));
points = malloc(pGC->lineWidth * sizeof (DDXPointRec));
if (!points)
return;
widths = xalloc (pGC->lineWidth * sizeof (int));
widths = malloc(pGC->lineWidth * sizeof (int));
if (!widths)
{
xfree (points);
free(points);
return;
}
spanRec.points = points;
@@ -1148,8 +1148,8 @@ miLineArc (
if (!spanData)
{
(*pGC->ops->FillSpans)(pDraw, pGC, n, points, widths, TRUE);
xfree(widths);
xfree(points);
free(widths);
free(points);
if (pixel != oldPixel)
{
DoChangeGC(pGC, GCForeground, &oldPixel, FALSE);

2
mi/miwindow.c
View File

@@ -245,7 +245,7 @@ miHandleValidateExposures(WindowPtr pWin)
REGION_UNINIT(pScreen, &val->after.borderExposed);
(*WindowExposures)(pChild, &val->after.exposed, NullRegion);
REGION_UNINIT(pScreen, &val->after.exposed);
xfree(val);
free(val);
pChild->valdata = NULL;
if (pChild->firstChild)
{

10
mi/mizerarc.c
View File

@@ -737,7 +737,7 @@ miZeroPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
dospans = (pGC->fillStyle != FillSolid);
if (dospans)
{
widths = xalloc(sizeof(int) * numPts);
widths = malloc(sizeof(int) * numPts);
if (!widths)
return;
maxw = 0;
@@ -754,12 +754,12 @@ miZeroPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
(unsigned char *) pGC->dash, (int)pGC->numInDashList,
&dinfo.dashOffsetInit);
}
points = xalloc(sizeof(DDXPointRec) * numPts);
points = malloc(sizeof(DDXPointRec) * numPts);
if (!points)
{
if (dospans)
{
xfree(widths);
free(widths);
}
return;
}
@@ -836,9 +836,9 @@ miZeroPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs, xArc *parcs)
}
}
}
xfree(points);
free(points);
if (dospans)
{
xfree(widths);
free(widths);
}
}

8
mi/mizerline.c
View File

@@ -155,8 +155,8 @@ miZeroLine(
width = xright - xleft + 1;
height = ybottom - ytop + 1;
list_len = (height >= width) ? height : width;
pspanInit = xalloc(list_len * sizeof(DDXPointRec));
pwidthInit = xalloc(list_len * sizeof(int));
pspanInit = malloc(list_len * sizeof(DDXPointRec));
pwidthInit = malloc(list_len * sizeof(int));
if (!pspanInit || !pwidthInit)
return;
@@ -359,8 +359,8 @@ miZeroLine(
(*pGC->ops->FillSpans)(pDraw, pGC, Nspans, pspanInit,
pwidthInit, FALSE);
xfree(pwidthInit);
xfree(pspanInit);
free(pwidthInit);
free(pspanInit);
}
void