public override void CheckSemantic(Scope scope, List<Error> errors)
{
if (BuiltInFunctions.Functions.Contains(NameFunction))//marcar la funcion builtin para añadirla al ensamblado
BuiltInFunctions.UsedFunctions.Add(NameFunction);
foreach (ExpressionNode realParam in Arguments)
realParam.CheckSemantic(scope, errors);
DeclarationNode funDeclaration = scope.GetFunVar(NameFunction);
if (funDeclaration == null || !(funDeclaration is FunctionDecNode))
{
errors.Add(new Error(GetChild(0), "La función '{0}' no está definida en el ámbito actual", NameFunction));
HasError = true;
ReturnType = UndefinedType.UndefinedInstance;
}
else
{
FunDeclaration = (FunctionDecNode)funDeclaration;
if (FunDeclaration.Arguments.Count == Arguments.Count)
{
for (int i = 0; i < Arguments.Count; i++)
if (!FunDeclaration.Arguments[i].RelatedType.MatchWith(Arguments[i].ReturnType))
{
errors.Add(new Error(Arguments[i], "En el llamado a '{0}' el tipo del parámetro real no. {1} no coincide con el tipo del parámetro formal '{2}'", FunDeclaration.Name, (i + 1), FunDeclaration.Arguments[i].VariableName));
HasError = true;
}
}
else
{
errors.Add(new Error(GetChild(0),"En el llamado a '{0}' la cantidad de parámetros reales no coincide con la de parámetros formales",FunDeclaration.Name));
HasError = true;
}
ReturnType = funDeclaration.RelatedType;
}
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
DeclarationNode funDeclaration = scope.GetFunVar(VariableName, false);
//El tipo del parametro se determino en el chequeo de semantica de la secuencia de declaraciones de funciones
if (funDeclaration != null)
{
errors.Add(new Error(this, "Se han definido dos o más parámetros con el nombre '{0}' dentro de la función", VariableName));
HasError = true;
}
else
scope.AddFunVar(VariableName, this);
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
DeclarationNode varDeclaration = scope.GetFunVar(Name);
if (varDeclaration == null || !(varDeclaration is VariableDecNode))
{
errors.Add(new Error(GetChild(0),"La variable '{0}' no está definida",Name));
HasError = true;
ReturnType = UndefinedType.UndefinedInstance;
}
else
{
ReturnType = varDeclaration.RelatedType;
VarDeclaration = (VariableDecNode)varDeclaration;
}
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
InitialExp.CheckSemantic(scope, errors);
//se pone por defecto con error y de tipo indefinido para factorizar
HasError = true;
RelatedType = UndefinedType.UndefinedInstance;
if (TypeName != null) //se conoce el tipo de la variable
{
TigerType formalType = scope.GetType(TypeName);
if (formalType == null) //el tipo formal no esta definido
errors.Add(new Error(GetChild(2),"El tipo '{0}' no ha sido definido en el ámbito actual", TypeName));
else
if (!InitialExp.ReturnType.MatchWith(formalType)) //el tipo real no coincide con el formal
{
errors.Add(new Error(InitialExp, "En una declaración el tipo de variable debe coincidir con el tipo de la expresión de inicialización y se encontró el tipo '{0}' y una expresión de tipo '{1}'", formalType, InitialExp.ReturnType));
RelatedType = formalType; // En C# si se declara 'string a = 5' se asume que 'a' es de tipo 'string' aunque no machee
}
else //si entra aqui es que no hay error
{
HasError = false;
RelatedType = formalType;
}
}
else //se debe inferir el tipo de la variable
{
if (InitialExp.ReturnType == NillType.NillInstance)
errors.Add(new Error(InitialExp,"No es posible inferir el tipo de la variable '{0}' debido a que la expresión de inicialización es de tipo 'nil'",VariableName));
else if (InitialExp.ReturnType.MatchWith(VoidType.VoidInstance))
errors.Add(new Error(InitialExp,"No es posible inferir el tipo de la variable debido a que la expresión de inicialización es de tipo 'void'"));
else //si entra aqui es que no hay error
{
HasError = false;
RelatedType = InitialExp.ReturnType;
}
}
DeclarationNode varDeclaretions = scope.GetFunVar(VariableName, false);
if (varDeclaretions != null)
{
if (varDeclaretions is VariableDecNode)
errors.Add(new Error(GetChild(0),"No es posible definir una variable con el nombre '{0}' debido a que existe otra variable con igual nombre dentro del mismo 'let'",VariableName));
else
errors.Add(new Error(GetChild(0),"No es posible definir una variable con el nombre '{0}' debido a que existe una función con igual nombre dentro del mismo 'let'", VariableName));
HasError = true;
}
else
scope.AddFunVar(VariableName, this);
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
foreach (FunctionDecNode funcDec in Declarations)
{
#region determinar el tipo de retorno
if (funcDec.ReturnTypeName == null) // es un procedure
funcDec.RelatedType = VoidType.VoidInstance;
else // es una function
{
TigerType funType = scope.GetType(funcDec.ReturnTypeName);
if (funType == null)
{
errors.Add(
new Error(funcDec.GetChild(0),
"El tipo '{0}' no está definido en el ámbito actual", funcDec.ReturnTypeName));
HasError = true;
funcDec.RelatedType = UndefinedType.UndefinedInstance;
}
else
funcDec.RelatedType = funType;
}
#endregion
#region determinar el tipo de cada parametro
foreach (FunctionVariableDecNode paramDecl in funcDec.Arguments)
{
TigerType paramType = scope.GetType(paramDecl.TypeName);
if (paramType == null)
{
paramDecl.RelatedType = UndefinedType.UndefinedInstance;
HasError = true;
errors.Add(new Error(paramDecl.GetChild(0),"El tipo '{0}' no está definido en el ámbito actual", paramDecl.TypeName));
}
else
paramDecl.RelatedType = paramType;
}
#endregion
#region añadir la funcion al scope si no esta repetida
DeclarationNode funDeclarations = scope.GetFunVar(funcDec.Name, false);
if (funDeclarations != null)
{
if (funDeclarations is FunctionDecNode)
errors.Add(new Error(funcDec.GetChild(0),"No es posible definir una función con el nombre '{0}' debido a que existe otra función con igual nombre dentro de un mismo 'let'", funcDec.Name));
else
errors.Add(new Error(funcDec.GetChild(0), "No es posible definir una función con el nombre '{0}' debido a que existe una variable con igual nombre dentro de un mismo 'let'", funcDec.Name));
HasError = true;
}
else if (BuiltInFunctions.Functions.Contains(funcDec.Name))
{
errors.Add(new Error(funcDec.GetChild(0),"La función '{0}' está definida en la Biblioteca Estándar de Tiger y no puede ser redefinida", funcDec.Name));
HasError = true;
}
else
scope.AddFunVar(funcDec.Name, funcDec);
#endregion
}
foreach (FunctionDecNode funcDecl in Declarations)
funcDecl.CheckSemantic(scope, errors);
}
