Newsgroup: it.comp.lang.c
Titolo: PROGRAMMA

Ciao a tutti.
C'è qualcuno che potrebbe dirmi perchè il programma riportato in seguito non
funziona??
Lo scopo del programma è quello di leggere i dati nella sezione Entities,
dove 10, 20, 30 sono le coordinate cartesiane e 40 è il raggio, la quale si
trova alla fine del file DXF (file per l'esportazione dei disegni di
AutoCad). Ora dovrebbe ordinare un albero
binario secondo il raggio con criterio r>=rrad DX, r<rrad SX e annullare il
raggio per un dato Range di valori.
Mi richiede il nome del file e poi si ferma, anche se sembra che stia ancora
lavorando.
Grazie a chiunque voglia aiutarmi.
Ciao, Stefano.
Questo è il file sorgente:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
int Epoint  =1;
int Eline   =2;
int Epline  =3;
int Etext   =4;
int Ecircle =5;
struct dim_cer{
       float x, y, z, r;
};
typedef struct dim_cer Dim_cer;
struct cerchio{
       int n;
       char piano[80];
       Dim_cer p[200];
};
typedef struct cerchio Cerchio;
struct nodo {
       float val;
       int cont;
       struct nodo *alb_sx;
       struct nodo *alb_dx;
};
/*******************
 * Dichiarazione funzioni *
 *******************/
int Entita(FILE*fp);
Dim_cer *leggi_dati(FILE *fp, Dim_cer *p);
struct nodo *crea_nodo(struct nodo *, float);
void anticipato(struct nodo *);
Cerchio *circle(FILE *fp);
struct nodo *alb_bin(Cerchio *);
/********************
 * Corpo del programma *
 ********************/
void main()
{
FILE *fp;
char file[30];
Cerchio *p;
printf("\n\n\nInserire il nome del file DXF: ");
scanf("%s", &file);
fp = fopen(file, "r");
/********************
 * Verifica se il file esiste *
 ********************/
if(fp == NULL) {
  printf("Il file %s non esiste.\n", file);
  exit(1);
  }
/**********************
 * Controlla se S un cerchio *
 **********************/
int i;
if(file != NULL) {
  do{
    i= Entita(fp);
    if(i==Epoint);
    if(i==Epline);
    if(i==Ecircle)p=circle(fp);
    if(i==Eline);
    if(i==Etext);
    }while(i!=-1);
    fclose(fp);
    }
/******************************************
 * Creazione albero binario e visita in ordine anticipato *
 ******************************************/
struct nodo *radice;
radice = alb_bin(p);           /*Invoca la funzione alb_bin*/
printf("\nQuesto è l'albero binario ordinato secondo il criterio dato:\n");
anticipato(radice);
}
/***********************
 * Definizione funzione Entita *
 ***********************/
int Entita(FILE *fp)
{
  char s[80];
  int ee =0;
  do {
    fscanf(fp, "%s", s);
    if(!strcmp(s, "POINT"))     ee= Epoint;
    if(!strcmp(s, "LINE"))      ee= Eline;
    if(!strcmp(s, "POLYLINE"))  ee= Epline;
    if(!strcmp(s, "TEXT"))      ee= Etext;
    if(!strcmp(s, "CIRCLE"))    ee= Ecircle;
    if(feof(fp))                ee=-1;
    } while(ee==0);
    return(ee);
}
/***************************
 * Definizione funzione *leggi_dati *
 ***************************/
Dim_cer *leggi_dati(FILE*fp, Dim_cer *p)
{
char s[80];
p->x=0;
p->y=0;
p->z=0;
p->r=0;
float x=0, y=0, z=0, r=0;
do{
  fscanf(fp, "%s", s);
  if(!strcmp(s, "8"))
    { fscanf(fp, "%s", s);
      strcpy(s, "00");
    }
  if(!strcmp(s, "10"))fscanf(fp, "%f", &x);
  if(!strcmp(s, "20"))fscanf(fp, "%f", &y);
  if(!strcmp(s, "30"))fscanf(fp, "%f", &z);
  if(!strcmp(s, "40"))fscanf(fp, "%f", &r);
  } while (strcmp(s, "0"));
  p->x=x;
  p->y=y;
  p->z=z;
  p->r=r;
  return(p);
}
/************************
 * Definizione funzione alb_bin *
 ************************/
struct nodo *alb_bin(Cerchio *c)
{
int i;
char s[80];
struct nodo *p = NULL;
struct nodo x;
FILE *fp;
for(i=0; i<=c->n; i++){
   do{
     if(!strcmp(s, "40"))
       fscanf(fp, "%f", &x.val);
       if(x.val>=0 && x.val<10) x.val=0;
       p= crea_nodo(p, x.val);
       } while (strcmp(s, "ENDSEC"));
       }
  return(p);
}
/****************************
 * Definizione funzione *crea_nodo *
 ****************************/
struct nodo *crea_nodo(struct nodo *p, float val)
{
 if(p==NULL) {
   p=(struct nodo *) malloc (sizeof(struct nodo));
   p->alb_sx = NULL;
   p->alb_dx = NULL;
   p->val=val;
   p->cont =0;
   }
     else
  if (val >= p->val)
  p->alb_dx = crea_nodo(p->alb_dx, val);
     else
  if (val < p->val)
  p->alb_sx = crea_nodo(p->alb_sx, val);
     else
  ++p->cont;
 return(p);
}
/**********************************
 * Visita l'albero binario in ordine anticipato *
 **********************************/
void anticipato(struct nodo *p)
{
if(p!=NULL) {
  printf("%f ",p->val);
  anticipato(p->alb_sx);
  anticipato(p->alb_dx);
  }
}
/************************
 * Definizione funzione *circle *
 ***********************/
Cerchio *circle(FILE *fp)
{
char s[80];
int k =-1;
Cerchio *p;
Dim_cer *pu;
p=NULL;
pu=NULL;
p=(Cerchio*)malloc(sizeof(Cerchio));
pu=(Dim_cer*)malloc(sizeof(Dim_cer));
p->n=0;
do{
  fscanf(fp, "%s",s);
  if(!strcmp(s,"8")) fscanf(fp, "%s", p->piano);
  if(!strcmp(s, "CIRCLE")){
    k++;
    pu=leggi_dati(fp, pu);
    p->p[k]=*pu;
    }
  }while(strcmp(s, "ENDSEC"));
p->n=k;
return(p);
}
Questa è la parte finale del DXF con 2 cerchi:
  0
SECTION
  2
ENTITIES
  0
CIRCLE
  8
0
  5
1
 10
82.640228
 20
181.77907
 30
0.0
 40
77.511815
  0
CIRCLE
  8
0
  5
2
 10
356.641287
 20
97.011627
 30
0.0
 40
141.583153
  0
ENDSEC
  0
EOF

       } while (strcmp(s, "ENDSEC"));
Qui hai qualche problema :
- s non viene mai inizializzata
- stesso dicasi per fp
- inoltre non puoi fare la fscanf in quanto non hai nessun file aperto
(oltre al fatto che fp punta chissa' dove)
In pratica il suddetto do{}while va avanti all'infinito e, se termina,
e' solo perche' nella crea_nodo succede qualche casino con la memoria
probabilmente dovuto ad un cattivo uso della ricorsivita'.
Quindi : controlla a fondo le funzioni alb_bin e crea_nodo
ciao

 >       } while (strcmp(s, "ENDSEC"));
