/**
* \brief Stop all threads and free allocated resources.
*
* \return 1 on success, 0 on failure
*/
void kvz_threadqueue_free(threadqueue_queue_t *threadqueue)
{
if (threadqueue == NULL) return;
kvz_threadqueue_stop(threadqueue);
// Free all jobs.
while (threadqueue->first) {
threadqueue_job_t *next = threadqueue->first->next;
kvz_threadqueue_free_job(&threadqueue->first);
threadqueue->first = next;
}
threadqueue->last = NULL;
FREE_POINTER(threadqueue->threads);
threadqueue->thread_count = 0;
if (pthread_mutex_destroy(&threadqueue->lock) != 0) {
fprintf(stderr, "pthread_mutex_destroy failed!\n");
}
if (pthread_cond_destroy(&threadqueue->job_available) != 0) {
fprintf(stderr, "pthread_cond_destroy failed!\n");
}
if (pthread_cond_destroy(&threadqueue->job_done) != 0) {
fprintf(stderr, "pthread_cond_destroy failed!\n");
}
FREE_POINTER(threadqueue);
}
int
llistai_free (llistai_t * llista)
{
FREE_POINTER (llista->llista);
FREE_POINTER (llista);
return 0;
}
/**
* \brief Free memory allocated to the config
* \param cfg config object
* \return 1 on success, 0 on failure
*/
int config_destroy(config *cfg)
{
FREE_POINTER(cfg->input);
FREE_POINTER(cfg->output);
free(cfg);
return 1;
}
/**
* \brief Deallocate a cmdline_opts_t structure.
*/
void cmdline_opts_free(const kvz_api *const api, cmdline_opts_t *opts)
{
if (opts) {
FREE_POINTER(opts->input);
FREE_POINTER(opts->output);
FREE_POINTER(opts->debug);
api->config_destroy(opts->config);
opts->config = NULL;
}
FREE_POINTER(opts);
}
int kvz_config_destroy(kvz_config *cfg)
{
if (cfg) {
FREE_POINTER(cfg->cqmfile);
FREE_POINTER(cfg->tiles_width_split);
FREE_POINTER(cfg->tiles_height_split);
FREE_POINTER(cfg->slice_addresses_in_ts);
}
free(cfg);
return 1;
}
static void kvazaar_close(kvz_encoder *encoder)
{
if (encoder) {
if (encoder->states) {
for (unsigned i = 0; i < encoder->num_encoder_states; ++i) {
kvz_encoder_state_finalize(&encoder->states[i]);
}
}
FREE_POINTER(encoder->states);
kvz_encoder_control_free(encoder->control);
encoder->control = NULL;
}
FREE_POINTER(encoder);
}
void cSatipRtsp::ParseHeader(void)
{
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
char *s, *p = headerBufferM.Data();
char *r = strtok_r(p, "\r\n", &s);
while (r) {
debug16("%s (%zu): %s", __PRETTY_FUNCTION__, headerBufferM.Size(), r);
r = skipspace(r);
if (strstr(r, "com.ses.streamID")) {
int streamid = -1;
if (sscanf(r, "com.ses.streamID:%11d", &streamid) == 1)
tunerM.SetStreamId(streamid);
}
else if (strstr(r, "Session:")) {
int timeout = -1;
char *session = NULL;
if (sscanf(r, "Session:%m[^;];timeout=%11d", &session, &timeout) == 2)
tunerM.SetSessionTimeout(skipspace(session), timeout * 1000);
else if (sscanf(r, "Session:%m[^;]", &session) == 1)
tunerM.SetSessionTimeout(skipspace(session), -1);
FREE_POINTER(session);
}
r = strtok_r(NULL, "\r\n", &s);
}
}
static int parse_slice_specification(const char* const arg, int32_t * const nslices, int32_t** const array) {
const char* current_arg = NULL;
int32_t current_value;
int32_t values[MAX_SLICES];
int i;
//Free pointer in any case
if (*array) {
FREE_POINTER(*array);
}
//If the arg starts with u, we want an uniform split
if (arg[0]=='u') {
*nslices = atoi(arg+1);
if (MAX_SLICES <= *nslices || 0 >= *nslices) {
fprintf(stderr, "Invalid number of tiles (0 < %d <= %d = MAX_SLICES)!\n", *nslices + 1, MAX_SLICES);
return 0;
}
//Done with parsing
return 1;
}
//We have a comma-separated list of int for the split...
current_arg = arg;
//We always have a slice starting at 0
values[0] = 0;
*nslices = 1;
do {
int ret = sscanf(current_arg, "%d", ¤t_value);
if (ret != 1) {
fprintf(stderr, "Could not parse integer \"%s\"!\n", current_arg);
return 0;
}
current_arg = strchr(current_arg, ',');
//Skip the , if we found one
if (current_arg) ++current_arg;
values[*nslices] = current_value;
++(*nslices);
if (MAX_SLICES <= *nslices) break;
} while (current_arg);
if (MAX_SLICES <= *nslices || 0 >= *nslices) {
fprintf(stderr, "Invalid number of slices (0 < %d <= %d = MAX_SLICES)!\n", *nslices, MAX_SLICES);
return 0;
}
*array = MALLOC(int32_t, *nslices);
if (!*array) {
fprintf(stderr, "Could not allocate array for slices\n");
return 0;
}
//TODO: memcpy?
for (i = 0; i < *nslices; ++i) {
(*array)[i] = values[i];
}
return 1;
}
size_t cSatipRtsp::HeaderCallback(void *ptrP, size_t sizeP, size_t nmembP, void *dataP)
{
cSatipRtsp *obj = reinterpret_cast<cSatipRtsp *>(dataP);
size_t len = sizeP * nmembP;
debug16("%s len=%zu", __PRETTY_FUNCTION__, len);
char *s, *p = (char *)ptrP;
char *r = strtok_r(p, "\r\n", &s);
while (obj && r) {
debug16("%s (%zu): %s", __PRETTY_FUNCTION__, len, r);
r = skipspace(r);
if (strstr(r, "com.ses.streamID")) {
int streamid = -1;
if (sscanf(r, "com.ses.streamID:%11d", &streamid) == 1)
obj->tunerM.SetStreamId(streamid);
}
else if (strstr(r, "Session:")) {
int timeout = -1;
char *session = NULL;
if (sscanf(r, "Session:%m[^;];timeout=%11d", &session, &timeout) == 2)
obj->tunerM.SetSessionTimeout(skipspace(session), timeout * 1000);
else if (sscanf(r, "Session:%m[^;]", &session) == 1)
obj->tunerM.SetSessionTimeout(skipspace(session), -1);
FREE_POINTER(session);
}
r = strtok_r(NULL, "\r\n", &s);
}
return len;
}
/**
* \brief Free memory allocated to frame
* \param pic picture pointer
* \return 1 on success, 0 on failure
*/
int kvz_videoframe_free(videoframe_t * const frame)
{
kvz_image_free(frame->source);
frame->source = NULL;
kvz_image_free(frame->rec);
frame->rec = NULL;
kvz_cu_array_free(&frame->cu_array);
FREE_POINTER(frame->sao_luma);
FREE_POINTER(frame->sao_chroma);
free(frame);
return 1;
}
/**
* \brief Destroy scaling list allocated memory
*
*/
void kvz_scalinglist_destroy(scaling_list_t * const scaling_list)
{
uint32_t sizeId,listId,qp;
for (sizeId = 0; sizeId < 4; sizeId++) {
for (listId = 0; listId < kvz_g_scaling_list_num[sizeId]; listId++) {
for (qp = 0; qp < 6; qp++) {
if (!(sizeId == 3 && listId == 3)) {
FREE_POINTER(scaling_list->quant_coeff[sizeId][listId][qp]);
FREE_POINTER(scaling_list->de_quant_coeff[sizeId][listId][qp]);
FREE_POINTER(scaling_list->error_scale[sizeId][listId][qp]);
}
}
FREE_POINTER(scaling_list->scaling_list_coeff[sizeId][listId]);
}
}
}
CCCollisionManager::~CCCollisionManager()
{
if( tree != NULL )
{
CCOctreeDeleteLeafs( tree );
FREE_POINTER( tree );
}
}
int
data_stress_molecular_free (void)
{
FREE_POINTER (stress_tensor);
FREE_POINTER (mean_stress);
FREE_POINTER (mean_stress2);
FREE_POINTER (mean_stress_L);
FREE_POINTER (mean_stress2_L);
FREE_POINTER (mean_stress_R);
FREE_POINTER (mean_stress2_R);
FREE_POINTER (forca_L);
FREE_POINTER (forca_R);
return 0;
}
void free_stack_description (StackDescription* stkd)
{
FREE_POINTER (free_materials_list, stkd->MaterialsList) ;
FREE_POINTER (free_channel, stkd->Channel) ;
FREE_POINTER (free_dies_list, stkd->DiesList) ;
FREE_POINTER (free_conventional_heat_sink, stkd->ConventionalHeatSink) ;
FREE_POINTER (free_stack_elements_list, stkd->BottomStackElement) ;
FREE_POINTER (free_dimensions, stkd->Dimensions) ;
FREE_POINTER (free, stkd->FileName) ;
stkd->TopStackElement = NULL ;
}
int kvz_cu_array_free(cu_array_t * const cua)
{
int32_t new_refcount;
if (!cua) return 1;
new_refcount = KVZ_ATOMIC_DEC(&(cua->refcount));
//Still we have some references, do nothing
if (new_refcount > 0) return 1;
FREE_POINTER(cua->data);
free(cua);
return 1;
}
/**
* \brief Free a job.
*
* Decrement reference count of the job. If no references exist any more,
* deallocate associated memory and destroy mutexes.
*
* Sets the job pointer to NULL.
*/
void kvz_threadqueue_free_job(threadqueue_job_t **job_ptr)
{
threadqueue_job_t *job = *job_ptr;
if (job == NULL) return;
*job_ptr = NULL;
int new_refcount = KVZ_ATOMIC_DEC(&job->refcount);
if (new_refcount > 0) {
// There are still references so we don't free the data yet.
return;
}
assert(new_refcount == 0);
for (int i = 0; i < job->rdepends_count; i++) {
kvz_threadqueue_free_job(&job->rdepends[i]);
}
job->rdepends_count = 0;
FREE_POINTER(job->rdepends);
pthread_mutex_destroy(&job->lock);
FREE_POINTER(job);
}
void cSatipRtsp::ParseData(void)
{
debug1("%s [device %d]", __PRETTY_FUNCTION__, tunerM.GetId());
char *s, *p = dataBufferM.Data();
char *r = strtok_r(p, "\r\n", &s);
while (r) {
debug16("%s (%zu): %s", __PRETTY_FUNCTION__, dataBufferM.Size(), r);
r = skipspace(r);
if (strstr(r, "No-More:")) {
char *tmp = NULL;
if (sscanf(r, "No-More:%m[^;]", &tmp) == 1) {
errorNoMoreM = skipspace(tmp);
debug3("%s No-More: %s [device %d]", __PRETTY_FUNCTION__, *errorNoMoreM, tunerM.GetId());
}
FREE_POINTER(tmp);
}
else if (strstr(r, "Out-of-Range:")) {
char *tmp = NULL;
if (sscanf(r, "Out-of-Range:%m[^;]", &tmp) == 1) {
errorOutOfRangeM = skipspace(tmp);
debug3("%s Out-of-Range: %s [device %d]", __PRETTY_FUNCTION__, *errorOutOfRangeM, tunerM.GetId());
}
FREE_POINTER(tmp);
}
else if (strstr(r, "Check-Syntax:")) {
char *tmp = NULL;
if (sscanf(r, "Check-Syntax:%m[^;]", &tmp) == 1) {
errorCheckSyntaxM = skipspace(tmp);
debug3("%s Check-Syntax: %s [device %d]", __PRETTY_FUNCTION__, *errorCheckSyntaxM, tunerM.GetId());
}
FREE_POINTER(tmp);
}
r = strtok_r(NULL, "\r\n", &s);
}
}
int cPluginSatip::ParseCicams(const char *valueP, int *cicamsP)
{
debug1("%s (%s,)", __PRETTY_FUNCTION__, valueP);
int n = 0;
char *s, *p = strdup(valueP);
char *r = strtok_r(p, " ", &s);
while (r) {
r = skipspace(r);
debug3("%s cicams[%d]=%s", __PRETTY_FUNCTION__, n, r);
if (n < MAX_CICAM_COUNT) {
cicamsP[n++] = atoi(r);
}
r = strtok_r(NULL, " ", &s);
}
FREE_POINTER(p);
return n;
}
int cPluginSatip::ParseSources(const char *valueP, int *sourcesP)
{
debug1("%s (%s,)", __PRETTY_FUNCTION__, valueP);
int n = 0;
char *s, *p = strdup(valueP);
char *r = strtok_r(p, " ", &s);
while (r) {
r = skipspace(r);
debug3("%s sources[%d]=%s", __PRETTY_FUNCTION__, n, r);
if (n < MAX_DISABLED_SOURCES_COUNT) {
sourcesP[n++] = cSource::FromString(r);
}
r = strtok_r(NULL, " ", &s);
}
FREE_POINTER(p);
return n;
}
const bool CCTextureFontPageFile::load(const char *name, const CCResourceType resourceType, const bool generateMipMap)
{
CCText textureFilename( name );
textureFilename += ".png";
texturePageIndex = gEngine->textureManager->assignTextureIndex( textureFilename.buffer, resourceType, true, generateMipMap );
CCText filename( name );
filename += ".data";
// Load the descriptor file
char *fileData = NULL;
CCFileManager::getPackagedFile( filename.buffer, &fileData );
CCText textData( fileData );
FREE_POINTER( fileData );
CCList<char> *lettersSplit = textData.split( "\n" );
CCText rawLetterData;
for( int i=0; i<lettersSplit->length; ++i )
{
const char *raw = lettersSplit->list[i];
rawLetterData.set( raw );
CCList<char> *letterDataSplit = rawLetterData.split( "," );
ASSERT( letterDataSplit->length == 4 );
Letters &letter = letters[i];
letter.start.x = (float)atof( letterDataSplit->list[0] );
letter.start.y = (float)atof( letterDataSplit->list[1] );
letter.end.x = (float)atof( letterDataSplit->list[2] );
letter.end.y = (float)atof( letterDataSplit->list[3] );
// 16.0f because there's 16 tiles per font page
letter.size.width = ( letter.end.x - letter.start.x ) * 16.0f;
letter.size.height = ( letter.end.y - letter.start.y ) * 16.0f;
DELETE_POINTER( letterDataSplit );
}
DELETE_POINTER( lettersSplit );
return true;
}
int
data_print (const int snap)
{
double * sys = sys_handle ();
dr_writer_write_frame (pfile_historia, snap, sys);
fflush (pfile_historia);
/* S'agafa forca_handle, enlloc de odedef_func, perquè volem la forca també
* a les parets, i odedef_func, treu la interacció de phys amb parets i la
* substitueix per V. Així la f de les parets és la que els toca. */
double * f = (double *) malloc (sys_array_size * sizeof (double));
forca_function_pointer forca = odedef_get_forca_handle ();
int i; for (i = 0; i < sys_array_size; i++) f[i] = 0.;
cells_loop_force (t, sys, f, NULL, forca);
dr_writer_write_frame (pfile_historia_forces, snap, f);
fflush (pfile_historia_forces);
FREE_POINTER (f);
return 0;
}
void CCModelBase::destruct()
{
if( scale )
{
FREE_POINTER( scale );
}
if( colour != NULL )
{
delete colour;
}
if( colourOutline != NULL )
{
delete colourOutline;
}
models.deleteObjectsAndList();
primitives.deleteObjectsAndList();
super::destruct();
}
void cPluginSatip::ParseServer(const char *paramP)
{
debug1("%s (%s)", __PRETTY_FUNCTION__, paramP);
int n = 0;
char *s, *p = strdup(paramP);
char *r = strtok_r(p, ";", &s);
while (r) {
r = skipspace(r);
debug3("%s server[%d]=%s", __PRETTY_FUNCTION__, n, r);
cString sourceAddr, serverAddr, serverModel, serverFilters, serverDescription;
int serverQuirk = cSatipServer::eSatipQuirkNone;
int serverPort = SATIP_DEFAULT_RTSP_PORT;
int n2 = 0;
char *s2, *p2 = r;
char *r2 = strtok_r(p2, "|", &s2);
while (r2) {
debug3("%s param[%d]=%s", __PRETTY_FUNCTION__, n2, r2);
switch (n2++) {
case 0:
{
char *r3 = strchr(r2, '@');
if (r3) {
*r3 = 0;
sourceAddr = r2;
r2 = r3 + 1;
}
serverAddr = r2;
r3 = strchr(r2, ':');
if (r3) {
serverPort = strtol(r3 + 1, NULL, 0);
serverAddr = serverAddr.Truncate(r3 - r2);
}
}
break;
case 1:
{
serverModel = r2;
char *r3 = strchr(r2, ':');
if (r3) {
serverFilters = r3 + 1;
serverModel = serverModel.Truncate(r3 - r2);
}
}
break;
case 2:
{
serverDescription = r2;
char *r3 = strchr(r2, ':');
if (r3) {
serverQuirk = strtol(r3 + 1, NULL, 0);
serverDescription = serverDescription.Truncate(r3 - r2);
}
}
break;
default:
break;
}
r2 = strtok_r(NULL, "|", &s2);
}
if (*serverAddr && *serverModel && *serverDescription) {
debug1("%s srcaddr=%s ipaddr=%s port=%d model=%s (%s) desc=%s (%d)", __PRETTY_FUNCTION__, *sourceAddr, *serverAddr, serverPort, *serverModel, *serverFilters, *serverDescription, serverQuirk);
if (!serversM)
serversM = new cSatipDiscoverServers();
serversM->Add(new cSatipDiscoverServer(*sourceAddr, *serverAddr, serverPort, *serverModel, *serverFilters, *serverDescription, serverQuirk));
}
++n;
r = strtok_r(NULL, ";", &s);
}
FREE_POINTER(p);
}
const bool CCDeviceRenderer::loadShader(CCShader *shader)
{
// Create shader program
shader->program = new QGLShaderProgram();
// Create and compile vertex shader
CCText shaderFilename( "Resources/Shaders/" );
shaderFilename += shader->name;
shaderFilename += ".fx";
const char *qtDefines = "#define QT\r\n";
QGLShader *vertexShader = new QGLShader( QGLShader::Vertex );
QGLShader *fragmentShader = new QGLShader( QGLShader::Fragment );
{
char *fileData = NULL;
CCFileManager::getPackagedFile( shaderFilename.buffer, &fileData );
{
QString shaderData = QString( qtDefines );
shaderData.append( "#define VERTEX_SHADER\r\n" );
shaderData.append( fileData );
if( vertexShader->compileSourceCode( shaderData ) == false )
{
QString error( "CCDeviceRenderer::Failed to compile vertex shader.\n" );
error.append( vertexShader->log() );
ASSERT_MESSAGE( false, error.toUtf8().constData() );
delete vertexShader;
vertexShader = NULL;
}
}
{
QString shaderData = QString( qtDefines );
shaderData.append( "#define PIXEL_SHADER\r\n" );
shaderData.append( fileData );
if( fragmentShader->compileSourceCode( shaderData ) == false )
{
QString error( "CCDeviceRenderer::Failed to compile pixel shader.\n" );
error.append( fragmentShader->log() );
ASSERT_MESSAGE( false, error.toUtf8().constData() );
delete fragmentShader;
fragmentShader = NULL;
}
}
FREE_POINTER( fileData );
}
// Attach vertex shader to program
shader->program->addShader( vertexShader );
// Attach fragment shader to program
shader->program->addShader( fragmentShader );
// Bind attribute locations
// this needs to be done prior to linking
shader->program->bindAttributeLocation( "vs_position", ATTRIB_VERTEX );
shader->program->bindAttributeLocation( "vs_color", ATTRIB_COLOR );
shader->program->bindAttributeLocation( "vs_texCoord", ATTRIB_TEXCOORD );
// Link program
if( !shader->program->link() )
{
// Should log: "Failed to link program";
return false;
}
return true;
}
void cRssParser::ResetMemory(void)
{
// free any allocated memory
FREE_POINTER(dataM.memory);
dataM.size = 0;
}
int radar12491259() {
int *p = malloc(12);
FREE_POINTER(p);
FREE_POINTER(p); // no-warning: we are suppressing errors coming from sys/queue macros.
return 0;
}
void kvz_pixels_blit_avx2(const kvz_pixel * const orig, kvz_pixel * const dst,
const unsigned width, const unsigned height,
const unsigned orig_stride, const unsigned dst_stride)
{
unsigned y;
//There is absolutely no reason to have a width greater than the source or the destination stride.
assert(width <= orig_stride);
assert(width <= dst_stride);
#ifdef CHECKPOINTS
char *buffer = malloc((3 * width + 1) * sizeof(char));
for (y = 0; y < height; ++y) {
int p;
for (p = 0; p < width; ++p) {
sprintf((buffer + 3*p), "%02X ", orig[y*orig_stride]);
}
buffer[3*width] = 0;
CHECKPOINT("kvz_pixels_blit_avx2: %04d: %s", y, buffer);
}
FREE_POINTER(buffer);
#endif //CHECKPOINTS
if (width == orig_stride && width == dst_stride) {
memcpy(dst, orig, width * height * sizeof(kvz_pixel));
return;
}
int nxn_width = (width == height) ? width : 0;
switch (nxn_width) {
case 4:
*(int32_t*)&dst[dst_stride*0] = *(int32_t*)&orig[orig_stride*0];
*(int32_t*)&dst[dst_stride*1] = *(int32_t*)&orig[orig_stride*1];
*(int32_t*)&dst[dst_stride*2] = *(int32_t*)&orig[orig_stride*2];
*(int32_t*)&dst[dst_stride*3] = *(int32_t*)&orig[orig_stride*3];
break;
case 8:
*(int64_t*)&dst[dst_stride*0] = *(int64_t*)&orig[orig_stride*0];
*(int64_t*)&dst[dst_stride*1] = *(int64_t*)&orig[orig_stride*1];
*(int64_t*)&dst[dst_stride*2] = *(int64_t*)&orig[orig_stride*2];
*(int64_t*)&dst[dst_stride*3] = *(int64_t*)&orig[orig_stride*3];
*(int64_t*)&dst[dst_stride*4] = *(int64_t*)&orig[orig_stride*4];
*(int64_t*)&dst[dst_stride*5] = *(int64_t*)&orig[orig_stride*5];
*(int64_t*)&dst[dst_stride*6] = *(int64_t*)&orig[orig_stride*6];
*(int64_t*)&dst[dst_stride*7] = *(int64_t*)&orig[orig_stride*7];
break;
case 16:
for (int i = 0; i < 16; ++i) {
__m128i temp = _mm_loadu_si128((__m128i*)(orig + i * orig_stride));
_mm_storeu_si128((__m128i*)(dst + i * dst_stride), temp);
}
break;
case 32:
for (int i = 0; i < 32; ++i) {
__m256i temp = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride));
_mm256_storeu_si256((__m256i*)(dst + i * dst_stride), temp);
}
break;
case 64:
for (int i = 0; i < 64; ++i) {
__m256i temp0 = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride));
_mm256_storeu_si256((__m256i*)(dst + i * dst_stride), temp0);
__m256i temp1 = _mm256_loadu_si256((__m256i*)(orig + i * orig_stride + sizeof(__m256)));
_mm256_storeu_si256((__m256i*)(dst + i * dst_stride + sizeof(__m256)), temp1);
}
break;
default:
if (orig == dst) {
//If we have the same array, then we should have the same stride
assert(orig_stride == dst_stride);
return;
}
assert(orig != dst || orig_stride == dst_stride);
for (y = 0; y < height; ++y) {
memcpy(&dst[y*dst_stride], &orig[y*orig_stride], width * sizeof(kvz_pixel));
}
break;
}
}
void print_detailed_stack_description
(
FILE *stream,
String_t prefix,
StackDescription *stkd
)
{
String_t new_prefix =
(String_t) malloc (sizeof(*new_prefix) * (5 + strlen(prefix))) ;
if (new_prefix == NULL) return ;
sprintf (new_prefix, "%s ", prefix) ;
fprintf (stream,
"%sStackDescription = %p\n",
prefix, stkd) ;
fprintf (stream,
"%s FileName = " "%s\n",
prefix, stkd->FileName) ;
fprintf (stream,
"%s MaterialsList = %p\n",
prefix, stkd->MaterialsList) ;
if (stkd->MaterialsList != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_materials_list
(stream, new_prefix, stkd->MaterialsList) ;
fprintf (stream, "%s\n", prefix) ;
}
fprintf (stream,
"%s ConventionalHeatSink = %p\n",
prefix, stkd->ConventionalHeatSink) ;
if (stkd->ConventionalHeatSink != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_conventional_heat_sink
(stream, new_prefix, stkd->ConventionalHeatSink) ;
fprintf (stream, "%s\n", prefix) ;
}
fprintf (stream,
"%s Channel = %p\n",
prefix, stkd->Channel) ;
if (stkd->Channel != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_channel (stream, new_prefix, stkd->Channel) ;
fprintf (stream, "%s\n", prefix) ;
}
fprintf (stream,
"%s DiesList = %p\n",
prefix, stkd->DiesList) ;
if (stkd->DiesList != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_dies_list
(stream, new_prefix, stkd->DiesList) ;
fprintf (stream, "%s\n", prefix) ;
}
fprintf (stream,
"%s TopStackElement = %p\n",
prefix, stkd->TopStackElement) ;
fprintf (stream,
"%s BottomStackElement = %p\n",
prefix, stkd->BottomStackElement) ;
if (stkd->TopStackElement != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_stack_elements_list
(stream, new_prefix, stkd->TopStackElement) ;
fprintf (stream, "%s\n", prefix) ;
}
fprintf (stream,
"%s Dimensions = %p\n",
prefix, stkd->Dimensions) ;
if (stkd->Dimensions != NULL)
{
fprintf (stream, "%s\n", prefix) ;
print_detailed_dimensions
(stream, new_prefix, stkd->Dimensions) ;
fprintf (stream, "%s\n", prefix) ;
}
FREE_POINTER (free, new_prefix) ;
}
void free_tcell (Tcell *tcell)
{
FREE_POINTER(free, tcell) ;
}
