/** * \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) ; }