//private string v;
//private ObjClass Type;
//private Node s;
public AttributeNode(CoolParser.AttribFeatureContext context, Node s) : base(s.Childs)
{
CoolParser.ClassdefContext p = (CoolParser.ClassdefContext)context.Parent;
var classname = p.t.Text;
var type = "Object";
if (context.t.Text != null)// if I have a type
{
type = context.t.Text;
}
var name = context.id.Text;
this.SetType(SymbolTable.Classes[type]);
//Atribute c;
//if (SymbolTable.Classes.ContainsKey(type) && !(SymbolTable.Classes[classname].Attributes.ContainsKey(name)))// if you know my type and not myself
{
this.Name = name;
//c = new Atribute(name, SymbolTable.Classes[type])
{
this.Expression = context.expresion();
this.Self = context;
}//;
SymbolTable.Classes[classname].Attributes.Add(Name, this);//let me introduce myself
}
this.context = context;
//this.s = s;
}
public override object VisitAttribFeature([NotNull] CoolParser.AttribFeatureContext context)
{
CoolParser.ClassdefContext p = (CoolParser.ClassdefContext)(context.Parent);
dotcode += p.t.Text + "->" + context.id.Text + "\n";
dotcode += context.id.Text + "[label=\"" + context.id.Text + ":" + context.t.Text + "\nattribute\"]\n";
return(VisitChildren(context));
}
public override object VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
List <Method> methods = new List <Method>();
List <Attribute> attributes = new List <Attribute>();
foreach (var child in context.feature())
{
var result = Visit(child);
if (result is Method)
{
methods.Add(result as Method);
}
else
{
attributes.Add(result as Attribute);
}
}
Coord c = GetCoord(context);
Type inheritedType = null;
if (context.INHERITS() != null)
{
if (p.Types.ContainsKey(context.TYPE()[1].GetText()))
{
inheritedType = p.Types[context.TYPE()[1].GetText()];
}
else
{
inheritedType = new Type(context.TYPE()[1].GetText(), null, new Coord(0, 0));
p.Types[context.TYPE()[1].GetText()] = inheritedType;
}
}
return(new Type(context.TYPE()[0].GetText(), methods, attributes, inheritedType, c));
}
public override Node VisitMethodFeature([NotNull] CoolParser.MethodFeatureContext context)
{
CoolParser.ClassdefContext p = (CoolParser.ClassdefContext)context.Parent;
var classname = p.t.Text;
//var type = "Object";
//if (context.TYPE().GetText() != null)
// type = context.TYPE().GetText();
//var name = context.ID().GetText();
//Method c;
//if (SymbolTable.Classes.ContainsKey(type) && !(SymbolTable.Classes[classname].Methods.ContainsKey(name)))// if you know my type and not myself
//{
// c = new Method(name, SymbolTable.Classes[type])
// {
// Expression = context.expresion(),// this shouln't be on the ctor
// Self = context
// };
// SymbolTable.Classes[classname].Methods.Add(c.Name, c);//let me introduce myself
// var formals = context.formal();
// foreach (var item in formals)// add the parameters of the method
// {
// SymbolTable.Classes[classname].Methods[name].Params.Add(item.id.Text, new Atribute(item.id.Text, SymbolTable.Classes[item.t.Text]));
// }
//}
//this.currentMethod = name;
//this.currentClass = classname;
var s = VisitChildren(context);
chec_typeAdded(s, context, classname);
return(new MethodNode(context, s));
}
public override Node VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
var s = VisitChildren(context);
var name = context.TYPE(0).GetText();
var n = SymbolTable.Classes[name];
n.Context = context;
n.Childs = s.Childs;
return(n);
//return new ClassNode(context, s);
}
//public object VisitChildren(IRuleNode node)
//{
// throw new NotImplementedException();
//}
//public object VisitTerminal(ITerminalNode node)
//{
// throw new NotImplementedException();
//}
//public object VisitErrorNode(IErrorNode node)
//{
// throw new NotImplementedException();
//}
//public override
public override object VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
dotcode += "program->" + context.t.Text + "\n";
dotcode += context.t.Text + "[label=\"" + context.t.Text;
if (context.it != null)
{
dotcode += ":" + context.it.Text;
}
dotcode += "\nclass\"]\n";
return(VisitChildren(context));
}
public ClassNode(CoolParser.ClassdefContext context, Node s) : base(s.Childs)
{
Name = context.TYPE(0).GetText();
Type = Name;
//this = SymbolTable.Classes[Name];
this.Context = context;
Attributes = new Dictionary <string, AttributeNode>();
Methods = new Dictionary <string, MethodNode>();
}
public MethodNode(CoolParser.MethodFeatureContext context, Node s) : base(s.Childs)
{
Symbols = new Dictionary <string, ClassNode>();
Params = new Dictionary <string, AttributeNode>();
//Variables = new Dictionary<string, AttributeNode>();
CoolParser.ClassdefContext p = (CoolParser.ClassdefContext)context.Parent;
var classname = p.t.Text;
var type = "Object";
if (context.TYPE().GetText() != null)
{
type = context.TYPE().GetText();
}
var name = context.ID().GetText();
Name = name;
SetType(SymbolTable.Classes[type]);
//Method c;
if (SymbolTable.Classes.ContainsKey(type) && !(SymbolTable.Classes[classname].Methods.ContainsKey(name)))// if you know my type and not myself
{
//c = new Method(name, SymbolTable.Classes[type])
{
Expression = context.expresion();// this shouln't be on the ctor
Self = context;
}
SymbolTable.Classes[classname].Methods.Add(Name, this);//let me introduce myself
var formals = context.formal();
//foreach (var item in formals)// add the parameters of the method
//{
// //SymbolTable.Classes[classname].Methods[name].Params.Add(item.id.Text, new FormalNode(item.id.Text, SymbolTable.Classes[item.t.Text]));
//}
foreach (var item in Childs)
{
try{ SymbolTable.Classes[classname].Methods[name].Params.Add(((FormalNode)item).ID, new AttributeNode(((FormalNode)item).ID, ((FormalNode)item).GetType())); }catch (System.Exception) {}
}
}
this.context = context;
var d = (CoolParser.ClassdefContext)context.Parent;
this.ClassName = d.TYPE(0).GetText();// + ".";
//this.Childs = s.Childs;
this.Name = context.ID().GetText();
if (ClassName.ToLower() == "main")
{
ClassName = "";
}
foreach (var item in Params)
{
Symbols.Add(item.Key, item.Value.GetType());// maybe here we could make a dict of atributes but i think this will be harder after in other places and since i only need the class :)
}
}
public override ASTNode VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
var classNode = new ClassNode(context);
var typeClass = new TypeNode(context.TYPE(0).Symbol.Line,
context.TYPE(0).Symbol.Column, context.TYPE(0).GetText());
classNode.TypeClass = typeClass;
var inheritType = context.TYPE(1) == null ? new TypeNode(0, 0, "Object") :
new TypeNode(context.TYPE(1).Symbol.Line, context.TYPE(1).Symbol.Column, context.TYPE(1).GetText());
classNode.TypeClassInherit = inheritType;
classNode.Features = (from x in context.feature() select Visit(x) as FeatureNode).ToList();
return(classNode);
}
public override object VisitMethodFeature([NotNull] CoolParser.MethodFeatureContext context)
{
CoolParser.ClassdefContext p = (CoolParser.ClassdefContext)(context.Parent);
dotcode += p.t.Text + "->" + context.id.Text + "\n";
dotcode += context.id.Text + "[label=\"" + context.id.Text;
if (context.t != null)
{
dotcode += ":" + context.t.Text;
}
dotcode += "\nmethod\"]\n";
// TODO fix signature of methods in dotcode?
// do not make a new node for each formal
var fs = context.formal();
foreach (var item in fs)
{
dotcode += context.id.Text + "->" + item.id.Text + "\n";
dotcode += item.id.Text + "[label=\"" + item.id.Text + ":" + item.t.Text + "\nformal\"]\n";
}
return(VisitChildren(context));
}
/// <summary>
/// Visit a parse tree produced by <see cref="CoolParser.classdef"/>.
/// <para>
/// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
/// on <paramref name="context"/>.
/// </para>
/// </summary>
/// <param name="context">The parse tree.</param>
/// <return>The visitor result.</return>
public virtual Result VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
return(VisitChildren(context));
}
/// <summary>
/// Exit a parse tree produced by <see cref="CoolParser.classdef"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitClassdef([NotNull] CoolParser.ClassdefContext context)
{
}
public override bool VisitClassdef([NotNull] CoolParser.ClassdefContext context)
{
return(VisitChildren(context));
}
