/* Retorna o polinômio de nome x. */ Polinomio RecuperaPolinomio(char x) { if (!Operando(&x)) { IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO); } else if (vetorPoli[x - 'A'] == NULL) { IMPRIME_ERRO(MSG_ERRO_POLINOMIO_NAO_INICIALIZADO); } return vetorPoli[x - 'A']; }
/* Desempilha um elemento, enviando uma mensagem de erro caso a pilha esteja * vazia. */ ElemPilha* VerificaDesempilha(Pilha* pilha) { if (PilhaVazia(pilha)) { IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO); } return (ElemPilha*) Desempilha(pilha); }
/* Armazena o polinômio 'p' sob o nome 'x' na base. */ void ArmazenaPolinomio(char x, Polinomio p) { if (!Operando(&x)) { IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO); } vetorPoli[x - 'A'] = p; }
Polinomio RecuperaPolinomio(char x) { /* Retorna o polinômio de nome x. */ Polinomio poli; x = toupper(x); if (x >= 'A' && x < 'A' + TAM_BASE) poli = vetorPoli[x - 'A']; else { IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO); return NULL; } if (poli == NULL) IMPRIME_ERRO(MSG_ERRO_POLINOMIO_NAO_INICIALIZADO); return poli; }
void ArmazenaPolinomio(char x, Polinomio p) { /* Armazena o polinômio p sob o nome x na base. */ x = toupper(x); if (x >= 'A' && x < 'A' + TAM_BASE) vetorPoli[x - 'A'] = p; else IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO); }
ElemPilha* VerificaDesempilha(Pilha* pilha) { /* Desempilha um elemento, enviando uma mensagem de erro caso a pilha */ /* esteja vazia. */ if (PilhaVazia(pilha)) { IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO); return NULL; } return (ElemPilha*) Desempilha(pilha); }
/* Retorna o polinômio referente à expressão dada; este polinômio devolvido é * sempre uma nova cópia, mesmo que a expressão seja uma variável simples. */ Polinomio CalcExpr(char* expr) { Pilha polPilha; ElemPilha *r; Polinomio p; int i; CriaPilha(&polPilha); i = 0; while (expr[i] != '\0') { if (Operando(expr + i)) { EmpilhaOperando(&polPilha, RecuperaPolinomio(expr[i]), false); } else if (Operador(expr + i)) { ExecutaOperacao(&polPilha, expr[i]); } else { IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO); } i++; } r = VerificaDesempilha(&polPilha); if (!PilhaVazia(&polPilha)) { IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR); } if (r->temp) { p = r->poli; } else { p = CopiaPolinomio(r->poli); } FREE(r); return p; }
Polinomio CalcExpr(char* expr) /* Retorna o polinômio referente à expressão dada */ { char aux; Pilha duracell; Polinomio res; ElemPilha *op1, *op2, *final; /* Inicializa Pilha da expressão */ CriaPilha(&duracell); while(*expr != '\0') { if (Operando(*expr)) { /* Empilha polinômio. */ aux = toupper(*expr); EmpilhaOperando(&duracell, vetorPoli[(aux - 'A')], false); } else switch(*expr) { case '+': case '-': case '*': /* Operadores Binários */ /* Desempilha os operandos. */ op2 = VerificaDesempilha(&duracell); op1 = VerificaDesempilha(&duracell); if (op1 == NULL || op2 == NULL) IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO); /* Empilha o resultado da Operação. */ if (*expr == '+') EmpilhaOperando(&duracell, SomaPolinomios(op1->poli, op2->poli), true); if (*expr == '-') EmpilhaOperando(&duracell, SubPolinomios(op1->poli, op2->poli), true); if (*expr == '*') EmpilhaOperando(&duracell, MultPolinomios(op1->poli, op2->poli), true); /* Libera a memoria dinâmica necessária. */ if (op1->temp) LiberaPolinomio(op1->poli); if (op2->temp) LiberaPolinomio(op2->poli); FREE(op1); FREE(op2); break; case '~': /* Operador unário */ /* Desempilha o operando. */ op1 = VerificaDesempilha(&duracell); /* Empilha o resultado da Operação. */ EmpilhaOperando(&duracell, MultTermo(op1->poli, 0, -1.0), true); /* Libera a memoria dinâmica necessária. */ if (op1->temp) LiberaPolinomio(op1->poli); FREE(op1); break; default: /* Erro: nenhum operador válido. */ IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO); } /* Avança para o próximo caractere da expressão. */ expr += 1; } final = VerificaDesempilha(&duracell);
void* Desempilha (Pilha* p) { /* Desempilha um elemento da pilha. */ if (PilhaVazia(p)) IMPRIME_ERRO(MSG_ERRO_PILHA_VAZIA); return p->vetor[p->topo--]; }
void Empilha (Pilha* p, void *elem) { /* Empilha um elemento na pilha. */ if (PilhaCheia(p)) IMPRIME_ERRO(MSG_ERRO_PILHA_CHEIA); p->vetor[++p->topo] = elem; }
Polinomio CalcExpr(char* expr) { /* Retorna o polinômio referente à expressão dada. */ /* O polinômio devolvido é sempre uma nova cópia, mesmo que a */ /* expressão seja uma variável simples. */ Pilha operacao; ElemPilha *aux1, *aux2; Polinomio temp; CriaPilha(&operacao); printf("Comeca a CalcExpr\n"); /*Faz a leitura da expressão dada, termo por termo, até chegar no final da linha*/ while(*expr != '\0'){ /*Caso a entrada seja um operador*/ if(!Operando(*expr)){ printf("Operando\n"); /*Caso o operador seja binário*/ if(*expr == '+' || *expr == '-' || *expr == '*'){ /*Como é um operador, deve-se utilizar os dois elementos do topo da pilha*/ aux1 = VerificaDesempilha(&operacao); aux2 = VerificaDesempilha(&operacao); /*Caso tente desempilhar mas a pilha ja esta vazia, entao falta operandos*/ if(aux1 == NULL || aux2 == NULL){ IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO); } /*Faz a operacao entre os dois elementos desempilhados*/ if(*expr == '+'){ printf("Soma\n"); temp = SomaPolinomios(aux2->poli, aux1->poli); } else if(*expr == '-'){ printf("Sub\n"); temp = SubPolinomios(aux2->poli, aux1->poli); } else if(*expr == '*'){ printf("Multi\n"); temp = MultPolinomios(aux2->poli, aux1->poli); } /*Empilha o elemento resultante das operacoes*/ EmpilhaOperando(&operacao, temp, true); /*Libera os elementos da pilha utilizados*/ if(aux1->temp == true){ LiberaPolinomio(aux1->poli); } if(aux2->temp == true){ LiberaPolinomio(aux2->poli); } FREE(aux1); FREE(aux2); } /*Caso o operador seja unário*/ else if(*expr == '~'){ /*Como é um operador unario, só é nescessario usar o elemento do topo da pilha*/ aux1 = VerificaDesempilha(&operacao); temp = MultTermo(aux1->poli, 0, -1.0); EmpilhaOperando(&operacao, temp, true); /*Desaloca a memoria nescessaria*/ if(aux1->temp == true){ LiberaPolinomio(aux1->poli); } FREE(aux1); } /*Se não entrou em nenhum dos outros casos, a entada é invalida*/ else{ IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO); } } /*Se a entrada não for um operador, é um polinomio*/ else{ printf("Operador\n"); /*Empilha o elemento apontado na pilha operacao*/ EmpilhaOperando(&operacao, vetorPoli[*expr - 'A'], false); } /*Avança a leitura*/ expr++; } /*Depois de terminar de ler as operacoes retira o ultimo elemento e verifica se a pilha está vazia, se sim, é por que completou as operacoes corretamente, entao retorna esse polinomio */ aux1 = VerificaDesempilha(&operacao); if(PilhaVazia(&operacao)){ temp = aux1->poli; /*Cria um novo polinomio para poder ser retornado caso o elemento retornado seja uma das 5 bases*/ if(aux1->temp == false){ temp = MultTermo(aux1->poli, 0, 1.0); } /*Desaloca o ultima elemento da pilha*/ FREE(aux1); return temp; }else{ /*Se a pilha ainda conter algum elemento*/ IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR); } }