Don't cast the return value of malloc/realloc
This patch has been generated by the following Coccinelle semantic patch: // Don't cast the return value of malloc/realloc. // // Casting the return value of malloc/realloc only stands to hide // errors. @@ type T; expression E1, E2; @@ - (T) ( _mesa_align_calloc(E1, E2) | _mesa_align_malloc(E1, E2) | calloc(E1, E2) | malloc(E1) | realloc(E1, E2) )
This commit is contained in:
parent
812931f602
commit
2b7a972e3f
|
@ -156,7 +156,7 @@ _eglInitThreadInfo(_EGLThreadInfo *t)
|
|||
static _EGLThreadInfo *
|
||||
_eglCreateThreadInfo(void)
|
||||
{
|
||||
_EGLThreadInfo *t = (_EGLThreadInfo *) calloc(1, sizeof(_EGLThreadInfo));
|
||||
_EGLThreadInfo *t = calloc(1, sizeof(_EGLThreadInfo));
|
||||
if (t)
|
||||
_eglInitThreadInfo(t);
|
||||
else
|
||||
|
|
|
@ -266,7 +266,7 @@ _eglFindDisplay(_EGLPlatformType plat, void *plat_dpy)
|
|||
|
||||
/* create a new display */
|
||||
if (!dpy) {
|
||||
dpy = (_EGLDisplay *) calloc(1, sizeof(_EGLDisplay));
|
||||
dpy = calloc(1, sizeof(_EGLDisplay));
|
||||
if (dpy) {
|
||||
_eglInitMutex(&dpy->Mutex);
|
||||
dpy->Platform = plat;
|
||||
|
|
|
@ -270,7 +270,7 @@ _eglChooseModeMESA(_EGLDriver *drv, _EGLDisplay *dpy, _EGLScreen *scrn,
|
|||
}
|
||||
|
||||
/* allocate array of mode pointers */
|
||||
modeList = (_EGLMode **) malloc(modes_size * sizeof(_EGLMode *));
|
||||
modeList = malloc(modes_size * sizeof(_EGLMode *));
|
||||
if (!modeList) {
|
||||
_eglError(EGL_BAD_MODE_MESA, "eglChooseModeMESA(out of memory)");
|
||||
return EGL_FALSE;
|
||||
|
|
|
@ -94,7 +94,7 @@ _eglInitScreen(_EGLScreen *screen, _EGLDisplay *dpy, EGLint num_modes)
|
|||
|
||||
if (num_modes > _EGL_SCREEN_MAX_MODES)
|
||||
num_modes = _EGL_SCREEN_MAX_MODES;
|
||||
screen->Modes = (_EGLMode *) calloc(num_modes, sizeof(*screen->Modes));
|
||||
screen->Modes = calloc(num_modes, sizeof(*screen->Modes));
|
||||
screen->NumModes = (screen->Modes) ? num_modes : 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -58,7 +58,7 @@ static void refill_pool(struct memory_pool * pool)
|
|||
if (!blocksize)
|
||||
blocksize = 2*POOL_LARGE_ALLOC;
|
||||
|
||||
newblock = (struct memory_block*)malloc(blocksize);
|
||||
newblock = malloc(blocksize);
|
||||
newblock->next = pool->blocks;
|
||||
pool->blocks = newblock;
|
||||
|
||||
|
@ -85,7 +85,7 @@ void * memory_pool_malloc(struct memory_pool * pool, unsigned int bytes)
|
|||
|
||||
return ptr;
|
||||
} else {
|
||||
struct memory_block * block = (struct memory_block*)malloc(bytes + sizeof(struct memory_block));
|
||||
struct memory_block * block = malloc(bytes + sizeof(struct memory_block));
|
||||
|
||||
block->next = pool->blocks;
|
||||
pool->blocks = block;
|
||||
|
|
|
@ -82,7 +82,7 @@
|
|||
do { \
|
||||
assert(sizeof(*(ptr)) == sizeof(uint32_t)); \
|
||||
cs_count = (size); \
|
||||
cs_ptr = (ptr) = (uint32_t*)malloc((size) * sizeof(uint32_t)); \
|
||||
cs_ptr = (ptr) = malloc((size) * sizeof(uint32_t)); \
|
||||
} while (0)
|
||||
|
||||
#define END_CB do { \
|
||||
|
@ -99,7 +99,7 @@
|
|||
uint32_t *cs_ptr = NULL; (void) cs_ptr
|
||||
|
||||
#define NEW_CB(ptr, size) \
|
||||
cs_ptr = (ptr) = (uint32_t*)malloc((size) * sizeof(uint32_t))
|
||||
cs_ptr = (ptr) = malloc((size) * sizeof(uint32_t))
|
||||
|
||||
#define BEGIN_CB(ptr, size) cs_ptr = (ptr)
|
||||
#define END_CB
|
||||
|
|
|
@ -210,7 +210,7 @@ void compute_memory_grow_pool(struct compute_memory_pool* pool,
|
|||
COMPUTE_DBG(" Aligned size = %d\n", new_size_in_dw);
|
||||
|
||||
compute_memory_shadow(pool, pipe, 1);
|
||||
pool->shadow = (uint32_t*)realloc(pool->shadow, new_size_in_dw*4);
|
||||
pool->shadow = realloc(pool->shadow, new_size_in_dw*4);
|
||||
pool->size_in_dw = new_size_in_dw;
|
||||
pool->screen->screen.resource_destroy(
|
||||
(struct pipe_screen *)pool->screen,
|
||||
|
|
|
@ -4981,7 +4981,7 @@ static void fc_set_mid(struct r600_shader_ctx *ctx, int fc_sp)
|
|||
{
|
||||
struct r600_cf_stack_entry *sp = &ctx->bc->fc_stack[fc_sp];
|
||||
|
||||
sp->mid = (struct r600_bytecode_cf **)realloc((void *)sp->mid,
|
||||
sp->mid = realloc((void *)sp->mid,
|
||||
sizeof(struct r600_bytecode_cf *) * (sp->num_mid + 1));
|
||||
sp->mid[sp->num_mid] = ctx->bc->cf_last;
|
||||
sp->num_mid++;
|
||||
|
|
|
@ -101,7 +101,7 @@ _gl_context_modes_create(unsigned count, size_t minimum_size)
|
|||
|
||||
next = &base;
|
||||
for (i = 0; i < count; i++) {
|
||||
*next = (__GLcontextModes *) malloc(size);
|
||||
*next = malloc(size);
|
||||
if (*next == NULL) {
|
||||
_gl_context_modes_destroy(base);
|
||||
base = NULL;
|
||||
|
@ -165,7 +165,7 @@ __glXQueryServerString(Display * dpy, int opcode, CARD32 screen, CARD32 name)
|
|||
length = reply.length * 4;
|
||||
numbytes = reply.size;
|
||||
|
||||
buf = (char *) malloc(numbytes);
|
||||
buf = malloc(numbytes);
|
||||
if (buf != NULL) {
|
||||
_XRead(dpy, buf, numbytes);
|
||||
length -= numbytes;
|
||||
|
@ -619,10 +619,10 @@ __glXInitialize(Display * dpy)
|
|||
/*
|
||||
** Allocate memory for all the pieces needed for this buffer.
|
||||
*/
|
||||
private = (XExtData *) malloc(sizeof(XExtData));
|
||||
private = malloc(sizeof(XExtData));
|
||||
if (!private)
|
||||
return NULL;
|
||||
dpyPriv = (__GLXdisplayPrivate *) calloc(1, sizeof(__GLXdisplayPrivate));
|
||||
dpyPriv = calloc(1, sizeof(__GLXdisplayPrivate));
|
||||
if (!dpyPriv) {
|
||||
free(private);
|
||||
return NULL;
|
||||
|
|
|
@ -220,7 +220,7 @@ bits_per_pixel( XMesaVisual xmv )
|
|||
/* Create a temporary XImage */
|
||||
img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
|
||||
ZPixmap, 0, /*format, offset*/
|
||||
(char*) malloc(8), /*data*/
|
||||
malloc(8), /*data*/
|
||||
1, 1, /*width, height*/
|
||||
32, /*bitmap_pad*/
|
||||
0 /*bytes_per_line*/
|
||||
|
|
|
@ -329,7 +329,7 @@ void vegaConvolve(VGImage dst, VGImage src,
|
|||
vg_validate_state(ctx);
|
||||
|
||||
buffer_len = 8 + 2 * 4 * kernel_size;
|
||||
buffer = (VGfloat*)malloc(buffer_len * sizeof(VGfloat));
|
||||
buffer = malloc(buffer_len * sizeof(VGfloat));
|
||||
|
||||
buffer[0] = 0.f;
|
||||
buffer[1] = 1.f;
|
||||
|
@ -519,7 +519,7 @@ void vegaGaussianBlur(VGImage dst, VGImage src,
|
|||
stdDeviationX, stdDeviationY);
|
||||
|
||||
buffer_len = 8 + 2 * 4 * kernel_size;
|
||||
buffer = (VGfloat*)malloc(buffer_len * sizeof(VGfloat));
|
||||
buffer = malloc(buffer_len * sizeof(VGfloat));
|
||||
|
||||
buffer[0] = 0.f;
|
||||
buffer[1] = 1.f;
|
||||
|
|
|
@ -83,7 +83,7 @@ static void polygon_print(struct polygon *poly)
|
|||
|
||||
struct polygon * polygon_create(int size)
|
||||
{
|
||||
struct polygon *poly = (struct polygon*)malloc(sizeof(struct polygon));
|
||||
struct polygon *poly = malloc(sizeof(struct polygon));
|
||||
|
||||
poly->data = malloc(sizeof(float) * COMPONENTS * size);
|
||||
poly->size = size;
|
||||
|
@ -114,7 +114,7 @@ void polygon_destroy(struct polygon *poly)
|
|||
|
||||
void polygon_resize(struct polygon *poly, int new_size)
|
||||
{
|
||||
float *data = (float*)malloc(sizeof(float) * COMPONENTS * new_size);
|
||||
float *data = malloc(sizeof(float) * COMPONENTS * new_size);
|
||||
int size = MIN2(sizeof(float) * COMPONENTS * new_size,
|
||||
sizeof(float) * COMPONENTS * poly->size);
|
||||
memcpy(data, poly->data, size);
|
||||
|
|
|
@ -182,7 +182,7 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
|
|||
out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
|
||||
|
||||
if (num_consts >= 1) {
|
||||
constant = (struct ureg_src *) malloc(sizeof(struct ureg_src) * end_const);
|
||||
constant = malloc(sizeof(struct ureg_src) * end_const);
|
||||
for (i = start_const; i < end_const; i++) {
|
||||
constant[i] = ureg_DECL_constant(ureg, i);
|
||||
}
|
||||
|
@ -190,14 +190,14 @@ combine_shaders(const struct shader_asm_info *shaders[SHADER_STAGES], int num_sh
|
|||
}
|
||||
|
||||
if (num_temps >= 1) {
|
||||
temp = (struct ureg_dst *) malloc(sizeof(struct ureg_dst) * end_temp);
|
||||
temp = malloc(sizeof(struct ureg_dst) * end_temp);
|
||||
for (i = start_temp; i < end_temp; i++) {
|
||||
temp[i] = ureg_DECL_temporary(ureg);
|
||||
}
|
||||
}
|
||||
|
||||
if (num_samplers >= 1) {
|
||||
sampler = (struct ureg_src *) malloc(sizeof(struct ureg_src) * end_sampler);
|
||||
sampler = malloc(sizeof(struct ureg_src) * end_sampler);
|
||||
for (i = start_sampler; i < end_sampler; i++) {
|
||||
sampler[i] = ureg_DECL_sampler(ureg, i);
|
||||
}
|
||||
|
|
|
@ -284,10 +284,10 @@ static unsigned radeon_add_reloc(struct radeon_cs_context *csc,
|
|||
csc->nrelocs += 10;
|
||||
|
||||
size = csc->nrelocs * sizeof(struct radeon_bo*);
|
||||
csc->relocs_bo = (struct radeon_bo**)realloc(csc->relocs_bo, size);
|
||||
csc->relocs_bo = realloc(csc->relocs_bo, size);
|
||||
|
||||
size = csc->nrelocs * sizeof(struct drm_radeon_cs_reloc);
|
||||
csc->relocs = (struct drm_radeon_cs_reloc*)realloc(csc->relocs, size);
|
||||
csc->relocs = realloc(csc->relocs, size);
|
||||
|
||||
csc->chunks[1].chunk_data = (uint64_t)(uintptr_t)csc->relocs;
|
||||
}
|
||||
|
|
|
@ -201,7 +201,7 @@ XF86DRIOpenConnection(Display * dpy, int screen, drm_handle_t * hSAREA,
|
|||
}
|
||||
|
||||
if (rep.length) {
|
||||
if (!(*busIdString = (char *) calloc(rep.busIdStringLength + 1, 1))) {
|
||||
if (!(*busIdString = calloc(rep.busIdStringLength + 1, 1))) {
|
||||
_XEatData(dpy, ((rep.busIdStringLength + 3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
|
@ -302,7 +302,7 @@ XF86DRIGetClientDriverName(Display * dpy, int screen,
|
|||
if (rep.length) {
|
||||
if (!
|
||||
(*clientDriverName =
|
||||
(char *) calloc(rep.clientDriverNameLength + 1, 1))) {
|
||||
calloc(rep.clientDriverNameLength + 1, 1))) {
|
||||
_XEatData(dpy, ((rep.clientDriverNameLength + 3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
|
@ -521,7 +521,7 @@ XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable,
|
|||
if (*numClipRects) {
|
||||
int len = sizeof(drm_clip_rect_t) * (*numClipRects);
|
||||
|
||||
*pClipRects = (drm_clip_rect_t *) calloc(len, 1);
|
||||
*pClipRects = calloc(len, 1);
|
||||
if (*pClipRects)
|
||||
_XRead(dpy, (char *) *pClipRects, len);
|
||||
}
|
||||
|
@ -532,7 +532,7 @@ XF86DRIGetDrawableInfo(Display * dpy, int screen, Drawable drawable,
|
|||
if (*numBackClipRects) {
|
||||
int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);
|
||||
|
||||
*pBackClipRects = (drm_clip_rect_t *) calloc(len, 1);
|
||||
*pBackClipRects = calloc(len, 1);
|
||||
if (*pBackClipRects)
|
||||
_XRead(dpy, (char *) *pBackClipRects, len);
|
||||
}
|
||||
|
@ -582,7 +582,7 @@ XF86DRIGetDeviceInfo(Display * dpy, int screen, drm_handle_t * hFrameBuffer,
|
|||
*devPrivateSize = rep.devPrivateSize;
|
||||
|
||||
if (rep.length) {
|
||||
if (!(*pDevPrivate = (void *) calloc(rep.devPrivateSize, 1))) {
|
||||
if (!(*pDevPrivate = calloc(rep.devPrivateSize, 1))) {
|
||||
_XEatData(dpy, ((rep.devPrivateSize + 3) & ~3));
|
||||
UnlockDisplay(dpy);
|
||||
SyncHandle();
|
||||
|
|
|
@ -75,7 +75,7 @@ __indirect_glPushClientAttrib(GLuint mask)
|
|||
|
||||
if (spp < &gc->attributes.stack[__GL_CLIENT_ATTRIB_STACK_DEPTH]) {
|
||||
if (!(sp = *spp)) {
|
||||
sp = (__GLXattribute *) malloc(sizeof(__GLXattribute));
|
||||
sp = malloc(sizeof(__GLXattribute));
|
||||
*spp = sp;
|
||||
}
|
||||
sp->mask = mask;
|
||||
|
|
|
@ -326,7 +326,7 @@ GetDrawableAttribute(Display * dpy, GLXDrawable drawable,
|
|||
length = reply.length;
|
||||
if (length) {
|
||||
num_attributes = (use_glx_1_3) ? reply.numAttribs : length / 2;
|
||||
data = (CARD32 *) malloc(length * sizeof(CARD32));
|
||||
data = malloc(length * sizeof(CARD32));
|
||||
if (data == NULL) {
|
||||
/* Throw data on the floor */
|
||||
_XEatData(dpy, length);
|
||||
|
|
|
@ -146,7 +146,7 @@ __glXGetStringFromServer(Display * dpy, int opcode, CARD32 glxCode,
|
|||
length = reply.length * 4;
|
||||
numbytes = reply.size;
|
||||
|
||||
buf = (char *) malloc(numbytes);
|
||||
buf = malloc(numbytes);
|
||||
if (buf != NULL) {
|
||||
_XRead(dpy, buf, numbytes);
|
||||
length -= numbytes;
|
||||
|
|
|
@ -2454,7 +2454,7 @@ _X_HIDDEN char *
|
|||
__glXstrdup(const char *str)
|
||||
{
|
||||
char *copy;
|
||||
copy = (char *) malloc(strlen(str) + 1);
|
||||
copy = malloc(strlen(str) + 1);
|
||||
if (!copy)
|
||||
return NULL;
|
||||
strcpy(copy, str);
|
||||
|
|
|
@ -230,7 +230,7 @@ glx_config_create_list(unsigned count)
|
|||
|
||||
next = &base;
|
||||
for (i = 0; i < count; i++) {
|
||||
*next = (struct glx_config *) malloc(size);
|
||||
*next = malloc(size);
|
||||
if (*next == NULL) {
|
||||
glx_config_destroy_list(base);
|
||||
base = NULL;
|
||||
|
|
|
@ -384,7 +384,7 @@ indirect_create_context(struct glx_screen *psc,
|
|||
*/
|
||||
|
||||
bufSize = (XMaxRequestSize(psc->dpy) * 4) - sz_xGLXRenderReq;
|
||||
gc->buf = (GLubyte *) malloc(bufSize);
|
||||
gc->buf = malloc(bufSize);
|
||||
if (!gc->buf) {
|
||||
free(gc->client_state_private);
|
||||
free(gc);
|
||||
|
|
|
@ -89,7 +89,7 @@ __indirect_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
|
|||
if (stride != k) {
|
||||
GLubyte *buf;
|
||||
|
||||
buf = (GLubyte *) malloc(compsize);
|
||||
buf = malloc(compsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
@ -152,7 +152,7 @@ __indirect_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
|
|||
if (stride != k) {
|
||||
GLubyte *buf;
|
||||
|
||||
buf = (GLubyte *) malloc(compsize);
|
||||
buf = malloc(compsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
@ -227,7 +227,7 @@ __indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr,
|
|||
if ((vstr != k) || (ustr != k * vord)) {
|
||||
GLdouble *buf;
|
||||
|
||||
buf = (GLdouble *) malloc(compsize);
|
||||
buf = malloc(compsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
@ -303,7 +303,7 @@ __indirect_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustr,
|
|||
if ((vstr != k) || (ustr != k * vord)) {
|
||||
GLfloat *buf;
|
||||
|
||||
buf = (GLfloat *) malloc(compsize);
|
||||
buf = malloc(compsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
|
|
@ -84,7 +84,7 @@ __glXSendLargeImage(struct glx_context * gc, GLint compsize, GLint dim,
|
|||
GLubyte * pc, GLubyte * modes)
|
||||
{
|
||||
/* Allocate a temporary holding buffer */
|
||||
GLubyte *buf = (GLubyte *) malloc(compsize);
|
||||
GLubyte *buf = malloc(compsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
@ -178,7 +178,7 @@ __indirect_glSeparableFilter2D(GLenum target, GLenum internalformat,
|
|||
pc += hdrlen;
|
||||
|
||||
/* Allocate a temporary holding buffer */
|
||||
buf = (GLubyte *) malloc(bufsize);
|
||||
buf = malloc(bufsize);
|
||||
if (!buf) {
|
||||
__glXSetError(gc, GL_OUT_OF_MEMORY);
|
||||
return;
|
||||
|
|
|
@ -68,7 +68,7 @@ __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
|
|||
heightsize = __glImageSize(height, 1, 1, format, type, 0);
|
||||
|
||||
/* Allocate a holding buffer to transform the data from */
|
||||
rowBuf = (GLubyte *) malloc(widthsize);
|
||||
rowBuf = malloc(widthsize);
|
||||
if (!rowBuf) {
|
||||
/* Throw data away */
|
||||
_XEatData(dpy, compsize);
|
||||
|
@ -82,7 +82,7 @@ __indirect_glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
|
|||
__glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row);
|
||||
free((char *) rowBuf);
|
||||
}
|
||||
colBuf = (GLubyte *) malloc(heightsize);
|
||||
colBuf = malloc(heightsize);
|
||||
if (!colBuf) {
|
||||
/* Throw data away */
|
||||
_XEatData(dpy, compsize - __GLX_PAD(widthsize));
|
||||
|
@ -155,7 +155,7 @@ void gl_dispatch_stub_GetSeparableFilterEXT (GLenum target, GLenum format,
|
|||
const GLint heightsize =
|
||||
__glImageSize(height, 1, 1, format, type, 0);
|
||||
GLubyte *const buf =
|
||||
(GLubyte *) malloc((widthsize > heightsize) ? widthsize : heightsize);
|
||||
malloc((widthsize > heightsize) ? widthsize : heightsize);
|
||||
|
||||
if (buf == NULL) {
|
||||
/* Throw data away */
|
||||
|
|
|
@ -245,7 +245,7 @@ DRI_glXUseXFont(struct glx_context *CC, Font font, int first, int count, int lis
|
|||
max_bm_width = (max_width + 7) / 8;
|
||||
max_bm_height = max_height;
|
||||
|
||||
bm = (GLubyte *) malloc((max_bm_width * max_bm_height) * sizeof(GLubyte));
|
||||
bm = malloc((max_bm_width * max_bm_height) * sizeof(GLubyte));
|
||||
if (!bm) {
|
||||
XFreeFontInfo(NULL, fs, 1);
|
||||
__glXSetError(CC, GL_OUT_OF_MEMORY);
|
||||
|
|
|
@ -244,7 +244,7 @@ static char *
|
|||
str_dup(const char *str)
|
||||
{
|
||||
char *copy;
|
||||
copy = (char*) malloc(strlen(str) + 1);
|
||||
copy = malloc(strlen(str) + 1);
|
||||
if (!copy)
|
||||
return NULL;
|
||||
strcpy(copy, str);
|
||||
|
|
|
@ -1660,7 +1660,7 @@ _mesa_meta_BlitFramebuffer(struct gl_context *ctx,
|
|||
}
|
||||
|
||||
if (mask & GL_DEPTH_BUFFER_BIT) {
|
||||
GLuint *tmp = (GLuint *) malloc(srcW * srcH * sizeof(GLuint));
|
||||
GLuint *tmp = malloc(srcW * srcH * sizeof(GLuint));
|
||||
if (tmp) {
|
||||
if (!blit->DepthFP)
|
||||
init_blit_depth_pixels(ctx);
|
||||
|
@ -2712,7 +2712,7 @@ _mesa_meta_Bitmap(struct gl_context *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
bitmap8 = (GLubyte *) malloc(width * height);
|
||||
bitmap8 = malloc(width * height);
|
||||
if (bitmap8) {
|
||||
memset(bitmap8, bg, width * height);
|
||||
_mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
|
||||
|
|
|
@ -111,7 +111,7 @@ rehash(struct brw_cache *cache)
|
|||
GLuint size, i;
|
||||
|
||||
size = cache->size * 3;
|
||||
items = (struct brw_cache_item**) calloc(1, size * sizeof(*items));
|
||||
items = calloc(1, size * sizeof(*items));
|
||||
|
||||
for (i = 0; i < cache->size; i++)
|
||||
for (c = cache->items[i]; c; c = next) {
|
||||
|
@ -327,7 +327,7 @@ brw_init_caches(struct brw_context *brw)
|
|||
|
||||
cache->size = 7;
|
||||
cache->n_items = 0;
|
||||
cache->items = (struct brw_cache_item **)
|
||||
cache->items =
|
||||
calloc(1, cache->size * sizeof(struct brw_cache_item));
|
||||
|
||||
cache->bo = drm_intel_bo_alloc(intel->bufmgr,
|
||||
|
|
|
@ -235,7 +235,7 @@ GLboolean r200CreateContext( gl_api api,
|
|||
assert(screen);
|
||||
|
||||
/* Allocate the R200 context */
|
||||
rmesa = (r200ContextPtr) calloc(1, sizeof(*rmesa));
|
||||
rmesa = calloc(1, sizeof(*rmesa));
|
||||
if ( !rmesa ) {
|
||||
*error = __DRI_CTX_ERROR_NO_MEMORY;
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -658,8 +658,7 @@ static int find_or_add_value( struct reg *reg, int val )
|
|||
if (j == reg->nalloc) {
|
||||
reg->nalloc += 5;
|
||||
reg->nalloc *= 2;
|
||||
reg->values = (union fi *) realloc( reg->values,
|
||||
reg->nalloc * sizeof(union fi) );
|
||||
reg->values = realloc( reg->values, reg->nalloc * sizeof(union fi) );
|
||||
}
|
||||
|
||||
reg->values[reg->nvalues++].i = val;
|
||||
|
|
|
@ -201,7 +201,7 @@ r100CreateContext( gl_api api,
|
|||
assert(screen);
|
||||
|
||||
/* Allocate the Radeon context */
|
||||
rmesa = (r100ContextPtr) calloc(1, sizeof(*rmesa));
|
||||
rmesa = calloc(1, sizeof(*rmesa));
|
||||
if ( !rmesa ) {
|
||||
*error = __DRI_CTX_ERROR_NO_MEMORY;
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -42,7 +42,7 @@ void radeon_emit_queryobj(struct gl_context *ctx, struct radeon_state_atom *atom
|
|||
static inline void radeon_init_query_stateobj(radeonContextPtr radeon, int SZ)
|
||||
{
|
||||
radeon->query.queryobj.cmd_size = (SZ);
|
||||
radeon->query.queryobj.cmd = (uint32_t*) calloc(SZ, sizeof(uint32_t));
|
||||
radeon->query.queryobj.cmd = calloc(SZ, sizeof(uint32_t));
|
||||
radeon->query.queryobj.name = "queryobj";
|
||||
radeon->query.queryobj.idx = 0;
|
||||
radeon->query.queryobj.check = radeon_check_query_active;
|
||||
|
|
|
@ -380,8 +380,7 @@ static int find_or_add_value( struct reg *reg, int val )
|
|||
if (j == reg->nalloc) {
|
||||
reg->nalloc += 5;
|
||||
reg->nalloc *= 2;
|
||||
reg->values = (union fi *) realloc( reg->values,
|
||||
reg->nalloc * sizeof(union fi) );
|
||||
reg->values = realloc( reg->values, reg->nalloc * sizeof(union fi) );
|
||||
}
|
||||
|
||||
reg->values[reg->nvalues++].i = val;
|
||||
|
|
|
@ -488,7 +488,7 @@ radeonCreateScreen2(__DRIscreen *sPriv)
|
|||
uint32_t device_id = 0;
|
||||
|
||||
/* Allocate the private area */
|
||||
screen = (radeonScreenPtr) calloc(1, sizeof(*screen));
|
||||
screen = calloc(1, sizeof(*screen));
|
||||
if ( !screen ) {
|
||||
fprintf(stderr, "%s: Could not allocate memory for screen structure", __FUNCTION__);
|
||||
fprintf(stderr, "leaving here\n");
|
||||
|
|
|
@ -382,7 +382,7 @@ static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,
|
|||
|
||||
VERIFY(GetTextMetrics(fontDevice, &metric));
|
||||
|
||||
dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
|
||||
dibInfo = calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
|
||||
dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
||||
dibInfo->bmiHeader.biPlanes = 1;
|
||||
dibInfo->bmiHeader.biBitCount = 1;
|
||||
|
|
|
@ -35,7 +35,7 @@ static WMesaFramebuffer
|
|||
wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)
|
||||
{
|
||||
WMesaFramebuffer pwfb
|
||||
= (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));
|
||||
= malloc(sizeof(struct wmesa_framebuffer));
|
||||
if (pwfb) {
|
||||
_mesa_initialize_window_framebuffer(&pwfb->Base, visual);
|
||||
pwfb->hDC = hdc;
|
||||
|
|
|
@ -1249,7 +1249,7 @@ Fake_glXChooseVisual( Display *dpy, int screen, int *list )
|
|||
return xmvis->vishandle;
|
||||
#else
|
||||
/* create a new vishandle - the cached one may be stale */
|
||||
xmvis->vishandle = (XVisualInfo *) malloc(sizeof(XVisualInfo));
|
||||
xmvis->vishandle = malloc(sizeof(XVisualInfo));
|
||||
if (xmvis->vishandle) {
|
||||
memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
|
||||
}
|
||||
|
@ -1964,7 +1964,7 @@ Fake_glXGetFBConfigs( Display *dpy, int screen, int *nelements )
|
|||
visuals = XGetVisualInfo(dpy, visMask, &visTemplate, nelements);
|
||||
if (*nelements > 0) {
|
||||
XMesaVisual *results;
|
||||
results = (XMesaVisual *) malloc(*nelements * sizeof(XMesaVisual));
|
||||
results = malloc(*nelements * sizeof(XMesaVisual));
|
||||
if (!results) {
|
||||
*nelements = 0;
|
||||
return NULL;
|
||||
|
@ -1994,7 +1994,7 @@ Fake_glXChooseFBConfig( Display *dpy, int screen,
|
|||
|
||||
xmvis = choose_visual(dpy, screen, attribList, GL_TRUE);
|
||||
if (xmvis) {
|
||||
GLXFBConfig *config = (GLXFBConfig *) malloc(sizeof(XMesaVisual));
|
||||
GLXFBConfig *config = malloc(sizeof(XMesaVisual));
|
||||
if (!config) {
|
||||
*nitems = 0;
|
||||
return NULL;
|
||||
|
@ -2019,7 +2019,7 @@ Fake_glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config )
|
|||
return xmvis->vishandle;
|
||||
#else
|
||||
/* create a new vishandle - the cached one may be stale */
|
||||
xmvis->vishandle = (XVisualInfo *) malloc(sizeof(XVisualInfo));
|
||||
xmvis->vishandle = malloc(sizeof(XVisualInfo));
|
||||
if (xmvis->vishandle) {
|
||||
memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
|
||||
}
|
||||
|
|
|
@ -115,7 +115,7 @@ get_dispatch(Display *dpy)
|
|||
|
||||
if (t) {
|
||||
struct display_dispatch *d;
|
||||
d = (struct display_dispatch *) malloc(sizeof(struct display_dispatch));
|
||||
d = malloc(sizeof(struct display_dispatch));
|
||||
if (d) {
|
||||
d->Dpy = dpy;
|
||||
d->Table = t;
|
||||
|
|
|
@ -247,7 +247,7 @@ Fake_glXUseXFont(Font font, int first, int count, int listbase)
|
|||
max_bm_width = (max_width + 7) / 8;
|
||||
max_bm_height = max_height;
|
||||
|
||||
bm = (GLubyte *) malloc((max_bm_width * max_bm_height) * sizeof(GLubyte));
|
||||
bm = malloc((max_bm_width * max_bm_height) * sizeof(GLubyte));
|
||||
if (!bm) {
|
||||
XFreeFontInfo(NULL, fs, 1);
|
||||
_mesa_error(NULL, GL_OUT_OF_MEMORY,
|
||||
|
|
|
@ -171,7 +171,7 @@ bits_per_pixel( XMesaVisual xmv )
|
|||
/* Create a temporary XImage */
|
||||
img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
|
||||
ZPixmap, 0, /*format, offset*/
|
||||
(char*) malloc(8), /*data*/
|
||||
malloc(8), /*data*/
|
||||
1, 1, /*width, height*/
|
||||
32, /*bitmap_pad*/
|
||||
0 /*bytes_per_line*/
|
||||
|
|
|
@ -203,7 +203,7 @@ alloc_back_buffer(XMesaBuffer b, GLuint width, GLuint height)
|
|||
_mesa_warning(NULL, "alloc_back_buffer: XCreateImage failed.\n");
|
||||
return;
|
||||
}
|
||||
b->backxrb->ximage->data = (char *) malloc(b->backxrb->ximage->height
|
||||
b->backxrb->ximage->data = malloc(b->backxrb->ximage->height
|
||||
* b->backxrb->ximage->bytes_per_line);
|
||||
if (!b->backxrb->ximage->data) {
|
||||
_mesa_warning(NULL, "alloc_back_buffer: MALLOC failed.\n");
|
||||
|
@ -469,7 +469,7 @@ xmesa_MapRenderbuffer(struct gl_context *ctx,
|
|||
int bytes_per_line =
|
||||
_mesa_format_row_stride(xrb->Base.Base.Format,
|
||||
xrb->Base.Base.Width);
|
||||
char *image = (char *) malloc(bytes_per_line *
|
||||
char *image = malloc(bytes_per_line *
|
||||
xrb->Base.Base.Height);
|
||||
ximage = XCreateImage(xrb->Parent->display,
|
||||
xrb->Parent->xm_visual->visinfo->visual,
|
||||
|
|
|
@ -289,7 +289,7 @@ accum_or_load(struct gl_context *ctx, GLfloat value,
|
|||
GLuint i, j;
|
||||
GLfloat (*rgba)[4];
|
||||
|
||||
rgba = (GLfloat (*)[4]) malloc(width * 4 * sizeof(GLfloat));
|
||||
rgba = malloc(width * 4 * sizeof(GLfloat));
|
||||
if (rgba) {
|
||||
for (j = 0; j < height; j++) {
|
||||
GLshort *acc = (GLshort *) accMap;
|
||||
|
@ -381,8 +381,8 @@ accum_return(struct gl_context *ctx, GLfloat value,
|
|||
GLint i, j;
|
||||
GLfloat (*rgba)[4], (*dest)[4];
|
||||
|
||||
rgba = (GLfloat (*)[4]) malloc(width * 4 * sizeof(GLfloat));
|
||||
dest = (GLfloat (*)[4]) malloc(width * 4 * sizeof(GLfloat));
|
||||
rgba = malloc(width * 4 * sizeof(GLfloat));
|
||||
dest = malloc(width * 4 * sizeof(GLfloat));
|
||||
|
||||
if (rgba && dest) {
|
||||
for (j = 0; j < height; j++) {
|
||||
|
|
|
@ -352,11 +352,9 @@ _mesa_BeginFragmentShaderATI(void)
|
|||
a start */
|
||||
for (i = 0; i < MAX_NUM_PASSES_ATI; i++) {
|
||||
ctx->ATIFragmentShader.Current->Instructions[i] =
|
||||
(struct atifs_instruction *)
|
||||
calloc(1, sizeof(struct atifs_instruction) *
|
||||
(MAX_NUM_INSTRUCTIONS_PER_PASS_ATI));
|
||||
ctx->ATIFragmentShader.Current->SetupInst[i] =
|
||||
(struct atifs_setupinst *)
|
||||
calloc(1, sizeof(struct atifs_setupinst) *
|
||||
(MAX_NUM_FRAGMENT_REGISTERS_ATI));
|
||||
}
|
||||
|
|
|
@ -398,7 +398,7 @@ _mesa_PushAttrib(GLbitfield mask)
|
|||
|
||||
if (mask & GL_POLYGON_STIPPLE_BIT) {
|
||||
GLuint *stipple;
|
||||
stipple = (GLuint *) malloc( 32*sizeof(GLuint) );
|
||||
stipple = malloc( 32*sizeof(GLuint) );
|
||||
memcpy( stipple, ctx->PolygonStipple, 32*sizeof(GLuint) );
|
||||
save_attrib_data(&head, GL_POLYGON_STIPPLE_BIT, stipple);
|
||||
}
|
||||
|
|
|
@ -871,7 +871,7 @@ _mesa_alloc_dispatch_table(int size)
|
|||
/* should never happen, but just in case */
|
||||
numEntries = MAX2(numEntries, size);
|
||||
|
||||
table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
|
||||
table = malloc(numEntries * sizeof(_glapi_proc));
|
||||
if (table) {
|
||||
_glapi_proc *entry = (_glapi_proc *) table;
|
||||
GLint i;
|
||||
|
@ -1075,7 +1075,7 @@ _mesa_create_context(gl_api api,
|
|||
ASSERT(visual);
|
||||
/*ASSERT(driverContext);*/
|
||||
|
||||
ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));
|
||||
ctx = calloc(1, sizeof(struct gl_context));
|
||||
if (!ctx)
|
||||
return NULL;
|
||||
|
||||
|
|
|
@ -51,7 +51,7 @@ _mesa_get_cpu_string(void)
|
|||
#define MAX_STRING 50
|
||||
char *buffer;
|
||||
|
||||
buffer = (char *) malloc(MAX_STRING);
|
||||
buffer = malloc(MAX_STRING);
|
||||
if (!buffer)
|
||||
return NULL;
|
||||
|
||||
|
|
|
@ -283,7 +283,7 @@ write_texture_image(struct gl_texture_object *texObj,
|
|||
GLubyte *buffer;
|
||||
char s[100];
|
||||
|
||||
buffer = (GLubyte *) malloc(img->Width * img->Height
|
||||
buffer = malloc(img->Width * img->Height
|
||||
* img->Depth * 4);
|
||||
|
||||
store = ctx->Pack; /* save */
|
||||
|
@ -332,7 +332,7 @@ _mesa_write_renderbuffer_image(const struct gl_renderbuffer *rb)
|
|||
return;
|
||||
}
|
||||
|
||||
buffer = (GLubyte *) malloc(rb->Width * rb->Height * 4);
|
||||
buffer = malloc(rb->Width * rb->Height * 4);
|
||||
|
||||
ctx->Driver.ReadPixels(ctx, 0, 0, rb->Width, rb->Height,
|
||||
format, type, &ctx->DefaultPacking, buffer);
|
||||
|
@ -466,7 +466,7 @@ _mesa_dump_color_buffer(const char *filename)
|
|||
const GLuint h = ctx->DrawBuffer->Height;
|
||||
GLubyte *buf;
|
||||
|
||||
buf = (GLubyte *) malloc(w * h * 4);
|
||||
buf = malloc(w * h * 4);
|
||||
|
||||
_mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
|
||||
_mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
|
@ -498,8 +498,8 @@ _mesa_dump_depth_buffer(const char *filename)
|
|||
GLubyte *buf2;
|
||||
GLuint i;
|
||||
|
||||
buf = (GLuint *) malloc(w * h * 4); /* 4 bpp */
|
||||
buf2 = (GLubyte *) malloc(w * h * 3); /* 3 bpp */
|
||||
buf = malloc(w * h * 4); /* 4 bpp */
|
||||
buf2 = malloc(w * h * 3); /* 3 bpp */
|
||||
|
||||
_mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
|
||||
_mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
|
@ -534,8 +534,8 @@ _mesa_dump_stencil_buffer(const char *filename)
|
|||
GLubyte *buf2;
|
||||
GLuint i;
|
||||
|
||||
buf = (GLubyte *) malloc(w * h); /* 1 bpp */
|
||||
buf2 = (GLubyte *) malloc(w * h * 3); /* 3 bpp */
|
||||
buf = malloc(w * h); /* 1 bpp */
|
||||
buf2 = malloc(w * h * 3); /* 3 bpp */
|
||||
|
||||
_mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
|
||||
_mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
|
@ -579,7 +579,7 @@ _mesa_dump_image(const char *filename, const void *image, GLuint w, GLuint h,
|
|||
}
|
||||
else if (format == GL_RGBA && type == GL_FLOAT) {
|
||||
/* convert floats to ubyte */
|
||||
GLubyte *buf = (GLubyte *) malloc(w * h * 4 * sizeof(GLubyte));
|
||||
GLubyte *buf = malloc(w * h * 4 * sizeof(GLubyte));
|
||||
const GLfloat *f = (const GLfloat *) image;
|
||||
GLuint i;
|
||||
for (i = 0; i < w * h * 4; i++) {
|
||||
|
@ -590,7 +590,7 @@ _mesa_dump_image(const char *filename, const void *image, GLuint w, GLuint h,
|
|||
}
|
||||
else if (format == GL_RED && type == GL_FLOAT) {
|
||||
/* convert floats to ubyte */
|
||||
GLubyte *buf = (GLubyte *) malloc(w * h * sizeof(GLubyte));
|
||||
GLubyte *buf = malloc(w * h * sizeof(GLubyte));
|
||||
const GLfloat *f = (const GLfloat *) image;
|
||||
GLuint i;
|
||||
for (i = 0; i < w * h; i++) {
|
||||
|
|
|
@ -573,7 +573,7 @@ make_list(GLuint name, GLuint count)
|
|||
{
|
||||
struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);
|
||||
dlist->Name = name;
|
||||
dlist->Head = (Node *) malloc(sizeof(Node) * count);
|
||||
dlist->Head = malloc(sizeof(Node) * count);
|
||||
dlist->Head[0].opcode = OPCODE_END_OF_LIST;
|
||||
return dlist;
|
||||
}
|
||||
|
@ -995,7 +995,7 @@ dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes)
|
|||
Node *newblock;
|
||||
n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
|
||||
n[0].opcode = OPCODE_CONTINUE;
|
||||
newblock = (Node *) malloc(sizeof(Node) * BLOCK_SIZE);
|
||||
newblock = malloc(sizeof(Node) * BLOCK_SIZE);
|
||||
if (!newblock) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
|
||||
return NULL;
|
||||
|
@ -3190,7 +3190,7 @@ save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
|
|||
if (n) {
|
||||
n[1].e = map;
|
||||
n[2].i = mapsize;
|
||||
n[3].data = (void *) malloc(mapsize * sizeof(GLfloat));
|
||||
n[3].data = malloc(mapsize * sizeof(GLfloat));
|
||||
memcpy(n[3].data, (void *) values, mapsize * sizeof(GLfloat));
|
||||
}
|
||||
if (ctx->ExecuteFlag) {
|
||||
|
@ -5018,7 +5018,7 @@ save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
|
|||
|
||||
n = alloc_instruction(ctx, OPCODE_LOAD_PROGRAM_NV, 4);
|
||||
if (n) {
|
||||
GLubyte *programCopy = (GLubyte *) malloc(len);
|
||||
GLubyte *programCopy = malloc(len);
|
||||
if (!programCopy) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
|
||||
return;
|
||||
|
@ -5045,7 +5045,7 @@ save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)
|
|||
|
||||
n = alloc_instruction(ctx, OPCODE_TRACK_MATRIX_NV, 2);
|
||||
if (n) {
|
||||
GLuint *idCopy = (GLuint *) malloc(num * sizeof(GLuint));
|
||||
GLuint *idCopy = malloc(num * sizeof(GLuint));
|
||||
if (!idCopy) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
|
||||
return;
|
||||
|
@ -5216,7 +5216,7 @@ save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,
|
|||
|
||||
n = alloc_instruction(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);
|
||||
if (n) {
|
||||
GLubyte *nameCopy = (GLubyte *) malloc(len);
|
||||
GLubyte *nameCopy = malloc(len);
|
||||
if (!nameCopy) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
|
||||
return;
|
||||
|
@ -5315,7 +5315,7 @@ save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
|
|||
|
||||
n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 4);
|
||||
if (n) {
|
||||
GLubyte *programCopy = (GLubyte *) malloc(len);
|
||||
GLubyte *programCopy = malloc(len);
|
||||
if (!programCopy) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
|
||||
return;
|
||||
|
|
|
@ -218,7 +218,7 @@ GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
|
|||
if (!points || !size)
|
||||
return NULL;
|
||||
|
||||
buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
|
||||
buffer = malloc(uorder * size * sizeof(GLfloat));
|
||||
|
||||
if (buffer)
|
||||
for (i = 0, p = buffer; i < uorder; i++, points += ustride)
|
||||
|
@ -242,7 +242,7 @@ GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
|
|||
if (!points || !size)
|
||||
return NULL;
|
||||
|
||||
buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
|
||||
buffer = malloc(uorder * size * sizeof(GLfloat));
|
||||
|
||||
if (buffer)
|
||||
for (i = 0, p = buffer; i < uorder; i++, points += ustride)
|
||||
|
@ -286,9 +286,9 @@ GLfloat *_mesa_copy_map_points2f( GLenum target,
|
|||
hsize = (uorder > vorder ? uorder : vorder)*size;
|
||||
|
||||
if(hsize>dsize)
|
||||
buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
|
||||
buffer = malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
|
||||
else
|
||||
buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
|
||||
buffer = malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
|
||||
|
||||
/* compute the increment value for the u-loop */
|
||||
uinc = ustride - vorder*vstride;
|
||||
|
@ -329,9 +329,9 @@ GLfloat *_mesa_copy_map_points2d(GLenum target,
|
|||
hsize = (uorder > vorder ? uorder : vorder)*size;
|
||||
|
||||
if(hsize>dsize)
|
||||
buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
|
||||
buffer = malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
|
||||
else
|
||||
buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
|
||||
buffer = malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
|
||||
|
||||
/* compute the increment value for the u-loop */
|
||||
uinc = ustride - vorder*vstride;
|
||||
|
@ -940,7 +940,7 @@ init_1d_map( struct gl_1d_map *map, int n, const float *initial )
|
|||
map->Order = 1;
|
||||
map->u1 = 0.0;
|
||||
map->u2 = 1.0;
|
||||
map->Points = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
map->Points = malloc(n * sizeof(GLfloat));
|
||||
if (map->Points) {
|
||||
GLint i;
|
||||
for (i=0;i<n;i++)
|
||||
|
@ -961,7 +961,7 @@ init_2d_map( struct gl_2d_map *map, int n, const float *initial )
|
|||
map->u2 = 1.0;
|
||||
map->v1 = 0.0;
|
||||
map->v2 = 1.0;
|
||||
map->Points = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
map->Points = malloc(n * sizeof(GLfloat));
|
||||
if (map->Points) {
|
||||
GLint i;
|
||||
for (i=0;i<n;i++)
|
||||
|
|
|
@ -867,7 +867,7 @@ _mesa_make_extension_string(struct gl_context *ctx)
|
|||
if (extra_extensions != NULL)
|
||||
length += 1 + strlen(extra_extensions); /* +1 for space */
|
||||
|
||||
exts = (char *) calloc(ALIGN(length + 1, 4), sizeof(char));
|
||||
exts = calloc(ALIGN(length + 1, 4), sizeof(char));
|
||||
if (exts == NULL) {
|
||||
free(extra_extensions);
|
||||
return NULL;
|
||||
|
|
|
@ -2078,7 +2078,7 @@ _mesa_unpack_ubyte_rgba_row(gl_format format, GLuint n,
|
|||
default:
|
||||
/* get float values, convert to ubyte */
|
||||
{
|
||||
GLfloat *tmp = (GLfloat *) malloc(n * 4 * sizeof(GLfloat));
|
||||
GLfloat *tmp = malloc(n * 4 * sizeof(GLfloat));
|
||||
if (tmp) {
|
||||
GLuint i;
|
||||
_mesa_unpack_rgba_row(format, n, src, (GLfloat (*)[4]) tmp);
|
||||
|
|
|
@ -97,7 +97,7 @@ _mesa_align_malloc(size_t bytes, unsigned long alignment)
|
|||
|
||||
ASSERT( alignment > 0 );
|
||||
|
||||
ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *));
|
||||
ptr = malloc(bytes + alignment + sizeof(void *));
|
||||
if (!ptr)
|
||||
return NULL;
|
||||
|
||||
|
@ -146,7 +146,7 @@ _mesa_align_calloc(size_t bytes, unsigned long alignment)
|
|||
|
||||
ASSERT( alignment > 0 );
|
||||
|
||||
ptr = (uintptr_t) calloc(1, bytes + alignment + sizeof(void *));
|
||||
ptr = calloc(1, bytes + alignment + sizeof(void *));
|
||||
if (!ptr)
|
||||
return NULL;
|
||||
|
||||
|
@ -527,7 +527,7 @@ _mesa_strdup( const char *s )
|
|||
{
|
||||
if (s) {
|
||||
size_t l = strlen(s);
|
||||
char *s2 = (char *) malloc(l + 1);
|
||||
char *s2 = malloc(l + 1);
|
||||
if (s2)
|
||||
strcpy(s2, s);
|
||||
return s2;
|
||||
|
|
|
@ -671,7 +671,7 @@ init_matrix_stack( struct gl_matrix_stack *stack,
|
|||
stack->MaxDepth = maxDepth;
|
||||
stack->DirtyFlag = dirtyFlag;
|
||||
/* The stack */
|
||||
stack->Stack = (GLmatrix *) calloc(maxDepth, sizeof(GLmatrix));
|
||||
stack->Stack = calloc(maxDepth, sizeof(GLmatrix));
|
||||
for (i = 0; i < maxDepth; i++) {
|
||||
_math_matrix_ctr(&stack->Stack[i]);
|
||||
}
|
||||
|
|
|
@ -1939,7 +1939,7 @@ generate_mipmap_uncompressed(struct gl_context *ctx, GLenum target,
|
|||
}
|
||||
|
||||
/* Map src texture image slices */
|
||||
srcMaps = (GLubyte **) calloc(srcDepth, sizeof(GLubyte *));
|
||||
srcMaps = calloc(srcDepth, sizeof(GLubyte *));
|
||||
if (srcMaps) {
|
||||
for (slice = 0; slice < srcDepth; slice++) {
|
||||
ctx->Driver.MapTextureImage(ctx, srcImage, slice,
|
||||
|
@ -1957,7 +1957,7 @@ generate_mipmap_uncompressed(struct gl_context *ctx, GLenum target,
|
|||
}
|
||||
|
||||
/* Map dst texture image slices */
|
||||
dstMaps = (GLubyte **) calloc(dstDepth, sizeof(GLubyte *));
|
||||
dstMaps = calloc(dstDepth, sizeof(GLubyte *));
|
||||
if (dstMaps) {
|
||||
for (slice = 0; slice < dstDepth; slice++) {
|
||||
ctx->Driver.MapTextureImage(ctx, dstImage, slice,
|
||||
|
@ -2053,7 +2053,7 @@ generate_mipmap_compressed(struct gl_context *ctx, GLenum target,
|
|||
/* allocate storage for the temporary, uncompressed image */
|
||||
/* 20 extra bytes, just be safe when calling last FetchTexel */
|
||||
temp_src_stride = _mesa_format_row_stride(temp_format, srcImage->Width);
|
||||
temp_src = (GLubyte *) malloc(temp_src_stride * srcImage->Height + 20);
|
||||
temp_src = malloc(temp_src_stride * srcImage->Height + 20);
|
||||
if (!temp_src) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");
|
||||
return;
|
||||
|
@ -2102,7 +2102,7 @@ generate_mipmap_compressed(struct gl_context *ctx, GLenum target,
|
|||
|
||||
temp_dst_stride = _mesa_format_row_stride(temp_format, dstWidth);
|
||||
if (!temp_dst) {
|
||||
temp_dst = (GLubyte *) malloc(temp_dst_stride * dstHeight);
|
||||
temp_dst = malloc(temp_dst_stride * dstHeight);
|
||||
if (!temp_dst) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "generate mipmaps");
|
||||
break;
|
||||
|
|
|
@ -65,11 +65,11 @@ mmInit(unsigned ofs, unsigned size)
|
|||
if (!size)
|
||||
return NULL;
|
||||
|
||||
heap = (struct mem_block *) calloc(1, sizeof(struct mem_block));
|
||||
heap = calloc(1, sizeof(struct mem_block));
|
||||
if (!heap)
|
||||
return NULL;
|
||||
|
||||
block = (struct mem_block *) calloc(1, sizeof(struct mem_block));
|
||||
block = calloc(1, sizeof(struct mem_block));
|
||||
if (!block) {
|
||||
free(heap);
|
||||
return NULL;
|
||||
|
@ -103,7 +103,7 @@ SliceBlock(struct mem_block *p,
|
|||
|
||||
/* break left [p, newblock, p->next], then p = newblock */
|
||||
if (startofs > p->ofs) {
|
||||
newblock = (struct mem_block*) calloc(1, sizeof(struct mem_block));
|
||||
newblock = calloc(1, sizeof(struct mem_block));
|
||||
if (!newblock)
|
||||
return NULL;
|
||||
newblock->ofs = startofs;
|
||||
|
@ -127,7 +127,7 @@ SliceBlock(struct mem_block *p,
|
|||
|
||||
/* break right, also [p, newblock, p->next] */
|
||||
if (size < p->size) {
|
||||
newblock = (struct mem_block*) calloc(1, sizeof(struct mem_block));
|
||||
newblock = calloc(1, sizeof(struct mem_block));
|
||||
if (!newblock)
|
||||
return NULL;
|
||||
newblock->ofs = startofs + size;
|
||||
|
|
|
@ -157,7 +157,7 @@ _mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
|
|||
|
||||
/* Alloc dest storage */
|
||||
bytes = ((width + 7) / 8 * height);
|
||||
buffer = (GLubyte *) malloc( bytes );
|
||||
buffer = malloc( bytes );
|
||||
if (!buffer)
|
||||
return NULL;
|
||||
|
||||
|
@ -1270,7 +1270,7 @@ _mesa_pack_rgba_span_float(struct gl_context *ctx, GLuint n, GLfloat rgba[][4],
|
|||
dstFormat == GL_LUMINANCE_ALPHA ||
|
||||
dstFormat == GL_LUMINANCE_INTEGER_EXT ||
|
||||
dstFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT) {
|
||||
luminance = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
luminance = malloc(n * sizeof(GLfloat));
|
||||
if (!luminance) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
|
||||
return;
|
||||
|
@ -4361,7 +4361,7 @@ _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
|
|||
{
|
||||
GLint dstComponents;
|
||||
GLint rDst, gDst, bDst, aDst, lDst, iDst;
|
||||
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
|
||||
GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
|
||||
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -4376,7 +4376,7 @@ _mesa_unpack_color_span_ubyte(struct gl_context *ctx,
|
|||
* Extract image data and convert to RGBA floats
|
||||
*/
|
||||
if (srcFormat == GL_COLOR_INDEX) {
|
||||
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
|
||||
GLuint *indexes = malloc(n * sizeof(GLuint));
|
||||
|
||||
if (!indexes) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -4555,7 +4555,7 @@ _mesa_unpack_color_span_float( struct gl_context *ctx,
|
|||
{
|
||||
GLint dstComponents;
|
||||
GLint rDst, gDst, bDst, aDst, lDst, iDst;
|
||||
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
|
||||
GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
|
||||
GLboolean intFormat = _mesa_is_enum_format_integer(srcFormat);
|
||||
|
||||
if (!rgba) {
|
||||
|
@ -4578,7 +4578,7 @@ _mesa_unpack_color_span_float( struct gl_context *ctx,
|
|||
* Extract image data and convert to RGBA floats
|
||||
*/
|
||||
if (srcFormat == GL_COLOR_INDEX) {
|
||||
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
|
||||
GLuint *indexes = malloc(n * sizeof(GLuint));
|
||||
|
||||
if (!indexes) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -4691,7 +4691,7 @@ _mesa_unpack_color_span_uint(struct gl_context *ctx,
|
|||
const GLvoid *source,
|
||||
const struct gl_pixelstore_attrib *srcPacking)
|
||||
{
|
||||
GLuint (*rgba)[4] = (GLuint (*)[4]) malloc(n * 4 * sizeof(GLfloat));
|
||||
GLuint (*rgba)[4] = malloc(n * 4 * sizeof(GLfloat));
|
||||
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -4869,7 +4869,7 @@ _mesa_unpack_dudv_span_byte( struct gl_context *ctx,
|
|||
GLint dstComponents;
|
||||
GLbyte *dst = dest;
|
||||
GLuint i;
|
||||
GLfloat (*rgba)[4] = (GLfloat (*)[4]) malloc(4 * n * sizeof(GLfloat));
|
||||
GLfloat (*rgba)[4] = malloc(4 * n * sizeof(GLfloat));
|
||||
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -4956,7 +4956,7 @@ _mesa_unpack_index_span( struct gl_context *ctx, GLuint n,
|
|||
/*
|
||||
* general solution
|
||||
*/
|
||||
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
|
||||
GLuint *indexes = malloc(n * sizeof(GLuint));
|
||||
|
||||
if (!indexes) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
|
@ -5007,7 +5007,7 @@ _mesa_pack_index_span( struct gl_context *ctx, GLuint n,
|
|||
const struct gl_pixelstore_attrib *dstPacking,
|
||||
GLbitfield transferOps )
|
||||
{
|
||||
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
|
||||
GLuint *indexes = malloc(n * sizeof(GLuint));
|
||||
|
||||
if (!indexes) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
|
||||
|
@ -5183,7 +5183,7 @@ _mesa_unpack_stencil_span( struct gl_context *ctx, GLuint n,
|
|||
/*
|
||||
* general solution
|
||||
*/
|
||||
GLuint *indexes = (GLuint *) malloc(n * sizeof(GLuint));
|
||||
GLuint *indexes = malloc(n * sizeof(GLuint));
|
||||
|
||||
if (!indexes) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil unpacking");
|
||||
|
@ -5253,7 +5253,7 @@ _mesa_pack_stencil_span( struct gl_context *ctx, GLuint n,
|
|||
GLenum dstType, GLvoid *dest, const GLubyte *source,
|
||||
const struct gl_pixelstore_attrib *dstPacking )
|
||||
{
|
||||
GLubyte *stencil = (GLubyte *) malloc(n * sizeof(GLubyte));
|
||||
GLubyte *stencil = malloc(n * sizeof(GLubyte));
|
||||
|
||||
if (!stencil) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "stencil packing");
|
||||
|
@ -5475,7 +5475,7 @@ _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
|
|||
depthValues = (GLfloat *) dest;
|
||||
}
|
||||
else {
|
||||
depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
depthTemp = malloc(n * sizeof(GLfloat));
|
||||
if (!depthTemp) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");
|
||||
return;
|
||||
|
@ -5656,7 +5656,7 @@ _mesa_pack_depth_span( struct gl_context *ctx, GLuint n, GLvoid *dest,
|
|||
GLenum dstType, const GLfloat *depthSpan,
|
||||
const struct gl_pixelstore_attrib *dstPacking )
|
||||
{
|
||||
GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
|
||||
if (!depthCopy) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel packing");
|
||||
return;
|
||||
|
@ -5778,8 +5778,8 @@ _mesa_pack_depth_stencil_span(struct gl_context *ctx,GLuint n,
|
|||
const GLubyte *stencilVals,
|
||||
const struct gl_pixelstore_attrib *dstPacking)
|
||||
{
|
||||
GLfloat *depthCopy = (GLfloat *) malloc(n * sizeof(GLfloat));
|
||||
GLubyte *stencilCopy = (GLubyte *) malloc(n * sizeof(GLubyte));
|
||||
GLfloat *depthCopy = malloc(n * sizeof(GLfloat));
|
||||
GLubyte *stencilCopy = malloc(n * sizeof(GLubyte));
|
||||
GLuint i;
|
||||
|
||||
if (!depthCopy || !stencilCopy) {
|
||||
|
@ -5877,7 +5877,7 @@ _mesa_unpack_image( GLuint dimensions,
|
|||
|
||||
{
|
||||
GLubyte *destBuffer
|
||||
= (GLubyte *) malloc(bytesPerRow * height * depth);
|
||||
= malloc(bytesPerRow * height * depth);
|
||||
GLubyte *dst;
|
||||
GLint img, row;
|
||||
if (!destBuffer)
|
||||
|
|
|
@ -143,7 +143,7 @@ read_depth_pixels( struct gl_context *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
depthValues = (GLfloat *) malloc(width * sizeof(GLfloat));
|
||||
depthValues = malloc(width * sizeof(GLfloat));
|
||||
|
||||
if (depthValues) {
|
||||
/* General case (slower) */
|
||||
|
@ -191,7 +191,7 @@ read_stencil_pixels( struct gl_context *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
stencil = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
stencil = malloc(width * sizeof(GLubyte));
|
||||
|
||||
if (stencil) {
|
||||
/* process image row by row */
|
||||
|
@ -486,7 +486,7 @@ fast_read_depth_stencil_pixels_separate(struct gl_context *ctx,
|
|||
return GL_TRUE; /* don't bother trying the slow path */
|
||||
}
|
||||
|
||||
stencilVals = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
stencilVals = malloc(width * sizeof(GLubyte));
|
||||
|
||||
if (stencilVals) {
|
||||
for (j = 0; j < height; j++) {
|
||||
|
@ -557,8 +557,8 @@ slow_read_depth_stencil_pixels_separate(struct gl_context *ctx,
|
|||
stencilStride = depthStride;
|
||||
}
|
||||
|
||||
stencilVals = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
depthVals = (GLfloat *) malloc(width * sizeof(GLfloat));
|
||||
stencilVals = malloc(width * sizeof(GLubyte));
|
||||
depthVals = malloc(width * sizeof(GLfloat));
|
||||
|
||||
if (stencilVals && depthVals) {
|
||||
for (j = 0; j < height; j++) {
|
||||
|
|
|
@ -377,7 +377,7 @@ detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
|
|||
_mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
|
||||
|
||||
/* alloc new, smaller array */
|
||||
newList = (struct gl_shader **)
|
||||
newList =
|
||||
malloc((n - 1) * sizeof(struct gl_shader *));
|
||||
if (!newList) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
|
||||
|
@ -1299,7 +1299,7 @@ read_shader(const char *fname)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
buffer = (char *) malloc(max);
|
||||
buffer = malloc(max);
|
||||
len = fread(buffer, 1, max, f);
|
||||
buffer[len] = 0;
|
||||
|
||||
|
@ -1336,7 +1336,7 @@ _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
|
|||
* This array holds offsets of where the appropriate string ends, thus the
|
||||
* last element will be set to the total length of the source code.
|
||||
*/
|
||||
offsets = (GLint *) malloc(count * sizeof(GLint));
|
||||
offsets = malloc(count * sizeof(GLint));
|
||||
if (offsets == NULL) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
|
||||
return;
|
||||
|
@ -1363,7 +1363,7 @@ _mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
|
|||
* valgrind warnings in the parser/grammer code.
|
||||
*/
|
||||
totalLength = offsets[count - 1] + 2;
|
||||
source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
|
||||
source = malloc(totalLength * sizeof(GLcharARB));
|
||||
if (source == NULL) {
|
||||
free((GLvoid *) offsets);
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
|
||||
|
|
|
@ -208,7 +208,7 @@ _mesa_cpal_compressed_teximage2d(GLenum target, GLint level,
|
|||
|
||||
/* allocate and fill dest image buffer */
|
||||
if (palette) {
|
||||
image = (GLubyte *) malloc(num_texels * info->size);
|
||||
image = malloc(num_texels * info->size);
|
||||
paletted_to_color(info, palette, indices, num_texels, image);
|
||||
}
|
||||
|
||||
|
|
|
@ -80,7 +80,7 @@ get_tex_depth(struct gl_context *ctx, GLuint dimensions,
|
|||
const GLint height = texImage->Height;
|
||||
const GLint depth = texImage->Depth;
|
||||
GLint img, row;
|
||||
GLfloat *depthRow = (GLfloat *) malloc(width * sizeof(GLfloat));
|
||||
GLfloat *depthRow = malloc(width * sizeof(GLfloat));
|
||||
|
||||
if (!depthRow) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage");
|
||||
|
@ -236,7 +236,7 @@ get_tex_rgba_compressed(struct gl_context *ctx, GLuint dimensions,
|
|||
GLuint row;
|
||||
|
||||
/* Decompress into temp float buffer, then pack into user buffer */
|
||||
tempImage = (GLfloat *) malloc(width * height * depth
|
||||
tempImage = malloc(width * height * depth
|
||||
* 4 * sizeof(GLfloat));
|
||||
if (!tempImage) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()");
|
||||
|
@ -310,7 +310,7 @@ get_tex_rgba_uncompressed(struct gl_context *ctx, GLuint dimensions,
|
|||
GLboolean tex_is_uint = _mesa_is_format_unsigned(texImage->TexFormat);
|
||||
|
||||
/* Allocate buffer for one row of texels */
|
||||
rgba = (GLfloat (*)[4]) malloc(4 * width * sizeof(GLfloat));
|
||||
rgba = malloc(4 * width * sizeof(GLfloat));
|
||||
rgba_uint = (GLuint (*)[4]) rgba;
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()");
|
||||
|
|
|
@ -354,7 +354,7 @@ _mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
|
|||
textureBaseFormat == GL_INTENSITY ||
|
||||
textureBaseFormat == GL_DEPTH_COMPONENT);
|
||||
|
||||
tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
|
||||
tempImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* components * sizeof(GLfloat));
|
||||
if (!tempImage)
|
||||
return NULL;
|
||||
|
@ -392,7 +392,7 @@ _mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
|
|||
*/
|
||||
ASSERT(texComponents >= logComponents);
|
||||
|
||||
newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
|
||||
newImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* texComponents * sizeof(GLfloat));
|
||||
if (!newImage) {
|
||||
free(tempImage);
|
||||
|
@ -463,7 +463,7 @@ make_temp_uint_image(struct gl_context *ctx, GLuint dims,
|
|||
textureBaseFormat == GL_INTENSITY ||
|
||||
textureBaseFormat == GL_ALPHA);
|
||||
|
||||
tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
|
||||
tempImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* components * sizeof(GLuint));
|
||||
if (!tempImage)
|
||||
return NULL;
|
||||
|
@ -501,7 +501,7 @@ make_temp_uint_image(struct gl_context *ctx, GLuint dims,
|
|||
*/
|
||||
ASSERT(texComponents >= logComponents);
|
||||
|
||||
newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
|
||||
newImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* texComponents * sizeof(GLuint));
|
||||
if (!newImage) {
|
||||
free(tempImage);
|
||||
|
@ -591,7 +591,7 @@ _mesa_make_temp_ubyte_image(struct gl_context *ctx, GLuint dims,
|
|||
textureBaseFormat == GL_INTENSITY);
|
||||
|
||||
/* unpack and transfer the source image */
|
||||
tempImage = (GLubyte *) malloc(srcWidth * srcHeight * srcDepth
|
||||
tempImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* components * sizeof(GLubyte));
|
||||
if (!tempImage) {
|
||||
return NULL;
|
||||
|
@ -632,7 +632,7 @@ _mesa_make_temp_ubyte_image(struct gl_context *ctx, GLuint dims,
|
|||
*/
|
||||
ASSERT(texComponents >= logComponents);
|
||||
|
||||
newImage = (GLubyte *) malloc(srcWidth * srcHeight * srcDepth
|
||||
newImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* texComponents * sizeof(GLubyte));
|
||||
if (!newImage) {
|
||||
free(tempImage);
|
||||
|
@ -2393,7 +2393,7 @@ _mesa_texstore_dudv8(TEXSTORE_PARAMS)
|
|||
GLbyte *tempImage, *dst, *src;
|
||||
GLint row;
|
||||
|
||||
tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth
|
||||
tempImage = malloc(srcWidth * srcHeight * srcDepth
|
||||
* components * sizeof(GLbyte));
|
||||
if (!tempImage)
|
||||
return GL_FALSE;
|
||||
|
@ -2797,8 +2797,8 @@ _mesa_texstore_z24_s8(TEXSTORE_PARAMS)
|
|||
}
|
||||
else if (srcFormat == GL_DEPTH_COMPONENT ||
|
||||
srcFormat == GL_STENCIL_INDEX) {
|
||||
GLuint *depth = (GLuint *) malloc(srcWidth * sizeof(GLuint));
|
||||
GLubyte *stencil = (GLubyte *) malloc(srcWidth * sizeof(GLubyte));
|
||||
GLuint *depth = malloc(srcWidth * sizeof(GLuint));
|
||||
GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
|
||||
|
||||
if (!depth || !stencil) {
|
||||
free(depth);
|
||||
|
@ -2880,8 +2880,8 @@ _mesa_texstore_s8_z24(TEXSTORE_PARAMS)
|
|||
ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||
|
||||
srcType == GL_UNSIGNED_INT_24_8_EXT);
|
||||
|
||||
depth = (GLuint *) malloc(srcWidth * sizeof(GLuint));
|
||||
stencil = (GLubyte *) malloc(srcWidth * sizeof(GLubyte));
|
||||
depth = malloc(srcWidth * sizeof(GLuint));
|
||||
stencil = malloc(srcWidth * sizeof(GLubyte));
|
||||
|
||||
if (!depth || !stencil) {
|
||||
free(depth);
|
||||
|
@ -2967,7 +2967,7 @@ _mesa_texstore_s8(TEXSTORE_PARAMS)
|
|||
const GLint srcRowStride
|
||||
= _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
|
||||
GLint img, row;
|
||||
GLubyte *stencil = (GLubyte *) malloc(srcWidth * sizeof(GLubyte));
|
||||
GLubyte *stencil = malloc(srcWidth * sizeof(GLubyte));
|
||||
|
||||
if (!stencil)
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -643,7 +643,7 @@ _mesa_TransformFeedbackVaryings(GLuint program, GLsizei count,
|
|||
|
||||
/* allocate new memory for varying names */
|
||||
shProg->TransformFeedback.VaryingNames =
|
||||
(GLchar **) malloc(count * sizeof(GLchar *));
|
||||
malloc(count * sizeof(GLchar *));
|
||||
|
||||
if (!shProg->TransformFeedback.VaryingNames) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTransformFeedbackVaryings()");
|
||||
|
|
|
@ -99,7 +99,7 @@ _mesa_uniform_attach_driver_storage(struct gl_uniform_storage *uni,
|
|||
enum gl_uniform_driver_format format,
|
||||
void *data)
|
||||
{
|
||||
uni->driver_storage = (struct gl_uniform_driver_storage*)
|
||||
uni->driver_storage =
|
||||
realloc(uni->driver_storage,
|
||||
sizeof(struct gl_uniform_driver_storage)
|
||||
* (uni->num_driver_storage + 1));
|
||||
|
|
|
@ -224,7 +224,7 @@ compute_version(struct gl_context *ctx)
|
|||
|
||||
override_version(ctx);
|
||||
|
||||
ctx->VersionString = (char *) malloc(max);
|
||||
ctx->VersionString = malloc(max);
|
||||
if (ctx->VersionString) {
|
||||
_mesa_snprintf(ctx->VersionString, max,
|
||||
"%u.%u Mesa " MESA_VERSION_STRING
|
||||
|
@ -256,7 +256,7 @@ compute_version_es1(struct gl_context *ctx)
|
|||
_mesa_problem(ctx, "Incomplete OpenGL ES 1.0 support.");
|
||||
}
|
||||
|
||||
ctx->VersionString = (char *) malloc(max);
|
||||
ctx->VersionString = malloc(max);
|
||||
if (ctx->VersionString) {
|
||||
_mesa_snprintf(ctx->VersionString, max,
|
||||
"OpenGL ES-CM 1.%d Mesa " MESA_VERSION_STRING
|
||||
|
@ -289,7 +289,7 @@ compute_version_es2(struct gl_context *ctx)
|
|||
_mesa_problem(ctx, "Incomplete OpenGL ES 2.0 support.");
|
||||
}
|
||||
|
||||
ctx->VersionString = (char *) malloc(max);
|
||||
ctx->VersionString = malloc(max);
|
||||
if (ctx->VersionString) {
|
||||
_mesa_snprintf(ctx->VersionString, max,
|
||||
"OpenGL ES 2.0 Mesa " MESA_VERSION_STRING
|
||||
|
|
|
@ -67,7 +67,7 @@ msetup(str, n)
|
|||
return NULL;
|
||||
if (pgsize == 0)
|
||||
pgsize = getpagesize();
|
||||
curobj = (char *)malloc(n + EXTRABYTES + pgsize * 2);
|
||||
curobj = malloc(n + EXTRABYTES + pgsize * 2);
|
||||
if (curobj == NULL)
|
||||
return NULL;
|
||||
e = curobj + n + EXTRABYTES;
|
||||
|
|
|
@ -208,7 +208,7 @@ static int test_norm_function( normal_func func, int mtype, long *cycles )
|
|||
|
||||
(void) cycles;
|
||||
|
||||
mat->m = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
mat->m = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
mat->inv = m = mat->m;
|
||||
|
||||
init_matrix( m );
|
||||
|
|
|
@ -183,7 +183,7 @@ static int test_transform_function( transform_func func, int psize,
|
|||
return 0;
|
||||
}
|
||||
|
||||
mat->m = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
mat->m = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
mat->type = mtypes[mtype];
|
||||
|
||||
m = mat->m;
|
||||
|
|
|
@ -1468,10 +1468,10 @@ _math_matrix_loadf( GLmatrix *mat, const GLfloat *m )
|
|||
void
|
||||
_math_matrix_ctr( GLmatrix *m )
|
||||
{
|
||||
m->m = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
m->m = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
if (m->m)
|
||||
memcpy( m->m, Identity, sizeof(Identity) );
|
||||
m->inv = (GLfloat *) _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
m->inv = _mesa_align_malloc( 16 * sizeof(GLfloat), 16 );
|
||||
if (m->inv)
|
||||
memcpy( m->inv, Identity, sizeof(Identity) );
|
||||
m->type = MATRIX_IDENTITY;
|
||||
|
|
|
@ -1236,7 +1236,7 @@ Parse_PrintInstruction(struct parse_state *parseState,
|
|||
for (len = 0; str[len] != '\''; len++) /* find closing quote */
|
||||
;
|
||||
parseState->pos += len + 1;
|
||||
msg = (GLubyte*) malloc(len + 1);
|
||||
msg = malloc(len + 1);
|
||||
|
||||
memcpy(msg, str, len);
|
||||
msg[len] = 0;
|
||||
|
@ -1481,7 +1481,7 @@ _mesa_parse_nv_fragment_program(struct gl_context *ctx, GLenum dstTarget,
|
|||
GLubyte *programString;
|
||||
|
||||
/* Make a null-terminated copy of the program string */
|
||||
programString = (GLubyte *) malloc(len + 1);
|
||||
programString = malloc(len + 1);
|
||||
if (!programString) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
|
||||
return;
|
||||
|
|
|
@ -1050,7 +1050,7 @@ Parse_PrintInstruction(struct parse_state *parseState, struct prog_instruction *
|
|||
for (len = 0; str[len] != '\''; len++) /* find closing quote */
|
||||
;
|
||||
parseState->pos += len + 1;
|
||||
msg = (GLubyte*) malloc(len + 1);
|
||||
msg = malloc(len + 1);
|
||||
|
||||
memcpy(msg, str, len);
|
||||
msg[len] = 0;
|
||||
|
@ -1293,7 +1293,7 @@ _mesa_parse_nv_vertex_program(struct gl_context *ctx, GLenum dstTarget,
|
|||
GLubyte *programString;
|
||||
|
||||
/* Make a null-terminated copy of the program string */
|
||||
programString = (GLubyte *) malloc(len + 1);
|
||||
programString = malloc(len + 1);
|
||||
if (!programString) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
|
||||
return;
|
||||
|
|
|
@ -88,7 +88,7 @@ rehash(struct gl_program_cache *cache)
|
|||
cache->last = NULL;
|
||||
|
||||
size = cache->size * 3;
|
||||
items = (struct cache_item**) malloc(size * sizeof(*items));
|
||||
items = malloc(size * sizeof(*items));
|
||||
memset(items, 0, size * sizeof(*items));
|
||||
|
||||
for (i = 0; i < cache->size; i++)
|
||||
|
@ -141,7 +141,7 @@ _mesa_new_program_cache(void)
|
|||
struct gl_program_cache *cache = CALLOC_STRUCT(gl_program_cache);
|
||||
if (cache) {
|
||||
cache->size = 17;
|
||||
cache->items = (struct cache_item **)
|
||||
cache->items =
|
||||
calloc(1, cache->size * sizeof(struct cache_item));
|
||||
if (!cache->items) {
|
||||
free(cache);
|
||||
|
|
|
@ -69,7 +69,7 @@ _mesa_init_instructions(struct prog_instruction *inst, GLuint count)
|
|||
struct prog_instruction *
|
||||
_mesa_alloc_instructions(GLuint numInst)
|
||||
{
|
||||
return (struct prog_instruction *)
|
||||
return
|
||||
calloc(1, numInst * sizeof(struct prog_instruction));
|
||||
}
|
||||
|
||||
|
|
|
@ -260,7 +260,7 @@ _mesa_remove_dead_code_global(struct gl_program *prog)
|
|||
/*_mesa_print_program(prog);*/
|
||||
}
|
||||
|
||||
removeInst = (GLboolean *)
|
||||
removeInst =
|
||||
calloc(1, prog->NumInstructions * sizeof(GLboolean));
|
||||
|
||||
/* Determine which temps are read and written */
|
||||
|
@ -604,7 +604,7 @@ _mesa_remove_dead_code_local(struct gl_program *prog)
|
|||
GLboolean *removeInst;
|
||||
GLuint i, arg, rem = 0;
|
||||
|
||||
removeInst = (GLboolean *)
|
||||
removeInst =
|
||||
calloc(1, prog->NumInstructions * sizeof(GLboolean));
|
||||
|
||||
for (i = 0; i < prog->NumInstructions; i++) {
|
||||
|
@ -745,7 +745,7 @@ _mesa_remove_extra_moves(struct gl_program *prog)
|
|||
_mesa_print_program(prog);
|
||||
}
|
||||
|
||||
removeInst = (GLboolean *)
|
||||
removeInst =
|
||||
calloc(1, prog->NumInstructions * sizeof(GLboolean));
|
||||
|
||||
/*
|
||||
|
|
|
@ -249,7 +249,7 @@ _mesa_find_line_column(const GLubyte *string, const GLubyte *pos,
|
|||
while (*p != 0 && *p != '\n')
|
||||
p++;
|
||||
len = p - lineStart;
|
||||
s = (GLubyte *) malloc(len + 1);
|
||||
s = malloc(len + 1);
|
||||
memcpy(s, lineStart, len);
|
||||
s[len] = 0;
|
||||
|
||||
|
|
|
@ -875,8 +875,8 @@ draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
|
|||
pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
|
||||
assert(pixels);
|
||||
|
||||
sValues = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
zValues = (GLuint *) malloc(width * sizeof(GLuint));
|
||||
sValues = malloc(width * sizeof(GLubyte));
|
||||
zValues = malloc(width * sizeof(GLuint));
|
||||
|
||||
if (sValues && zValues) {
|
||||
GLint row;
|
||||
|
@ -1598,7 +1598,7 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
/* copy image from ptRead surface to ptTex surface */
|
||||
if (type == GL_COLOR) {
|
||||
/* alternate path using get/put_tile() */
|
||||
GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
|
||||
GLfloat *buf = malloc(width * height * 4 * sizeof(GLfloat));
|
||||
enum pipe_format readFormat, drawFormat;
|
||||
readFormat = util_format_linear(rbRead->texture->format);
|
||||
drawFormat = util_format_linear(pt->format);
|
||||
|
@ -1610,7 +1610,7 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
}
|
||||
else {
|
||||
/* GL_DEPTH */
|
||||
GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));
|
||||
GLuint *buf = malloc(width * height * sizeof(GLuint));
|
||||
pipe_get_tile_z(pipe, ptRead, 0, 0, readW, readH, buf);
|
||||
pipe_put_tile_z(pipe, ptTex, pack.SkipPixels, pack.SkipRows,
|
||||
readW, readH, buf);
|
||||
|
|
|
@ -648,7 +648,7 @@ decompress_with_blit(struct gl_context * ctx,
|
|||
enum pipe_format pformat = util_format_linear(dst_texture->format);
|
||||
GLfloat *rgba;
|
||||
|
||||
rgba = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
|
||||
rgba = malloc(width * 4 * sizeof(GLfloat));
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glGetTexImage()");
|
||||
goto end;
|
||||
|
@ -775,7 +775,7 @@ fallback_copy_texsubimage(struct gl_context *ctx,
|
|||
yStep = 1;
|
||||
}
|
||||
|
||||
data = (uint *) malloc(width * sizeof(uint));
|
||||
data = malloc(width * sizeof(uint));
|
||||
|
||||
if (data) {
|
||||
/* To avoid a large temp memory allocation, do copy row by row */
|
||||
|
@ -796,7 +796,7 @@ fallback_copy_texsubimage(struct gl_context *ctx,
|
|||
else {
|
||||
/* RGBA format */
|
||||
GLfloat *tempSrc =
|
||||
(GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
|
||||
malloc(width * height * 4 * sizeof(GLfloat));
|
||||
|
||||
if (tempSrc && texDest) {
|
||||
const GLint dims = 2;
|
||||
|
|
|
@ -720,7 +720,7 @@ GLboolean
|
|||
_swrast_CreateContext( struct gl_context *ctx )
|
||||
{
|
||||
GLuint i;
|
||||
SWcontext *swrast = (SWcontext *) calloc(1, sizeof(SWcontext));
|
||||
SWcontext *swrast = calloc(1, sizeof(SWcontext));
|
||||
#ifdef _OPENMP
|
||||
const GLuint maxThreads = omp_get_max_threads();
|
||||
#else
|
||||
|
@ -775,7 +775,7 @@ _swrast_CreateContext( struct gl_context *ctx )
|
|||
* using multiple threads, it is necessary to have one SpanArrays instance
|
||||
* per thread.
|
||||
*/
|
||||
swrast->SpanArrays = (SWspanarrays *) malloc(maxThreads * sizeof(SWspanarrays));
|
||||
swrast->SpanArrays = malloc(maxThreads * sizeof(SWspanarrays));
|
||||
if (!swrast->SpanArrays) {
|
||||
free(swrast);
|
||||
return GL_FALSE;
|
||||
|
@ -803,10 +803,10 @@ _swrast_CreateContext( struct gl_context *ctx )
|
|||
|
||||
ctx->swrast_context = swrast;
|
||||
|
||||
swrast->stencil_temp.buf1 = (GLubyte *) malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf2 = (GLubyte *) malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf3 = (GLubyte *) malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf4 = (GLubyte *) malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf1 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf2 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf3 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
swrast->stencil_temp.buf4 = malloc(SWRAST_MAX_WIDTH * sizeof(GLubyte));
|
||||
|
||||
if (!swrast->stencil_temp.buf1 ||
|
||||
!swrast->stencil_temp.buf2 ||
|
||||
|
|
|
@ -139,7 +139,7 @@ copy_rgba_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
span.arrayAttribs = FRAG_BIT_COL0; /* we'll fill in COL0 attrib values */
|
||||
|
||||
if (overlapping) {
|
||||
tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat) * 4);
|
||||
tmpImage = malloc(width * height * sizeof(GLfloat) * 4);
|
||||
if (!tmpImage) {
|
||||
_mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
|
||||
return;
|
||||
|
@ -286,7 +286,7 @@ copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
|
||||
if (overlapping) {
|
||||
GLint ssy = sy;
|
||||
tmpImage = (GLfloat *) malloc(width * height * sizeof(GLfloat));
|
||||
tmpImage = malloc(width * height * sizeof(GLfloat));
|
||||
if (!tmpImage) {
|
||||
_mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
|
||||
return;
|
||||
|
@ -303,7 +303,7 @@ copy_depth_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
p = NULL;
|
||||
}
|
||||
|
||||
depth = (GLfloat *) malloc(width * sizeof(GLfloat));
|
||||
depth = malloc(width * sizeof(GLfloat));
|
||||
if (!depth) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels()");
|
||||
goto end;
|
||||
|
@ -383,7 +383,7 @@ copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
|
||||
if (overlapping) {
|
||||
GLint ssy = sy;
|
||||
tmpImage = (GLubyte *) malloc(width * height * sizeof(GLubyte));
|
||||
tmpImage = malloc(width * height * sizeof(GLubyte));
|
||||
if (!tmpImage) {
|
||||
_mesa_error( ctx, GL_OUT_OF_MEMORY, "glCopyPixels" );
|
||||
return;
|
||||
|
@ -400,7 +400,7 @@ copy_stencil_pixels( struct gl_context *ctx, GLint srcx, GLint srcy,
|
|||
p = NULL;
|
||||
}
|
||||
|
||||
stencil = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
stencil = malloc(width * sizeof(GLubyte));
|
||||
if (!stencil) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels()");
|
||||
goto end;
|
||||
|
|
|
@ -311,7 +311,7 @@ _swrast_depth_test_span(struct gl_context *ctx, SWspan *span)
|
|||
}
|
||||
else {
|
||||
/* copy Z buffer values into temp buffer (32-bit Z values) */
|
||||
zBufferTemp = (GLuint *) malloc(count * sizeof(GLuint));
|
||||
zBufferTemp = malloc(count * sizeof(GLuint));
|
||||
if (!zBufferTemp)
|
||||
return 0;
|
||||
|
||||
|
@ -422,7 +422,7 @@ _swrast_depth_bounds_test( struct gl_context *ctx, SWspan *span )
|
|||
GLuint *zBufferTemp;
|
||||
const GLuint *zBufferVals;
|
||||
|
||||
zBufferTemp = (GLuint *) malloc(count * sizeof(GLuint));
|
||||
zBufferTemp = malloc(count * sizeof(GLuint));
|
||||
if (!zBufferTemp) {
|
||||
/* don't generate a stream of OUT_OF_MEMORY errors here */
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -267,7 +267,7 @@ draw_stencil_pixels( struct gl_context *ctx, GLint x, GLint y,
|
|||
GLint row;
|
||||
GLubyte *values;
|
||||
|
||||
values = (GLubyte *) malloc(width * sizeof(GLubyte));
|
||||
values = malloc(width * sizeof(GLubyte));
|
||||
if (!values) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
|
||||
return;
|
||||
|
@ -592,7 +592,7 @@ draw_depth_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
|
|||
GLuint *zValues; /* 32-bit Z values */
|
||||
GLint i;
|
||||
|
||||
zValues = (GLuint *) malloc(width * sizeof(GLuint));
|
||||
zValues = malloc(width * sizeof(GLuint));
|
||||
if (!zValues) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glDrawPixels");
|
||||
return;
|
||||
|
|
|
@ -98,14 +98,14 @@ texture_combine( struct gl_context *ctx, GLuint unit,
|
|||
GLchan (*rgbaChan)[4] = span->array->rgba;
|
||||
|
||||
/* alloc temp pixel buffers */
|
||||
rgba = (float4_array) malloc(4 * n * sizeof(GLfloat));
|
||||
rgba = malloc(4 * n * sizeof(GLfloat));
|
||||
if (!rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < numArgsRGB || i < numArgsA; i++) {
|
||||
ccolor[i] = (float4_array) malloc(4 * n * sizeof(GLfloat));
|
||||
ccolor[i] = malloc(4 * n * sizeof(GLfloat));
|
||||
if (!ccolor[i]) {
|
||||
while (i) {
|
||||
free(ccolor[i]);
|
||||
|
@ -611,7 +611,7 @@ _swrast_texture_span( struct gl_context *ctx, SWspan *span )
|
|||
* thread.
|
||||
*/
|
||||
swrast->TexelBuffer =
|
||||
(GLfloat *) malloc(ctx->Const.MaxTextureImageUnits * maxThreads *
|
||||
malloc(ctx->Const.MaxTextureImageUnits * maxThreads *
|
||||
SWRAST_MAX_WIDTH * 4 * sizeof(GLfloat));
|
||||
if (!swrast->TexelBuffer) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_combine");
|
||||
|
@ -619,7 +619,7 @@ _swrast_texture_span( struct gl_context *ctx, SWspan *span )
|
|||
}
|
||||
}
|
||||
|
||||
primary_rgba = (float4_array) malloc(span->end * 4 * sizeof(GLfloat));
|
||||
primary_rgba = malloc(span->end * 4 * sizeof(GLfloat));
|
||||
|
||||
if (!primary_rgba) {
|
||||
_mesa_error(ctx, GL_OUT_OF_MEMORY, "texture_span");
|
||||
|
|
|
@ -1618,7 +1618,7 @@ create_filter_table(void)
|
|||
{
|
||||
GLuint i;
|
||||
if (!weightLut) {
|
||||
weightLut = (GLfloat *) malloc(WEIGHT_LUT_SIZE * sizeof(GLfloat));
|
||||
weightLut = malloc(WEIGHT_LUT_SIZE * sizeof(GLfloat));
|
||||
|
||||
for (i = 0; i < WEIGHT_LUT_SIZE; ++i) {
|
||||
GLfloat alpha = 2;
|
||||
|
|
|
@ -83,7 +83,7 @@ _swrast_alloc_texture_image_buffer(struct gl_context *ctx,
|
|||
* We allocate the array for 1D/2D textures too in order to avoid special-
|
||||
* case code in the texstore routines.
|
||||
*/
|
||||
swImg->ImageOffsets = (GLuint *) malloc(texImage->Depth * sizeof(GLuint));
|
||||
swImg->ImageOffsets = malloc(texImage->Depth * sizeof(GLuint));
|
||||
if (!swImg->ImageOffsets)
|
||||
return GL_FALSE;
|
||||
|
||||
|
|
|
@ -375,7 +375,7 @@ _swrast_write_zoomed_stencil_span(struct gl_context *ctx, GLint imgX, GLint imgY
|
|||
ASSERT(zoomedWidth > 0);
|
||||
ASSERT(zoomedWidth <= SWRAST_MAX_WIDTH);
|
||||
|
||||
zoomedVals = (GLubyte *) malloc(zoomedWidth * sizeof(GLubyte));
|
||||
zoomedVals = malloc(zoomedWidth * sizeof(GLubyte));
|
||||
if (!zoomedVals)
|
||||
return;
|
||||
|
||||
|
@ -420,7 +420,7 @@ _swrast_write_zoomed_z_span(struct gl_context *ctx, GLint imgX, GLint imgY,
|
|||
ASSERT(zoomedWidth > 0);
|
||||
ASSERT(zoomedWidth <= SWRAST_MAX_WIDTH);
|
||||
|
||||
zoomedVals = (GLuint *) malloc(zoomedWidth * sizeof(GLuint));
|
||||
zoomedVals = malloc(zoomedWidth * sizeof(GLuint));
|
||||
if (!zoomedVals)
|
||||
return;
|
||||
|
||||
|
|
|
@ -49,7 +49,7 @@
|
|||
GLboolean
|
||||
_swsetup_CreateContext( struct gl_context *ctx )
|
||||
{
|
||||
SScontext *swsetup = (SScontext *) calloc(1, sizeof(SScontext));
|
||||
SScontext *swsetup = calloc(1, sizeof(SScontext));
|
||||
|
||||
if (!swsetup)
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -50,7 +50,7 @@ _tnl_CreateContext( struct gl_context *ctx )
|
|||
|
||||
/* Create the TNLcontext structure
|
||||
*/
|
||||
ctx->swtnl_context = tnl = (TNLcontext *) calloc(1, sizeof(TNLcontext));
|
||||
ctx->swtnl_context = tnl = calloc(1, sizeof(TNLcontext));
|
||||
|
||||
if (!tnl) {
|
||||
return GL_FALSE;
|
||||
|
|
|
@ -521,7 +521,7 @@ init_vp(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
|
|||
|
||||
/* a few other misc allocations */
|
||||
_mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
|
||||
store->clipmask = (GLubyte *) _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
|
||||
store->clipmask = _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
|
|
@ -570,8 +570,8 @@ static GLboolean alloc_texgen_data( struct gl_context *ctx,
|
|||
for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
|
||||
_mesa_vector4f_alloc( &store->texcoord[i], 0, VB->Size, 32 );
|
||||
|
||||
store->tmp_f = (GLfloat (*)[3]) malloc(VB->Size * sizeof(GLfloat) * 3);
|
||||
store->tmp_m = (GLfloat *) malloc(VB->Size * sizeof(GLfloat));
|
||||
store->tmp_f = malloc(VB->Size * sizeof(GLfloat) * 3);
|
||||
store->tmp_m = malloc(VB->Size * sizeof(GLfloat));
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
|
|
@ -245,7 +245,7 @@ static GLboolean init_vertex_stage( struct gl_context *ctx,
|
|||
_mesa_vector4f_alloc( &store->clip, 0, size, 32 );
|
||||
_mesa_vector4f_alloc( &store->proj, 0, size, 32 );
|
||||
|
||||
store->clipmask = (GLubyte *) _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
|
||||
store->clipmask = _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
|
||||
|
||||
if (!store->clipmask ||
|
||||
!store->eye.data ||
|
||||
|
|
|
@ -87,7 +87,7 @@ void _tnl_register_fastpath( struct tnl_clipspace *vtx,
|
|||
fastpath->attr_count = vtx->attr_count;
|
||||
fastpath->match_strides = match_strides;
|
||||
fastpath->func = vtx->emit;
|
||||
fastpath->attr = (struct tnl_attr_type *)
|
||||
fastpath->attr =
|
||||
malloc(vtx->attr_count * sizeof(fastpath->attr[0]));
|
||||
|
||||
for (i = 0; i < vtx->attr_count; i++) {
|
||||
|
@ -495,7 +495,7 @@ void _tnl_init_vertices( struct gl_context *ctx,
|
|||
if (max_vertex_size > vtx->max_vertex_size) {
|
||||
_tnl_free_vertices( ctx );
|
||||
vtx->max_vertex_size = max_vertex_size;
|
||||
vtx->vertex_buf = (GLubyte *)_mesa_align_calloc(vb_size * max_vertex_size, 32 );
|
||||
vtx->vertex_buf = _mesa_align_calloc(vb_size * max_vertex_size, 32 );
|
||||
invalidate_funcs(vtx);
|
||||
}
|
||||
|
||||
|
|
|
@ -1179,7 +1179,7 @@ void vbo_exec_vtx_init( struct vbo_exec_context *exec )
|
|||
ctx->Shared->NullBufferObj);
|
||||
|
||||
ASSERT(!exec->vtx.buffer_map);
|
||||
exec->vtx.buffer_map = (GLfloat *)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
|
||||
exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
|
||||
exec->vtx.buffer_ptr = exec->vtx.buffer_map;
|
||||
|
||||
vbo_exec_vtxfmt_init( exec );
|
||||
|
|
|
@ -86,7 +86,7 @@ find_sub_primitives(const void *elements, unsigned element_size,
|
|||
GLuint scan_index;
|
||||
unsigned scan_num;
|
||||
|
||||
sub_prims = (struct sub_primitive *)
|
||||
sub_prims =
|
||||
malloc(max_prims * sizeof(struct sub_primitive));
|
||||
|
||||
if (!sub_prims) {
|
||||
|
|
|
@ -146,7 +146,7 @@ void vbo_rebase_prims( struct gl_context *ctx,
|
|||
/* If we can just tell the hardware or the TNL to interpret our
|
||||
* indices with a different base, do so.
|
||||
*/
|
||||
tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);
|
||||
tmp_prims = malloc(sizeof(*prim) * nr_prims);
|
||||
|
||||
for (i = 0; i < nr_prims; i++) {
|
||||
tmp_prims[i] = prim[i];
|
||||
|
@ -195,7 +195,7 @@ void vbo_rebase_prims( struct gl_context *ctx,
|
|||
else {
|
||||
/* Otherwise the primitives need adjustment.
|
||||
*/
|
||||
tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);
|
||||
tmp_prims = malloc(sizeof(*prim) * nr_prims);
|
||||
|
||||
for (i = 0; i < nr_prims; i++) {
|
||||
/* If this fails, it could indicate an application error:
|
||||
|
|
Loading…
Reference in New Issue