public void Visit(LetNode node)
{
VariableManager.PushVariableCounter();
foreach (var attr in node.Initialization)
{
VariableManager.IncrementVariableCounter();
VariableManager.PushVariable(attr.Formal.Id.Text, attr.Formal.Type.Text);
VariableManager.PushVariableCounter();
attr.Accept(this);
//IntermediateCode.Add(new AssignmentVariableToVariable(VariableManager.PeekVariableCounter(), VariableManager.VariableCounter));
VariableManager.PopVariableCounter();
}
VariableManager.IncrementVariableCounter();
node.ExpressionBody.Accept(this);
foreach (var attr in node.Initialization)
{
VariableManager.PopVariable(attr.Formal.Id.Text);
}
VariableManager.PopVariableCounter();
if (special_object_return_type)
{
SetReturnType(node.StaticType.Text);
}
}
public void Visit(LetNode node)
{
var scopeLet = scope.CreateChild();
foreach (var expInit in node.Initialization)
{
expInit.AssignExp.Accept(new Tour2(scopeLet, errors));
var typeAssignExp = expInit.AssignExp.StaticType;
if (!scopeLet.IsDefinedType(expInit.Formal.Type.Text, out TypeInfo typeDeclared))
{
errors.Add(SemanticError.NotDeclaredType(expInit.Formal.Type));
}
if (!(typeAssignExp <= typeDeclared))
{
errors.Add(SemanticError.CannotConvert(expInit.Formal.Type, typeAssignExp, typeDeclared));
}
if (scopeLet.IsDefined(expInit.Formal.Id.Text, out TypeInfo typeOld))
{
scopeLet.Change(expInit.Formal.Id.Text, typeDeclared);
}
else
{
scopeLet.Define(expInit.Formal.Id.Text, typeDeclared);
}
}
node.ExpressionBody.Accept(new Tour2(scopeLet, errors));
node.StaticType = node.ExpressionBody.StaticType;
}
public void Visit(LetNode node)
{
VariableManager.PushVariableCounter();
foreach (var attr in node.Initialization)
{
VariableManager.IncrementVariableCounter();
VariableManager.PushVariable(attr.Formal.Id.Text, attr.Formal.Type.Text);
VariableManager.PushVariableCounter();
attr.Accept(this);
VariableManager.PopVariableCounter();
}
VariableManager.IncrementVariableCounter();
node.ExpressionBody.Accept(this);
foreach (var attr in node.Initialization)
{
VariableManager.PopVariable(attr.Formal.Id.Text);
}
VariableManager.PopVariableCounter();
if (object_return_type)
{
SetReturnType(node.StaticType.Text);
}
}
public override Node VisitLet([NotNull] TigerParser.LetContext context)
{
var node = new LetNode(context);
TigerParser.DeclsContext[] decls = context.decls();
var declarations = new DeclarationListNode(decls[0]);
declarations.Children.AddRange(from d in decls select Visit(d)); // declaration list -> DECLARATION+
node.Children.Add(declarations); // DECLARATION LIST
TigerParser.ExprContext[] exprs = context.expr();
ExpressionSeqNode expressions;
if (exprs.Length > 0)
{
expressions = new ExpressionSeqNode(exprs[0]);
}
else
{
expressions = new ExpressionSeqNode(-1, -1);
}
expressions.Children.AddRange(from e in exprs select Visit(e)); // expression sequence -> EXPRESSION*
node.Children.Add(expressions); // EXPRESSION SEQUENCE
return(node);
}
public void TestLetNodeNoEqualOperator()
{
string t = "#{let c tuple[x:3, y:5]}";
LexicalParser lp = new LexicalParser();
lp.SetParseContent(t);
var tokens = lp.Parse();
LetNode l = new LetNode(tokens[0]);
}
public void TestLetNodeNoExpr()
{
string t = "#{let c= }";
LexicalParser lp = new LexicalParser();
lp.SetParseContent(t);
var tokens = lp.Parse();
LetNode l = new LetNode(tokens[0]);
}
public override ASTNode VisitLetIn([NotNull] CoolParser.LetInContext context)
{
LetNode node = new LetNode(context)
{
Initialization = (from x in context.property() select Visit(x) as AttributeNode).ToList(),
ExpressionBody = Visit(context.expression()) as ExpressionNode
};
return(node);
}
public void GenerateCode(LetNode node, ICIL_CodeGenerator codeGenerator)
{
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
GenerateCode(node.LetExprs, codeGenerator);
GenerateCode(node.Expression, codeGenerator);
codeGenerator.AddInstruction(
new Assign((Variable)node.Holder, node.Expression.Holder));
}
public void TestLetNode()
{
string t = "#{let c = tuple[x:3, y:5]}";
LexicalParser lp = new LexicalParser();
lp.SetParseContent(t);
var tokens = lp.Parse();
LetNode l = new LetNode(tokens[0]);
Assert.AreEqual("c", l.VarName);
Assert.AreEqual("tuple[x:3, y:5]", l.Expression);
}
Node expr()
{
switch (currToken.Type)
{
case TokenType.IDE:
return ide();
case TokenType.LET:
Env savedEnv = top;
top = new Env(top);
Token letToken = match(currToken.Type);
IdeNode id = ide();
match(TokenType.EQUAL);
Node definition = expr();
top.Put(id.Token, definition.eval());
match(TokenType.IN);
Node body = expr();
LetNode let = new LetNode(letToken, id, definition, body, top);
top = savedEnv;
return let;
case TokenType.AND:
Token andToken = match(currToken.Type);
match(TokenType.OPENB);
AndNode and = new AndNode(andToken);
while (currToken.Type != TokenType.CLOSEB)
{
and.addExpression(expr());
if (currToken.Type != TokenType.CLOSEB)
match(TokenType.COMMA);
}
match(TokenType.CLOSEB);
return and;
case TokenType.BOOL:
return new Node(match(currToken.Type));
default:
Error("Error: invalid token: " + currToken.Type.ToString());
return null;
}
}
public override string Visit(LetNode node)
{
var symbol = Scope.FindVariableInCurrent(node.Id);
if (symbol != null)
{
AddError(Error.ErrorLevel.Error, node, $"Variable `{node.Id}` already exists.");
}
symbol = Scope.AddVariable(node.Id, node);
var left = symbol.AbsoluteName();
var right = Visit(node.Expr);
if (right == null)
{
AddError(Error.ErrorLevel.Error, node, $"Variable `{node.Id}` has no value defined.");
}
return($"{left} = {right}");
}
public void CheckSemantic(LetNode node, IScope scope = null)
{
CheckSemantic(node.LetExprs, scope);
CheckSemantic(node.Expression, scope);
node.ComputedType = node.Expression.ComputedType;
}
/// <summary>
/// let_stmt = "let" identifier "=" expr
/// </summary>
private LetNode parseLetStmt()
{
if (!check(LexemType.Let))
return null;
var node = new LetNode();
node.Name = ensure(LexemType.Identifier, ParserMessages.VarIdentifierExpected).Value;
ensure(LexemType.Assign, ParserMessages.SymbolExpected, '=');
node.Value = ensure(parseExpr, ParserMessages.InitExpressionExpected);
return node;
}
public void Visit(LetNode node)
{
throw new NotImplementedException();
}
private Node ParseParagraph()
{
Token <TokenType> t = PeekNextToken();
ParaNode node = new ParaNode();
while (!t.End)
{
switch (t.TokenType)
{
case TokenType.If:
node.ParamNodes.Add(ParseIfBlock());
break;
case TokenType.For:
node.ParamNodes.Add(ParseForBlock());
break;
case TokenType.Let:
LetNode let = new LetNode(GetNextToken());
node.ParamNodes.Add(let);
break;
case TokenType.Remark:
RemarkNode rem = new RemarkNode(GetNextToken());
node.ParamNodes.Add(rem);
break;
case TokenType.Expression:
case TokenType.Text:
SimpleNode sNode = new SimpleNode(GetNextToken());
node.ParamNodes.Add(sNode);
break;
case TokenType.Include:
IncludeNode include = new IncludeNode(GetNextToken());
node.ParamNodes.Add(include);
break;
case TokenType.Else: //Note: if next token is else, then the trueNode of if is finished.
case TokenType.End:
if (node.ParamNodes.Count == 1)
{
return(node.ParamNodes[0]);
}
else
{
return(node);
}
case TokenType.Break:
GetNextToken();
node.ParamNodes.Add(new BreakNode());
break;
case TokenType.Continue:
GetNextToken();
node.ParamNodes.Add(new ContinueNode());
break;
}
t = PeekNextToken();
}
if (node.ParamNodes.Count == 1)
{
return(node.ParamNodes[0]);
}
else
{
return(node);
}
}
