public object VisitMethodDeclAST([NotNull] MethodDeclASTContext context)
{
string type = "void";
if (context.type() != null)
{
type = (string)Visit(context.type());
}
IdentASTContext ident = (IdentASTContext)Visit(context.ident());
if (ident != null)
{
if (!ExistIdent(ident.IDENT().Symbol.Text, true))
{
MethodIdentifier identifier = new MethodIdentifier(ident.IDENT().Symbol.Text, ident.IDENT().Symbol, identificationTable.getLevel(), type,
context, (FormParsASTContext)context.formPars());
identificationTable.Insert(identifier);
identificationTable.OpenLevel(); // Para los parámetros ya existe un scope nuevo
if (context.formPars() != null)
{
Visit(context.formPars()); //Cuando se visitan los parámetros y se encuentra un error, ellos lo reportan
}
if (context.varDecl() != null)
{
context.varDecl().ToList().ForEach(varDecl => Visit(varDecl));
}
if (context.block() != null)
{
List <Pair <string, IToken> > returnedTypes = Visit(context.block()) as List <Pair <string, IToken> >;
returnedTypes.ForEach(returned => {
if (returned.a != null && (!returned.a.Equals(type) && (type == "void" || returned.a != "none")))
{
InsertError(returned.b, $"El tipo de retorno del método {identifier.Id} es {type}, pero se retorna {(returned.a == "none" ? "null" : returned.a)}");
}
});
}
identificationTable.CloseLevel();
}
else
{
InsertError(ident.IDENT().Symbol, "El identificador " + ident.IDENT().Symbol.Text + " ya fue declarado en este scope");
}
}
return(null);
}
public void AddDefaultMethods()
{
// CHR
Identifier chrIdenfifier = new MethodIdentifier("chr", "char", new List <string> {
"int"
});
identificationTable.Insert(chrIdenfifier);
// ORD
Identifier ordIdenfifier = new MethodIdentifier("ord", "int", new List <string> {
"char"
});
identificationTable.Insert(ordIdenfifier);
// LEN
Identifier lenIdenfifier = new MethodIdentifier("len", "int", new List <string> {
"array"
});
identificationTable.Insert(lenIdenfifier);
}
public object VisitActParsAST([NotNull] ActParsASTContext context)
{
var callFactor = context.Parent is IdentOrCallFactorASTContext ? (IdentOrCallFactorASTContext)context.Parent : null;
var callStatement = context.Parent is CallStatementASTContext ? (CallStatementASTContext)context.Parent : null;
MethodIdentifier methodIdentifier = null;
if (callFactor != null)
{
methodIdentifier = (MethodIdentifier)Visit(callFactor.designator());
}
else if (callStatement != null)
{
methodIdentifier = (MethodIdentifier)Visit(callStatement.designator());
}
if (methodIdentifier == null)
{
return(null);
}
FormParsASTContext originalPars = methodIdentifier.FormPars;
if (originalPars == null)
{
if (methodIdentifier.DefaultMethod)
{
if (methodIdentifier.DefaulMethodParams == null)
{
InsertError(context.Start,
"El método '" + methodIdentifier.Id + "' no recibe parámetros, y se recibieron " + context.expr().Length);
}
else if (context.expr().Length != methodIdentifier.DefaulMethodParams.Count)
{
InsertError(context.Start,
"El método '" + methodIdentifier.Id + "' recibe " + methodIdentifier.DefaulMethodParams.Count + " parámetros, y se recibieron " + context.expr().Length);
}
else
{
for (int i = 0; i < methodIdentifier.DefaulMethodParams.Count; i++)
{
string exprType = (string)Visit(context.expr()[i]);
if (exprType == null)
{
return(null);
}
else if (exprType != "none" && ((methodIdentifier.DefaulMethodParams[i] == "array" && !exprType.Contains("[]")) && exprType != methodIdentifier.DefaulMethodParams[i]))
{
InsertError(context.expr()[i].Start,
$"El tipo de la expresión '{ context.expr()[i].GetText()}' es '" + exprType + "', y se esperaba el tipo '" + methodIdentifier.DefaulMethodParams[i] + "'");
}
}
}
}
else
{
InsertError(context.Start, "El método '" + methodIdentifier.Id + "' no recibe parámetros, y se recibieron " + context.expr().Length);
}
}
else if (context.expr().Length != originalPars.ident().Length)
{
InsertError(context.Start, "El método '" + methodIdentifier.Id + "' recibe " + originalPars.ident().Length + " parámetros, y se recibieron " + context.expr().Length);
}
else
{
for (int i = 0; i < originalPars.ident().Length; i++)
{
string exprType = (string)Visit(context.expr()[i]);
if (exprType == null)
{
return(null);
}
else if (exprType != "none" && exprType != originalPars.type()[i].GetText())
{
InsertError(context.expr()[i].Start,
$"El tipo de la expresión '{ context.expr()[i].GetText()}' es '" + exprType + "', y se esperaba el tipo '" + originalPars.type()[i].GetText() + "'");
}
}
}
return(null);
}