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