private void ExecuteExpression()
{
string identificador = ListaIdentificadores[ListaIdentificadores.Count - 1];
LastIdentifier = identificador;
if (!TabelaSimbolos.ContainsKey(identificador))
{
throw new SemanticException(string.Format("{0} não declarado", identificador));
}
string tipoIdentificador = TabelaSimbolos[identificador];
string tipoExpressao = PilhaTipos.Pop();
if (tipoIdentificador != tipoExpressao)
{
throw new SemanticException("Tipo incompatível para atribuição");
}
if (tipoIdentificador == int64)
{
AddCode(convi8);
}
AddCode(stloc + " " + identificador);
}
private void ExecuteRead()
{
foreach (var identificador in ListaIdentificadores)
{
if (!TabelaSimbolos.ContainsKey(identificador))
{
throw new SemanticException(string.Format("{0} não declarado", identificador));
}
string tipoIdentificador = TabelaSimbolos[identificador];
string classe = string.Empty;
if (tipoIdentificador == int64)
{
classe = "Int64";
}
else if (tipoIdentificador == float64)
{
classe = "Double";
}
AddCode("call string [mscorlib]System.Console::ReadLine()");
AddCode(string.Format("call {0} [mscorlib]System.{1}::Parse(string)", tipoIdentificador, classe));
AddCode(stloc + " " + identificador);
}
}
public AnalisadorLexico(TabelaSimbolos tabelaSimbolos)
{
linha = 1;
tbSimbolos = tabelaSimbolos;
devolve = false;
EOF = false;
}
private void ExecuteIdentifierList()
{
foreach (var identificador in ListaIdentificadores)
{
if (TabelaSimbolos.ContainsKey(identificador))
{
throw new SemanticException(string.Format("{0} já declarado", identificador));
}
TabelaSimbolos[identificador] = TipoVariavel;
AddCode(string.Format(".locals({0} {1})", TipoVariavel, identificador));
}
ListaIdentificadores.Clear();
}
public Boolean Inserir(TabelaSimbolos tabelaSimb)
{
// Falta fazer a parte das verificacoes.
if (Busca(tabelaSimb.Nome, tabelaSimb.Nivel).Equals(false))
{
ListTabekaSimbolos.Add(tabelaSimb);
return(true);
}
else
{
//MessageBox.Show("Identificador Já declarado.");
return(false);
}
}
private void AdicionarSimbolo(string lexema, Token token, Posicao posicao)
{
int indiceSimbolo = -1;
Simbolo simbolo = new Simbolo(lexema, token);
for (int i = 0; i < TabelaSimbolos.Count && token.DeveEstarTabelaSimbolos; i++)
{
if (TabelaSimbolos[i].Lexema == simbolo.Lexema &&
TabelaSimbolos[i].Token.Nome == simbolo.Token.Nome)
{
indiceSimbolo = i;
break;
}
}
// Simbolo ja adicionado na tabela
if (indiceSimbolo > -1 && token.DeveEstarTabelaSimbolos)
{
simbolo = TabelaSimbolos[indiceSimbolo];
simbolo.Ocorrencias.Add(posicao);
}
else if (token.DeveEstarTabelaSimbolos)
{
simbolo.Endereco = ++controleAlocacaoMemoria;
simbolo.Ocorrencias.Add(posicao);
TabelaSimbolos.Add(simbolo);
}
if (simbolo.Endereco > -1)
{
FluxoTokens.Add(string.Format(FormatoItemFluxoTokenComPosicao, token.Nome, simbolo.Endereco));
}
else
{
FluxoTokens.Add(string.Format(FormatoItemFluxoTokenSemPosicao, lexema));
}
}
private void ExecuteFator(Token token)
{
string identificador = token.Lexeme;
LastIdentifier = identificador;
if (!TabelaSimbolos.ContainsKey(identificador))
{
throw new SemanticException(string.Format("{0} não declarado", identificador));
}
string tipoIdentificador = TabelaSimbolos[identificador];
PilhaTipos.Push(tipoIdentificador);
AddCode(ldloc + " " + identificador);
if (tipoIdentificador == int64)
{
AddCode(convr8);
}
}
private void ExecuteAssignment(Token token)
{
string lexeme = token.Lexeme;
if ((lexeme == "+=" || lexeme == "-=") && !string.IsNullOrWhiteSpace(LastIdentifier))
{
if (!TabelaSimbolos.ContainsKey(LastIdentifier))
{
throw new SemanticException(string.Format("{0} não declarado", LastIdentifier));
}
string tipoIdentificador = TabelaSimbolos[LastIdentifier];
AddCode(ldloc + " " + LastIdentifier);
if (tipoIdentificador == int64)
{
AddCode(convr8);
}
PendingAction = lexeme;
LastIdentifier = string.Empty;
}
}
public void TableSymbolReset()
{
TabelaSimbolos.Clear();
}
public List <string> analisar(List <TabelaSimbolos> tokens)
{
List <string> listaRetorno = new List <string>();
List <int> fita = mapearFitaSaidaAnaliseSintatica(tokens);
List <int> pilha = new List <int>();
int indiceLeituraFita = 0;
pilha.Add(tabelaLALR.estados[0]);
while (true)
{
int estadoTopoPilha = pilha.Last();
int tokenAtualFita = fita[indiceLeituraFita];
AcaoTabelaLALR acaoTabela = tabelaLALR.acoes[estadoTopoPilha, tokenAtualFita];
if (acaoTabela == null)
{
if (indiceLeituraFita == tokens.Count)
{
TabelaSimbolos token = tokens[indiceLeituraFita - 1];
listaRetorno.Add("Fim de arquivo inesperado. O token " + token.rotulo + ", na linha " + token.linha + " não um conclui uma expressão.");
}
else
{
TabelaSimbolos token = tokens[indiceLeituraFita];
listaRetorno.Add("Token " + token.rotulo + " inesperado na linha " + token.linha + ".");
}
break;
}
else if (acaoTabela.acao == Enumeradores.Acao.Aceitar)
{
break;
}
else if (acaoTabela.acao == Enumeradores.Acao.Shift)
{
pilha.Add(acaoTabela.valor);
indiceLeituraFita += 1;
}
else if (acaoTabela.acao == Enumeradores.Acao.Reduce)
{
Producao producaoReducao = producoes[acaoTabela.valor];
if (producaoReducao != null)
{
int tamanhoProducao = producaoReducao.simbolosProducao.Count();
pilha.RemoveRange(pilha.Count() - tamanhoProducao, tamanhoProducao);
pilha.Add(tabelaLALR.acoes[pilha.Last(), producaoReducao.indiceNaoTerminal].valor);
}
else
{
listaRetorno.Add("Produção de redução não encontrada.");
break;
}
}
if (indiceLeituraFita == fita.Count())
{
listaRetorno.Add("Fim da fita de análise... O código não foi reconhecido.");
break;
}
}
return(listaRetorno);
}
static void Main(string[] args)
{
Level level = Level.EXEC;
Log.level = Level.EXEC;
if (!LerArquivo(args))
{
Log.println("Erro de leitura do arquivo fonte!", Level.EXEC);
Console.ReadKey();
return; //sai do programa
}
//ANÁLISE LÉXICA
AnalisadorLexico analisadorLexico = new AnalisadorLexico(file);
analisadorLexico.Analisar();
if (analisadorLexico.TemErros())
{
Log.println("Análise Léxica terminada com erro:", Level.DEBUG);
analisadorLexico.MostraErros();
Console.ReadKey();
return;
}
else
{
Log.println("Análise Léxica terminada com sucesso!", Level.DEBUG);
if (level == Level.DEBUG)
{
analisadorLexico.MostraTokens();
}
}
//ANÁLISE SINTÁTICA COM GERAÇÃO DE ÁRVORE
AnalisadorSintaticoGeradorArvore analisadorSintatico = new AnalisadorSintaticoGeradorArvore(analisadorLexico.Tokens);
analisadorSintatico.Analisar();
if (analisadorSintatico.TemErros())
{
Log.println("Análise Sintática terminada com erro:", Level.DEBUG);
analisadorSintatico.MostraErros();
Console.ReadKey();
return;
}
else
{
Log.println("Análise Sintática terminada com sucesso!", Level.DEBUG);
if (level == Level.DEBUG)
{
analisadorLexico.MostraTokens();
TabelaSimbolos.MostraSimbolos();
}
}
//analisadorSintatico.MostraArvore();
AnalisadorSemantico analisadorSemantico = new AnalisadorSemantico(analisadorSintatico.Raiz);
analisadorSemantico.Analisar();
if (analisadorSemantico.TemErros())
{
Log.println("Análise Semântica terminada com erro:", Level.DEBUG);
analisadorSemantico.MostraErros();
Console.ReadKey();
return;
}
else
{
Log.println("Análise Semântica terminada com sucesso!", Level.DEBUG);
if (level == Level.DEBUG)
{
TabelaSimbolos.MostraSimbolos();
}
}
try
{
DateTime inicio = DateTime.Now;
Interpretador interpretador = new Interpretador(analisadorSemantico.Raiz, args);
//interpretador.Memoization = true;
interpretador.Executar();
DateTime fim = DateTime.Now;
Log.println("\n\nExecução encerrada com sucesso! Tempo gasto: " + fim.Subtract(inicio).TotalMilliseconds + " ms", Level.EXEC);
}
catch (Exception ex)
{
Log.println("Erro na interpretação: " + ex.Message, Level.EXEC);
}
Console.ReadKey();
}
