Hola buenas, estaba haciendo un código en lenguaje C que consta de 3 ficheros. El programa lo que hace es leer de un fichero en formato txt las dimensiones y el dibujo de un laberinto, y mediante reserva dinámica de memoria, crearlo y luego liberar la memoria reservada. Dicho fichero lo paso por la línea de comandos junto con el nombre del ejecutable predeterminado (a.out) y las coordenadas mediante las cuales se soluciona el laberinto. El programa funciona bien salvo por un pequeño detalle, y es que el main no retorna 0, sino 86. Lo más curioso es que la propia función main, al final, le tengo puesto explícitamente que retorne 0. He probado a poner una estructura de control que garantice que siempre retorne 0, y sin embargo, no lo hace. A continuación, paso la función main de mi programa fuente:

int main (int argc,char * argv[])
{
	/* Examina el número de parámetros pasados */
	if(argc!=4)
	{
		fprintf(stderr,"ERROR: linea de comandos incorrecta. Utilice:\n\
leelabfich fichero_de_entrada columna_inicio fila_inicio\n");
		return 0;
	}
 
	int inix=atoi(argv[2]); //Cambia a formato numérico los caracteres
	int iniy=atoi(argv[3]); //pasados en línea de comando
 
	char dim[BUFF];
	char * pdim=&dim[0];
	char ** lab=NULL;
	char ** p=NULL;
	int i=0;
	int j=0;
	int ctrl=0;
	int ctrl2=0;
	int tamh=0;
	int tamv=0;
    int varokey = 0;
 
	nodo * lista=NULL;
 
	//inicializamos el buffer donde se guardarán las dimensiones
	memset(dim,0,BUFF);
 
	FILE * fp=NULL;
 
	fp=fopen(argv[1],"r"); // abrimos el archivo
	if(NULL==fp) // comprobamos que se ha abierto correctamente
	{
		fprintf(stderr,"No se puede abrir el fichero de entrada.\n");
		return 0;
	}
 
	pdim=fgets(dim,BUFF-1,fp);
	// Leemos la primera línea y la guardamos en el buffer
/* Se espera encontrar sólo dos números enteros, descartando
** que haya más.
**
** Para vrificar errores, numeros decimales o símbolos, la sentencia else y
** el if anidado en él controlan que no haya caracteres que induzcan
** al error, descartando los espacios.
*/
	for(i=0;dim[i]!='\n';i++)
	{
		if((dim[i]>='0')&&(dim[i]<='9'))
		{
			for(j=0;(dim[i+j]>='0')&&(dim[i+j]<='9');j++)
				;
			i=i+j-1;
			ctrl++;
		}
		else
		{
			if(dim[i]!=' ')
				ctrl2++;
		}
	}
/* aquí se determina si lo leído coincide con 2 enteros correspondientes
** a las dimensiones o hay un error.
*/
	if(ctrl!=2||ctrl2!=0)
	{
		//fprintf(stderr, "Dimensiones del laberinto incorrectas.\n\n");
		fprintf(stderr,"Las dimensiones han de ser dos números enteros.\n\n");
		return 0;
	}
// si todo es correcto se leen del propio buffer las dimensiones
	sscanf(pdim,"%d %d",&tamh,&tamv);
 
 
/* Se reserva memoria dinámicamente de acuerdo con las dimensiones
** especificadas. */
 
	lab=crea_laberinto(tamh,tamv);
 
	if(NULL==lab)
	{
		fprintf(stderr,"Error en la reserva de memoria.\n");
		return 0;
	}
	p=lab;
//inicializamos las variables de control
	ctrl=0;
	ctrl2=0;
 
/* Ahora leemos el propio laberinto desde el fichero indicado.
**
** Serán leídas tantas filas como diga la dimensión vertical.
** Cada línea leída se cuenta para asegurarnos que no se excede
** el valor indicado por la dimensión horizontal y haya una
** inconsistencia de datos
*/
	for(i=0,j=0;0==j;i++)
	{
		if(i<tamv)
		{
			fscanf(fp,"%s",p[i]);
			ctrl=(int)strlen(p[i]);
			if((ctrl!=tamh)&&((j=feof(fp))==0))
			{
				fprintf(stderr,"Fila %d leída errónea.\n",i+1);
				ctrl2++;
			}
			ctrl=0;
		}
		else
		{
			fscanf(fp,"%s",dim);
			ctrl++;
		}
		j=feof(fp);
	}
	if(1!=ctrl)
	{
		j=FALTANFILAS;
		if(i>tamv)
			--i;
	}
	else
		--i;
 
/* Examinamos que no hay una inconsistencia de datos analizando
** las variables de control. Si hay filas erróneas, se imprimen
** por la salida de errores los mesajes pertinentes, siendo ctrl2
** la variable que contiene el número de filas con errores.
*/
	if((ctrl2!=0)||(j==FALTANFILAS))
	{
		fprintf(stderr,"\nERROR en las filas leídas.\n");
		fprintf(stderr,"Filas válidas leídas: %d.\n",(i-ctrl2));
		fprintf(stderr, "Filas indicadas en dimensión: %d.\n",tamv);
 
		if(j!=FALTANFILAS)
		{
			fprintf(stderr, "\nERROR en las columnas leídas.\n");
			fprintf(stderr, "%d filas con errores en sus columnas.\n",
				ctrl2);
		}
 
		fprintf(stderr, "\nInconsistencias en los datos de entrada.\n\
NO RESOLVEMOS EL LABERINTO.\n\n");
 
			return 0;
	}
 
	if((inix>tamh)||(inix<0)) //se analiza que no empieze fuera del laberinto
	{
		printf("El punto (%d, %d) no pertenece al laberinto.\n",inix,iniy);
		return 0;
	}
	else
	{
		if((iniy>tamv)||(iniy<0))
		{
			printf("El punto (%d, %d) no pertenece al laberinto.\n",inix,iniy);
			return 0;
		}
	}
	p=lab;
	if(p[iniy][inix]=='#') // se analiza si el punto de inicio es
						   // un obstáculo
	{
		printf("El punto (%d, %d) es un obstaculo.\n",inix,iniy);
		return 0;
	}
 
 
	int a=0;
	a=fclose(fp); //cerramos el fichero donde está el laberinto.
    if (a){
        fprintf(stderr, "Error cerrando\n");
    }
/*
** Llamamos a la función que propiamente encuentra la salida del laberinto
** Los parametros pasados a la funcion son:
** primero un puntero que indica la posicion donde empiezo
** Un puntero a una zona de memoria que contiene al laberinto
** Tamaño horizontal del laberinto
** Tamaño vertical del laberinto
*/
 
	a=encuentraRuta(inix,iniy,lab,tamh,tamv,&lista);
 
//si la función no encuentra ninguna ruta, se imprime el mensaje pertinente
	if(a==0)
		printf("No existe salida desde el punto (%d, %d).\n",inix,iniy);
	else
	{
// Aqui es donde se imprimir el laberinto de forma "visual".
		cambonito(lab,tamh,tamv,&lista);
	}
// Liberamos la memoria donde se encontraba el laberinto y la
// lista de puntos por los que paso
 
	libera(lab,tamh,tamv,&lista);
    varokey = OK;
    if(varokey = OK){
	return 0;
    }
}
 

Mod: Al publicar código usa etiquetas GeSHi