public bool Visit(AST_ClassDef node)
{
bool solve = true;
if (!All_Types.ContainsKey(node.Id.Id))
{
return(false);
}
CurrType = All_Types[node.Id.Id];
CurrContext = CurrContext.CreateChild();
SemanticType father = All_Types[node.Id.Id].Father;
while (true)
{
var my_atributes = father.GetAllAttr();
foreach (var attr in my_atributes)
{
//if (attr.Type.Name == "int")
// attr.Type.Name = "Int";
//if (attr.Type.Name == "string")
// attr.Type.Name = "String";
//if (attr.Type.Name == "bool")
// attr.Type.Name = "Bool";
if (!All_Types.ContainsKey(attr.Type.Name))
{
CurrErrorLoger.LogError(node.row, node.col, "El tipo de la declaracion del atributo no existe");
if (!CurrContext.NullFather())
{
CurrContext = CurrContext.GetParent();
}
return(false);
}
CurrContext.SetType(attr.Id, attr.Type);
}
father = father.Father;
if (father == null)
{
break;
}
}
bool visit_result = node.Property_list.Visit(this) &&
node.Method_list.Visit(this);
if (!CurrContext.NullFather())
{
CurrContext = CurrContext.GetParent();
}
CurrType = null;
return(visit_result);
}
public bool Visit(AST_ClassDef node)
{
bool solve = true;
solve &= node.Property_list.Visit(this);
solve &= node.Method_list.Visit(this);
return(solve);
}
public string Visit(AST_ClassDef node)
{
SemanticType t = semantictypes[node.Id.Id];
List <CIL_ClassAttr> lattr = new List <CIL_ClassAttr>();
foreach (var item in t.GetAllAttr())
{
lattr.Add(new CIL_ClassAttr(item.Id));
}
List <CIL_ClassMethod> lmeth = new List <CIL_ClassMethod>();
foreach (var item in t.Father.GetAllMethods())
{
if (t._find_method(item.Name) == -1)
{
lmeth.Add(new CIL_ClassMethod(item.Name, item.Label()));
}
}
foreach (var item in t.Methods)
{
lmeth.Add(new CIL_ClassMethod(item.Name, item.Label()));
}
methodcontext.actual_type = semantictypes[node.Id.Id];
methodcontext.propertys_class = node.Property_list;
foreach (var item in node.Method_list.Methods)
{
methodcontext.Reset(methodcontext.actual_type.GetMethod(item.Id.Id).Label());
methodcontext.Staments.Add(new CIL_ExceptionCond("self", "0", "error_null"));
// poniendo los valores por defecto en el constructor
if (item.Id.Id == "init" || (methodcontext.actual_type.Name == "Main" && item.Id.Id == "main"))
{
foreach (var prop in methodcontext.propertys_class.Propertys)
{
if (prop.exp != null)
{
var s = prop.exp.Visit(this);
if (data.ContainsValue(s))
{
// Load STR
var exp2 = methodcontext.GenLocal("exp", true);
methodcontext.Staments.Add(new CIL_LoadStr(s, exp2));
s = exp2;
}
methodcontext.Staments.Add(new CIL_SetAttr("self", prop.decl.id.Id, s, methodcontext.actual_type.Name));
}
}
}
Visit(item);
}
listtypes.Add(new CIL_ClassDef(node.Id.Id, new CIL_ListNode <CIL_ClassAttr>(lattr), new CIL_ListNode <CIL_ClassMethod>(lmeth)));
return("");
}
public override AST_Node VisitClasslist([NotNull] CoolParser.ClasslistContext context)
{
List <AST_ClassDef> li = new List <AST_ClassDef>();
foreach (var item in context.classdefine())
{
AST_ClassDef i = (AST_ClassDef)Visit(item);
li.Add(i);
}
return(new AST_Root(context, new AST_Node[] { new AST_ListClass(context, li) }));
}
public bool Visit(AST_ClassDef node)
{
bool solve = true;
CurrContext = CurrContext.CreateChild();
SemanticType father = All_Types[node.Id.Id].Father;
while (true)
{
var my_atributes = father.GetAllAttr();
foreach (var attr in my_atributes)
{
if (CurrContext.IsDefine(attr.Id))
{
solve = false;
CurrErrorLoger.LogError(node.row, node.col, "Propiedad " + attr.Id + " previamente definida");
}
CurrContext.Define(attr.Id);
}
father = father.Father;
if (father == null)
{
break;
}
}
foreach (var prop in node.Property_list.Propertys)
{
if (CurrContext.IsDefine(prop.decl.id.Id))
{
solve = false;
CurrErrorLoger.LogError(prop.decl.row, prop.decl.col, "Propiedad " + node.Id + " previamente definida");
}
else
{
CurrContext.Define(prop.decl.id.Id);
}
}
solve = node.Method_list.Visit(this);
if (!CurrContext.NullFather())
{
CurrContext = CurrContext.GetParent();
}
return(solve);
}
public bool Visit(AST_ClassDef node)
{
if (node.Id.Id == "Main")
{
if (!All_Types["Main"].HasMethod("main"))
{
CurrErrorLoger.LogError(node.row, node.col, "Tiene que tener un metodo main");
return(false);
}
}
bool solve = true;
solve &= node.Property_list.Visit(this);
solve &= node.Method_list.Visit(this);
SemanticType curr = All_Types[node.Id.Id];
var my_methods = curr.Methods;
while (curr.Father != null)
{
var curr_father = curr.Father;
if (curr_father.Name == "Bool" || curr_father.Name == "String" || curr_father.Name == "Int")
{
CurrErrorLoger.LogError(node.row, node.col, "No se puede heredar de los tipos built_int");
return(false);
}
var father_method = curr_father.Methods;
foreach (var mine in my_methods)
{
foreach (var him in father_method)
{
if (mine.Name == him.Name && mine.Name != "init")
{
if (mine.AttrParams.Count != him.AttrParams.Count)
{
CurrErrorLoger.LogError(node.row, node.col, "Para sobresicribir metodos deben tener la misma signatura");
solve = false;
}
else
{
var x = All_Types[node.Id.Id].GetMethod(mine.Name);
var y = curr_father.GetMethod(him.Name);
if (x.Name != y.Name || x.ReturnType.Name != y.ReturnType.Name)
{
solve = false;
CurrErrorLoger.LogError(node.row, node.col, "Tiene que ser el mismo tipo de retorno para la redefinicion de metodos");
}
else
{
for (int i = 0; i < mine.AttrParams.Count; i++)
{
if (mine.AttrParams[i].Type.Name != him.AttrParams[i].Type.Name)
{
solve = false;
CurrErrorLoger.LogError(node.row, node.col, "Tienen que ser del mismo tipo los parametros para la redefinicion de metodos");
}
}
}
}
}
}
}
curr = curr.Father;
}
return(solve);
}
public Base_Object_Value Visit(AST_ClassDef node)
{
throw new NotImplementedException();
}
