/* 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);
}
}