Erro Primario() {
/* Processa um fator primário da cadeia de entrada. */
Erro err = resCorreto;
char letra;
/* Remover os espaços do início */
while (isspace(in[indIn]))
indIn++;
/* Se for parêntese, iniciar expressão aninhada */
if (in[indIn] == '(') {
indIn++;
err = Expressao();
if (err.codigoErro != EXPR_VALIDA)
return err;
if (in[indIn] == ')')
indIn++;
else
return montaErro(FECHA_PARENTESE_ESPERADO, indIn);
} else {
letra = in[indIn];
/* Verificar se é um operando válido */
if (isalpha(letra))
pos[indPos++] = letra;
else
return montaErro(CARACTERE_INVALIDO, indIn);
indIn++;
}
return resCorreto;
} /* Primario */
/*Verifica se o caractere de entrada é valido, se nao for modifica 'geral'*/
void VerificaCaractere(){
char car = in[indIn];
if ((car >= 'a' && car <= 'z') || car == '+' || car == '-' || car == '*' || car == '/' ||
car == '^' || car == '(' || car == ')' || car == '\0') {
return;
}else{
geral = montaErro(CARACTERE_INVALIDO, indIn);
}
}/*Verifica Caractere*/
Erro InPos(char *infixa, char *posfixa) {
/* Transforma uma expressão da notação infixa para a pós-fixa. Em caso
de erro, devolve o código e a posição na cadeia de entrada onde o
erro foi encontrado. */
Erro err = resCorreto;
char c;
in = infixa;
indIn = 0;
pos = posfixa;
indPos = 0;
/* Remover os espaços do início */
while (isspace(in[indIn]))
indIn++;
/* Se não há nada na entrada, marcar erro */
if (in[indIn] == '\0')
err = montaErro(CADEIA_DE_BRANCOS, 0);
/* Senão, computar a expressão */
else
err = Expressao();
/* Se a entrada não acabou, marcar erro */
if (in[indIn] != '\0' && err.codigoErro == EXPR_VALIDA)
err = montaErro(OPERADOR_ESPERADO, indIn);
/* Verificar se o caracter que causou o erro é inválido */
if (err.codigoErro != EXPR_VALIDA) {
c = in[indIn];
if (!isalpha(c) && !isspace(c) &&
c != '+' && c != '-' && c != '*' && c != '/' &&
c != '(' && c != ')' && c != '^' && c != '\0')
err = montaErro(CARACTERE_INVALIDO, indIn);
}
posfixa[indPos] = '\0';
return err;
}
Erro InPos(char *infixa, char *posfixa) {
/* Transforma uma expressão da notação infixa para a pós-fixa. Em caso
de erro, devolve o código e a posição na cadeia de entrada onde o
erro foi encontrado.
*/
in = &infixa[0];
pos = &posfixa[0];
indPos = indIn = 0;
/* Zera a variavel global de erro */
geral.posicao = -1;
/* Caso a programa comece com um espaco, pula ate o caractere valido mais proximo */
while(in[indIn] == ' '){
indIn++;
}
/* Caso pule todos os espacos e termine, a entrada eh branca */
if (in[indIn] == '\0'){
return montaErro(CADEIA_DE_BRANCOS, 0);
}
Expressao();
/* Termina de montar a string da posfixa */
pos[indPos] = '\0';
/* Se terminou de ler o programa e ainda possui algum caractere na entrada */
if(in[indIn] != '\0'){
geral = montaErro(OPERADOR_ESPERADO, indIn);
}
/* Caso o programa tenha apresentado algum erro */
if (geral.posicao != -1) {
return geral;
}
return resCorreto;
}
/*A funcao primaria possui duas possibilidades :
p = x ou p = (e), ou seja, uma expressao entre
parenteses ou uma variável
*/
Erro Primario() {
/* Processa um fator primário da cadeia de entrada. */
char corrente = in[indIn];
switch(corrente){
/* Caso seja um parenteses, tera uma expressao dentro dele */
case '(':
avancaCaractere();
Expressao();
/* Verifica o fechamento do parenteses */
if(in[indIn] == ')'){
avancaCaractere();
}else{
geral = montaErro(FECHA_PARENTESE_ESPERADO, indIn);
}
break;
/* Caso seja um operador nao esperado */
case ')':
case '/':
case '*':
case '+':
case '-':
case '\0':
geral = montaErro(OPERANDO_ESPERADO, indIn);
break;
/* Caso seja uma variavel(a, b, c, ... ,z) */
default:
imprimeSaida(in[indIn]);
avancaCaractere();
break;
}
return resCorreto;
} /* Primario */
Erro Termo() {
/* Processa um termo da cadeia de entrada. */
Erro err = resCorreto;
char op;
/* Remover os espaços do início */
while (isspace(in[indIn]))
indIn++;
/* Fim da entrada */
if (in[indIn] == '\0' || in[indIn] == ')')
return montaErro(OPERANDO_ESPERADO, indIn);
err = Fator();
if (err.codigoErro != EXPR_VALIDA)
return err;
do {
/* Remover os espaços até o próximo caracter */
while (isspace(in[indIn]))
indIn++;
op = in[indIn];
if (op == '*' || op == '/') {
/* Consumir o operador */
indIn++;
err = Fator();
if (err.codigoErro != EXPR_VALIDA)
return err;
pos[indPos++] = op;
} else
break;
} while (true);
return resCorreto;
} /* Termo */
Erro Expressao() {
/* Processa uma expressão da cadeia de entrada. */
Erro err = resCorreto;
char op;
/* Remover os espaços do início */
while (isspace(in[indIn]))
indIn++;
/* Fim da entrada */
if (in[indIn] == '\0' && in[indIn] == ')')
return montaErro(OPERANDO_ESPERADO, indIn);
/* Tratar mais e menos unário aqui, pois eles só podem aparecer
* no primeiro elemento de uma expressão */
if (in[indIn] == '-') {
indIn++;
err = Termo();
if (err.codigoErro != EXPR_VALIDA) {
/* O erro parentético tem precedência */
if (err.codigoErro == FECHA_PARENTESE_ESPERADO)
return err;
return montaErro(OPERANDO_ESPERADO, indIn);
}
pos[indPos++] = '~';
} else if (in[indIn] == '+') {
indIn++;
err = Termo();
if (err.codigoErro != EXPR_VALIDA) {
/* O erro parentético tem precedência */
if (err.codigoErro == FECHA_PARENTESE_ESPERADO)
return err;
return montaErro(OPERANDO_ESPERADO, indIn);
}
pos[indPos++] = '&';
} else {
err = Termo();
if (err.codigoErro != EXPR_VALIDA) {
/* O erro parentético tem precedência */
if (err.codigoErro == FECHA_PARENTESE_ESPERADO)
return err;
return montaErro(OPERANDO_ESPERADO, indIn);
}
}
do {
/* Remover os espaços até o próximo caracter */
while (isspace(in[indIn]))
indIn++;
op = in[indIn];
if (op == '+' || op == '-') {
/* Consumir o operador */
indIn++;
err = Termo();
if (err.codigoErro != EXPR_VALIDA) {
/* O erro parentético tem precedência */
if (err.codigoErro == FECHA_PARENTESE_ESPERADO)
return err;
return montaErro(OPERANDO_ESPERADO, indIn);
}
pos[indPos++] = op;
} else
break;
} while (true);
return resCorreto;
} /* Expressao */
