{
GLdouble *vertex;
int i;
- vertex = (GLdouble *) malloc(6 * sizeof(GLdouble));
+ vertex = malloc(6 * sizeof(GLdouble));
vertex[0] = coords[0];
vertex[1] = coords[1];
vertex[2] = coords[2];
int x=0;
/* int y=0; */
- d=(GLdouble**) malloc(sizeof(GLdouble)* p->op.u.polygon.cnt);
+ d= malloc(sizeof(GLdouble)* p->op.u.polygon.cnt);
for (x=0;x < p->op.u.polygon.cnt; x++)
{
/* GLdouble temp; */
- d[x]=(GLdouble*)(malloc(sizeof(GLdouble)*3));
+ d[x]=malloc(sizeof(GLdouble)*3);
d[x][0]=p->op.u.polygon.pts[x].x;
d[x][1]=p->op.u.polygon.pts[x].y;
d[x][2]=p->op.u.polygon.pts[x].z+view->Topview->global_z;
{
//returns graph index , otherwise -1
Agraph_t *graph;
- graph = (Agraph_t *) malloc(sizeof(Agraph_t));
+ graph = malloc(sizeof(Agraph_t));
if (graph) {
view->graphCount = view->graphCount + 1;
view->g[view->graphCount - 1] = graph;
if (sz > bufsz) {
if (buf)
free(buf);
- buf = (char *) malloc(sz);
+ buf = malloc(sz);
}
if (*gname == '%') /* anonymous graph */
else {
if (!buf) {
sz = strlen(outfile) + 100; /* enough to handle '_<g>_<b>' */
- buf = (char *) malloc(sz);
+ buf = malloc(sz);
}
if (suffix) {
if (nb < 0)
if (sfx) {
size = sfx - name;
suffix = sfx + 1;
- path = (char *) malloc(size + 1);
+ path = malloc(size + 1);
strncpy(path, name, size);
*(path + size) = '\0';
} else {
#include <cgraph/cgraph.h>
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
typedef struct {
Agrec_t h;
if (sfx) {
suffix = sfx + 1;
size = sfx - name;
- path = (char *) malloc(size + 1);
+ path = malloc(size + 1);
strncpy(path, name, size);
*(path + size) = '\0';
} else {
name = outfile;
else {
if (!buf)
- buf = (char *) malloc(strlen(outfile) + 20); /* enough to handle '_number' */
+ buf = malloc(strlen(outfile) + 20); /* enough to handle '_number' */
if (suffix)
sprintf(buf, "%s_%d.%s", path, sufcnt, suffix);
else
if (n > len) {
sz = n + 100;
if (len == 0)
- buf = (char *) malloc(sz);
+ buf = malloc(sz);
else
buf = (char *) realloc(buf, sz);
len = sz;
#endif
#include <string.h>
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
#include <cgraph/cgraph.h>
char buf[1];
};
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
/* Round x up to next multiple of y, which is a power of 2 */
#define ROUND2(x,y) (((x) + ((y)-1)) & ~((y)-1))
#define SMALLBUF 128
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
#define EMPTY(s) ((s == 0) || (*s == '\0'))
#define SLEN(s) (sizeof(s)-1)
/* assemble the sorted list of nodes and store the initial colors */
nn = agnnodes(g);
- nlist = (Agnode_t **) malloc(nn * sizeof(Agnode_t *));
+ nlist = malloc(nn * sizeof(Agnode_t *));
i = 0;
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
nlist[i++] = n;
char buf[1];
};
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
/* Round x up to next multiple of y, which is a power of 2 */
#define ROUND2(x,y) (((x) + ((y)-1)) & ~((y)-1))
type = mm_get_type(matcode);
switch (type) {
case MATRIX_TYPE_REAL:
- val = (real *) malloc(nz * sizeof(real));
+ val = malloc(nz * sizeof(real));
for (i = 0; i < nz; i++) {
fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]);
I[i]--; /* adjust from 1-based to 0-based */
vp = (void *) val;
break;
case MATRIX_TYPE_INTEGER:
- vali = (int *) malloc(nz * sizeof(int));
+ vali = malloc(nz * sizeof(int));
for (i = 0; i < nz; i++) {
fscanf(f, "%d %d %d\n", &I[i], &J[i], &vali[i]);
I[i]--; /* adjust from 1-based to 0-based */
}
break;
case MATRIX_TYPE_COMPLEX:
- val = (real *) malloc(2 * nz * sizeof(real));
+ val = malloc(2 * nz * sizeof(real));
v = val;
for (i = 0; i < nz; i++) {
fscanf(f, "%d %d %lg %lg\n", &I[i], &J[i], &v[0], &v[1]);
/* reseve memory for matrices */
- I = (int *) malloc(nz * sizeof(int));
- J = (int *) malloc(nz * sizeof(int));
- val = (double *) malloc(nz * sizeof(double));
+ I = malloc(nz * sizeof(int));
+ J = malloc(nz * sizeof(int));
+ val = malloc(nz * sizeof(double));
*val_ = val;
*I_ = I;
return ret_code;
- *I = (int *) malloc(*nz * sizeof(int));
- *J = (int *) malloc(*nz * sizeof(int));
+ *I = malloc(*nz * sizeof(int));
+ *J = malloc(*nz * sizeof(int));
*val = NULL;
if (mm_is_complex(*matcode)) {
- *val = (double *) malloc(*nz * 2 * sizeof(double));
+ *val = malloc(*nz * 2 * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0)
return ret_code;
} else if (mm_is_real(*matcode)) {
- *val = (double *) malloc(*nz * sizeof(double));
+ *val = malloc(*nz * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0)
static void initStack(Stack * sp, int sz)
{
- sp->data = (Agnode_t **) malloc(sz * sizeof(Agnode_t *));
+ sp->data = malloc(sz * sizeof(Agnode_t *));
sp->ptr = sp->data;
}
#include <common/timing.h>
#include <stdlib.h>
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
typedef struct {
size_t infosize;
infosize = (agnnodes(g)+1)*sizeof(nodeinfo_t);
- ninfo = (nodeinfo_t*)malloc(infosize);
+ ninfo = malloc(infosize);
if (Verbose)
fprintf(stderr, "Processing graph %s\n", agnameof(g));
{
generic_list_t *list;
- list = (generic_list_t *) malloc(sizeof(generic_list_t));
+ list = malloc(sizeof(generic_list_t));
if (list == NULL) {
perror("[new_generic_list()] Error allocating memory:");
return NULL;
}
if (size != 0) {
- list->data = (gl_data *) malloc(size * sizeof(gl_data));
+ list->data = malloc(size * sizeof(gl_data));
if (list->data == NULL) {
perror("[new_generic_list()] Error allocating memory:");
free(list);
char *p;
strattr_t *sp;
- sp = (strattr_t *) malloc(sizeof(strattr_t));
+ sp = malloc(sizeof(strattr_t));
if (sp == NULL) {
perror("[addattr()->malloc()]");
exit(EXIT_FAILURE);
static void initStack(Stack * sp, int sz)
{
- sp->data = (Agnode_t **) malloc(sz * sizeof(Agnode_t *));
+ sp->data = malloc(sz * sizeof(Agnode_t *));
sp->ptr = sp->data;
}
return NIL(Dt_t*);
/* allocate space for dictionary */
- if(!(dt = (Dt_t*) malloc(sizeof(Dt_t))))
+ if(!(dt = malloc(sizeof(Dt_t))))
return NIL(Dt_t*);
/* initialize all absolutely private data */
if(ds->dt_max+1 > Size)
{ if(Size > 0)
free(Count);
- if(!(Count = (int*)malloc((ds->dt_max+1)*sizeof(int))) )
+ if(!(Count = malloc((ds->dt_max+1)*sizeof(int))) )
return -1;
Size = ds->dt_max+1;
}
if(ds->dt_n+1 > Size)
{ if(Size > 0)
free(Count);
- if(!(Count = (int*)malloc((ds->dt_n+1)*sizeof(int))) )
+ if(!(Count = malloc((ds->dt_n+1)*sizeof(int))) )
return -1;
Size = ds->dt_n+1;
}
fflush(agerrout);
endpos = ftell(agerrout);
len = endpos - aglast;
- buf = (char*)malloc(len + 1);
+ buf = malloc(len + 1);
fseek(agerrout, aglast, SEEK_SET);
fread(buf, sizeof(char), len, agerrout);
buf[len] = '\0';
int n;
if (!buf) {
- buf = (char*)malloc(bufsz);
+ buf = malloc(bufsz);
if (!buf) {
fputs("userout: could not allocate memory\n", stderr );
return;
if (g)
r = (refstr_t *) agalloc(g, sz);
else
- r = (refstr_t *) malloc(sz);
+ r = malloc(sz);
r->refcnt = 1;
strcpy(r->store, s);
r->s = r->store;
if (g)
r = (refstr_t *) agalloc(g, sz);
else
- r = (refstr_t *) malloc(sz);
+ r = malloc(sz);
r->refcnt = 1 | HTML_BIT;
strcpy(r->store, s);
r->s = r->store;
static vec* vec_new(void)
{
- vec* pvec = (vec*)malloc(sizeof(vec));
+ vec* pvec = malloc(sizeof(vec));
pvec->_capelems = 10;
pvec->_elems = 0;
- pvec->_mem = (void**)malloc(pvec->_capelems * sizeof(void*));
+ pvec->_mem = malloc(pvec->_capelems * sizeof(void*));
return pvec;
}
static vec* vec_copy(vec* pvec)
{
- vec* nvec = (vec*)malloc(sizeof(vec));
+ vec* nvec = malloc(sizeof(vec));
nvec->_capelems = pvec->_capelems;
nvec->_elems = pvec->_elems;
- nvec->_mem = (void**)malloc(pvec->_capelems * sizeof(void*));
+ nvec->_mem = malloc(pvec->_capelems * sizeof(void*));
memcpy(nvec->_mem, pvec->_mem, pvec->_elems * sizeof(void*));
return nvec;
}
glCompFont *glNewFont (glCompSet * s, char *text, glCompColor * c,glCompFontType type, char *fontdesc, int fs,int is2D)
{
- glCompFont *font = (glCompFont*) malloc(sizeof(glCompFont));
+ glCompFont *font = malloc(sizeof(glCompFont));
font->reference = 0;
font->color.R = c->R;
font->color.G = c->G;
Agraph_t *sg;
char* name;
Dt_t* emap = dtopen (&edgepair, Dtoset);
- edgepair_t* data = (edgepair_t*)malloc(sizeof(edgepair_t)*agnedges(src));
+ edgepair_t* data = malloc(sizeof(edgepair_t)*agnedges(src));
edgepair_t* ep = data;
for (t = agfstnode(src); t; t = agnxtnode(src, t)) {
{
record *newr;
- newr = (record *) malloc(sizeof(record));
+ newr = malloc(sizeof(record));
if (!newr) {
fprintf(stderr, "mkdefs: out of memory, line %d\n", lineno);
exit(1);
new_ing(ingraph_state * sp, char **files, Agraph_t** graphs, ingdisc * disc)
{
if (!sp) {
- sp = (ingraph_state *) malloc(sizeof(ingraph_state));
+ sp = malloc(sizeof(ingraph_state));
if (!sp) {
fprintf(stderr, "ingraphs: out of memory\n");
return 0;
sp->ctr = 0;
sp->errors = 0;
sp->fp = NULL;
- sp->fns = (ingdisc *) malloc(sizeof(ingdisc));
+ sp->fns = malloc(sizeof(ingdisc));
if (!sp->fns) {
fprintf(stderr, "ingraphs: out of memory\n");
if (sp->heap)
Node_t *n;
rtp->NodeCount++;
- n = (Node_t *) malloc(sizeof(Node_t));
+ n = malloc(sizeof(Node_t));
InitNode(n);
return n;
}
storage = (float *) realloc(C[0], dim1 * dim3 * sizeof(A[0]));
*CC = C = (float **) realloc(C, dim1 * sizeof(A));
} else {
- storage = (float *) malloc(dim1 * dim3 * sizeof(A[0]));
- *CC = C = (float **) malloc(dim1 * sizeof(A));
+ storage = malloc(dim1 * dim3 * sizeof(A[0]));
+ *CC = C = malloc(dim1 * sizeof(A));
}
for (i = 0; i < dim1; i++) {
storage = (double *) realloc(C[0], dim1 * dim3 * sizeof(double));
*CC = C = (double **) realloc(C, dim1 * sizeof(double *));
} else {
- storage = (double *) malloc(dim1 * dim3 * sizeof(double));
- *CC = C = (double **) malloc(dim1 * sizeof(double *));
+ storage = malloc(dim1 * dim3 * sizeof(double));
+ *CC = C = malloc(dim1 * sizeof(double *));
}
for (i = 0; i < dim1; i++) {
storage = (float *) realloc(C[0], dim1 * dim2 * sizeof(A[0]));
*CC = C = (float **) realloc(C, dim1 * sizeof(A));
} else {
- storage = (float *) malloc(dim1 * dim2 * sizeof(A[0]));
- *CC = C = (float **) malloc(dim1 * sizeof(A));
+ storage = malloc(dim1 * dim2 * sizeof(A[0]));
+ *CC = C = malloc(dim1 * sizeof(A));
}
for (i = 0; i < dim1; i++) {
if (newopn <= opn)
return;
if (!ops) {
- if (!(ops = (Ppoint_t *) malloc(POINTSIZE * newopn))) {
+ if (!(ops = malloc(POINTSIZE * newopn))) {
prerror("cannot malloc ops");
longjmp(jbuf,1);
}
if (newpnln <= pnln)
return;
if (!pnls) {
- if (!(pnls = (pointnlink_t *) malloc(POINTNLINKSIZE * newpnln))) {
+ if (!(pnls = malloc(POINTNLINKSIZE * newpnln))) {
prerror("cannot malloc pnls");
longjmp(jbuf,1);
}
- if (!(pnlps = (pointnlink_t **) malloc(POINTNLINKPSIZE * newpnln))) {
+ if (!(pnlps = malloc(POINTNLINKPSIZE * newpnln))) {
prerror("cannot malloc pnlps");
longjmp(jbuf,1);
}
if (newtrin <= trin)
return;
if (!tris) {
- if (!(tris = (triangle_t *) malloc(TRIANGLESIZE * newtrin))) {
+ if (!(tris = malloc(TRIANGLESIZE * newtrin))) {
prerror("cannot malloc tris");
longjmp(jbuf,1);
}
return;
if (!dq.pnlps) {
if (!
- (dq.pnlps =
- (pointnlink_t **) malloc(POINTNLINKPSIZE * newdqn))) {
+ (dq.pnlps = malloc(POINTNLINKPSIZE * newdqn))) {
prerror("cannot malloc dq.pnls");
longjmp(jbuf,1);
}
if (newopn <= opn)
return;
if (!ops) {
- if (!(ops = (Ppoint_t *) malloc(POINTSIZE * newopn))) {
+ if (!(ops = malloc(POINTSIZE * newopn))) {
prerror("cannot malloc ops");
longjmp(jbuf,1);
}
int k, t;
/* allocate arrays */
- dad = (int *) malloc(V * sizeof(int));
- vl = (COORD *) malloc((V + 1) * sizeof(COORD)); /* One extra for sentinel */
+ dad = malloc(V * sizeof(int));
+ vl = malloc((V + 1) * sizeof(COORD)); /* One extra for sentinel */
val = vl + 1;
/* initialize arrays */
int V = conf->N;
if (directVis(p, pp, q, qp, conf)) {
- int *dad = (int *) malloc(sizeof(int) * (V + 2));
+ int *dad = malloc(sizeof(int) * (V + 2));
dad[V] = V + 1;
dad[V + 1] = -1;
return dad;
#include <stdlib.h>
#include <pathplan/pathutil.h>
-#define ALLOC(size,ptr,type) (ptr? (type*)realloc(ptr,(size)*sizeof(type)):(type*)malloc((size)*sizeof(type)))
+#define ALLOC(size,ptr,type) (ptr? (type*)realloc(ptr,(size)*sizeof(type)):malloc((size)*sizeof(type)))
Ppoly_t copypoly(Ppoly_t argpoly)
{
array2 arr;
COORD *p;
- arr = (COORD **) malloc((V + extra) * sizeof(COORD *));
+ arr = malloc((V + extra) * sizeof(COORD *));
p = (COORD *) calloc(V * V, sizeof(COORD));
for (i = 0; i < V; i++) {
arr[i] = p;
Ppoint_t pk;
COORD d;
- vadj = (COORD *) malloc((V + 2) * sizeof(COORD));
+ vadj = malloc((V + 2) * sizeof(COORD));
if (pp == POLYID_UNKNOWN)
{
printf("type key for new node\n");
scanf("%i",&newKey);
- newInt=(int*) malloc(sizeof(int));
+ newInt= malloc(sizeof(int));
*newInt=newKey;
RBTreeInsert(tree,newInt,0);
}
static char *Buf;
/* set up local buffer */
- if (!Buf && !(Buf = (char *) malloc(SF_MAXDIGITS)))
+ if (!Buf && !(Buf = malloc(SF_MAXDIGITS)))
return SF_INFINITE;
*sign = *decpt = 0;
if (f->size > 0)
data = (uchar *) realloc((char *) f->data, size);
else
- data = (uchar *) malloc(size);
+ data = malloc(size);
if (!data)
goto chk_stack;
f->endb = data + size;
return pid;
}
- if (!(w = (Waitpid_t *) malloc(sizeof(Waitpid_t))))
+ if (!(w = malloc(sizeof(Waitpid_t))))
continue;
w->pid = id;
p->sf = p->array;
} else { /* allocate a larger array */
n = (p->sf != p->array ? p->s_sf : (p->s_sf / 4 + 1) * 4) + 4;
- if (!(array = (Sfio_t **) malloc(n * sizeof(Sfio_t *))))
+ if (!(array = malloc(n * sizeof(Sfio_t *))))
goto done;
/* move old array to new one */
/* make buffer if nothing yet */
size = ((size + SF_GRAIN - 1) / SF_GRAIN) * SF_GRAIN;
if (!(rsrv = f->rsrv) || size > rsrv->size) {
- if (!(rs = (Sfrsrv_t *) malloc(size + sizeof(Sfrsrv_t))))
+ if (!(rs = malloc(size + sizeof(Sfrsrv_t))))
size = -1;
else {
if (rsrv) {
if (f->proc)
return 0;
- if (!(p = f->proc = (Sfproc_t *) malloc(sizeof(Sfproc_t))))
+ if (!(p = f->proc = malloc(sizeof(Sfproc_t))))
return -1;
p->pid = pid;
if (p->ndata > p->size) {
if (p->rdata)
free((char *) p->rdata);
- if ((p->rdata = (uchar *) malloc(p->ndata)))
+ if ((p->rdata = malloc(p->ndata)))
p->size = p->ndata;
else {
p->size = 0;
}
if (!f) {
- if (!(f = (Sfio_t *) malloc(sizeof(Sfio_t))))
+ if (!(f = malloc(sizeof(Sfio_t))))
return NIL(Sfio_t *);
SFCLEAR(f);
}
}
if (!buf) { /* do allocation */
while (!buf && size > 0) {
- if ((buf = (void *) malloc(size)))
+ if ((buf = malloc(size)))
break;
else
size /= 2;
f1->file == 1 ? sfstdout :
f1->file == 2 ? sfstderr : NIL(Sfio_t *);
if ((!f2 || !(f2->mode & SF_AVAIL))) {
- if (!(f2 = (Sfio_t *) malloc(sizeof(Sfio_t)))) {
+ if (!(f2 = malloc(sizeof(Sfio_t)))) {
f1->mode = f1mode;
SFOPEN(f1, 0);
return NIL(Sfio_t *);
if (!fp) { /* constructing position array only */
if (!dollar
- || !(fp = (Fmtpos_t *) malloc((maxp + 1) * sizeof(Fmtpos_t))))
+ || !(fp = malloc((maxp + 1) * sizeof(Fmtpos_t))))
return NIL(Fmtpos_t *);
for (n = 0; n <= maxp; ++n)
fp[n].ft.fmt = 0;
while (*p && *p != ':') /* skip dir name */
++p;
}
- if (n == 0 || !(dirs = (char **) malloc((n + 1) * sizeof(char *))))
+ if (n == 0 || !(dirs = malloc((n + 1) * sizeof(char *))))
return NIL(char **);
- if (!(p = (char *) malloc(strlen(path) + 1))) {
+ if (!(p = malloc(strlen(path) + 1))) {
free(dirs);
return NIL(char **);
}
uchar *data;
if (f->size < 0)
f->size = 0;
- if (!(data = (uchar *) malloc(f->size + 16))) {
+ if (!(data = malloc(f->size + 16))) {
c = -1;
goto done;
}
continue;
fmstk->ft = ft = argv.ft;
} else { /* stack a new environment */
- if (!(fm = (Fmt_t *) malloc(sizeof(Fmt_t))))
+ if (!(fm = malloc(sizeof(Fmt_t))))
goto done;
if (argv.ft->form) {
continue;
fmstk->ft = ft = argv.ft;
} else { /* stack a new environment */
- if (!(fm = (Fmt_t *) malloc(sizeof(Fmt_t))))
+ if (!(fm = malloc(sizeof(Fmt_t))))
goto done;
if (argv.ft->form) {
#include <common/utils.h>
#include <gvc/gvio.h>
-#define GNEW(t) (t*)malloc(sizeof(t))
+#define GNEW(t) malloc(sizeof(t))
/* #define NEW_XDOT */
char *name;
window_t *window;
- window = (window_t *)malloc(sizeof(window_t));
+ window = malloc(sizeof(window_t));
if (window == NULL) {
fprintf(stderr, "Failed to malloc window_t\n");
return;
firstjob->display = (void*)dpy;
firstjob->screen = scr;
- keycodes = (KeyCode *)malloc(firstjob->numkeys * sizeof(KeyCode));
+ keycodes = malloc(firstjob->numkeys * sizeof(KeyCode));
if (keycodes == NULL) {
fprintf(stderr, "Failed to malloc %d*KeyCode\n", firstjob->numkeys);
return;
}
}
if (!gs) {
- gs = (gs_t *)malloc(sizeof(gs_t));
+ gs = malloc(sizeof(gs_t));
if (!gs) {
job->common->errorfn("malloc() failure\n");
return NULL;
int faces;
} availfont_t;
-#define NEW(t) (t*)malloc(sizeof(t))
+#define NEW(t) malloc(sizeof(t))
#define N_NEW(n,t) (t*)calloc((n),sizeof(t))
static PostscriptAlias postscript_alias[] = {
int w, h;
double zoom_to_fit;
- window = (window_t *)malloc(sizeof(window_t));
+ window = malloc(sizeof(window_t));
if (window == NULL) {
fprintf(stderr, "Failed to malloc window_t\n");
return;
firstjob->display = (void*)dpy;
firstjob->screen = scr;
- keycodes = (KeyCode *)malloc(firstjob->numkeys * sizeof(KeyCode));
+ keycodes = malloc(firstjob->numkeys * sizeof(KeyCode));
if (keycodes == NULL) {
fprintf(stderr, "Failed to malloc %d*KeyCode\n", firstjob->numkeys);
return;
ictx_t *ictx = (ictx_t *)disc;
gctx_t *gctx;
- gctx = (gctx_t *)malloc(sizeof(gctx_t));
+ gctx = malloc(sizeof(gctx_t));
gctx->g = g;
gctx->ictx = ictx;
return (void *)gctx;
newSize =
(tblHdrPtr->tableSize + numNewEntries) * tblHdrPtr->entrySize;
- tblHdrPtr->bodyPtr = (ubyte_pt) malloc(newSize);
+ tblHdrPtr->bodyPtr = malloc(newSize);
memcpy(tblHdrPtr->bodyPtr, oldbodyPtr,
(tblHdrPtr->tableSize * tblHdrPtr->entrySize));
tclhandleLinkInNewEntries(tblHdrPtr, tblHdrPtr->tableSize,
/*
* Set up the table entry.
*/
- tblHdrPtr = (tblHeader_pt) malloc(sizeof(tblHeader_t));
+ tblHdrPtr = malloc(sizeof(tblHeader_t));
/*
* Calculate entry size, including header, rounded up to sizeof (void *).
tblHdrPtr->entrySize = ENTRY_HEADER_SIZE + ROUND_ENTRY_SIZE(entrySize);
tblHdrPtr->freeHeadIdx = NULL_IDX;
tblHdrPtr->tableSize = initEntries;
- tblHdrPtr->handleFormat = (char *) malloc(strlen(prefix) + 4);
+ tblHdrPtr->handleFormat = malloc(strlen(prefix) + 4);
strcpy(tblHdrPtr->handleFormat, prefix);
strcat(tblHdrPtr->handleFormat, "%lu");
- tblHdrPtr->bodyPtr =
- (ubyte_pt) malloc(initEntries * tblHdrPtr->entrySize);
+ tblHdrPtr->bodyPtr = malloc(initEntries * tblHdrPtr->entrySize);
tclhandleLinkInNewEntries(tblHdrPtr, 0, initEntries);
return tblHdrPtr;
free(tblHdrPtr->bodyPtr);
tblHdrPtr->freeHeadIdx = NULL_IDX;
tblHdrPtr->tableSize = initEntries;
- tblHdrPtr->bodyPtr =
- (ubyte_pt) malloc(initEntries * tblHdrPtr->entrySize);
+ tblHdrPtr->bodyPtr = malloc(initEntries * tblHdrPtr->entrySize);
tclhandleLinkInNewEntries(tblHdrPtr, 0, initEntries);
return TCL_OK;
all.first = all.final = NIL;
all.number = 0;
- pvertex = (struct vertex **)
- malloc((input->nvertices) * sizeof(struct vertex *));
+ pvertex = malloc((input->nvertices) * sizeof(struct vertex *));
for (i = 0; i < input->nvertices; i++)
pvertex[i] = vertex_list + i;
j++, tempa = tempa->next)
find_intersection(tempa->name, templ, ilist, input); /* test */
- new =
- (struct active_edge *)
- malloc(sizeof(struct active_edge));
+ new = malloc(sizeof(struct active_edge));
if (all.number == 0) {
all.first = new;
new->last = NIL;
char vbuf[30];
vgpane_t *vgp;
- vgp = (vgpane_t *) malloc(sizeof(vgpane_t));
+ vgp = malloc(sizeof(vgpane_t));
*(vgpane_t **) tclhandleAlloc(vgpaneTable, vbuf, NULL) = vgp;
vgp->vc = (vconfig_t *) 0;
{
Ppoly_t polys[2], *polys_ptr[2];
- polys[0].ps = (Ppoint_t *) malloc(3 * sizeof(Ppoint_t));
- polys[1].ps = (Ppoint_t *) malloc(3 * sizeof(Ppoint_t));
+ polys[0].ps = malloc(3 * sizeof(Ppoint_t));
+ polys[1].ps = malloc(3 * sizeof(Ppoint_t));
polys[0].pn = 3;
polys[1].pn = 3;
struct data input;
struct intersection ilist[10000];
- polygon_list = (struct polygon *)
- malloc(n_polys * sizeof(struct polygon));
+ polygon_list = malloc(n_polys * sizeof(struct polygon));
for (i = nverts = 0; i < n_polys; i++)
nverts += polys[i]->pn;
- vertex_list = (struct vertex *)
- malloc(nverts * sizeof(struct vertex));
+ vertex_list = malloc(nverts * sizeof(struct vertex));
for (i = vno = 0; i < n_polys; i++) {
polygon_list[i].start = &vertex_list[vno];
projects / graphviz / commitdiff