Problemas con la funcion Free del c

[o.m.h]

Este es el codigo,

He resumido el codigo ya que el server no me permite poner todo el codigo. La variable a seguir puede ser por ejemplo *pi. En ninguna de las lineas omitidas se libera este vector.

Al final pongo la libreria la funcion nrutil.c (RESERVA DE MEMORIA)

Mas abajo indico la linea que me da problemas


#include "nrutil.h"

ichar *point_grup;
char **nombre_puntos,**files_arestes,**files_punts,**pu nt_inicial,**punt_final;


int *punts_elimin,*pi,*pf,*flag_aresta,*grup_aresta;
int **punts,**arestes_in;

double *gamm,*obs,*topo;




int main (int argc,char **argv)

{



if (argc == 1)
{
printf ("Usage: %s filename\n", argv[0]);
exit (1);
}
strcpy (filename, argv[1]);


if (!(in1 = fopen (filename, "r"))) nrerror (strcat (strcat ("Cannot open ", filename), " file"));



printf("INPUT DATA\n");

input_data(); //read and allocate the input parameters data


************************************************** ********
ESTA ES LA INSTRUCCION QUE ME DA PROBLEMAS

-----> free_ivector(pi,1,numero_de_observaciones);
************************************************** ******
free_dvector(obs,1,numero_de_observaciones);
free_dvector(gamm,1,numero_de_observaciones);
free_dvector(topo,1,numero_de_observaciones);
fclose (in1);
fclose (in2);
return 0;
}
int input_data()
{
int i,r,k;
int *noss_loc,*nompunt_loc;


fscanf(in1,"%u",&ncol);
fscanf(in1,"%u",&nlin);
fscanf(in1,"%u",&num_prov);
fscanf(in1,"%u",&llindar_incidencia);
fscanf(in1,"%f",&llindar_gamma);


files_arestes=malloc((num_prov+1)*sizeof(char*));

for (i=0;i<num_prov+1;i++)
files_arestes[i]=malloc(10*sizeof(char));

noss_loc=ivector(1,num_prov);
nompunt_loc=ivector(1,num_prov);

noss=0;
for (k=0;k<num_prov;k++)
{

fscanf(in1,"%s",&titolo);
sprintf(files_arestes[k],"%s",titolo);
if((in2=fopen(files_arestes[k],"r"))==NULL)
{

printf("El fitxer d'arestes %s no existeix\n",files_arestes[k]);
getch();
exit(1);

}

i=0;
i1=0;

while ( !feof(in2) )
{
fscanf(in2,"%s",&titolo);
fscanf(in2,"%s",&titolo);
fscanf (in2,"%u",&i1);
fscanf(in2,"%u", &i2);
fscanf(in2,"%f",&f1);
fscanf(in2,"%f",&f1);
fscanf(in2,"%f",&f2);
i++;
}
noss_loc[k+1]=i-1;
noss=noss+i-1;

fclose (in2);
}

numero_de_observaciones=noss;

punt_inicial=malloc(numero_de_observaciones*sizeof (char *));
punt_final=malloc(numero_de_observaciones*sizeof(c har *));

auxarestes=noss;
***************************RESERVO**************** ***************pi = ivector(1,numero_de_observaciones);

********************************************
for(i=0;i<noss;i++)
{
punt_inicial[i]=malloc(10*sizeof(char ));
punt_final[i]=malloc(10*sizeof(char));
flag_aresta[i]=0;
pi[i]=-100;
pf[i]=-100;
grup_aresta[i]=-100;
}
return(1);

}
***************nrutil.c

float *vector();
float **matrix();
float **convert_matrix();
double *dvector();
double **dmatrix();
int *ivector();
int **imatrix();
long int *livector();
float **submatrix();
void free_vector();
void free_dvector();
void free_ivector();
void free_livector();
void free_matrix();
void free_dmatrix();
void free_imatrix();
void free_submatrix();
void free_convert_matrix();
void nrerror();

#include <malloc.h>
#include <stdio.h>

void nrerror(error_text)
char error_text[];
{
void exit();

fprintf(stderr,"Error...\n");
fprintf(stderr,"%s\n",error_text);
fprintf(stderr,"...now exiting to system...\n");
exit(1);
}



float *vector(nl,nh)
int nl,nh;
{
float *v;

v=(float *)malloc((unsigned) (nh-nl+1)*sizeof(float));
if (!v) nrerror("allocation failure in vector()");
return v-nl;
}

int *ivector(nl,nh)
int nl,nh;
{
int *v;

v=( int *)malloc((unsigned) (nh-nl+1)*sizeof( int));
if (!v) nrerror("allocation failure in ivector()");
return v-nl;
}
long int *livector(nl,nh)
long int nl,nh;
{
long int *v;

v=(long int *)malloc((unsigned) (nh-nl+1)*sizeof(long int));
if (!v) nrerror("allocation failure in ivector()");
return v-nl;
}


double *dvector(nl,nh)
int nl,nh;
{
double *v;

v=(double *)malloc((unsigned) (nh-nl+1)*sizeof(double));
if (!v) nrerror("allocation failure in dvector()");
return v-nl;
}



float **matrix(nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
{
int i;
float **m;

m=(float **) malloc((unsigned) (nrh-nrl+1)*sizeof(float*));
if (!m) nrerror("allocation failure 1 in matrix()");
m -= nrl;

for(i=nrl;i<=nrh;i++) {
m[i]=(float *) malloc((unsigned) (nch-ncl+1)*sizeof(float));
if (!m[i]) nrerror("allocation failure 2 in matrix()");
m[i] -= ncl;
}
return m;
}

double **dmatrix(nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
{
int i;
double **m;

m=(double **) malloc((unsigned) (nrh-nrl+1)*sizeof(double*));
if (!m) nrerror("allocation failure 1 in dmatrix()");
m -= nrl;

for(i=nrl;i<=nrh;i++) {
m[i]=(double *) malloc((unsigned) (nch-ncl+1)*sizeof(double));
if (!m[i]) nrerror("allocation failure 2 in dmatrix()");
m[i] -= ncl;
}
return m;
}

int **imatrix(nrl,nrh,ncl,nch)
int nrl,nrh,ncl,nch;
{
int i,**m;

m=( int **)malloc((unsigned) (nrh-nrl+1)*sizeof( int*));
if (!m) nrerror("allocation failure 1 in imatrix()");
m -= nrl;

for(i=nrl;i<=nrh;i++) {
m[i]=( int *)malloc((unsigned) (nch-ncl+1)*sizeof( int));
if (!m[i]) nrerror("allocation failure 2 in imatrix()");
m[i] -= ncl;
}
return m;
}



float **submatrix(a,oldrl,oldrh,oldcl,oldch,newrl,newcl)
float **a;
int oldrl,oldrh,oldcl,oldch,newrl,newcl;
{
int i,j;
float **m;

m=(float **) malloc((unsigned) (oldrh-oldrl+1)*sizeof(float*));
if (!m) nrerror("allocation failure in submatrix()");
m -= newrl;

for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+oldcl-newcl;

return m;
}



void free_vector(v,nl,nh)
float *v;
int nl,nh;
{
free((char*) (v+nl));
}

void free_ivector(v,nl,nh)
int *v,nl,nh;
{
free((char*) (v+nl));
}
void free_livector(v,nl,nh)
long int *v,nl,nh;
{
free((char*) (v+nl));
}

void free_dvector(v,nl,nh)
double *v;
int nl,nh;
{
free((char*) (v+nl));
}



void free_matrix(m,nrl,nrh,ncl,nch)
float **m;
int nrl,nrh,ncl,nch;
{
int i;

for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
free((char*) (m+nrl));
}

void free_dmatrix(m,nrl,nrh,ncl,nch)
double **m;
int nrl,nrh,ncl,nch;
{
int i;

for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
free((char*) (m+nrl));
}

void free_imatrix(m,nrl,nrh,ncl,nch)
int **m;
int nrl,nrh,ncl,nch;
{
int i;

for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
free((char*) (m+nrl));
}



void free_submatrix(b,nrl,nrh,ncl,nch)
float **b;
int nrl,nrh,ncl,nch;
{
free((char*) (b+nrl));
}



float **convert_matrix(a,nrl,nrh,ncl,nch)
float *a;
int nrl,nrh,ncl,nch;
{
int i,j,nrow,ncol;
float **m;

nrow=nrh-nrl+1;
ncol=nch-ncl+1;
m = (float **) malloc((unsigned) (nrow)*sizeof(float*));
if (!m) nrerror("allocation failure in convert_matrix()");
m -= nrl;
for(i=0,j=nrl;i<=nrow-1;i++,j++) m[j]=a+ncol*i-ncl;
return m;
}



void free_convert_matrix(b,nrl,nrh,ncl,nch)
float **b;
int nrl,nrh,ncl,nch;
{
free((char*) (b+nrl));
}