/// <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); }