1: L:264: F:"q3radiant/Undo.cpp":
	undo = (undo_t *) malloc(sizeof(undo_t));

2: L:590: F:"q3radiant/Undo.cpp":
	redo = (undo_t *) malloc(sizeof(undo_t));

3: L:44: F:"q3radiant/PMESH.CPP":
  patchMesh_t *pm = reinterpret_cast<patchMesh_t*>(qmalloc(sizeof(patchMesh_t)));

4: L:442: F:"q3radiant/TexWnd.cpp":
  q = (qtexture_t*)qmalloc(sizeof(*q));

5: L:451: F:"q3radiant/TexWnd.cpp":
	dest = (unsigned char*)qmalloc (width*height*4);

6: L:549: F:"q3radiant/TexWnd.cpp":
  qtexture_t* q = (qtexture_t*)qmalloc(sizeof(*q));

7: L:709: F:"q3radiant/TexWnd.cpp":
  q = (qtexture_t*)qmalloc(sizeof(*q));

8: L:771: F:"q3radiant/TexWnd.cpp":
  q = (qtexture_t*)qmalloc(sizeof(*q));

9: L:1113: F:"q3radiant/TexWnd.cpp":
	notexture = q = (qtexture_t*)qmalloc(sizeof(*q));

10: L:1117: F:"q3radiant/TexWnd.cpp":
	q = (qtexture_t*)qmalloc(sizeof(*q));

11: L:185: F:"q3radiant/Winding.cpp":
	w = (winding_t*) malloc (size);

12: L:210: F:"q3radiant/Winding.cpp":
	c = (winding_t*)qmalloc (size);

13: L:24: F:"q3radiant/Bmp.cpp":
#include <malloc.h>

14: L:192: F:"q3radiant/Bmp.cpp":
	    bit->palette = reinterpret_cast<rgb_t*>(malloc(sizeof(rgb_t) * 256));

15: L:215: F:"q3radiant/Bmp.cpp":
    scanline = reinterpret_cast<char*>(malloc(rowbytes));

16: L:218: F:"q3radiant/Bmp.cpp":
    bit->data = reinterpret_cast<unsigned char*>(malloc(info.biWidth * pixbytes * info.biHeight));

17: L:376: F:"q3radiant/Bmp.cpp":
	bit->data = reinterpret_cast<unsigned char*>(malloc(width * height * pixbytes));

18: L:380: F:"q3radiant/Bmp.cpp":
		Error("NewBMP: malloc failed.");

19: L:386: F:"q3radiant/Bmp.cpp":
		bit->palette = (rgb_t *) malloc(768);

20: L:390: F:"q3radiant/Bmp.cpp":
			Error("NewBMP: unable to malloc palette.");

21: L:71: F:"q3radiant/QE3.CPP":
	b = (char*)malloc(strlen(s)+1);

22: L:3322: F:"q3radiant/XYWnd.cpp":
	n = (entity_t*)qmalloc(sizeof(*n));

23: L:3334: F:"q3radiant/XYWnd.cpp":
		np = (epair_t*)qmalloc(sizeof(*np));

24: L:533: F:"q3radiant/MAP.CPP":
	world_entity = (entity_s*)qmalloc(sizeof(*world_entity));

25: L:215: F:"q3radiant/LBMLIB.CPP":
			cmapbuffer = (unsigned char*)malloc (768);

26: L:223: F:"q3radiant/LBMLIB.CPP":
			pic_p = picbuffer = (unsigned char*)malloc (bmhd.w*bmhd.h);

27: L:285: F:"q3radiant/LBMLIB.CPP":
	lbm = lbmptr = (unsigned char*)malloc (width*height+1000);

28: L:463: F:"q3radiant/LBMLIB.CPP":
		*palette = (unsigned char*)malloc(768);

29: L:478: F:"q3radiant/LBMLIB.CPP":
	out = (unsigned char*)malloc ( (pcx->ymax+1) * (pcx->xmax+1) );

30: L:523: F:"q3radiant/LBMLIB.CPP":
	pcx = (pcx_t*)malloc (width*height*2+1000);

31: L:609: F:"q3radiant/LBMLIB.CPP":
			*palette = (unsigned char*)malloc (768);

32: L:814: F:"q3radiant/LBMLIB.CPP":
	bmpRGBA = reinterpret_cast<unsigned char*>(malloc( numPixels * 4 ));

33: L:937: F:"q3radiant/LBMLIB.CPP":
	out = reinterpret_cast<unsigned char*>(malloc ( (ymax+1) * (xmax+1) ));

34: L:945: F:"q3radiant/LBMLIB.CPP":
		*palette = reinterpret_cast<unsigned char*>(malloc(768));

35: L:1004: F:"q3radiant/LBMLIB.CPP":
	pic32 = *pic = reinterpret_cast<unsigned char*>(malloc(4 * c ));

36: L:1109: F:"q3radiant/LBMLIB.CPP":
	targa_rgba = reinterpret_cast<unsigned char*>(malloc (numPixels*4));

37: L:440: F:"q3radiant/PlugInManager.cpp":
    pData->m_pVectors = reinterpret_cast<vec3_t*>(qmalloc(g_nPlugCount * sizeof(vec3_t)));

38: L:874: F:"q3radiant/PlugInManager.cpp":
	epair_t *e = (epair_t*)qmalloc (sizeof(*e));

39: L:875: F:"q3radiant/PlugInManager.cpp":
	e->key = (char*)qmalloc(strlen(key)+1);

40: L:877: F:"q3radiant/PlugInManager.cpp":
	e->value = (char*)qmalloc(strlen(val)+1);

41: L:925: F:"q3radiant/PlugInManager.cpp":
	entity_t *pe = reinterpret_cast<entity_t*>(qmalloc(sizeof(entity_t)));

42: L:286: F:"q3radiant/ECLASS.CPP":
        pModel->pNext = reinterpret_cast<entitymodel_t*>(qmalloc(sizeof(entitymodel_t)));

43: L:426: F:"q3radiant/ECLASS.CPP":
	e = (eclass_t*)qmalloc(sizeof(*e));

44: L:433: F:"q3radiant/ECLASS.CPP":
	e->name = (char*)qmalloc (strlen(com_token)+1);

45: L:504: F:"q3radiant/ECLASS.CPP":
	e->comments = (char*)qmalloc (len+1);

46: L:559: F:"q3radiant/ECLASS.CPP":
      e->model = reinterpret_cast<entitymodel_t*>(qmalloc(sizeof(entitymodel_t)));

47: L:596: F:"q3radiant/ECLASS.CPP":
      model->pNext = reinterpret_cast<entitymodel_t*>(qmalloc(sizeof(entitymodel_t)));

48: L:902: F:"q3radiant/ECLASS.CPP":
	e = (eclass_t*)qmalloc(sizeof(*e));

49: L:32: F:"q3radiant/splines/q_shared.cpp":
// malloc / free all in one place for debugging

50: L:67: F:"q3radiant/splines/q_shared.h":
#ifdef WIN32				// mac doesn't have malloc.h

51: L:68: F:"q3radiant/splines/q_shared.h":
#include <malloc.h>			// for _alloca()

52: L:276: F:"q3radiant/splines/q_shared.h":
#undef ERR_FATAL						// malloc.h on unix

53: L:77: F:"q3radiant/ENTITY.CPP":
			ep->value = (char*)qmalloc(strlen(value)+1);

54: L:82: F:"q3radiant/ENTITY.CPP":
	ep = (epair_t*)qmalloc (sizeof(*ep));

55: L:85: F:"q3radiant/ENTITY.CPP":
	ep->key = (char*)qmalloc(strlen(key)+1);

56: L:87: F:"q3radiant/ENTITY.CPP":
	ep->value = (char*)qmalloc(strlen(value)+1);

57: L:273: F:"q3radiant/ENTITY.CPP":
	e = (epair_t*)qmalloc (sizeof(*e));

58: L:275: F:"q3radiant/ENTITY.CPP":
	e->key = (char*)qmalloc(strlen(token)+1);

59: L:279: F:"q3radiant/ENTITY.CPP":
	e->value = (char*)qmalloc(strlen(token)+1);

60: L:309: F:"q3radiant/ENTITY.CPP":
	ent = (entity_t*)qmalloc (sizeof(*ent));

61: L:717: F:"q3radiant/ENTITY.CPP":
	e = (entity_t*)qmalloc(sizeof(*e));

62: L:856: F:"q3radiant/ENTITY.CPP":
	n = (entity_t*)qmalloc(sizeof(*n));

63: L:866: F:"q3radiant/ENTITY.CPP":
		np = (epair_t*)qmalloc(sizeof(*np));

64: L:242: F:"q3radiant/terrain.cpp":
	pm = reinterpret_cast< terrainMesh_t * >( qmalloc( size ) );

65: L:47: F:"q3radiant/Brush.cpp":
  brush_t *b = (brush_t*)qmalloc(sizeof(brush_t));

66: L:170: F:"q3radiant/Brush.cpp":
	face_t *f = (face_t*)qmalloc( sizeof( *f ) );

67: L:38: F:"q3radiant/QE3.H":
#include <malloc.h>

68: L:245: F:"q3radiant/QE3.H":
//void *qmalloc (size_t size);

69: L:57: F:"q3radiant/GroupDlg.cpp":
  group_t *g = (group_t*)qmalloc(sizeof(group_t));

70: L:81: F:"q3radiant/GroupDlg.cpp":
  group_t *g = (group_t*)qmalloc(sizeof(group_t));

71: L:681: F:"q3radiant/WIN_QE3.CPP":
	return malloc(bytes);

72: L:1202: F:"libs/pak/unzip.cpp":
# define ALLOC(size) (malloc(size))

73: L:1385: F:"libs/pak/unzip.cpp":
	buf = (unsigned char*)malloc(BUFREADCOMMENT+4);

74: L:1432: F:"libs/pak/unzip.cpp":
	s=(unz_s*)malloc(sizeof(unz_s));

75: L:1531: F:"libs/pak/unzip.cpp":
	s=(unz_s*)malloc(sizeof(unz_s));

76: L:1982: F:"libs/pak/unzip.cpp":
									    malloc(sizeof(file_in_zip_read_info_s));

77: L:1986: F:"libs/pak/unzip.cpp":
	pfile_in_zip_read_info->read_buffer=(char*)malloc(UNZ_BUFSIZE);

78: L:2689: F:"libs/pak/unzip.cpp":
  inflate_huft *hufts;  /* single malloc for tree space */

79: L:4537: F:"libs/pak/unzip.cpp":
    return (voidp)malloc(items*size);

80: L:258: F:"libs/pak/pakstuff.cpp":
void* __qblockmalloc(size_t nSize)

81: L:267: F:"libs/pak/pakstuff.cpp":
	b = malloc(nSize + 1);

82: L:272: F:"libs/pak/pakstuff.cpp":
void* __qmalloc (size_t nSize)

83: L:275: F:"libs/pak/pakstuff.cpp":
	b = malloc(nSize + 1);

84: L:549: F:"libs/pak/pakstuff.cpp":
  dir = (PACKDirPtr)__qmalloc(size);

85: L:768: F:"libs/pak/pakstuff.cpp":
	if((newPtr = (DIRLIST *)__qmalloc(sizeof(DIRLIST))) == NULL)

86: L:806: F:"libs/pak/pakstuff.cpp":
	if((newPtr = (FILELIST *)__qmalloc(sizeof(FILELIST))) == NULL)

87: L:867: F:"libs/pak/pakstuff.cpp":
			if((buffer = __qmalloc(p->size+5)) == NULL)

88: L:909: F:"libs/pak/pakstuff.cpp":
        void *buffer = __qblockmalloc(pInfo->m_lSize+1);

89: L:929: F:"libs/pak/pakstuff.cpp":
	      void *buffer = __qmalloc (pakdirptr[i].size+1);

90: L:962: F:"libs/pak/pakstuff.cpp":
	if((newPtr = (DIRECTORY *)__qmalloc(sizeof(DIRECTORY))) == NULL)

91: L:71: F:"libs/cmdlib.h":
void *qmalloc (size_t size);

92: L:72: F:"libs/cmdlib.h":
void* qblockmalloc(size_t nSize);

93: L:30: F:"libs/jpeg6/jmemnobs.cpp":
  return (void *) malloc(sizeofobject);

94: L:50: F:"libs/jpeg6/jmemnobs.cpp":
  return (void FAR *) malloc(sizeofobject);

95: L:38: F:"libs/jpeg6/jmemsys.h":
 * Behavior should be the same as for the standard library functions malloc

96: L:40: F:"libs/jpeg6/jmemsys.h":
 * On most systems, these ARE malloc and free.  jpeg_free_small is passed the

97: L:54: F:"libs/jpeg6/jmemmgr.cpp":
 * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()

98: L:266: F:"libs/jpeg6/jmemmgr.cpp":
    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */

99: L:350: F:"libs/jpeg6/jmemmgr.cpp":
    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */

100: L:1007: F:"libs/jpeg6/jmemmgr.cpp":
   * with some (brain-damaged) malloc libraries.

101: L:80: F:"libs/jpeg6/jpgload.cpp":
  out = reinterpret_cast<unsigned char*>(malloc(nSize+1));

102: L:33: F:"libs/jpeg6/jcomapi.cpp":
   * with some (brain-damaged) malloc libraries.

103: L:89: F:"libs/cmdlib/cmdlib.cpp":
void* qblockmalloc(size_t nSize)

104: L:98: F:"libs/cmdlib/cmdlib.cpp":
	b = malloc(nSize + 1);

105: L:103: F:"libs/cmdlib/cmdlib.cpp":
void* qmalloc (size_t nSize)

106: L:106: F:"libs/cmdlib/cmdlib.cpp":
	b = malloc(nSize + 1);

107: L:199: F:"libs/cmdlib/cmdlib.cpp":
	buffer = qblockmalloc (length+1);

108: L:226: F:"libs/cmdlib/cmdlib.cpp":
	buffer = qmalloc (length+1);

109: L:761: F:"libs/jpeglib.h":
 * to free, especially where malloc()/free() are not too speedy.

110: L:380: F:"common/bspfile.c":
	e = malloc( sizeof(epair_t) );

111: L:524: F:"common/bspfile.c":
	ep = malloc (sizeof(*ep));

112: L:284: F:"common/l3dslib.c":
	ptri = malloc (MAXTRIANGLES * sizeof(triangle_t));

113: L:65: F:"common/mutex.c":
	crit = (CRITICAL_SECTION *) malloc(sizeof(CRITICAL_SECTION));

114: L:112: F:"common/mutex.c":
	my_mutex = malloc (sizeof(*my_mutex));

115: L:166: F:"common/mutex.c":
	lck = (abilock_t *) malloc(sizeof(abilock_t));

116: L:130: F:"common/aselib.c":
	ase.curpos = ase.buffer = malloc( ase.len );

117: L:231: F:"common/imagelib.c":
			cmapbuffer = malloc (768);

118: L:239: F:"common/imagelib.c":
			pic_p = picbuffer = malloc (bmhd.w*bmhd.h);

119: L:301: F:"common/imagelib.c":
	lbm = lbmptr = malloc (width*height+1000);

120: L:471: F:"common/imagelib.c":
		*palette = malloc(768);

121: L:483: F:"common/imagelib.c":
	out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );

122: L:535: F:"common/imagelib.c":
	pcx = malloc (width*height*2+1000);

123: L:687: F:"common/imagelib.c":
			*palette = malloc(768);

124: L:704: F:"common/imagelib.c":
			*palette = malloc(768);

125: L:741: F:"common/imagelib.c":
	out = malloc ( bcWidth * bcHeight );

126: L:908: F:"common/imagelib.c":
	targa_rgba = malloc (numPixels*4);

127: L:1091: F:"common/imagelib.c":
	buffer = malloc(width*height*4 + 18);

128: L:1151: F:"common/imagelib.c":
		pixels32 = malloc(size * 4);

129: L:267: F:"common/threads.c":
		my_mutex = malloc (sizeof(*my_mutex));

130: L:355: F:"common/cmdlib.c":
	b = malloc(strlen(s)+1);

131: L:702: F:"common/cmdlib.c":
	buffer = malloc (length+1);

132: L:733: F:"common/cmdlib.c":
	buffer = malloc (nAllocSize+1);

133: L:762: F:"common/cmdlib.c":
	buffer = malloc (length+1);

134: L:66: F:"common/polylib.c":
	w = malloc (s);

135: L:304: F:"q3asm/q3asm.c":
	s = malloc( sizeof( *s ) );

136: L:360: F:"q3asm/cmdlib.c":
	b = malloc(strlen(s)+1);

137: L:707: F:"q3asm/cmdlib.c":
	buffer = malloc (length+1);

138: L:738: F:"q3asm/cmdlib.c":
	buffer = malloc (nAllocSize+1);

139: L:767: F:"q3asm/cmdlib.c":
	buffer = malloc (length+1);

140: L:213: F:"q3map/shaders.c":
	si->pixels = malloc( si->width * si->height * 4 );

141: L:594: F:"q3map/shaders.c":
    shaderFiles[numShaderFiles] = malloc(MAX_OS_PATH);

142: L:273: F:"q3map/light_trace.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

143: L:334: F:"q3map/light_trace.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

144: L:389: F:"q3map/light_trace.c":
		test = malloc( sizeof( *test ) );

145: L:624: F:"q3map/light_trace.c":
	tnodes = malloc( (MAX_TNODES+1) * sizeof(tnode_t));

146: L:44: F:"q3map/portals.c":
	p = malloc (sizeof(portal_t));

147: L:36: F:"q3map/facebsp.c":
	f = malloc(sizeof(*f));

148: L:66: F:"q3map/patch.c":
	ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );

149: L:109: F:"q3map/patch.c":
	m.verts = verts = malloc( m.width * m.height * sizeof( m.verts[0] ) );

150: L:144: F:"q3map/patch.c":
	pm = malloc( sizeof( *pm ) );

151: L:207: F:"q3map/patch.c":
	bordering = malloc( patchCount * patchCount );

152: L:1333: F:"q3map/visflow.c":
		passage = (passage_t *) malloc(sizeof(passage_t) + portalbytes);

153: L:1516: F:"q3map/visflow.c":
	p->portalfront = malloc (portalbytes);

154: L:1519: F:"q3map/visflow.c":
	p->portalflood = malloc (portalbytes);

155: L:1522: F:"q3map/visflow.c":
	p->portalvis = malloc (portalbytes);

156: L:1352: F:"q3map/soundv.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

157: L:1441: F:"q3map/soundv.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

158: L:1517: F:"q3map/soundv.c":
		test = malloc( sizeof( *test ) );

159: L:2814: F:"q3map/soundv.c":
	w = (winding_t *) malloc(sizeof(winding_t));

160: L:4923: F:"q3map/soundv.c":
	lightFloats = (float *) malloc(numLightBytes * sizeof(float));

161: L:5010: F:"q3map/soundv.c":
		dl = malloc(sizeof(*dl));

162: L:5129: F:"q3map/soundv.c":
	dl = malloc(sizeof(*dl));

163: L:5164: F:"q3map/soundv.c":
		dl2 = malloc(sizeof(*dl));

164: L:5249: F:"q3map/soundv.c":
			dl = malloc(sizeof(*dl));

165: L:5381: F:"q3map/soundv.c":
				dl = malloc(sizeof(*dl));

166: L:5465: F:"q3map/soundv.c":
	w = malloc (size);

167: L:5511: F:"q3map/soundv.c":
	portals = malloc(2*numportals*sizeof(lportal_t));

168: L:5514: F:"q3map/soundv.c":
	leafs = malloc(portalclusters*sizeof(lleaf_t));

169: L:5706: F:"q3map/soundv.c":
	lightFloats = (float *) malloc(numLightBytes * sizeof(float));

170: L:1352: F:"q3map/lightv.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

171: L:1441: F:"q3map/lightv.c":
	test->facets = malloc( sizeof( test->facets[0] ) * test->numFacets );

172: L:1517: F:"q3map/lightv.c":
		test = malloc( sizeof( *test ) );

173: L:2814: F:"q3map/lightv.c":
	w = (winding_t *) malloc(sizeof(winding_t));

174: L:4923: F:"q3map/lightv.c":
	lightFloats = (float *) malloc(numLightBytes * sizeof(float));

175: L:5010: F:"q3map/lightv.c":
		dl = malloc(sizeof(*dl));

176: L:5129: F:"q3map/lightv.c":
	dl = malloc(sizeof(*dl));

177: L:5164: F:"q3map/lightv.c":
		dl2 = malloc(sizeof(*dl));

178: L:5249: F:"q3map/lightv.c":
			dl = malloc(sizeof(*dl));

179: L:5381: F:"q3map/lightv.c":
				dl = malloc(sizeof(*dl));

180: L:5465: F:"q3map/lightv.c":
	w = malloc (size);

181: L:5511: F:"q3map/lightv.c":
	portals = malloc(2*numportals*sizeof(lportal_t));

182: L:5514: F:"q3map/lightv.c":
	leafs = malloc(portalclusters*sizeof(lleaf_t));

183: L:5712: F:"q3map/lightv.c":
	lightFloats = (float *) malloc(numLightBytes * sizeof(float));

184: L:88: F:"q3map/mesh.c":
	out = malloc( sizeof( *out ) );

185: L:93: F:"q3map/mesh.c":
	out->verts = malloc( size );

186: L:111: F:"q3map/mesh.c":
	out = malloc( sizeof( *out ) );

187: L:114: F:"q3map/mesh.c":
	out->verts = malloc( out->width * out->height * sizeof( drawVert_t ) );

188: L:173: F:"q3map/light.c":
	dl = malloc(sizeof(*dl));

189: L:203: F:"q3map/light.c":
		dl2 = malloc(sizeof(*dl));

190: L:322: F:"q3map/light.c":
			dl = malloc(sizeof(*dl));

191: L:485: F:"q3map/light.c":
		dl = malloc(sizeof(*dl));

192: L:1118: F:"q3map/light.c":
	out = malloc( sizeof( *out ) );

193: L:1122: F:"q3map/light.c":
	out->verts = malloc( out->width * out->height * sizeof(*out->verts) );

194: L:534: F:"q3map/bsp.c":
	//numthreads = 1;		// multiple threads aren't helping because of heavy malloc use

195: L:80: F:"q3map/tjunction.c":
	p = malloc( sizeof(edgePoint_t) );

196: L:425: F:"q3map/tjunction.c":
		ds->verts = malloc( numVerts * sizeof( *ds->verts ) );

197: L:455: F:"q3map/tjunction.c":
	ds->verts = malloc( numVerts * sizeof( *ds->verts ) );

198: L:251: F:"q3map/misc_model.c":
		out->verts = malloc( out->numVerts * sizeof( out->verts[0] ) );

199: L:254: F:"q3map/misc_model.c":
		out->indexes = malloc( out->numIndexes * sizeof( out->indexes[0] ) );

200: L:367: F:"q3map/misc_model.c":
		out->verts = malloc( out->numVerts * sizeof( out->verts[0] ) );

201: L:370: F:"q3map/misc_model.c":
		out->indexes = malloc( out->numIndexes * sizeof( out->indexes[0] ) );

202: L:99: F:"q3map/vis.c":
	w = malloc (size);

203: L:882: F:"q3map/vis.c":
	portals = malloc(2*numportals*sizeof(vportal_t));

204: L:885: F:"q3map/vis.c":
	leafs = malloc(portalclusters*sizeof(leaf_t));

205: L:968: F:"q3map/vis.c":
	faces = malloc(2*numfaces*sizeof(vportal_t));

206: L:971: F:"q3map/vis.c":
	faceleafs = malloc(portalclusters*sizeof(leaf_t));

207: L:125: F:"q3map/terrain.c":
		alphamap = malloc( size );

208: L:378: F:"q3map/terrain.c":
	newsurf->indexes = malloc( surf->numIndexes * sizeof( *newsurf->indexes ) );

209: L:382: F:"q3map/terrain.c":
	newsurf->verts = malloc( surf->numVerts * sizeof( *newsurf->verts ) );

210: L:439: F:"q3map/terrain.c":
		surf->verts			= malloc( surf->maxVerts * sizeof( *surf->verts ) );

211: L:443: F:"q3map/terrain.c":
		surf->indexes		= malloc( surf->maxIndexes * sizeof( *surf->indexes ) );

212: L:453: F:"q3map/terrain.c":
	indices = malloc ( maxindices * sizeof( *indices ) );

213: L:593: F:"q3map/terrain.c":
	surfaces = malloc( maxsurfaces * sizeof( *surfaces ) );

214: L:792: F:"q3map/terrain.c":
		surf->verts			= malloc( surf->maxVerts * sizeof( *surf->verts ) );

215: L:796: F:"q3map/terrain.c":
		surf->indexes		= malloc( surf->maxIndexes * sizeof( *surf->indexes ) );

216: L:807: F:"q3map/terrain.c":
	indices = malloc ( maxindices * sizeof( *indices ) );

217: L:1096: F:"q3map/terrain.c":
	t.map = malloc( t.width * t.height * sizeof( t.map[ 0 ] ) );

218: L:1145: F:"q3map/terrain.c":
	surfaces = malloc( maxsurfaces * sizeof( *surfaces ) );

219: L:86: F:"q3map/surface.c":
	ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );

220: L:429: F:"q3map/surface.c":
			newSide = malloc( sizeof( *side ) );

221: L:489: F:"q3map/surface.c":
	dsr = malloc( sizeof( *dsr ) );

222: L:538: F:"q3map/surface.c":
	dsr = malloc( sizeof( *dsr ) );

223: L:586: F:"q3map/surface.c":
	dsr = malloc( sizeof( *dsr ) );

224: L:63: F:"q3map/brush.c":
	bb = malloc(c);

225: L:549: F:"q3map/brush.c":
	tree = malloc(sizeof(*tree));

226: L:565: F:"q3map/brush.c":
	node = malloc(sizeof(*node));

227: L:35: F:"q3map/fog.c":
	m = malloc( sizeof( *m ) );

228: L:38: F:"q3map/fog.c":
	m->verts = malloc( sizeof(m->verts[0]) * m->width * m->height );

229: L:136: F:"q3map/fog.c":
	f = malloc( sizeof( *f ) );

230: L:148: F:"q3map/fog.c":
	f->verts = malloc( sizeof(f->verts[0]) * f->width * f->height );

231: L:150: F:"q3map/fog.c":
	b = malloc( sizeof( *b ) );

232: L:162: F:"q3map/fog.c":
	b->verts = malloc( sizeof(b->verts[0]) * b->width * b->height );

233: L:272: F:"q3map/fog.c":
	ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );

234: L:380: F:"q3map/fog.c":
	ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) );

235: L:39: F:"lcc/x86/linux/tst/wf1.1bk":
2	malloc

236: L:231: F:"lcc/x86/linux/tst/wf1.sbk":
call malloc

237: L:39: F:"lcc/x86/win32/tst/wf1.1bk":
2	malloc

238: L:229: F:"lcc/x86/win32/tst/wf1.sbk":
call _malloc

239: L:365: F:"lcc/x86/win32/tst/wf1.sbk":
extrn _malloc:near

240: L:82: F:"lcc/cpp/cpp.h":
#define	new(t)	(t *)domalloc(sizeof(t))

241: L:98: F:"lcc/cpp/cpp.h":
void	*domalloc(int);

242: L:251: F:"lcc/cpp/cpp.c":
domalloc(int size)

243: L:253: F:"lcc/cpp/cpp.c":
	void *p = malloc(size);

244: L:256: F:"lcc/cpp/cpp.c":
		error(FATAL, "Out of memory from malloc");

245: L:80: F:"lcc/cpp/tokens.c":
		trp->bp = (Token *)domalloc(size*sizeof(Token));

246: L:365: F:"lcc/cpp/tokens.c":
	uchar *ns = (uchar *)domalloc(l+o+1);

247: L:93: F:"lcc/cpp/unix.c":
   all and others do a terrible job (like calling malloc) */

248: L:114: F:"lcc/cpp/include.c":
	objname = (char*)domalloc(n+5);

249: L:59: F:"lcc/cpp/hideset.c":
	hs1 = (Hideset)domalloc(len*sizeof(Hideset));

250: L:96: F:"lcc/cpp/hideset.c":
	hidesets = (Hideset *)domalloc(maxhidesets*sizeof(Hideset *));

251: L:97: F:"lcc/cpp/hideset.c":
	hidesets[0] = (Hideset)domalloc(sizeof(Hideset));

252: L:556: F:"lcc/cpp/lex.c":
		s->inb = domalloc(len+4);

253: L:560: F:"lcc/cpp/lex.c":
		s->inb = domalloc(INS+4);

254: L:260: F:"lcc/src/bytecode.c":
	sourceFile = malloc( length + 1 );

255: L:20: F:"lcc/src/alloc.c":
	union header *new = malloc(sizeof *new + n);

256: L:66: F:"lcc/src/alloc.c":
				ap->next = malloc(m);

257: L:39: F:"lcc/sparc/solaris/tst/wf1.1bk":
2	malloc

258: L:150: F:"lcc/sparc/solaris/tst/wf1.sbk":
call malloc; nop

259: L:67: F:"lcc/tst/wf1.0":
	char *malloc();

260: L:82: F:"lcc/tst/wf1.0":
	words[next].word = malloc(strlen(word) + 1);

261: L:57: F:"lcc/tst/wf1.c":
	char *malloc();

262: L:72: F:"lcc/tst/wf1.c":
	words[next].word = malloc(strlen(word) + 1);

263: L:173: F:"lcc/etc/lcc.c":
		avail = malloc(n + 4*1024);

264: L:256: F:"lcc/etc/lcc.c":
			argv = malloc(argc*sizeof *argv);

265: L:62: F:"lcc/etc/bprint.c":
	void *new = malloc(n);

266: L:34: F:"lcc/include/sparc/solaris/stdlib.h":
extern void *malloc(size_t);

267: L:34: F:"lcc/include/alpha/osf/stdlib.h":
extern void *malloc(size_t);

268: L:34: F:"lcc/include/mips/irix/stdlib.h":
extern void *malloc(size_t);

269: L:39: F:"lcc/alpha/osf/tst/wf1.1bk":
2	malloc

270: L:222: F:"lcc/alpha/osf/tst/wf1.sbk":
jsr $26,malloc

271: L:39: F:"lcc/mips/irix/tst/wf1.1bk":
2	malloc

272: L:209: F:"lcc/mips/irix/tst/wf1.sbk":
jal malloc

273: L:21: F:"lcc/lburg/gram.c":
#include <stdlib.h> /* for malloc/realloc/free */

274: L:206: F:"lcc/lburg/gram.c":
YYDEFUN (yymalloc, (bytes), unsigned bytes)

275: L:208: F:"lcc/lburg/gram.c":
    YYPTR ptr = (YYPTR) malloc (bytes);

276: L:437: F:"lcc/lburg/gram.c":
        yyss = (short *) yymalloc (YYSTACKSIZE * sizeof (short));

277: L:440: F:"lcc/lburg/gram.c":
        yyvs = (YYSTYPE *) yymalloc (YYSTACKSIZE * sizeof (YYSTYPE));

278: L:540: F:"code/qcommon/files.c":
	// we are using direct malloc instead of Z_Malloc here, so it

279: L:542: F:"code/qcommon/files.c":
	buf = malloc( len );

280: L:563: F:"code/qcommon/cmd.c":
	// use a small malloc to avoid zone fragmentation

281: L:2439: F:"code/qcommon/unzip.c":
  inflate_huft *hufts;  /* single malloc for tree space */

282: L:742: F:"code/qcommon/common.c":
	int		size;			// total bytes malloced, including header

283: L:1376: F:"code/qcommon/common.c":
	// bk001205 - was malloc

284: L:1397: F:"code/qcommon/common.c":
	// bk001205 - was malloc

285: L:1523: F:"code/qcommon/common.c":
	// bk001205 - was malloc

286: L:402: F:"code/game/q_shared.h":
#undef ERR_FATAL			// this is be defined in malloc.h

287: L:265: F:"code/botlib/l_precomp.c":
//	t = (token_t *) malloc(sizeof(token_t));

288: L:352: F:"code/macosx/Q3Controller.m":
            cmdline = malloc(strlen([grCfg cString])+1);

289: L:361: F:"code/macosx/Q3Controller.m":
        cmdline = malloc(commandLineLength);

290: L:511: F:"code/macosx/macosx_glimp.m":
    buf = malloc(strlen(glConfig.renderer_string) + 1);

291: L:726: F:"code/macosx/macosx_glimp.m":
    symbolName = malloc(strlen(name) + 2);

292: L:146: F:"code/macosx/macosx_display.m":
    table->red = malloc(tableSize * sizeof(*table->red));

293: L:149: F:"code/macosx/macosx_display.m":
    table->green = malloc(tableSize * sizeof(*table->green));

294: L:152: F:"code/macosx/macosx_display.m":
    table->blue = malloc(tableSize * sizeof(*table->blue));

295: L:2025: F:"code/unix/ChangeLog":
	* code/qcommon/common.c: replaced malloc with calloc calls.

296: L:2914: F:"code/unix/ChangeLog":
	* unix/Makefile: added dmalloc in an attempt to get on

297: L:2915: F:"code/unix/ChangeLog":
	the Z_Free bug. Futile. Despite stripping dmalloc debug

298: L:2918: F:"code/unix/ChangeLog":
	  debug-malloc library: dumping program, fatal error

299: L:1240: F:"code/unix/unix_main.c":
  cmdline = malloc(len);

300: L:32: F:"code/splines/q_shared.cpp":
// malloc / free all in one place for debugging

301: L:68: F:"code/splines/q_shared.h":
#ifdef WIN32				// mac doesn't have malloc.h

302: L:69: F:"code/splines/q_shared.h":
#include <malloc.h>			// for _alloca()

303: L:288: F:"code/splines/q_shared.h":
#undef ERR_FATAL						// malloc.h on unix

304: L:68: F:"code/splines/q_shared.hpp":
#ifdef WIN32				// mac doesn't have malloc.h

305: L:69: F:"code/splines/q_shared.hpp":
#include <malloc.h>			// for _alloca()

306: L:288: F:"code/splines/q_shared.hpp":
#undef ERR_FATAL						// malloc.h on unix

307: L:19: F:"code/jpeg-6/jmemansi.c":
#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare malloc(),free() */

308: L:20: F:"code/jpeg-6/jmemansi.c":
extern void * malloc JPP((size_t size));

309: L:31: F:"code/jpeg-6/jmemansi.c":
 * routines malloc() and free().

310: L:37: F:"code/jpeg-6/jmemansi.c":
  return (void *) malloc(sizeofobject);

311: L:57: F:"code/jpeg-6/jmemansi.c":
  return (void FAR *) malloc(sizeofobject);

312: L:47: F:"code/jpeg-6/jmemdos.c":
extern void * malloc JPP((size_t size));

313: L:56: F:"code/jpeg-6/jmemdos.c":
#include <alloc.h>		/* need farmalloc(), farfree() */

314: L:57: F:"code/jpeg-6/jmemdos.c":
#define far_malloc(x)	farmalloc(x)

315: L:61: F:"code/jpeg-6/jmemdos.c":
#include <malloc.h>		/* need _fmalloc(), _ffree() */

316: L:62: F:"code/jpeg-6/jmemdos.c":
#define far_malloc(x)	_fmalloc(x)

317: L:68: F:"code/jpeg-6/jmemdos.c":
#define far_malloc(x)	malloc(x)

318: L:157: F:"code/jpeg-6/jmemdos.c":
 * routines malloc() and free().

319: L:163: F:"code/jpeg-6/jmemdos.c":
  return (void *) malloc(sizeofobject);

320: L:180: F:"code/jpeg-6/jmemdos.c":
  return (void FAR *) far_malloc(sizeofobject);

321: L:33: F:"code/jpeg-6/jcomapi.c":
   * with some (brain-damaged) malloc libraries.

322: L:38: F:"code/jpeg-6/jmemsys.h":
 * Behavior should be the same as for the standard library functions malloc

323: L:40: F:"code/jpeg-6/jmemsys.h":
 * On most systems, these ARE malloc and free.  jpeg_free_small is passed the

324: L:54: F:"code/jpeg-6/jmemmgr.c":
 * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()

325: L:266: F:"code/jpeg-6/jmemmgr.c":
    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */

326: L:350: F:"code/jpeg-6/jmemmgr.c":
    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */

327: L:1007: F:"code/jpeg-6/jmemmgr.c":
   * with some (brain-damaged) malloc libraries.

328: L:729: F:"code/jpeg-6/jpeglib.h":
 * to free, especially where malloc()/free() are not too speedy.

329: L:19: F:"code/jpeg-6/jmemname.c":
#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare malloc(),free() */

330: L:20: F:"code/jpeg-6/jmemname.c":
extern void * malloc JPP((size_t size));

331: L:133: F:"code/jpeg-6/jmemname.c":
 * routines malloc() and free().

332: L:139: F:"code/jpeg-6/jmemname.c":
  return (void *) malloc(sizeofobject);

333: L:159: F:"code/jpeg-6/jmemname.c":
  return (void FAR *) malloc(sizeofobject);

334: L:76: F:"code/bspc/l_mem.c":
	ptr = (void *) malloc(size);

335: L:91: F:"code/bspc/l_mem.c":
	ptr = malloc(size);

336: L:180: F:"code/bspc/l_mem.c":
	ptr = malloc(size + sizeof(memoryblock_t));

337: L:26: F:"code/bspc/qbsp.h":
#include <malloc.h>

338: L:409: F:"code/bspc/map_sin.c":
	temp = malloc(newbrushes*sizeof(mapbrush_t));

339: L:720: F:"code/bspc/l_bsp_hl.c":
	e = malloc (sizeof(epair_t));

340: L:850: F:"code/bspc/l_bsp_hl.c":
	ep = malloc (sizeof(*ep));

341: L:22: F:"code/bspc/l_poly.c":
#include <malloc.h>

342: L:268: F:"code/bspc/l_qfiles.c":
			qf = malloc(sizeof(quakefile_t));

343: L:332: F:"code/bspc/l_qfiles.c":
		idpackfiles = (dpackfile_t *) malloc(numpackdirs * sizeof(dpackfile_t));

344: L:344: F:"code/bspc/l_qfiles.c":
		packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));

345: L:358: F:"code/bspc/l_qfiles.c":
		packfiles = (dsinpackfile_t *) malloc(numpackdirs * sizeof(dsinpackfile_t));

346: L:381: F:"code/bspc/l_qfiles.c":
			qf = malloc(sizeof(quakefile_t));

347: L:507: F:"code/bspc/l_qfiles.c":
			qf = malloc(sizeof(quakefile_t));

348: L:309: F:"code/client/snd_adpcm.c":
		newchunk = SND_malloc();

349: L:58: F:"code/client/snd_mem.c":
sndBuffer*	SND_malloc() {

350: L:84: F:"code/client/snd_mem.c":
	buffer = malloc(scs*sizeof(sndBuffer) );

351: L:86: F:"code/client/snd_mem.c":
	sfxScratchBuffer = malloc(SND_CHUNK_SIZE * sizeof(short) * 4);	//Hunk_Alloc(SND_CHUNK_SIZE * sizeof(short) * 4);

352: L:269: F:"code/client/snd_mem.c":
			newchunk = SND_malloc();

353: L:147: F:"code/client/snd_wavelet.c":
		newchunk = SND_malloc();

354: L:216: F:"code/client/snd_wavelet.c":
		newchunk = SND_malloc();

355: L:169: F:"code/client/snd_local.h":
sndBuffer*	SND_malloc();

356: L:340: F:"code/client/snd_dma.c":
	sfx->soundData = SND_malloc();

357: L:1337: F:"code/renderer/tr_image.c":
    unsigned char *flip = (unsigned char*)malloc (columns*4);

Total match found:	357
Total files checked:	1434
Total files ignored:	47