um_atomo estado_branco (char **entrada)
{
um_atomo a = NULL;
// Excetuando o caso de brancos, as entradas so serao consumidas dentro
// de seus respectivos estados
if (ehBranco(**entrada))
consome_entrada(entrada, 1);
else if (ehLetra (**entrada) || **entrada == '_')
estado_lexico = IDENTIFICADOR;
else if (ehDigito (**entrada) || **entrada == '.')
estado_lexico = NUMERO;
else if (ehSimbolo (**entrada))
estado_lexico = SIMBOLO;
else if (**entrada == '%')
estado_lexico = COMENTARIO;
else if (**entrada == '\0')
a = novoAtomoInteiro (C_FIM, linha);
else
a = novoAtomoInteiro (C_INVALIDA, linha);
return a;
}
int main (void) {
int caractere,
ultimaFoiMaiuscula = 0;
while (caractere = getc(stdin), caractere != EOF) {
if (ehLetra(caractere)) {
if (ultimaFoiMaiuscula) {
putc(lowercase(caractere), stdout);
}
else {
putc(uppercase(caractere), stdout);
}
ultimaFoiMaiuscula = !ultimaFoiMaiuscula;
}
else {
putc(caractere, stdout);
}
if (caractere == '\n') {
ultimaFoiMaiuscula = 0;
}
}
return 0;
}
um_atomo estado_identificador (char **entrada)
{
um_atomo a = NULL;
static char * nome;
static int tamanho=0, max=0;
// Verifica se acabou de entrar nesse estado
if (tamanho == 0)
nome = malloc (sizeof (char));
if (ehDigito (**entrada) || ehLetra (**entrada) || **entrada == '_')
{
// Realoca mais 10 bytes ao nome, caso este estoure
if (++tamanho > max)
{
max += 10;
nome = realloc (nome, (max+1) * sizeof (char));
}
nome [tamanho-1] = **entrada;
consome_entrada (entrada, 1);
}
else // Transição vazia
{
uma_classe c;
estado_lexico = BRANCO;
nome [tamanho] = '\0';
tamanho = 0;
// Procura nome na tabela de palavras reservadas
c = busca_palavra_reservada (nome);
if (c != C_INVALIDA)
{
free (nome);
a = novoAtomoInteiro (c, 0);
}
else // Não é palavra reservada
{
int cod;
cod = busca_cod_ID (nome);
if (cod == ERRO)
cod = adicionaID (nome);
a = novoAtomoInteiro (C_IDENTIFICADOR, cod);
}
}
return a;
}
int verificaSimboloLido(char c){
if(ehLetra(c)){ //Simbolo lido eh letra
return 1;
}
if(ehNumero(c)){ //Simbolo lido eh numero
return 2;
}
if(ehSimbolo(c)){ //Simbolo lido eh Caracter Especial
return 3;
}
if(c=='/'){ //Simbolo lido eh '/'
return 4;
}
if(c=='"'){
return 5;
}
if(c==','){
return 6;
}
return 0;
}
int ehSimbolo(char c){
if(!ehLetra(c) && !ehNumero(c) && c!=32 && c!='\n' && c!='/' && c!='"' && c!=',' && c!=' '){
return 1;
}
return 0;
}
/**
* Construtor principal, atraves de uma palavra cria uma lista de tokens
**/
Lexico::Lexico(string palavra) {
string s;
s.clear();
//estado inicial
int estado = VAZIO;
bool tokenizer = false;
string erro;
for (int i=0; i < palavra.length(); ++i) {
switch(estado) {
case VAZIO:
if (ehLetra(palavra[i])) {
//estado inicial eh uma letra, passa pro estado letra
s += palavra[i];
estado = LETRA;
tokenizer = false;
} else if (ehBooleano(palavra[i])) {
//estado inicial eh um booleano, true ou false
if (palavra[i] == '0')
estado = FALSE;
if (palavra[i] == '1')
estado = TRUE;
tokenizer = true;
} else if (ehOperador(palavra[i])) {
//estado inicial eh um operador
tokenizer = true;
if (palavra[i] == '^') // estado AND
estado = AND;
if (palavra[i] == 'V') // estado OR
estado = OR;
if (palavra[i] == '\'') // estado NOT
estado = NOT;
if (palavra[i] == '-') {
// estado SE
estado = OPERADORSE;
tokenizer = false;
}
if (palavra[i] == '<') {
// estado intermediario SESOMENTESE
estado = OPERADOR;
tokenizer = false;
}
if (palavra[i] == ':') {
// estado ATRIBUICAO
estado = ATRIBUICAO;
tokenizer = false;
}
} else if (palavra[i] == '\"'){
//estado inicial eh aspas, passa para o estado booleano
estado = BOOLEANO;
tokenizer = false;
} else if (ehSeparador(palavra[i])) {
//estado = SEPARADOR;
//break;
} else if (ehBloco(palavra[i])) {
//estado inicial eh um bloco, passa para o estado de acordo com o caracter
if (palavra[i] == '}')
estado = RCHAVES;
else if (palavra[i] == '{')
estado = LCHAVES;
else if (palavra[i] == '(')
estado = LPARENTS;
else if (palavra[i] == ')')
estado = RPARENTS;
tokenizer = true;
} else if (palavra[i] == ';') {
//estado eh um ponto e virgula
estado = PONTOVIRGULA;
tokenizer = true;
} else if (palavra[i] == ',') {
//estado eh uma virgula
estado = VIRGULA;
tokenizer = true;
} else {
//estado inicial nao identificado
estado = ERRO;
erro = "ID ";
erro += palavra[i];
tokenizer = true;
}
break;
case LETRA:
if (ehLetra(palavra[i])) {
//continua como letra, concatena e segue o baile
s += palavra[i];
} else if (ehNumero(palavra[i])) {
s += palavra[i];
estado = IDENTIFICADOR;
} else {
//qualquer coisa diferente de letra muda o estado
tokenizer = true;
}
break;
case BOOLEANO:
if (ehLetra(palavra[i])) {
//acrescenta na string
s += palavra[i];
break;
} else if (palavra[i] == '\"') {
//final das aspas verifica se a palavra eh reconhecida ou nao na linguagem
if (s == "verdadeiro" || s == "true" || s == "v" ) {
estado = TRUE;
//palavra booleana reconhecida
} else if (s == "falso" || s == "false" || s == "f" ) {
estado = FALSE;
//palavra booleana reconhecida
} else {
estado = ERRO;
erro = "BOOLEANO_ASPAS";
}
} else {
estado = ERRO;
erro = "BOOLEANO ";
erro += palavra[i];
}
tokenizer = true;
break;
case OPERADOR: // <
if (palavra[i] == '-')
estado = OPERADORSSS;
else {
estado = ERRO;
erro = "OPERADOR";
tokenizer = true;
}
break;
case OPERADORSE:
if(!palavra[i] == '>') {
estado = ERRO;
erro = "OPERADORSE";
}
tokenizer = true;
break;
case OPERADORSSS:
if(!palavra[i] == '>') {
estado = ERRO;
erro = "OPERADORSSS";
}
tokenizer = true;
break;
case ATRIBUICAO:
if (!palavra[i] == '=') {
estado == ERRO;
erro = "ATRIBUICAO";
}
tokenizer = true;
break;
default:
estado = OUTRO;
tokenizer = true;
break;
}
if (tokenizer) {
//cria um token novo a ser inserido na lista
Token * novoToken = new Token();
if (estado == LETRA) {
estado = (ehReservado(s) ? PalavraReservada(s) : IDENTIFICADOR );
if (estado == IDENTIFICADOR)
novoToken->setId(s);
i--;
} else if (estado == ERRO) {
novoToken->setId(erro);
}
novoToken->setEstado(estado);
novoToken->setPosicao(i);
//insere na lista
listaTokens.push_back(novoToken);
//retorna a iteracao 1 passo, para o estado inicial vazio
//reseta o estado
s.clear();
estado = VAZIO;
tokenizer = false;
}
}
}
