#include <malloc.h>
#include <ctype.h>
#include "expressao.h"

/* Para todas as funcoes abaixo, lembre-se que um apontador para um 
   tipo, em C, eh um inteiro que indica a posicao de memoria de uma
   variavel daquele tipo. Dessa maneira, se *x eh um apontador para
   caractere, (*x)++ ira apontar para um endereco "um caractere" a 
   frente (se for um apontador para o elemento n de uma sequencia,
   ele entao apontara para o elemento n+1.
*/

/*LeEspaco:
  Deve ignorar espacos em branco a partir da posicao atual e deixa o apontador
  no proximo caractere nao-branco. Nas funcoes abaixo, lembre-se de 
  de vez em quando chamar esta funcao para garantir que o seu programa
  ignora espacos em branco.
*/
void LeEspaco(char **e){
  if ( e == NULL )
    comAviso(AVS1,"LeEspaco");
  else
    while ( (**e) == ' ' )
      (*e)++;
}

/*Primario
  Deve verificar se *e esta apontando para um primario. Um primario eh
  uma letra, ou uma expressao entre parenteses. O retorno eh true se 
  for um primario, ou false se nao for. O apontador passado por 
  parametro deve sair daqui apontando para o primeiro caractere apos o 
  primario.

  Exemplo: a, (E).
*/
bool Primario(char **e){
  if ( e != NULL) {
    LeEspaco(e);

    if ( ((**e) >= 'a') && ((**e) <= 'z') ) {
      (*e)++;
      return 1;
    } else if (**e == '(') {
      (*e)++;
      LeEspaco(e);
      if (Expressao(e)) {
	LeEspaco(e);
	if (**e == ')') {
	  (*e)++;
	  return 1;
	} else {
	  return 0;
	}
      } else
	return 0;
    } else
      return 0;
  } else {
    comAviso(AVS1,"Primario");
    return 0;
  }
  return 0;
}

/*Fator
  Deve verificar se *e esta apontando para um fator. Um fator eh
  um primario, ou um primario seguido do simbolo '^', seguido de 
  um fator. O retorno eh true se for um fator, ou false se nao for. 
  O apontador passado por parametro deve sair daqui apontando para 
  o primeiro caractere apos o fator.

  Exemplo: P, P^F.
*/
bool Fator(char **e){
  if (e != NULL) {
    LeEspaco(e);
    if (Primario(e)) {
      LeEspaco(e);

      if ( **e == '^') {
	(*e)++;
	return (Fator(e)); 
      }
      return 1;
    }
  } else {
    comAviso(AVS1,"Fator");
    return 0;
  }
  return 0;
} 

/*Termo
  Deve verificar se *e esta apontando para um termo. Um termo sao
  um ou mais fatores intercalados pelos simbolos '/' ou '*'.
  O retorno eh true se for um termo, ou false se nao for. 
  O apontador passado por parametro deve sair daqui apontando para 
  o primeiro caractere apos o termo.

  Exemplo: F, F*F, F/F, F*F/F*F/F, F/F/F/F*F.
*/
bool Termo(char **e){
  if (e != NULL) {
    LeEspaco(e);

    if (Fator(e)) {
      LeEspaco(e);
      while ( (**e == '/') || (**e == '*') ) {
	(*e)++;
        if (! Fator(e))
	  return 0;
      }
      if ( (**e == '(') || (( **e >= 'a')&&(**e <= 'z')) )
	return 0;

      return 1;
    } else 
      return 0;
  } else {
    comAviso(AVS1,"Termo");
    return 0;
  }
  return 0;

} 


/*Expressao
  Deve verificar se *e esta apontando para uma expressao. Uma 
  expressao sao um ou mais termos intercalados pelos simbolos '+' ou '-'.
  O retorno eh true se for uma expressao, ou false se nao for. 
  O apontador passado por parametro deve sair daqui apontando para 
  o primeiro caractere apos a expressao.

  Exemplo: T, T+T, T-T, T+T+T+T-T, T+T-T+T-T-T.
*/
bool Expressao(char **e){
  if (e != NULL) {
    LeEspaco(e);
    if (Termo(e)) {
      LeEspaco(e);
      while ( (**e == '+') || (**e == '-') ) {
	(*e)++;
	if (! Termo(e))
	  return 0;
      }
      if ( (**e == '(') || (( **e >= 'a')&&(**e <= 'z')) )
	return 0;

      return 1;
    } else
      return 0;
  } else {
    comAviso(AVS1,"Expressao");
    return 0;
  }
} 


/*TestaExpressao
  Recebe uma sequencia de caracteres (que pode ser vista como um 
  apontador para o primeiro caractere da sequencia), e deve 
  retornar verdadeiro se a expressao estiver escrita corretamente,
  ou falso se ela estiver escrita de maneira errada OU se 
  nao for passada nenhuma sequencia de caracteres.
*/

bool TestaExpressao(char *e) {
  if (e != NULL) {
    LeEspaco(&e);
    if ( *e == '\0')
      return 0; /* Sequencia Vazia */

    if (Expressao(&e)) {
      LeEspaco(&e);
      if (*e == '\0')
	return 1;
    }
    return 0;

  } else {
    comAviso(AVS1,"TestaExpressao");
    return 0;
  }
}




/* author: Gustavo Sverzut Barbieri (http://www.gustavobarbieri.com.br) */