#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define DIM_STRING 10
#define MAX_VERTICI 10
/*##############################################################*/
/* STRUTTURE DATI */
/*##############################################################*/
typedef struct specie
{
struct specie *next;
char stringa[DIM_STRING+1];
struct adiacenza *ad;
}
specie;
typedef struct adiacenza
{
struct specie *specie;
struct adiacenza *next;
}
adiacenza;
typedef struct animale
{
struct animale *next;
struct specie *specie;
int x;
int y;
}
animale;
typedef struct recinto
{
int val;
int num_vertici;
struct vertice * vertici;
struct recinto * next;
struct recinto * prev;
}
recinto;
typedef struct vertice
{
int x;
int y;
struct vertice * next;
}
vertice;
typedef struct bitmap
{
animale * a;
int del;
}
bitmap;
#define MAX_ARGS 21
struct comando /* gestore linea comandi */
{
char * nome;
char * argv[MAX_ARGS+1];
int argc;
};
/*##############################################################*/
/* PROTOTIPI FUNZIONI AUSILIARIE */
/*##############################################################*/
void cancella_lista_vertici(recinto *nodo);
void cancella_lista_recinti();
void cancella_lista_animali();
void cancella_lista_adiacenze(specie *nodo);
void cancella_lista_specie();
void cancella_campo();
specie* inserisci_specie(char *stringa);
void inserisci_animale(int x, int y, specie *spec);
void inserisci_recinto(int val,vertice *vertici, int num_vertici);
int cancella_recinto(recinto *nodo);
void riordina_recinto();
vertice * inserisci_vertice(int x, int y, vertice* t_vertice);
int posizione_punto(int xA, int yA, int xB, int yB, int xC, int yC);
int nel_recinto(int a, int b, recinto *r_tmp);
int relazione_errata(specie *specie1, char *s2);
void visita_grafo(specie *specie1, bitmap bit[]);
/*##############################################################*/
/* PROTOTIPI FUNZIONI PRINCIPALI */
/*##############################################################*/
void crea();
int inserisci(int a, int b, char *s, int verbose);
void inserisci_random(int a, int b, int c, int d, int n, char *s);
void elimina(int a, int b);
void ordina(char * s1, char * s2);
void recinta(int argc, char* argv[]);
void elimina_recinto(int a, int b);
void mostra_recinto(int r);
void mostra_campo();
void seleziona();
/*##############################################################*/
/* PROTOTIPI FUNZIONI DI GESTIONE DEL MAIN */
/*##############################################################*/
void parse_command(struct comando *command, char *linea);
/*##############################################################*/
/* VARIABILI GLOBALI */
/*##############################################################*/
specie *t_specie = NULL; /* puntatore alla testa della lista Specie */
animale *t_animale = NULL; /* puntatore alla testa della lista Animale */
animale *c_animale = NULL; /* puntatore alla coda della lista Animale */
recinto *t_recinto = NULL; /* puntatore alla testa della lista Recinto */
recinto *c_recinto = NULL; /* puntatore alla coda della lista Recinto */
int num_animali = 0; /* contatore elementi animali della lista */
int num_recinti = 0; /* contatore recinti nel campo */
/*##############################################################*/
/* FUNZIONI AUSILIARIE */
/*##############################################################*/
/* Dealloca la memoria occupata dalla lista dei vertici associata al recinto nodo */
void cancella_lista_vertici(recinto *nodo)
{
vertice *tmp = nodo->vertici;
vertice *tmp1 = NULL;
/* scorre la lista e cancella tutti i suoi elementi */
while(tmp!=NULL)
{
tmp1=tmp->next;
tmp=tmp1;
}
}
void cancella_lista_recinti()
{
recinto *tmp = t_recinto;
recinto *tmp1 = NULL;
/* scorre la lista e cancella tutti i suoi elementi */
while(tmp!=NULL)
{
tmp1=tmp;
cancella_lista_vertici(tmp);
tmp=tmp1->next;
}
t_recinto=NULL;
num_recinti=0;
}
void cancella_lista_animali()
{
animale *tmp = t_animale;
animale *tmp1 = NULL;
/* scorre la lista e cancella tutti i suoi elementi */
while(tmp!=NULL)
{
tmp1=tmp->next;
tmp=tmp1;
}
t_animale = NULL;
num_animali=0;
}
/* Dealloca la memoria occupata dalla lista dei vertici associata al recinto nodo */
void cancella_lista_adiacenze(specie *nodo)
{
adiacenza *tmp = nodo->ad;
adiacenza *tmp1 = NULL;
/* scorre la lista e cancella tutti i suoi elementi */
while(tmp!=NULL)
{
tmp1=tmp->next;
tmp=tmp1;
}
}
void cancella_lista_specie()
{
specie *tmp = t_specie;
specie *tmp1 = NULL;
/* scorre la lista e cancella tutti i suoi elementi */
while(tmp!=NULL)
{
tmp1=tmp->next;
cancella_lista_adiacenze(tmp);
tmp=tmp1;
}
t_specie = NULL;
}
void cancella_campo()
{
cancella_lista_animali();
cancella_lista_specie(); /* cancella la lista di adiacenze associata */
cancella_lista_recinti(); /* cancella la lista vertici associata */
printf("Campo inizializzato\n");
}
specie* inserisci_specie(char *stringa)
{ /* inserimento in testa */
specie *tmp;
/* Alloca il nodo "specie" */
tmp
= (specie
*)malloc(sizeof(specie
));
tmp->next=NULL;
tmp->ad=NULL;
if(t_specie==NULL) /* lista vuota */
{
t_specie=tmp;
return tmp;
} else
{
tmp->next=t_specie;
t_specie=tmp;
return tmp;
}
}
void inserisci_animale(int x, int y, specie *spec)
{ /* inserimento in coda */
animale *tmp;
tmp
= (animale
*)malloc(sizeof(animale
));
tmp->next=NULL;
tmp->x=x;
tmp->y=y;
tmp->specie=spec;
if(t_animale==NULL || c_animale==NULL)
{
t_animale=tmp;
c_animale=tmp;
}
else
{
c_animale->next=tmp;
c_animale=tmp;
}
num_animali++;
}
void inserisci_recinto(int val,vertice *vertici, int num_vertici)
{ /* inserimento in coda: lista doppia */
recinto *tmp;
tmp
= (recinto
*)malloc(sizeof(recinto
));
tmp->val=val;
tmp->num_vertici=num_vertici;
tmp->vertici=vertici;
if(t_recinto==NULL || c_recinto==NULL)
{
tmp->next=NULL;
tmp->prev=NULL;
c_recinto=tmp;
t_recinto=tmp;
}
else
{
tmp->next=NULL;
tmp->prev=c_recinto;
c_recinto->next=tmp;
c_recinto=tmp;
}
}
/* Elimina un nodo recinto e riordina la lista */
int cancella_recinto(recinto *nodo)
{
/* se la lista contiene un solo elemento */
if(nodo==c_recinto && nodo == t_recinto)
{
c_recinto=NULL;
t_recinto=NULL;
cancella_lista_vertici(nodo);
return 1;
}
/* se il nodo è la testa della lista */
else if(nodo==t_recinto)
{
nodo->next->prev=NULL;
t_recinto=nodo->next;
cancella_lista_vertici(nodo);
return 1;
}
/* se il nodo è la coda della lista */
else if(nodo==c_recinto)
{
nodo->prev->next=NULL;
c_recinto=nodo->prev;
cancella_lista_vertici(nodo);
return 1;
}
else
{
nodo->prev->next=nodo->next;
nodo->next->prev=nodo->prev;
cancella_lista_vertici(nodo);
return 1;
}
}
void riordina_recinto()
{
recinto *tmp = t_recinto;
int i=1;
/* Scorre la lista dei recinti e riassegna a ciascun nodo un numero
progressivo fino a raggiungere il valore dei recinti totali (num_recinti) */
while(tmp!=NULL)
{
tmp->val=i;
tmp=tmp->next;
i++;
}
}
vertice * inserisci_vertice(int x, int y, vertice* t_vertice)
{ /* inserimento in coda */
vertice *tmp,*tmp1;
tmp
= (vertice
*)malloc(sizeof(vertice
));
tmp->next=NULL;
tmp->x=x;
tmp->y=y;
if(t_vertice==NULL)
{ /* lista vuota */
t_vertice=tmp;
}
else
{
tmp1=t_vertice;
while (tmp1!=NULL)
{
if(tmp1->next==NULL)
{
tmp1->next=tmp;
break;
}
tmp1=tmp1->next;
}
}
return t_vertice;
}
/* Prende in ingresso tre punti definiti da coppie ordinate di numeri
e verifica la posizione del terzo punto C rispetto alla retta AB.
Restituisce 0 se i tre punti sono allineati, <0 se il punto si trova
alla destra della retta e >0 se si trova alla sinistra della retta */
int posizione_punto(int xA, int yA, int xB, int yB, int xC, int yC)
{
return (xC-xA)*(yB-yA)-(yC-yA)*(xB-xA);
}
/* Verifica che i punti a,b siano all'interno del recinto r_tmp */
int nel_recinto(int a, int b, recinto *r_tmp)
{
/* Un punto giace in un poligono convesso se per ogni lato il punto
si trova alla destra della retta (ab) per vertici allineati in senso orario*/
vertice *v_tmp=r_tmp->vertici;
int i=0;
int v[r_tmp->num_vertici*2]; /* alloca un array di dimensione (num_vertici*2) */
/* controlla che il punto (a,b) sia interno a tutti i lati del poligono */
while(v_tmp!=NULL) /* pone i valori della lista "vertici" nell'array */
{
v[i]=v_tmp->x;
v[i+1]=v_tmp->y;
v_tmp=v_tmp->next;
i=i+2;
}
for(i=1;i<r_tmp->num_vertici;i++)
{ /* se il punto è all'esterno del poligono */
if(posizione_punto(v[i*2-2],v[i*2-1],v[i*2+0],v[i*2+1],a,b)<0)
return 0;
}
if(posizione_punto(v[i*2-2],v[i*2-1],v[0],v[1],a,b)<0)
return 0;
return 1;
}
/* Funzione ricorsiva: ricompone il percorso del grafo
se trova una stringa ugale a s2 solleva errore */
int relazione_errata(specie *specie1, char *s2)
{
adiacenza *tmpad=NULL;
if(specie1->ad!=NULL)
{ /* segue il percorso per ogni nodo della lista adiacenza di s1 */
tmpad=specie1->ad;
while(tmpad!=NULL)
{ /* se le due stringhe sono uguali allora c'è un ciclo */
if(!strcmp(s2
,tmpad
->specie
->stringa
))
return 1;
if(relazione_errata(tmpad->specie,s2))
return 1;
tmpad=tmpad->next;
}
}
return 0;
}
/* Funzione ricorsiva: percorre il cammino del grafo a partire dal nodo specie1
e marca tutti gli animali nella bitmap che devono essere eliminati */
void visita_grafo(specie *specie1, bitmap bit[] )
{
adiacenza *tmpad=NULL;
int i;
if(specie1->ad!=NULL)
{ /* segue il percorso per ogni nodo della lista adiacenza */
tmpad=specie1->ad;
while(tmpad!=NULL)
{
/* sfoglia l'array bitmap */
for(i=0;bit[i].a!=NULL;i++)
{ /* se l'animale presente nella bitmap è da eliminare viene marcato */
if(!bit[i].del)
{ /* se l'animale non è marcato */
if(!strcmp(bit
[i
].
a->specie
->stringa
,tmpad
->specie
->stringa
))
bit[i].del=1;
}
}
visita_grafo(tmpad->specie, bit);
tmpad=tmpad->next;
}
}
return;
}
void mostra_grafo()
{
specie *tmp;
adiacenza *tmpad=NULL;
tmp=t_specie;
while(tmp!=NULL)
{
tmpad=tmp->ad;
printf("| %s |-> ",tmp
->stringa
);
while(tmpad!=NULL)
{
printf("%s -> ",tmpad
->specie
->stringa
);
tmpad=tmpad->next;
}
tmp=tmp->next;
}
}
/*##############################################################*/
/* FUNZIONI PRINCIPALI */
/*##############################################################*/
void crea()
{
cancella_campo();
}
int inserisci(int a, int b, char *s, int verbose)
{
animale *a_tmp = t_animale;
specie *s_tmp = t_specie;
specie *ptr_specie;
int presente_specie=0;
while(a_tmp!=NULL)
{ /* Scorre la lista animali e verifica se le coordinate sono occupate */
if(a_tmp->x==a && a_tmp->y==b)
{
if (verbose)
fprintf(stderr
, "errore: le coordinade (%d, %d) sono già occupate\n",a
,b
);
return 0;
}
a_tmp=a_tmp->next;
}
while(s_tmp!=NULL)
{
/* Se specie è presente */
{
presente_specie=1;
ptr_specie=s_tmp;
break;
}
s_tmp=s_tmp->next;
}
if(!presente_specie)
{
inserisci_specie(s);
ptr_specie = t_specie;
}
inserisci_animale(a,b,ptr_specie);
if (verbose)
printf("inserito:\t%d\t%d\t%s\n",a
,b
,s
);
return 1;
}
void inserisci_random(int a, int b, int c, int d, int n, char *s)
{
int x, y;
int i = 0;
/* Può entrare in un ciclo infinito se tutte le posizioni
nel range (ab)(cd) sono occupate */
while (i<n)
{
i=i+inserisci(x,y,(char*)s,0);
}
}
void elimina(int a, int b)
{
animale *a_tmp, *canc;
a_tmp = t_animale;
if(a_tmp!=NULL)
{ /* Se è presente almeno un elemento */
if(a_tmp->x==a && a_tmp->y==b) /* cancellazione in testa */
{
canc=a_tmp;
if(canc->next==NULL) /* se è l'ultimo nodo */
c_animale=NULL; /* aggiorna la coda */
a_tmp=a_tmp->next;
num_animali--;
t_animale=a_tmp; /* aggiorna il puntatore alla testa */
return;
}
while(a_tmp->next!=NULL)
{
if(a_tmp->next->x==a && a_tmp->next->y==b)
{
canc=a_tmp->next;
if(canc==c_animale) /* se è l'ultimo nodo */
c_animale=a_tmp; /* aggiorna la coda */
a_tmp->next=canc->next;
num_animali--;
return;
}
a_tmp=a_tmp->next;
}
}
fprintf(stderr
, "%d,%d:\tanimale non trovato\n",a
,b
);
}
void ordina(char * s1, char * s2)
{
specie *tmp, *specie1, *specie2;
adiacenza *tmpad;
int is_in_s1=0;
int is_in_s2=0;
/* Controlla che le due stringhe siano diverse */
{
fprintf(stderr
,"errore: le stringhe immesse sono uguali\n");
return;
}
/* Ottieni i puntatori ai nodi delle due stringhe passate
se non esistono vengono aggiunti */
tmp=t_specie;
while(tmp!=NULL)
{
{
is_in_s1=1;
specie1=tmp;
}
{
is_in_s2=1;
specie2=tmp;
}
if(is_in_s1==1 && is_in_s2==1) /* Le due stringhe sono state trovate */
break;
tmp=tmp->next;
}
if(!is_in_s1)
specie1=inserisci_specie(s1);
if(!is_in_s2)
specie2=inserisci_specie(s2);
/* Controlla l'esistenza della relazione */
tmpad=specie2->ad;
while(tmpad!=NULL)
{
if(!strcmp(tmpad
->specie
->stringa
,specie1
->stringa
))
{
fprintf(stderr
,"errore: la relazione è già esistente\n");
return;
}
tmpad=tmpad->next;
}
if(relazione_errata(specie1, s2))
{
return;
}
/* Lista di adiacenza */
if(specie2->ad==NULL)
{ /* Non esiste nessun nodo adiacente */
tmpad
= (adiacenza
*)malloc(sizeof(adiacenza
));
tmpad->specie=specie1;
tmpad->next = NULL;
specie2->ad=tmpad;
}
else
{ /* Esiste almeno un nodo adiacente */
tmpad
= (adiacenza
*)malloc(sizeof(adiacenza
));
tmpad->next=specie2->ad; /* primo nodo della lista adiacenza */
tmpad->specie=specie1;
specie2->ad=tmpad;
}
/* mostra_grafo(); */
}
void recinta(int argc, char* argv[])
{
int i;
vertice * t_vertice = NULL;
/* controlla che non ci siano 3 vertici allineati */
for(i=1;i<=(argc-1)/2;i++)
{
if(i>=3)
{
/* controlla se siano allineati gli ultimi 2 vertici con il primo */
if(i == (argc-1)/2) /* se è l'ultimo vertice */
{
if(!posizione_punto(
atoi(argv
[i
*2-1]),atoi(argv
[i
*2]), /* ultimo vertice */
atoi(argv
[3]),atoi(argv
[4]), /* secondo vertice */
atoi(argv
[1]),atoi(argv
[2]) /* primo vertice */
))
{
fprintf(stderr
,"errore: sono stati immessi tre o più vertici allineati\n");
return;
}
}else
if(!posizione_punto(
atoi(argv
[(i
-2)*2-1]),atoi(argv
[(i
-2)*2]), /* vertice A */
atoi(argv
[(i
-1)*2-1]),atoi(argv
[(i
-1)*2]), /* vertice B */
atoi(argv
[i
*2-1]),atoi(argv
[i
*2]))) /* vertice C */
{
fprintf(stderr
,"errore: sono stati immessi tre o più vertici allineati\n");
return;
}
}
}
/* assegna ai nodi della lista i valori delle coordinate */
for(i=1;i<=(argc-1)/2;i++)
{
t_vertice
=inserisci_vertice
(atoi(argv
[i
*2-1]),atoi(argv
[i
*2]),t_vertice
);
}
/* inserisco in coda un nodo alla lista RECINTI con il numero progressivo num_recinti++ */
inserisci_recinto(++num_recinti,t_vertice,(argc-1)/2);
}
void elimina_recinto(int a, int b)
{
recinto *r_tmp = t_recinto; /* puntatore alla testa della lista recinto */
/* scorre i nodi nella lista dei recinti */
while(r_tmp!=NULL)
{
/* verifica che a,b siano interni al recinto r_tmp */
if(nel_recinto(a,b,r_tmp))
{
printf("cancello recinto: %d\n",r_tmp
->val
);
/* cancella il nodo selezionato */
if(cancella_recinto(r_tmp))
num_recinti--; /* decrementa il numero di recinti totali */
}
r_tmp=r_tmp->next;
}
riordina_recinto();
}
void mostra_recinto(int r)
{
recinto *r_tmp = t_recinto;
animale *a_tmp = t_animale;
animale *buffer[num_animali+1];
int i=0;
int count = 0;
while(r_tmp!=NULL) /* scorre la lista recinto */
{
if(r==r_tmp->val) /* recinto trovato */
{ /* scorre la lista degli animali */
while(a_tmp!=NULL)
{
if(nel_recinto(a_tmp->x,a_tmp->y,r_tmp))
{ /* salva l'output in una struttura temporanea */
buffer[i]=a_tmp;
i++;
count++;
}
a_tmp=a_tmp->next;
}
buffer[i]=NULL; /* sentinella */
for(i=0;buffer[i]!=NULL;i++)
{
printf("%d,\t%d,\t%s\n",buffer
[i
]->x
, buffer
[i
]->y
,buffer
[i
]->specie
->stringa
);
}
return;
}
r_tmp=r_tmp->next;
}
/* se siamo qui non è stato trovato nessun recinto con valore r */
fprintf(stderr
,"nessun recinto con valore %d\n",r
);
}
void mostra_campo()
{
animale *a_tmp = t_animale;
while(a_tmp!=NULL)
{
printf("%d,\t%d,\t%s\n",a_tmp
->x
,a_tmp
->y
,a_tmp
->specie
->stringa
);
a_tmp=a_tmp->next;
}
}
void seleziona()
{
recinto *r_tmp = t_recinto;
animale *a_tmp;
bitmap bit[num_animali+1];
int i;
/* scorre la lista dei recinti */
while(r_tmp!=NULL)
{
/* svuota buffer */
bit[0].a=NULL;
i=0;
/* scorre la lista degli animali */
a_tmp = t_animale;
while(a_tmp!=NULL)
{ /* salva la lista degli animali presenti nel recinto in una struttura temporanea */
if(nel_recinto(a_tmp->x,a_tmp->y,r_tmp))
{
bit[i].a=a_tmp;
bit[i].del=0;
i++;
}
a_tmp=a_tmp->next;
}
bit[i].a=NULL; /* sentinella */
/* per ogni animale nel recinto */
for(i=0;bit[i].a!=NULL;i++)
{
if(!bit[i].del) /* se l'animale non è marcato */
visita_grafo(bit[i].a->specie,bit);
}
/* Cancella tutti gli animali marcati da eliminare */
for(i=0;bit[i].a!=NULL;i++)
{
if(bit[i].del==1)
elimina(bit[i].a->x,bit[i].a->y);
}
/* fine recinto */
r_tmp=r_tmp->next;
}
}
/*##############################################################*/
/* FUNZIONI DI GESTIONE DEL MAIN */
/*##############################################################*/
/* costruisce la riga di comando e separa il nome del comando e i suoi argomenti */
void parse_command(struct comando *command, char *linea)
{
char *token;
char *s;
s = linea;
/* cancella gli eventuali spazi bianchi all'inizio della stringa */
s++;
if(!*s)
{
command->nome=NULL;
return;
}
/* legge il primo token */
command->nome = token;
command->argv[0] = token;
/* legge i token successivi */
command->argc = 1;
while (token)
{
command->argv[(command->argc)++] = token;
}
/* la lista degli argomenti termina con sentinella */
command->argv[command->argc] = NULL;
}
/*##############################################################*/
/* FUNZIONE MAIN */
/*##############################################################*/
#define MAX_COMMAND 512
int main()
{
struct comando command;
char stringa[MAX_COMMAND+1];
int i;
printf("Massimo Zappino\t\t Matricola: 608655\t\t 20/04/2005\n");
printf("\t\tLaboratorio di Algoritmi e Strutture Dati\n\n");
printf("\t\t\t * FATTORIA *\n\n\n");
while(1)
{
/* ripulisce gli argomenti del comando */
for(i=0;i<MAX_ARGS;i++)
command.argv[i]=NULL;
/* prompt */
/* acquisisce la stringa da standard input */
if (fgets(stringa
, MAX_COMMAND
+1, stdin
)==NULL
)
stringa
[strlen(stringa
)-1] = '\0'; /* elimina il line-feed dalla stringa */
parse_command(&command,stringa); /* effettua il parsing dei comandi */
/* Gestione comandi */
if(command.nome!=NULL)
{
/* crea */
{
crea();
}
/* inserisci */
else if(!strcmp(command.
nome,"i"))
{
if(command.argc<4)
fprintf(stderr
, "Uso comando errato\n");
else
inserisci
(atoi(command.
argv[1]), atoi(command.
argv[2]), (char*)command.
argv[3],1);
}
/* inserisci_random */
else if(!strcmp(command.
nome,"ir"))
if(command.argc<7)
fprintf(stderr
, "Uso comando errato\n");
else
inserisci_random
(atoi(command.
argv[1]), atoi(command.
argv[2]),atoi(command.
argv[3]), atoi(command.
argv[4]),atoi(command.
argv[5]), (char*)command.
argv[6]);
/* elimina */
else if(!strcmp(command.
nome,"e"))
if(command.argc<3)
fprintf(stderr
, "Uso comando errato\n");
else
elimina
(atoi(command.
argv[1]), atoi(command.
argv[2]));
/* ordina */
else if(!strcmp(command.
nome,"o"))
if(command.argc<3)
fprintf(stderr
, "Uso comando errato\n");
else
ordina(command.argv[1], command.argv[2]);
/* recinta */
else if(!strcmp(command.
nome,"r"))
if((command.argc<7) | (command.argc>21))
fprintf(stderr
, "Uso comando errato\n");
else
recinta(command.argc,command.argv);
/* elimina_recinto */
else if(!strcmp(command.
nome,"er"))
if(command.argc<3)
fprintf(stderr
, "Uso comando errato\n");
else
elimina_recinto
(atoi(command.
argv[1]), atoi(command.
argv[2]));
/* mostra_recinto */
else if(!strcmp(command.
nome,"mr"))
if(command.argc<2)
fprintf(stderr
, "Uso comando errato\n");
else
mostra_recinto
(atoi(command.
argv[1]));
/* mostra_campo */
else if(!strcmp(command.
nome,"mc"))
mostra_campo();
/* seleziona */
else if(!strcmp(command.
nome,"s"))
seleziona();
/* fine */
else if(!strcmp(command.
nome,"f"))
{
return EXIT_SUCCESS;
}
/* mostra grafo relazioni */
else if(!strcmp(command.
nome,"mg"))
{
mostra_grafo();
}
/* comando errato */
else
fprintf(stderr
, "comando errato: %s\n",command.
nome);
}
}
}