/// <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(); }