public virtual void VisitForStatementNode(ForStatementNode node) { Visit(node.ForKeywordNode); Visit(node.LoopVariableNode); Visit(node.ColonEqualsNode); Visit(node.StartingValueNode); Visit(node.DirectionNode); Visit(node.EndingValueNode); Visit(node.DoKeywordNode); Visit(node.StatementNode); }
public void Visit(ForStatementNode node) { var lastId = currentId; currentId = id++; string varName = node[0].AnchorToken.Lexeme; string indexVarName = $"__{varName}_index"; builder.AppendLine("\t\tldc.i4.0"); StoreInVariable(indexVarName); Visit((dynamic)node[1]); builder.AppendLine($"\tfor_{currentId}:"); builder.AppendLine($"\t\tdup"); LoadVariable(indexVarName); switch (GetSymbol(varName).type) { case Type.BOOL: case Type.INT: builder.AppendLine($"\t\tldelem.i4"); break; default: builder.AppendLine($"\t\tldelem.ref"); break; } StoreInVariable(varName); builder.AppendLine(); Visit((dynamic)node[2]); builder.AppendLine(); LoadVariable(indexVarName); builder.AppendLine("\t\tldc.i4.1"); builder.AppendLine("\t\tadd"); StoreInVariable(indexVarName); builder.AppendLine($"\tnext_{currentId}:"); builder.AppendLine($"\t\tdup"); builder.AppendLine($"\t\tldlen"); builder.AppendLine($"\t\tconv.i4"); LoadVariable(indexVarName); builder.AppendLine($"\t\tbgt for_{currentId}"); builder.AppendLine($"\tend_{currentId}:"); builder.AppendLine($"\t\tpop"); currentId = lastId; }
private void EmitForStatement(ForStatementNode forStatement) { if (forStatement.IsLeftOrContinued()) { // There exists a Leave or Continue statement targeting this loop. // We need to add a label so that we can emit a correct break or // continue statement. output.Append("$loop_").Append(globalLoopCount).Append(':'); associatedLoopIds[forStatement] = globalLoopCount; globalLoopCount++; } output.Append("for("); if (forStatement.DeclaresNew) { output.Append("let "); output.Append(forStatement.VariableIdentifier); output.Append('='); Debug.Assert(forStatement.InitialValueNode != null); EmitExpression(forStatement.InitialValueNode); } output.Append(';'); if (forStatement.ConditionNode != null) { EmitExpression(forStatement.ConditionNode); } output.Append(';'); if (forStatement.WithExpressionNode != null) { output.Append(forStatement.VariableIdentifier); output.Append('='); EmitExpression(forStatement.WithExpressionNode); } else { output.Append(forStatement.VariableIdentifier); output.Append("++"); } output.Append(')'); EmitStatementBlock(forStatement.StatementNodes); }
private static PythonNode Wrap(ForStatement stmt, PythonNode parent) { var result = new ForStatementNode(stmt) { Parent = parent }; result.AddChild(Wrap(stmt.Left, result)); result.AddChild(Wrap(stmt.List, result)); result.AddChild(Wrap(stmt.Body, result)); if (stmt.Else != null) { result.AddChild(Wrap(stmt.Else, result)); } return(result); }
public ForStatementNode makeForStatementNode(Block forBlock, ExprNode expr1, ExprNode expr2, ExprNode expr3, StatementNode body) { List <StatementNode> bodyList = null; if (body is Block) { bodyList = ((Block)body).stmts; } else { bodyList = new List <StatementNode>(); bodyList.Add(body); } ForStatementNode node = new ForStatementNode(forBlock.stmts, expr1, expr2, expr3, bodyList); return(node); }
protected override Void handleFor(ForStatementNode forStatement, Set <TypeInfo> dependencies) { foreach (var s in forStatement.Initializer) { handleStatement(s, dependencies); } if (forStatement.Condition != null) { expressionHandler.handleExpression(forStatement.Condition, dependencies, true); } foreach (var s in forStatement.Iterator) { handleStatement(s, dependencies); } handleStatement(forStatement.Statement, dependencies); return(null); }
protected override Boolean handleFor(ForStatementNode forStatement, HashSet <StatementNode> visited) { foreach (var s in forStatement.Initializer) { if (!handleStatement(s, null)) { return(Boolean.FALSE); } } if (forStatement.Condition == null) { return(visitOrigin(forStatement.Statement)); } var state = expressionChecker.handleExpression(forStatement.Condition, visited, true); switch (state) { case Assigned: return(Boolean.FALSE); case AssignedAfterTrue: return(Boolean.TRUE); case AssignedAfterFalse: visitOrigin(forStatement.Statement); return(Boolean.FALSE); default: var cinfo = forStatement.Condition.getUserData(typeof(ExpressionInfo)); if (cinfo.IsConstant) { if ((Boolean)cinfo.Value) { return(visitOrigin(forStatement.Statement)); } else { return(Boolean.TRUE); } } visitStatement(forStatement.Statement, visited); return(Boolean.TRUE); } }
private void Write(ForStatementNode stmt) { Fill(); _code.Append("for "); Write(stmt.Children[0]); _code.Append(" in "); Write(stmt.Children[1]); Enter(); Write(stmt.Children[2]); Leave(); if (stmt.Children.Count == 4) { Fill(); _code.Append("else"); Enter(); Write(stmt.Children[3]); Leave(); } }
public Type Visit(ForStatementNode node) { Type varType = Visit((dynamic)node[0]); Type listType = Visit((dynamic)node[1]); if (varType.ToListType() != listType) { throw new SemanticError($"Incompatible types {varType} and {listType}", node[0].AnchorToken); } AddSymbolToScope($"__{node[0].AnchorToken.Lexeme}_index", Type.INT, Kind.VAR, value: 0); var lastInLoopOrFor = inLoopOrFor; inLoopOrFor = true; Visit((dynamic)node[2]); inLoopOrFor = lastInLoopOrFor; return(Type.VOID); }
void ForStatement(ref StatementNode node) { ExpressionNode varExpr = null, startExpr = null, limitExpr = null, incrExpr = ConstantNode.One; Expect(39); NumericVariable(ref varExpr); prog.CheckForVarName(varExpr); Expect(23); NumericExpression(ref startExpr); Expect(34); NumericExpression(ref limitExpr); if (la.kind == 40) { Get(); NumericExpression(ref incrExpr); } var fnode = new ForStatementNode(varExpr, startExpr, limitExpr, incrExpr); prog.PushFor(fnode); node = fnode; }
private ForStatementNode BuildForStatementNode( LexSpan lFor, SyntaxNodeOrToken assign, LexSpan to, SyntaxNodeOrToken limit, SyntaxNodeOrToken body, LexSpan end, LexSpan rFor) { var exp = new ForStatementNode(); exp.AddNode(new ForToken(lFor)); exp.AddNode(assign); exp.AddNode(new ToToken(to)); exp.AddNode(limit); exp.AddNode(body); exp.AddNode(new EndToken(end)); exp.AddNode(new ForToken(rFor)); return(exp); }
public Node ForStatement() { var for_node = new ForStatementNode() { AnchorToken = Expect(TokenCategory.FOR) }; for_node.Add(new IdentifierNode() { AnchorToken = Expect(TokenCategory.IDENTIFIER) }); Expect(TokenCategory.IN); for_node.Add(Expression()); Expect(TokenCategory.DO); for_node.Add(new StatementListNode() { ZeroOrMore(firstOfStatement, Statement) }); Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); return(for_node); }
protected override Void handleFor(ForStatementNode forStatement, Void source) { try { context.MemberResolver.enterScope(); foreach (var s in forStatement.Initializer) { handleStatement(s, null); } var condition = forStatement.Condition; if (condition != null) { this.ExpressionValidator.handleExpression(condition, null, true); ValidationHelper.setBoxing(context, context.TypeSystem.BooleanType, condition); var info = condition.getUserData(typeof(ExpressionInfo)); if (info == null || ValidationHelper.getType(context, condition) != context.TypeSystem.BooleanType) { throw context.error(CompileErrorId.NoImplicitConversion, condition, BytecodeHelper.getDisplayName(info == null ? null : info.Type), BytecodeHelper.getDisplayName(context.TypeSystem.BooleanType)); } } try { context.MemberResolver.enterScope(); handleStatement(forStatement.Statement, source); } finally { context.MemberResolver.leaveScope(); } foreach (var s in forStatement.Iterator) { handleStatement(s, source); } } finally { context.MemberResolver.leaveScope(); } return(null); }
public virtual Value evaluate(Context cx, ForStatementNode node) { output("<ForStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.initialize != null) { node.initialize.evaluate(cx, this); } if (node.test != null) { node.test.evaluate(cx, this); } if (node.increment != null) { node.increment.evaluate(cx, this); } if (node.statement != null) { node.statement.evaluate(cx, this); } indent_Renamed_Field--; output("</ForStatementNode>"); return(null); }
public void PushFor(ForStatementNode forNode) { openFors.Push(forNode); }
private bool BindInForStatement(ForStatementNode forStatement, VariableIdentifierMap variableIdentifierMap) { variableIdentifierMap.EnterBlock(); TypeSymbolNode iterationVariableType; if (forStatement.DeclaresNew) { Debug.Assert(forStatement.InitialValueNode != null); TypeSymbolNode?assignedValueType = BindInExpression(forStatement.InitialValueNode, variableIdentifierMap); if (assignedValueType == null) { return(false); } iterationVariableType = assignedValueType; VariableSymbolNode variable = forStatement.CreateVariable(iterationVariableType); variableIdentifierMap.AddSymbol(forStatement.VariableIdentifier, variable); } else { SymbolNode?symbol = GetExpressionSymbol(forStatement.VariableIdentifier, variableIdentifierMap); if (symbol == null) { ErrorProvider.ReportError(ErrorCode.CantFindIdentifierInScope, Compilation, forStatement.VariableIdentifierNode); return(false); } if (symbol is not VariableSymbolNode variable) { ErrorProvider.ReportError(ErrorCode.ForNotVariable, Compilation, forStatement.VariableIdentifierNode, $"Identifier: {forStatement.VariableIdentifier}"); return(false); } Debug.Assert(variable.TypeNode != null); iterationVariableType = variable.TypeNode; if (forStatement.InitialValueNode != null) { TypeSymbolNode?assignedValueType = BindInExpression(forStatement.InitialValueNode, variableIdentifierMap); if (assignedValueType == null) { return(false); } if (!TypeIsCompatibleWith(assignedValueType, iterationVariableType, possiblyOffendingNode: forStatement.InitialValueNode, out ImplicitConversionSymbolNode? implicitConversion)) { if (implicitConversion != null) { forStatement.InitialValueNode.SpecifyImplicitConversion(implicitConversion); } return(false); } } } { TypeSymbolNode?intType = typeManager[FrameworkType.Int]; TypeSymbolNode?rationalType = typeManager[FrameworkType.Rational]; TypeSymbolNode?complexType = typeManager[FrameworkType.Complex]; if (iterationVariableType != intType && iterationVariableType != rationalType && iterationVariableType != complexType) { ErrorProvider.ReportError(ErrorCode.ForIterationVariableHasToBeNumberType, Compilation, forStatement.VariableIdentifierNode, $"Type of iteration variable: {iterationVariableType.Identifier}"); return(false); } } if (forStatement.ConditionNode != null) { TypeSymbolNode?conditionType = BindInExpression(forStatement.ConditionNode, variableIdentifierMap); if (conditionType == null) { return(false); } TypeSymbolNode?boolType = typeManager[FrameworkType.Bool]; if (!TypeIsCompatibleWith(conditionType, boolType, possiblyOffendingNode: forStatement.ConditionNode, out ImplicitConversionSymbolNode? conversion)) { return(false); } if (conversion != null) { forStatement.ConditionNode.SpecifyImplicitConversion(conversion); } } if (forStatement.WithExpressionNode != null) { TypeSymbolNode?withType = BindInExpression(forStatement.WithExpressionNode, variableIdentifierMap); if (withType == null) { return(false); } if (!TypeIsCompatibleWith(withType, iterationVariableType, possiblyOffendingNode: forStatement.WithExpressionNode, out ImplicitConversionSymbolNode? conversion)) { return(false); } if (conversion != null) { forStatement.WithExpressionNode.SpecifyImplicitConversion(conversion); } } bool success = BindInStatementBlock(forStatement.StatementNodes, variableIdentifierMap); if (!success) { return(false); } variableIdentifierMap.LeaveBlock(); return(true); }
private static void Walk([NotNull] Agent agent, [NotNull] ForStatementNode forStatement, bool isStrict) { //TODO }
public virtual Value evaluate(Context cx, ForStatementNode node) { output("<ForStatementNode position=\"" + node.pos() + "\">"); indent_Renamed_Field++; if (node.initialize != null) { node.initialize.evaluate(cx, this); } if (node.test != null) { node.test.evaluate(cx, this); } if (node.increment != null) { node.increment.evaluate(cx, this); } if (node.statement != null) { node.statement.evaluate(cx, this); } indent_Renamed_Field--; output("</ForStatementNode>"); return null; }
public static BlockNode ProcessTokens(List <ScriptToken> tokens) { List <AstTreeNode> blockNodes = new List <AstTreeNode>(); AstTreeNode node = new BlockNode(null); int count = 0; StripWhiteSpace(tokens); while (tokens.Count > 0) { count++; if (count > 1000) { break; // Limit to 1000 iterations while in development } if (tokens[0].Type == EScriptTokenType.RETURN) { tokens.RemoveAt(0); // Last value in block is returned by default } ScriptToken scriptToken = tokens[0]; if (scriptToken.Type == EScriptTokenType.NAME) { node = new RootScopeMemberNode( new LiteralNode <string>(scriptToken.Value) ); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.ASSIGN) { node = AssignmentNode.Parse(node, scriptToken, tokens); } else if (scriptToken.Type == EScriptTokenType.IF) { node = IfStatementNode.Parse(node, scriptToken, tokens); blockNodes.Add(node); node = null; } else if (scriptToken.Type == EScriptTokenType.FOR) { node = ForStatementNode.Parse(node, scriptToken, tokens); blockNodes.Add(node); node = null; } else if (scriptToken.Type == EScriptTokenType.STRING_LITERAL) { node = new LiteralNode <string>(scriptToken.Value); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.NUMBER_LITERAL) { AstTreeNode _node; if (scriptToken.Value.Contains(".")) { _node = new FloatLiteralNode(scriptToken.Value); } else { _node = new IntegerLiteralNode(scriptToken.Value); } node = _node; tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.PERIOD) { if (tokens[1].Type == EScriptTokenType.NAME) { node = new ScopeMemberNode( node, new LiteralNode <string>(tokens[1].Value) ); tokens.RemoveAt(0); tokens.RemoveAt(0); } } else if (scriptToken.Type == EScriptTokenType.L_BRACKET) { if (node.GetType() == typeof(RootScopeMemberNode)) { // indice } else { node = ArrayNode.Parse(node, scriptToken, tokens); } } else if (scriptToken.Type == EScriptTokenType.L_PAREN) { List <List <ScriptToken> > funcArgs = GetBlockTokens(tokens); List <AstTreeNode> nodes = new List <AstTreeNode>(); ; foreach (List <ScriptToken> arg in funcArgs) { nodes.Add(ProcessTokens(arg)); } node = new FunctionCallNode( node, // Previous node should be a NAME new FunctionArgumentNode(nodes) ); } else if (scriptToken.Type == EScriptTokenType.SEMI_COLON) { if (node != null) { blockNodes.Add(node); } node = null; tokens.RemoveAt(0); } else if (ComparisonNode.Matches(tokens)) { node = ComparisonNode.Parse(node, scriptToken, tokens); } else if (ArithmeticNode.Matches(tokens)) { AstTreeNode _node = ArithmeticNode.Parse(node, scriptToken, tokens); node = _node; } else if (ArithmeticAssignmentNode.Matches(tokens)) { node = ArithmeticAssignmentNode.Parse(node, scriptToken, tokens); } else if (scriptToken.Type == EScriptTokenType.WHITESPACE) { tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.BOOLEAN_LITERAL) { node = new BooleanLiteralNode(tokens[0].Value); tokens.RemoveAt(0); } else if (scriptToken.Type == EScriptTokenType.NULL_LITERAL) { node = new LiteralNode <object>(null); tokens.RemoveAt(0); } else { string code = ScriptTree.ToCode(tokens, 10); Console.WriteLine($"Syntax Error.Near {code}"); } } if (node != null) { blockNodes.Add(node); } return(new BlockNode(blockNodes)); }