/**
@param recebe uma string que é o nome do ficheiro
@return retorna 1 se o ficheiro for guardado com sucesso
*/
int cmd_gravar (char * args)
{
if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else if(proteina.tem_coordenadas==NAO) return mensagem_de_erro(E_NAO_COLOC);
else if(numero_de_argumentos(args)!=1) return mensagem_de_erro(E_ARGS);
else gravar(args);
return 1;
}
/**
@param recebe uma string que é o nome do ficheiro com o qual vamos invocar a função criar_latex
@return retorna 1 se tudo correr bem
*/
int cmd_latex (char * args)
{
if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else if(proteina.esta_colocada==NAO) return mensagem_de_erro(E_NAO_COLOC);
else if(numero_de_argumentos(args)!=1) return mensagem_de_erro(E_ARGS);
criar_latex(args);
return 1;
}
/**
@param não recebe nada, opera com uma string de A's e B's na sua forma mais extensa
@return salvo erros que possam surgir, imprime no ecrã a sequencia na forma mais compactada
*/
int cmd_compactar (char * args)
{
if(args!=NULL) return mensagem_de_erro(E_ARGS);
else if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else{
if(proteina.tamanho==1) return printf("%s\n", obtem_sequencia()); /*3 casos em que a seq é a mesma na forma compactada*/
else if(proteina.tamanho==2 && proteina.seq[0]!=proteina.seq[1]) return printf("%s\n", obtem_sequencia());
else if((proteina.tamanho==3 && proteina.seq[0]!=proteina.seq[1]) && (proteina.seq[1]!=proteina.seq[2])) return printf("%s\n", obtem_sequencia());
else compactar_sequencia();
}
return printf("%s\n", obtem_seq_compactada());
}
/**
@param recebe instrucoes de dobragem
@return quando utilizado com argumentos nao devolve nada, sem argumentos devolve as coordenadas alteradas
*/
int cmd_dobrar (char * args)
{
if(args!=NULL){
if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else{
if(instrucoes_dobragem_validas(args)==PASSOU) dobra_e_guarda_coordenadas(args);
}
}
else if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else return mensagem_de_erro(E_ARGS);
return 1;
}
/**
@param recebe instruçõe de dobragem inválidas (F, D, E)
@return repara as instruções de dobragem de modo a obtermos uma configuração válida próxima da introduzida
*/
int cmd_reparar (char * dobragens)
{
if(dobragens==NULL) return mensagem_de_erro(E_INVARGS);
else if(ja_existe_sequencia()!=1) return mensagem_de_erro(E_NAO_COLOC);
else{
if(c_validar(NULL)==SIM) return printf("%s\n", dobragens);/*dobragens validas devolve as mesmas*/
else if(instrucoes_dobragem_validas(dobragens)==1){
procura_erro_repara(dobragens);
cmd_dobrar(dobragens);
}
else return mensagem_de_erro(E_INVARGS);
}
return 1;
}
/**
@param nao recebe argumentos
@return retorna SIM caso a sequencia esteja bem colocada, retorna NAO caso contrário
*/
int cmd_validar (char * args)
{
if(args==NULL){
if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else if(proteina.tem_coordenadas==SIM && testa_coordenadas_sao_validas()==PASSOU && proteina.tamanho>1){
proteina.esta_colocada=SIM;
return printf("SIM\n");
}
else if(proteina.tem_dobra==SIM && testa_coordenadas_sao_validas()==PASSOU){
proteina.esta_colocada=SIM;
return printf("SIM\n");
}
else return printf("NAO\n");
}
else return mensagem_de_erro(E_ARGS);
}
/**
@param recebe uma string que são as instruções de dobragem
@return devolve uma mensagem de erro caso sejam inválidas, retorna 1 caso contrário
*/
int instrucoes_dobragem_validas(char * arg)
{
int i;
int s=strlen(arg);
int t=proteina.tamanho;
if(s<t){
for(i=0;arg[i]!='\0';i++){
if(arg[i]=='F'||arg[i]=='D'||arg[i]=='E');
else return mensagem_de_erro(E_INVARGS);
}
}
else return mensagem_de_erro(E_ARGS); /*caso o tamanho das instruções exceda a sequencia de A's e B's*/
return PASSOU;
}
/**
* A função executa_comando é uma das funções mais importantes pois é ela que vai reagir aos comandos dados pelo utilizador.
* A função irá receber a linha de comando separa la em dois, no comando e nos argumentos do comando, e passa los para as funções associadas aos comandos.
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @param linha Recebe uma string que corresponde á linha lida da shell.
* @returns torna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executa_comando(char *linha,int *DIM,Elem **Tab) {
char cmd[1025];
char args[1025];
int nargs=sscanf(linha, "%s %[^\n]", cmd, args);
if((strcmp(cmd, "b") == 0 || strcmp(cmd, "p") == 0 || strcmp(cmd, "i") == 0))
return executaJogada(args,cmd,DIM,Tab);
if(strcmp(cmd, "cr") == 0 )
return executaCriaJogo(args,DIM,Tab);
if(strcmp(cmd,"gr")==0 )
return executaGravaJogo(args,DIM,Tab);
if(strcmp(cmd,"?")==0 && nargs==1)
return ajuda();
if(strcmp(cmd,"trp")==0 && nargs==1)
return trp(Tab,DIM);
if(strcmp(cmd,"snd")==0 && nargs==1)
return snd(Tab,DIM);
if(strcmp(cmd,"pis")==0 && nargs==1)
return pis(Tab,DIM);
if(strcmp(cmd,"pds")==0 && nargs==1)
return pds(Tab,DIM);
if(strcmp(cmd,"vb")==0 && nargs==1)
return vb(Tab,DIM);
if(strcmp(cmd,"vp")==0 && nargs==1)
return vp(Tab,DIM);
if(strcmp(cmd,"vl")==0 && nargs==1)
return vl(Tab,DIM);
if(strcmp(cmd,"q")==0)
exit(0);
return mensagem_de_erro(E_COMMAND);
}
int guardar_bd(char *output, long long *id) {
//gravar_id;
FILE *fw=fopen(output,"w+");
User_h **lista=NULL;
char idstr[MAXUSERSTR];
int i=0;
if(!fw){
return mensagem_de_erro(E_CREATE_FILE);
}
converte_ll_str(*id,idstr);
guardar_str(idstr,MAXUSERSTR,fw);
while(i<MAXNODES){
lista=&hash_nome[i];
while (*lista) {
guarda_user(fw,(*lista)->user);
lista=&((*lista)->next);
}
i++;
}
fclose(fw);
return 1;
}
int ler_user_ficheiro(FILE *fp, Perfil **ptr, int count) {
char idstr[MAXUSERSTR], apgdstr[MAXAPAGADO], nifstr[MAXNIF], endstr[END];
Perfil *p = malloc(sizeof(Perfil));
ler_parametro_f(fp,count,MAXUSERSTR,idstr);
count+=MAXUSERSTR;
ler_parametro_f(fp,count,MAXNIF,nifstr);
count+=MAXNIF;
ler_parametro_f(fp,count,MAXNOME,p->nome);
count+=MAXNOME;
ler_parametro_f(fp,count,MAXCIDADE,p->cidade);
count+=MAXCIDADE;
ler_parametro_f(fp,count,MAXESTADOCIV,p->estado_civil);
count+=MAXESTADOCIV;
ler_parametro_f(fp,count,MAXEMAIL,p->email);
count+=MAXEMAIL;
ler_parametro_f(fp,count,MAXAPAGADO,apgdstr);
count+=MAXAPAGADO;
ler_parametro_f(fp,count,END,endstr);
count+=END;
if (strcmp(endstr,".")!=0) {
free(p);
return mensagem_de_erro(E_OPEN_FILE);
}
p->id=ler_numero_ll(idstr);
if (p->id==-1) {
free(p);
return mensagem_de_erro(E_OPEN_FILE);
}
p->nif=ler_numero_ll(nifstr);
if (p->nif==-1) {
free(p);
return mensagem_de_erro(E_OPEN_FILE);
}
p->apagado=ler_numero_int(apgdstr);
if (p->apagado==-1) {
free(p);
return mensagem_de_erro(E_OPEN_FILE);
}
(*ptr)=p;
return count;
}
/**
@param o comando coords quando utilizado com argumentos guarda as coordenadas na forma de interiros caso sejam válidas
@return quando utilizado sem argumentos imprime no ecrã as coordenadas na forma (x, y)
*/
int cmd_coords (char * args)
{
if (args!=(NULL)) {
if ((ja_existe_sequencia())!=1)
return mensagem_de_erro(E_NO_SEQ);
else{
if (conta_coordenadas(args)!=(2*proteina.tamanho))
return mensagem_de_erro (E_ARGS);
else if (verifica_coordenadas(args)==PASSOU) guarda_coordenadas(args);
else mensagem_de_erro(E_COORDS);
}
}
else if ((ja_existe_sequencia())==NAO_EXISTE)
return mensagem_de_erro (E_NAO_COLOC);
else if (proteina.tem_coordenadas==SIM)
imprime_coordenadas();
return 1;
}
/**
@param recebe uma sequencia de A's e B's na forma extensa ou compactada se esta esta compactada guarda-a na forma mais extensa
@return quando utilizado sem argumentos imprime a sequencia na forma mais extensa
*/
int cmd_seq(char *args)
{
if (args!=(NULL)){
if(numero_de_argumentos(args)!=1)
return mensagem_de_erro(E_ARGS);
else{
if(nao_tem_so_A_B(args)==NAO_PASSOU) return mensagem_de_erro(E_SEQ_INV);
else if(testa_compactada_valida(args)==PASSOU) descompactar_e_guardar(args);
else return mensagem_de_erro(E_SEQ_INV);
return 1;
}
}
else{
if(ja_existe_sequencia()==EXISTE)
return printf("%s\n", obtem_sequencia());
else return mensagem_de_erro(E_NO_SEQ);
}
}
/**A função executaGravaJogo recebe os argumentos da linha de comando e vai verificar se tem os argumetos certos, se tal for verdade, executa gravaJogo com o nome do argumento no formato ".ltr".
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @param args Recebe uma string com os argumentos associados ao comando em questão("gr").
* @returns torna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executaGravaJogo(char *args,int *DIM,Elem **Tab) {
char buf[1024];
char nome[256];
int nargs = sscanf(args, "%s %[^\n]", nome, buf);
if(nargs != 1) {
return mensagem_de_erro(E_ARGS);
}
if(Tab){
strcat(nome,".ltr");
gravaJogo(nome,DIM,Tab);
}
else return mensagem_de_erro(E_NO_BOARD);
return 0;
}
int inserir_info_user(long long id, long long nif, Info **inf) {
(*inf) = malloc(sizeof(struct info));
if ((*inf)==NULL) {
return mensagem_de_erro(E_MEM);
}
(*inf)->nif=nif;
(*inf)->adjacentes=NULL;
return 1;
}
int ler_id(FILE *fp, int count, long long *id) {
char idstr[MAXUSERSTR];
ler_parametro_f(fp,count,MAXUSERSTR,idstr);
count+=MAXUSERSTR;
*id=ler_numero_ll(idstr);
if (*id==-1) {
return mensagem_de_erro(E_OPEN_FILE);
}
return count;
}
/**A função executajogada recebe os argumentos da linha de comandos e a cor que vai passar para a jogada.
* Vai verificar se tem os argumetos certos, e se tal vou verdade, chama a função jogada, para que esta se possa realizar.
* @param args Recebe ums string com os argumentos do comando do utilizador.
* @param cor Corresponde ao próprio comado que irá ser utilizado como a cor que se pretende mudar.
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @returns Retorna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executaJogada(char *args,char *cor,int *DIM,Elem **Tab) {
char buf[1024];
int x, y;
char teste1[1024],teste2[1024];
int nargs = sscanf(args, "%s %s %[^\n]", teste1,teste2, buf);
if(!isdigit(teste1[0]) || !isdigit(teste2[0])) {
return mensagem_de_erro(E_INVARGS);
}
nargs = sscanf(args, "%d %d %[^\n]", &x, &y, buf);
if(nargs != 2) {
return mensagem_de_erro(E_ARGS);
}
jogada(*cor,x,y,DIM,Tab);
return 0;
}
int remover_relacao(long long nif1, long long nif2, Grafo *g) {
Perfil *p1=findByNif(nif1);
Perfil *p2=findByNif(nif2);
Info *inf1, *inf2;
if (p1==NULL || p2==NULL) {
return mensagem_de_erro(E_NO_NIF);
}
inf1=g->nodos[p1->id];
inf2=g->nodos[p2->id];
if (inf1==NULL || inf2==NULL) {
return mensagem_de_erro(E_NO_NIF);
}
if (remove_nodos(&(inf1->adjacentes),nif2)) {
remove_nodos(&(inf2->adjacentes),nif1);
}
else return 0;
return 1;
}
/*
* O comando ajuda
*/
BOARD *cmd_help(char *args, BOARD *brd) {
int i;
if (strlen(args)==0) {
args = NULL;
for(i = 0; command[i].name != NULL; i++)
printf("%s: %s\n", command[i].name, command[i].doc);
}
else
mensagem_de_erro(E_INVARGS) ;
return brd;
}
/**
@param pode receber três valores que posteriormente são atribuídos às variáveis energéticas (e1, e2, e3), ou não receber nada, eventualmente consideramos os valores pré-defenidos para as variáveis energéticas
@return retorna o valor da energia da proteína considerada ou pode circunstancialmente retornar uma mensagem de erro
*/
int cmd_energia (char * args)
{
if(args==NULL){
if(ja_existe_sequencia()==NAO_EXISTE) return mensagem_de_erro(E_NO_SEQ);
else if(proteina.esta_colocada==SIM){
if(proteina.tem_dobra==NAO) return printf("0\n");
else calcula_imprime_energia(args);
}
else return mensagem_de_erro(E_NAO_COLOC);
}
else if(args!=NULL){
if(ja_existe_sequencia()==0) return mensagem_de_erro(E_NO_SEQ);
else if(proteina.esta_colocada==SIM){
if(proteina.tem_dobra==NAO) return printf("0\n");
else if(numero_de_argumentos(args)!=3) return mensagem_de_erro(E_ARGS);
else if(testa_argumentos(args)==NAO_PASSOU) return mensagem_de_erro(E_INVARGS);
else calcula_imprime_energia(args);
}
}
return 1;
}
/**A função executaCriaJog recebe os argumentos da linha de comando, vai verificar se tem os argumentos, certos se tal ocorre, executa criarJogo com o nome do argumento no formato ".ltr".
* @param args Recebe uma string com os argumentos associados ao comando em questão ("cr").
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @returns torna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executaCriaJogo(char *args,int *DIM,Elem **Tab) {
char buf[1024];
char nome[256];
int nargs = sscanf(args, "%s %[^\n]", nome, buf);
if(nargs != 1) {
return mensagem_de_erro(E_INVARGS);
}
strcat(nome,".ltr");
criarTabuleiro(nome,DIM,Tab);
return 0;
}
int criar_relacao(long long nif1, long long nif2, int peso, Grafo *g){
Perfil *p1=findByNif(nif1);
Perfil *p2=findByNif(nif2);
if(p1==NULL || p2==NULL){
return mensagem_de_erro(E_NO_NIF );
}
if (g->nodos[p1->id]==NULL) {
if (inserir_info_user(p1->id,nif1,&(g->nodos[p1->id]))==0) return 0;
}
if (g->nodos[p2->id]==NULL) {
if (inserir_info_user(p2->id,nif2,&(g->nodos[p2->id]))==0) return 0;
}
if (inserir_relacao(p1->id,p2->id,nif2,peso,g)) {
if (inserir_relacao(p2->id,p1->id,nif1,peso,g)) {
return 1;
}
}
return 0;
}
/**
* A função main é um ciclo que apenas termina quando o utilizador insere o comando "q".
* Esta função vai então ser responsável iniciar o programa e receber os comandos que o utilizador lhe introduz.
* Vai imprimir os resultados do jogo enquanto este decorrer.
*/
int main() {
char *cmd = NULL;
FUNCTION *fun = NULL;
BOARD * brd = NULL;
srand(time(NULL));
brd = initialize_state();
while(rl_gets() != NULL) {
int i, j;
/* Ignorar os espacos no inicio do comando */
for(i = 0; line_read[i] && whitespace(line_read[i]); i++);
/* Saltar a primeira palavra da linha */
for(j = i; line_read[j] && !whitespace(line_read[j]); j++);
/* Delimitar o nome do comando */
if(line_read[j])
line_read[j++] = 0;
/* Saltar os espacos mais uma vez */
for(; line_read[j] && whitespace(line_read[j]); j++);
cmd = line_read + i;
fun = find_command(cmd);
if(fun != NULL) {
brd = fun(line_read + j, brd);
print_state(brd);
} else {
mensagem_de_erro(E_COMMAND);
}
}
return 0;
}
/**Função que executa o comando dado o valor retornado na função que identifica que comando foi introduzido pelo utilizador.
*@param jogo Referencia-se a onde se encontra guardado as dimensões do tabuleiro.
*@param arg1 Variável onde está guardada o primeiro argumento dado pelo utilizador aquando a introdução do comando.
*@param arg2 Variável onde está guardada o segundo argumento dado pelo utilizador aquando a introdução do comando.
*@param comando Refere-se à opção que vai ser executada pelo utilizador.
*@param argumentos Número de argumentos introduzidos pelo utilizador.
*@return 1 a 7. Execução de comandos bem sucedida.
*@return 0. Execução de comandos mal sucedida.
*/
int executa_comando(Tabuleiro jogo, int comando, int argumentos, char * arg1, char * arg2)
{
switch(comando)
{
case 2: /*Se for 2 usa o carrega*/
if(argumentos == 2) /*Recebe 2 args pois recebe o cr e o tabuleiro tipo ex1(Exemplificar: cr ex1)*/
{
carrega_tab(jogo, arg1); /*Um argumento pois só precisa do ex1, por exemplo*/
return 0;
}
else
{
return mensagem_de_erro(E_ARGS);
}
break;
case 3: /*Se for 3 usa o comando grava*/
if(argumentos == 2) /*Recebe o gr e o tabuleiro que o utilizador quer*/
{
grava_tab(jogo, arg1);
return 0;
}
else
{
return mensagem_de_erro(E_ARGS);
}
break;
case 4:
if(argumentos == 3)
{
if(testa_inteiro(arg1) && testa_inteiro(arg2))
{
joga(jogo, atoi(arg1), atoi(arg2));
jogo->n_comando++;
}
else
{
mensagem_de_erro(E_INVARGS);
}
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 5:
if(argumentos == 1)
{
estrategia1(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 6:
if(argumentos == 1)
{
estrategia2(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 7:
if(argumentos == 3)
{
if(testa_inteiro(arg1) && testa_inteiro(arg2))
{
marca(jogo, atoi(arg1), atoi(arg2)); /*atoi significa converter uma string em inteiros*/
jogo->n_comando++;
}
else
{
mensagem_de_erro(E_INVARGS);
}
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 8:
if(argumentos == 1)
{
estrategia3(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 9:
if(argumentos == 1)
{
anula(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 10:
if(argumentos == 1)
{
estrategia4(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 11:
if(argumentos == 1)
{
estrategia5(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
case 12:
if(argumentos == 1)
{
resolve(jogo);
jogo->n_comando++;
impressao_ecra(jogo);
}
else
{
mensagem_de_erro(E_ARGS);
}
break;
}
return 0;
}
int grava_mensagem(long long nif2,long long nif1,char *mensagem,Lista_destinatario *ld){
Perfil *user1=findByNif(nif1);
Perfil *user2=findByNif(nif2);
long long id1;
long long id2;
if(!user1 || !user2){
return mensagem_de_erro(E_NO_NIF);
}
if (nif1==nif2) {
return mensagem_de_erro(E_NO_NIF);
}
Mensagens *mensagem1=malloc(sizeof(Mensagens));
strcpy(mensagem1->mensagem,mensagem);
mensagem1->next=NULL;
id1=user2->id;
id2=user1->id;
if (!(ld->L_mensagens[id2])) {
Destinatario *dest = malloc(sizeof(Destinatario));
dest->total_mensagens = 0;
dest->remetentes = NULL;
ld->L_mensagens[id2]=dest;
}
(ld->L_mensagens[id2]->total_mensagens)++;
mais_popular (ld->L_mensagens[id2]->total_mensagens, user1->nif, ld);
Remetente *aux_remetente=ld->L_mensagens[id2]->remetentes;
Remetente *aux_ant=ld->L_mensagens[id2]->remetentes;
while ((ld->L_mensagens[id2]->remetentes)!=NULL) {
aux_ant=ld->L_mensagens[id2]->remetentes;
if ((ld->L_mensagens[id2]->remetentes->id) == id1) break;
ld->L_mensagens[id2]->remetentes = ld->L_mensagens[id2]->remetentes->next;
}
if (ld->L_mensagens[id2]->remetentes==NULL) {
Remetente *rem = malloc(sizeof(Remetente));
rem->id=id1;
rem->n_mensagens=1;
rem->nif = nif2;
rem->msg = mensagem1;
rem->next=NULL;
ld->L_mensagens[id2]->remetentes = aux_ant;
if ((ld->L_mensagens[id2]->remetentes)==NULL) ld->L_mensagens[id2]->remetentes = rem;
else {
ld->L_mensagens[id2]->remetentes->next = rem;
ld->L_mensagens[id2]->remetentes=aux_remetente;
}
return 1;
}
if ((ld->L_mensagens[id2]->remetentes->n_mensagens)>19) {
Mensagens *m_aux = ld->L_mensagens[id2]->remetentes->msg;
ld->L_mensagens[id2]->remetentes->msg = ld->L_mensagens[id2]->remetentes->msg->next;
free(m_aux);
(ld->L_mensagens[id2]->remetentes->n_mensagens)--;
}
Mensagens *auxiliar = ld->L_mensagens[id2]->remetentes->msg;
while (ld->L_mensagens[id2]->remetentes->msg->next!=NULL) {
ld->L_mensagens[id2]->remetentes->msg=ld->L_mensagens[id2]->remetentes->msg->next;
}
ld->L_mensagens[id2]->remetentes->msg->next = mensagem1;
(ld->L_mensagens[id2]->remetentes->n_mensagens)++;
ld->L_mensagens[id2]->remetentes->msg=auxiliar;
ld->L_mensagens[id2]->remetentes=aux_remetente;
return 1;
}
int main()
{
char command[10], params[20], comando[30];
LRect L = NULL;
LArea A = NULL;
LRestr R = NULL;
Stack S = NULL;
DIM D = NULL;
L = (LRect) malloc (sizeof (NodoR));
A = (LArea) malloc (sizeof (NodoA));
R = (LRestr) malloc (sizeof (NodoRestr));
S = (Stack) malloc (sizeof (NStack));
D = (DIM) malloc (sizeof (struct sDIM));
while (fgets(comando, 30, stdin) != NULL)
{
sscanf(comando, "%s %[^\n]", command, params);
if (strcmp(command,"DIM")==0)
cDIM(params,D);
else if (strcmp(command,"RECT")==0)
cRECT(params,L,D);
else if (strcmp(command,"COL")==0)
cCOL(params,L,A,D,R,&S);
else if (strcmp(command,"DIR")==0)
cDIR(params,L,R);
else if (strcmp(command,"ESQ")==0)
cESQ(params,L,R);
else if (strcmp(command,"CIM")==0)
cCIM(params,L,R);
else if (strcmp(command,"BX")==0)
cBX(params,L,R);
else if (strcmp(command,"COLR")==0)
cCOLR(params,L,A,D,R,&S);
else if (strcmp(command,"CLD")==0)
cCLD(params,L,R);
else if (strcmp(command,"SEP")==0)
cSEP(params,L,R);
else if (strcmp(command,"AREA")==0)
cAREA(params,A,D,&S);
else if (strcmp(command,"DENTRO")==0)
cDENTRO(params,L,R,A,D);
else if (strcmp(command,"FORA")==0)
cFORA(params,L,R,A,D);
else if (strcmp(command,"ESTADO")==0)
cESTADO(L);
else if (strcmp(command,"DESF")==0)
cDESF(&S,&A,&L);
else if (strcmp(command,"RSV")==0)
{
if(cRSV(L,L,R,R,A,D,&S,0))
printf ("SIM\n");
else
printf ("NAO\n");
mensagem_de_erro (13);
}
else mensagem_de_erro (1);
}
return 0;
}
