//private Node s;
public LetNode(CoolParser.LetExpContext context, Node s) : base(s.Childs)
{
this.context = context;
IDs = new List <IToken>();
Types = new List <IToken>();
Exprs = new List <CoolParser.ExpresionContext>();
for (int i = 0; i < context.newvar().Length; i++)
{
IDs.Add(context.newvar()[i].id);
Types.Add(context.newvar()[i].t);
Exprs.Add(context.newvar()[i].e);
}
//IDs = new ITerminalNode[context];
//Types = context.TYPE();
//Exprs = context.expresion();
Symbols = new Dictionary <string, ClassNode>();
for (int i = 0; i < IDs.Count; i++)
{
var g = Types[i].Text;
//SymbolTable.Classes[Types[i].GetText()] = new ClassNode(g, null);
Symbols[IDs[i].Text] = SymbolTable.Classes[Types[i].Text];
//SymbolTable.Symbols.Push(Symbols);
}
}
public override object VisitLetExp([NotNull] CoolParser.LetExpContext context)
{
Coord c = GetCoord(context);
List <Identifier> letInits = new List <Identifier>();
//for (int i = 0; i < context.ID().Length; i++)
//{
// Type idType = new Type(context.TYPE()[i].GetText(), null, null);
// if (p.Types.ContainsKey(context.TYPE()[i].GetText()))
// {
// idType = p.Types[context.TYPE()[i].GetText()];
// }
// Expression exp = null;
// if (i<context.ASSIGN().Length)
// exp = (Expression)Visit(context.expresion()[i]);
// Identifier id = new Identifier(context.ID()[i].GetText(), exp, idType, new Coord(context.Depth(), context.getAltNumber()));
// letInits.Add(id);
// //Shady ...
// // ANTLR stores in context the def in grammar for Let:
// //LET ID COLON TYPE(ASSIGN expresion)? (COMMA ID COLON TYPE(ASSIGN expresion) ? )*IN expresion #letExp
// // as:
// // an array of IDs,array of COLON, array of ASSIGN, array of expressions
// // so im not sure if the lengths of these are equal since you theoretically can skip the assign part of any identifier and just declare it, so in that case i would not know if the ith assign correponds to the ith ID, is that so?, need to check
// //Console.WriteLine();
// //if(context.expresion[i])
//}
foreach (var x in context.newvar())
{
if (x.e != null)
{
letInits.Add(new Identifier(x.id.Text, (Expression)Visit(x.e), new Type(x.t.Text, null, null), GetCoord(context)));
}
else
{
letInits.Add(new Identifier(x.id.Text, null, new Type(x.t.Text, null, null), GetCoord(context)));
}
}
var new_body = (Expression)Visit(context.body);
//Expression body = (Expression)Visit(context.expresion()[0]);
//context.
return(new Let(letInits, new_body, GetCoord(context)));
}
public override Node VisitLetExp([NotNull] CoolParser.LetExpContext context)
{
var s = VisitChildren(context);
return(new LetNode(context, s));
}
public override object VisitLetExp([NotNull] CoolParser.LetExpContext context)
{
VisitExpr(context);
return(VisitChildren(context));
}
/// <summary>
/// Exit a parse tree produced by the <c>letExp</c>
/// labeled alternative in <see cref="CoolParser.expresion"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitLetExp([NotNull] CoolParser.LetExpContext context)
{
}
/// <summary>
/// Visit a parse tree produced by the <c>letExp</c>
/// labeled alternative in <see cref="CoolParser.expresion"/>.
/// <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 VisitLetExp([NotNull] CoolParser.LetExpContext context)
{
return(VisitChildren(context));
}
public override bool VisitLetExp([NotNull] CoolParser.LetExpContext context)
{
return(VisitChildren(context));
}
