/// <summary>
/// Interpret LetStatement
/// </summary>
/// <param name="statement">LetStatement to interpret</param>
public override void Visit(LetStatement statement)
{
//Create SymbolTable's for each assignment to let referencing work properly
foreach (Assignment asgn in statement.GetAssignments())
{
SymbolTable = new SymbolTable(SymbolTable);
asgn.AcceptVisitor(this);
}
//If no root element, create one
if (statement.GetStatements().Count > 1 && Root == null)
{
XHTMLElement newRoot = new XHTMLElement("html", null, true);
Root = newRoot;
Current = Root;
}
//Interpret statements
int depth = this.Depth;
foreach (Statement stmt in statement.GetStatements())
{
stmt.AcceptVisitor(this);
BackToParentXHTMLElement(depth);
}
//Go back to scope outside let statement
foreach (Assignment asgn in statement.GetAssignments())
{
SymbolTable = SymbolTable.GetParentSymbolTable();
}
}
private IStatement ParseLetStatement(Token currentToken)
{
var statement = new LetStatement(currentToken);
var peekToken = _parserTokens.PeekToken();
if (peekToken.TokenType != TokenType.IDENT)
{
return(NullStatement(currentToken, string.Empty));
}
var newToken = _parserTokens.NextToken();
statement.Name = newToken.Value;
newToken = _parserTokens.NextToken();
if (newToken.TokenType != TokenType.ASSIGN)
{
return(NullStatement(newToken, $"Expected '=' but have {newToken.TokenType}"));
}
while (newToken.TokenType != TokenType.SEMICOLON)
{
newToken = _parserTokens.NextToken();
}
return(statement);
}
private LetStatement ParseLetStatement()
{
var statement = new LetStatement(currentToken);
if (!ExpectPeek(TokenType.IDENT))
{
return(null);
}
statement.Name = new Identifier(currentToken, currentToken.Literal);
if (!ExpectPeek(TokenType.ASSIGN))
{
return(null);
}
statement.Value = ParseExpression(ExpressionType.Lowest);
while (!IsCurrentToken(TokenType.SEMMICOLON))
{
NextToken();
}
return(statement);
}
public LetStatement ParseLetStatement()
{
var statement = new LetStatement();
statement.Token = this.CurrentToken;
if (!this.ExpectPeek(TokenType.IDENT))
{
return(null);
}
statement.Name = new Identifier(CurrentToken, this.CurrentToken.Literal);
if (!this.ExpectPeek(TokenType.ASSIGN))
{
return(null);
}
this.ReadToken();
statement.Value = this.ParseExpression(Precedence.LOWEST);
if (this.NextToken.Type == TokenType.SEMICOLON)
{
this.ReadToken();
}
return(statement);
}
private LetStatement ParseLetStatement()
{
var stmt = new LetStatement()
{
Token = this._curToken,
};
if (!this.ExpectPeek(TokenType.IDENT))
{
throw new ParserException($"Expect IDENT Token but got {this._peekToken.Literal}");
}
stmt.Name = new Identifier(this._curToken, this._curToken.Literal);
if (!this.ExpectPeek(TokenType.ASSIGN))
{
throw new ParserException($"Expect ASSIGN Token but got {this._peekToken.Literal}");
}
this.NextToken();
stmt.Value = this.ParseExpression(Precedence.LOWEST);
if (this.PeekTokenIs(TokenType.SEMICOLON))
{
this.NextToken();
}
return(stmt);
}
private LetStatement ParseLetStatement()
{
var stmt = new LetStatement
{
Token = _currentToken
};
if (!ExpectPeek(TokenType.IDENT))
{
return(null);
}
stmt.Name = new Identifier
{
Token = _currentToken,
Value = _currentToken.Literal
};
if (!ExpectPeek(TokenType.ASSIGN))
{
return(null);
}
NextToken();
stmt.Value = ParseExpression(Precedences.LOWEST);
if (PeekTokenIs(TokenType.SEMICOLON))
{
NextToken();
}
return(stmt);
}
private LetStatement ParseLetStatement()
{
var stmt = new LetStatement {
Token = curToken
};
if (!ExpectPeek(TokenType.Ident))
{
return(null);
}
stmt.Name = new Identifier {
Token = curToken, Value = curToken.Literal
};
if (!ExpectPeek(TokenType.Assign))
{
return(null);
}
NextToken();
stmt.Value = ParseExpression(Precedence.Lowest);
if (PeekTokenIs(TokenType.Semicolon))
{
NextToken();
}
return(stmt);
}
private static IEnumerable <Command> CompileLetStatement(SubroutineCompilationUnit compilationUnit,
LetStatement letStatement)
{
foreach (var command in CompileExpression(compilationUnit, letStatement.Expression))
{
yield return(command);
}
switch (letStatement.Varible)
{
case ArrayIdentifier arrayIdentifier:
yield return(Commands.Pop.Temp(0));
yield return(compilationUnit.PushSymbol(arrayIdentifier.Identifier.Value));
foreach (var command in CompileExpression(compilationUnit, arrayIdentifier.Expression))
{
yield return(command);
}
yield return(Commands.Arithmetic.Add());
yield return(Commands.Pop.Pointer(1));
yield return(Commands.Push.Temp(0));
yield return(Commands.Pop.That(0));
break;
case Identifier identifier:
yield return(compilationUnit.PopSymbol(identifier.Value));
break;
}
}
public void TestString()
{
// Arrange
var lhsIdentifierToken = new Token(Token.IDENT, "myVar");
var rhsIdentifierToken = new Token(Token.IDENT, "anotherVar");
var letToken = new Token(Token.LET, "let");
var letStatement = new LetStatement(letToken)
{
Name = new Identifier(lhsIdentifierToken),
Value = new Identifier(rhsIdentifierToken)
};
var program = new ProgramRoot();
program.Statements.Add(letStatement);
// Act
var programString = program.String();
// Assert
var expected = "let myVar = anotherVar;";
Assert.AreEqual(expected, programString);
}
public void TestAstString()
{
var letStmt = new LetStatement();
letStmt.Token = Token.Create(TokenType.LET, "let");
letStmt.Name = new Identifier(Token.Create(TokenType.IDENT, "myVar"), "myVar");
letStmt.Value = new Identifier(Token.Create(TokenType.IDENT, "anotherVar"), "anotherVar");
Assert.AreEqual("let myVar = anotherVar;", letStmt.ToString());
}
private void TestLetStatement(Statement smst, string name)
{
Assert.AreEqual("let", smst.TokenLiteral(), $"statment.TokenLiteral is not let , but got {smst.TokenLiteral()}");
LetStatement lsmst = smst as LetStatement;
Assert.IsNotNull(lsmst, "smt is not LetStatement");
Assert.AreEqual(name, lsmst.Name.Value, $"lsmst' name value is not {name}, but got {lsmst.Name.Value}");
Assert.AreEqual(name, lsmst.Name.TokenLiteral(), $"lsmst' name tokenliteral is not {name}, but got {lsmst.Name.Value}");
}
public static void TestLetStatement(LetStatement statement, string name)
{
Assert.AreEqual(statement.TokenLiteral(), "let",
$"statement token literal not 'let', got={statement.TokenLiteral()}");
Assert.AreEqual(statement.GetType().Name, "LetStatement",
$"statement is not of LetStatement type, got={statement.GetType().Name}");
Assert.AreEqual(name, statement.Name.Value, $"statement name value not {name}, got={statement.Name.Value}");
Assert.AreEqual(name, statement.Name.TokenLiteral(),
$"statement name token literal not {name}, got={statement.Name.TokenLiteral()}");
}
public override string VisitLetStatement(BasicParser.LetStatementContext context)
{
var variableName = context.VARNAME().ToString();
var expressionVisitor = new ExpressionVisitor();
var expression = expressionVisitor.Visit(context.expression());
var letStatement = new LetStatement(variableName, expression);
Statements[_currentLineNumber] = letStatement;
return(base.VisitLetStatement(context));
}
private void TestLetStatements(IStatement stmt, string name)
{
Assert.AreEqual("let", stmt.TokenLiteral());
Assert.IsInstanceOfType(stmt, typeof(LetStatement));
LetStatement letStmt = (LetStatement)stmt;
Assert.AreEqual(name, letStmt.Name.Value);
Assert.AreEqual(name, letStmt.Name.TokenLiteral());
}
private string buildLetStatement(LetStatement letStatement)
{
// parse definition
var definition = Build(letStatement.Definition);
// add to defines
if (blockLevel == 0)
{
var vartype = Build(letStatement.Definition.ObjType);
var varname = Build(letStatement.Definition.Name);
objectDefines.Add(vartype + " " + varname + ";");
}
return(definition + ";");
}
public void LetStatement_ArrayIdentifier_IsCorrect()
{
var tokenizer = new Tokenizer(new Token[]
{
Keyword.Let,
new Identifier("a"),
Symbol.OpenBracket,
new IntegerConstant(1),
Symbol.Plus,
new IntegerConstant(1),
Symbol.CloseBracket,
Symbol.Equal,
new IntegerConstant(7),
Symbol.SemiColon
});
var letStatement = new LetStatement(tokenizer);
letStatement
.Varible.Should().BeOfType <ArrayIdentifier>()
.Which.Invoking(a =>
{
a.Identifier.Value.Should().Be("a");
a.Expression.Term.Should().BeOfType <IntegerConstant>()
.Which.Integer.Should().Be(1);
var tuple = a.Expression.OperatorTermPairs.Should().ContainSingle()
.Which;
tuple.Item1.Should().Be(Symbol.Plus);
tuple.Item2.Should().BeOfType <IntegerConstant>()
.Which.Integer.Should().Be(1);
})
.Invoke();
letStatement
.Expression.Term.Should().BeOfType <IntegerConstant>()
.Which.Integer.Should().Be(7);
letStatement.Expression.OperatorTermPairs.Should().BeEmpty();
}
public void LetStatement_Identifier_IsCorrect()
{
var tokenizer = new Tokenizer(new Token[]
{
Keyword.Let,
new Identifier("x"),
Symbol.Equal,
new IntegerConstant(5),
Symbol.SemiColon
});
var letStatement = new LetStatement(tokenizer);
letStatement
.Varible.Should().BeOfType <Identifier>()
.Which.Value.Should().Be("x");
letStatement
.Expression.Term.Should().BeOfType <IntegerConstant>()
.Which.Integer.Should().Be(5);
}
private IStatement ParseLetStatement()
{
var letStatement = new LetStatement(curToken);
if (!ExpectPeek(Token.IDENT))
{
return(null);
}
letStatement.Name = new Identifier(curToken);
if (!ExpectPeek(Token.ASSIGN))
{
return(null);
}
// TODO: We're skipping the expressions until we encounter a semicolon.
while (!CurrTokenIs(Token.SEMICOLON))
{
NextToken();
}
return(letStatement);
}
/// <summary>
/// Parser for LetStatement
/// </summary>
/// <returns>Parsed LetStatement</returns>
public LetStatement ParseLetStatement()
{
LetStatement letStatement = new LetStatement();
//Skip let token
NextToken("let", "let assignment+ in statement* end", "let");
//Parse arguments
while (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetValue().ToString() == "in")
{
break; //no more assignments left
}
letStatement.AddAssignment(ParseAssignment());
}
if (letStatement.GetAssignments().Count == 0)
{ //No assignments is not allowed
throw new UnexpectedToken("LetStatement doesn't contain assignments.", "Expected at least one assignment ", CurrentToken.GetLine());
//throw new UnexpectedToken();
}
//Skip in token
NextToken("in", "let assignment+ in statement* end", "in");
//Parse statements
while (TokenStream.HasNext())
{
if (TokenStream.Peek(1).GetValue().ToString() == "end")
{ //No more statements left
break;
}
letStatement.AddStatement(ParseStatement());
}
//Skip end token
NextToken("end", "let assignment+ in statement* end", "end");
return(letStatement);
}
/// <summary>
/// Visit LetStatement
/// </summary>
/// <param name="statement">LetStatement to check</param>
public override void Visit(LetStatement statement)
{
foreach (Assignment assignment in statement.GetAssignments())
{
//Go level deeper in SymbolTable, to check using variables in other assignments
CreateChildSymbolTable();
//Visit Assignment
assignment.AcceptVisitor(this);
}
//Visit statements
foreach (Statement stmt in statement.GetStatements())
{
stmt.AcceptVisitor(this);
}
//Go back to level of statement in SymbolTable
foreach (Assignment assignment in statement.GetAssignments())
{
MoveToParentSymbolTable();
}
}
private LetStatement ParseLetStatement()
{
var letStatement = new LetStatement {
Token = currentToken
};
// move past identifier (e.g. 'foo')
if (!ExpectPeek(TokenType.Ident))
{
return(null);
}
letStatement.Name = new Identifier {
Token = currentToken, Value = currentToken.Literal
};
// move past '='
if (!ExpectPeek(TokenType.Assign))
{
return(null);
}
// ???
NextToken();
letStatement.Value = ParseExpression(Precedence.Lowest);
// optional semicolon
if (PeekTokenIs(TokenType.Semicolon))
{
// ';'
NextToken();
}
return(letStatement);
}
public override object Visit(LetStatement that, object value)
{
string assignment;
switch (that.Modus)
{
case AssignmentKind.Addition:
assignment = "+=";
break;
case AssignmentKind.Bitwise_And:
assignment = "&=";
break;
case AssignmentKind.Bitwise_Ior:
assignment = "|=";
break;
case AssignmentKind.Bitwise_Xor:
assignment = "^=";
break;
case AssignmentKind.Default:
throw new System.Exception("'let x ?= y' not supported yet");
case AssignmentKind.Division:
assignment = "/=";
break;
case AssignmentKind.Identity:
assignment = "=";
break;
case AssignmentKind.Modulus:
assignment = "%=";
break;
case AssignmentKind.Multiplication:
assignment = "*=";
break;
case AssignmentKind.Subtraction:
assignment = "-=";
break;
default:
throw new System.ArgumentException("that.Modus");
}
_writer.Write("let ");
that.First.Visit(this);
_writer.Write(" {0} ", assignment);
that.Other.Visit(this);
_writer.WriteLine();
return null;
}
/** Creates a default setter for use in a field or a guard. */
private SetStatement CreateDefaultSetter(Cursor cursor, string value)
{
/** Create the \c value parameter. */
/** \todo Move creation of the \c value parameter to a suitable pass. */
Parameter parameter = new Parameter(
position,
new SymbolDefinition(position, "value", SymbolKind.Parameter),
DirectionKind.In,
new UnknownType(position)
);
/** Create the profile of the setter. */
Profile profile = new Profile(position, new NoneType(position), new Parameter[1]{ parameter });
/** Create the body of the setter: let .value := value. */
Statement statement = new LetStatement(
position,
AssignmentKind.Identity,
new NamedExpression(position, new SymbolReference(position, PathKind.Instance, value)),
new NamedExpression(position, new SymbolReference(position, PathKind.Relative, "value"))
);
Statement[] statements = new Statement[1]{ statement };
Block block = new Block(position, statements);
return new SetStatement(
position,
new SymbolDefinition(position, "set", SymbolKind.Setter),
profile,
block
);
}
public override object Visit(LetStatement that, object value = null)
{
PrintPrologue(that);
_writer.WriteLine("Modus = {0}", that.Modus.ToString());
PrintNodeId("First", that.First);
PrintNodeId("Other", that.Other);
PrintEpilogue(that);
that.First.Visit(this);
that.Other.Visit(this);
return null;
}
public override T VisitLetStatement(LetStatement node)
{
throw new NotImplementedException();
}
public override object Visit(LetStatement that, object value = null)
{
that.First.Visit(this);
that.Other.Visit(this);
return null;
}
public virtual void Visit(LetStatement statement)
{
VisitSubNodes(statement);
}
private void evalLetStatement(Object context, LetStatement statement)
{
DefinitionExpression definition = statement.Definition;
context[definition.Name.Literal] = Eval(context, definition.Value);
}
public override object Visit(LetStatement that, object value)
{
Storage other = (Storage) that.Other.Visit(this);
Storage first = (Storage) that.First.Visit(this);
_writer.Write("store ");
that.First.Type.Visit(this);
_writer.Write(" " + other.ToString() + ", ");
that.Other.Type.Visit(this);
_writer.Write("* ");
_writer.Write(first.ToString());
_writer.WriteLine();
return null;
}
public virtual object Visit(LetStatement that, object value)
{
throw new System.NotImplementedException();
}
