/// <summary>
/// <Retorno> ::= 'reditus' <Expr_Ret>
/// </summary>
private object Retorno(Node no)
{
List <Token> operans = (List <Token>)Analisar(no.GetFilho(1));
String tipoRetorno = EscopoAtual;
if (tipoRetorno.Equals("vacum"))
{
if (operans.Count > 0)
{
erros.Add("Função tipo 'vacum' não pode ter retorno de valor!");
}
}
else
{
foreach (Token operan in operans)
{
String tipoOperan = TabelaSimbolos.getTipo(operan);
if (tipoOperan == null)
{
erros.Add("ID (lado dir.)" + operan.Imagem + " não declarado. Linha: " + operan.Linha + ", Coluna: " + operan.Coluna);
}
else
{
if (!tipoRetorno.Equals(tipoOperan))
{
erros.Add("Tipo do operando de retorno " + operan.Imagem + " não compatível. Linha: " + operan.Linha + ", Coluna: " + operan.Coluna);
}
}
}
}
return(null);
}
/// <summary>
/// <Atrib> ::= '=' Identifier <Expr_Atrib>
/// </summary>
private object Atrib(Node no)
{
Token id = no.GetFilho(1).Token;
List <Token> operans = (List <Token>)Analisar(no.GetFilho(2));
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId == null)
{
erros.Add("ID (lado esq.) " + id.Imagem + " não declarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
else
{
foreach (Token operan in operans)
{
String tipoOperan = TabelaSimbolos.getTipo(operan);
if (tipoOperan == null)
{
erros.Add("ID (lado dir.)" + operan.Imagem + " não declarado. Linha: " + operan.Linha + ", Coluna: " + operan.Coluna);
}
else
{
if (!tipoId.Equals(tipoOperan))
{
erros.Add("Tipo do Operando (lado dir.) " + operan.Imagem + " não compatível. Linha: " + operan.Linha + ", Coluna: " + operan.Coluna);
}
}
}
}
return(null);
}
/// <summary>
/// <Chamada> ::= Identifier <List_Arg>
/// </summary>
private object Chamada(Node no)
{
Token idDef = no.GetFilho(0).Token;
String tipoDef = TabelaSimbolos.getTipoDef(idDef.Imagem);
if (tipoDef == null)
{
erros.Add("Função/def (lado dir.) " + idDef.Imagem + " não declarada. Linha: " + idDef.Linha + ", Coluna: " + idDef.Coluna);
}
else
{
TabelaSimbolos.setTipo(idDef, tipoDef);
List <Token> args = (List <Token>)Analisar(no.GetFilho(1));
args.Reverse();
List <Token> paramsDef = TabelaSimbolos.getParams(idDef);
if (args.Count != paramsDef.Count)
{
erros.Add("Números de parâmetros incorretos na chamada da função " + idDef + ". Linha: " + idDef.Linha + ", Coluna: " + idDef.Coluna);
}
else
{
for (int i = 0; i < args.Count; i++)
{
String tipoArg = TabelaSimbolos.getTipo(args[i]);
String tipoParam = TabelaSimbolos.getTipo(paramsDef[i]);
if (!tipoArg.Equals(tipoParam))
{
erros.Add("Tipo do argumento passado '" + args[i].Imagem + "' incorreto. Deveria ser do tipo " + tipoParam + ". Linha: " + paramsDef[i].Linha + ", Coluna: " + paramsDef[i].Coluna);
}
}
}
}
return(no.GetFilho(0).Token);
}
public void Executar()
{
TabelaSimbolos.GerarValoresPadrao();
PreencheDefs(Raiz);
if (defs.Count > 0)
{
Dictionary <Token, object> frame = new Dictionary <Token, object>();
List <Token> parametros = TabelaSimbolos.getParams(main.GetFilho(2).Token);
foreach (Token tok in parametros)
{
frame.Add(tok, TabelaSimbolos.getValorPadrao(tok)); //os valores dos parêmetros do lançador vem do ambiente
}
stack.Push(frame);
try
{
EscopoAtual = TabelaSimbolos.getTipo(main.GetFilho(2).Token);
Executar(main);
}
catch (RetornoException rex)
{
Log.println("Terminou no RetornoException: " + rex.Valor, Level.DEBUG);
}
finally
{
stack.Pop();
}
}
}
private void LeToken()
{
if (token != null && token.Classe == ClasseToken.Identificador)
{
TabelaSimbolos.addSimbolo(token, escopo);
}
token = tokens[pToken++];
}
/// <summary>
/// <Saida> ::= 'noto' <Operan>
/// </summary>
private object Saida(Node no)
{
Token id = (Token)Analisar(no.GetFilho(1));
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId == null)
{
erros.Add("Operando " + id.Imagem + " não declarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
return(null);
}
/// <summary>
/// <Entrada> ::= 'lego' Identifier
/// </summary>
private object Entrada(Node no)
{
Token id = no.GetFilho(1).Token;
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId == null)
{
erros.Add("ID " + id.Imagem + " não declarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
return(null);
}
/// <summary>
/// <Chamada> ::= Identifier <List_Arg>
/// </summary>
private object Chamada(Node no)
{
object retorno = null;
string EscopoAtualBak = EscopoAtual;
Dictionary <Token, object> frame = new Dictionary <Token, object>();
List <Token> parametros = TabelaSimbolos.getParams(no.GetFilho(0).Token);
List <object> argumentos = (List <object>)Executar(no.GetFilho(1));
argumentos.Reverse();
//verificação para Memoization
CallDef callDef = new CallDef();
callDef.NomeDef = no.GetFilho(0).Token.Imagem;
callDef.ParValues = argumentos;
if (memoTab.ContainsKey(callDef))
{
return(memoTab[callDef]);
//if (valor != null)
//{
// return valor; //valor encontrado na tabela da Memoization
//}
}
//termina verificação para Memoization
for (int i = 0; i < parametros.Count; i++)
{
frame.Add(parametros[i], argumentos[i]);
}
stack.Push(frame);
try
{
EscopoAtual = TabelaSimbolos.getTipo(no.GetFilho(0).Token);
Executar(defs[no.GetFilho(0).Token.Imagem]);
}
catch (RetornoException rex)
{
Log.println("Terminou no RetornoException: " + rex.Valor, Level.DEBUG);
retorno = rex.Valor;
//para Memoization
memoTab[callDef] = retorno;
//fim para Memoization
}
finally
{
stack.Pop();
EscopoAtual = EscopoAtualBak;
}
return(retorno);
}
/// <summary>
/// <List_Arg> ::= <Operan> <List_Arg> |
/// <List_Arg> ::= <Expr_Atrib> <List_Arg> | //mudança malopes 10/11/2011
/// </summary>
private object List_Arg(Node no)
{
if (no.Filhos.Count == 2)
{
List <Token> paramsExpr = (List <Token>)Analisar(no.GetFilho(0)); ////mudança malopes 10/11/2011
Token arg1 = null;
String tipoArg1 = null;
if (paramsExpr.Count > 1)
{
arg1 = paramsExpr[0];
tipoArg1 = TabelaSimbolos.getTipo(arg1);
if (tipoArg1 == null)
{
erros.Add("Argumento " + arg1.Imagem + " não declarado! Linha: " + arg1.Linha + ", Coluna: " + arg1.Coluna);
}
else
{
for (int i = 1; i < paramsExpr.Count; i++)
{
String tipoArgAtual = TabelaSimbolos.getTipo(paramsExpr[i]);
if (tipoArgAtual == null)
{
erros.Add("Argumento " + paramsExpr[i].Imagem + " não declarado! Linha: " + paramsExpr[i].Linha + ", Coluna: " + paramsExpr[i].Coluna);
}
else
{
if (!tipoArg1.Equals(tipoArgAtual))
{
erros.Add("Argumentos com tipos incompatíveis! Linha: " + paramsExpr[i].Linha + ", Coluna: " + paramsExpr[i].Coluna);
}
}
}
}
}
List <Token> parametros = (List <Token>)Analisar(no.GetFilho(1));
if (paramsExpr.Count == 1)
{
parametros.Add(paramsExpr[0]);
}
else if (paramsExpr.Count > 1 && tipoArg1 != null)
{
parametros.Add(geraTokenLiteralTipoCerto(tipoArg1));
}
//parametros.AddRange(paramsExpr); //mudança malopes 10/11/2011
return(parametros);
}
return(new List <Token>());
}
/// <summary>
/// <Def> ::= '(' <Tipo> Identifier '[' <List_Param> ']' <List_Coman> ')'
/// </summary>
private object Def(Node no)
{
List <Token> varsLocal = TabelaSimbolos.getVarsLocal(no.GetFilho(2).Token);
Dictionary <Token, object> frame = stack.Peek();
foreach (Token tok in varsLocal)
{
if (!frame.ContainsKey(tok))
{
frame.Add(tok, TabelaSimbolos.getValorPadrao(tok));
}
}
Executar(no.GetFilho(6));
return(null);
}
/// <summary>
/// <Param> ::= '(' <Tipo> Identifier ')'
/// </summary>
private object Param(Node no)
{
String tipo = (String)Analisar(no.GetFilho(1));
Token id = no.GetFilho(2).Token;
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId != null)
{
erros.Add("ID " + id.Imagem + " redeclarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
else
{
TabelaSimbolos.setTipo(id, tipo);
}
return(id);
}
/// <summary>
/// <Expr_Rel> ::= '(' <Op_Rel> <Operan> <Operan> ')'
/// </summary>
private object Expr_Rel(Node no)
{
Token operan1 = (Token)Analisar(no.GetFilho(2));
Token operan2 = (Token)Analisar(no.GetFilho(3));
String tipoOperan1 = TabelaSimbolos.getTipo(operan1);
String tipoOperan2 = TabelaSimbolos.getTipo(operan2);
if (tipoOperan1 == null || tipoOperan2 == null)
{
erros.Add("Operando não declarado! " + operan1.Imagem + " e/ou " + operan2.Imagem + ". Linha: " + operan1.Linha + ", Coluna: " + operan1.Coluna);
}
else
{
if (!tipoOperan1.Equals(tipoOperan2))
{
erros.Add("Tipos incompatíveis! Linha: " + operan1.Linha + ", Coluna: " + operan1.Coluna);
}
}
return(null);
}
/// <summary>
/// <Decl> ::= <Tipo> <List_Id>
/// </summary>
private object Decl(Node no)
{
String tipo = (String)Analisar(no.GetFilho(0));
List <Token> ids = (List <Token>)Analisar(no.GetFilho(1));
ids.Reverse();
foreach (Token id in ids)
{
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId != null)
{
erros.Add("ID " + id.Imagem + " redeclarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
else
{
TabelaSimbolos.setTipo(id, tipo);
}
}
return(null);
}
/// <summary>
/// <Def> ::= '(' <Tipo> Identifier '[' <List_Param> ']' <List_Coman> ')'
/// </summary>
private object Def(Node no)
{
String tipo = (String)Analisar(no.GetFilho(1));
Token id = no.GetFilho(2).Token;
EscopoAtual = tipo; //para avaliar o tipo do retorno!
String tipoId = TabelaSimbolos.getTipo(id);
if (tipoId != null)
{
erros.Add("ID de função '" + id.Imagem + "' redeclarado. Linha: " + id.Linha + ", Coluna: " + id.Coluna);
}
else
{
TabelaSimbolos.setTipo(id, tipo);
}
List <Token> parametros = (List <Token>)Analisar(no.GetFilho(4));
parametros.Reverse();
TabelaSimbolos.setParams(id, parametros);
Analisar(no.GetFilho(6));
return(null);
}
/// <summary>
/// <Entrada> ::= 'lego' Identifier
/// </summary>
private object Entrada(Node no)
{
Token id = no.GetFilho(1).Token;
String tipo = TabelaSimbolos.getTipo(id);
String entrada = Console.ReadLine(); //TODO: melhorar isso aqui!
if ("totum".Equals(tipo))
{
setValor(id, Convert.ToInt64(entrada));
}
else if ("verus".Equals(tipo))
{
setValor(id, Convert.ToDouble(entrada));
}
else if ("chorda".Equals(tipo))
{
setValor(id, entrada);
}
else if ("mus".Equals(tipo))
{
setValor(id, Convert.ToBoolean(entrada));
}
return(null);
}
