public virtual void VisitStatement(IStatementNode node) { if (node is CreateTableNode) { VisitCreateTable((CreateTableNode)node); } if (node is CreateViewNode) { VisitCreateView((CreateViewNode)node); } if (node is CreateTriggerNode) { VisitCreateTrigger((CreateTriggerNode)node); } else if (node is SelectStatementNode) { VisitSelect((SelectStatementNode)node); } else if (node is UpdateStatementNode) { VisitUpdate((UpdateStatementNode)node); } else if (node is InsertStatementNode) { VisitInsert((InsertStatementNode)node); } }
private IStatementNode ParseIfNode() { IStatementNode stmt = null; var fstmt = this.ParseSimpleStatementNode(); if (this.TryParseToken(TokenType.Delimiter, ";")) { stmt = fstmt; fstmt = this.ParseSimpleStatementNode(); } var expr = ((ExpressionStatementNode)fstmt).ExpressionNode; var thenCmd = this.ParseStatementBlock(); IStatementNode elseCmd = null; if (this.TryParseName("else")) { elseCmd = this.ParseStatementBlock(); } return(new IfNode(stmt, expr, thenCmd, elseCmd)); }
public void VisitStatement(IStatementNode node) { if (StatementVisitor != null) { node.AcceptStatementVisitor(StatementVisitor); } }
public FuncNode(string name, IList <NameNode> parameters, IStatementNode body, TypeInfo returnType) { this.name = name; this.parameters = parameters; this.body = body; this.returnType = returnType; }
public IfNode(IStatementNode statement, IExpressionNode expression, IStatementNode thenNode, IStatementNode elseNode) { this.statement = statement; this.expression = expression; this.thenCommand = thenNode; this.elseCommand = elseNode; }
public ForNode(IStatementNode initstmt, IExpressionNode expression, IStatementNode poststmt, IStatementNode body) { this.initstmt = initstmt; this.expression = expression; this.poststmt = poststmt; this.body = body; }
public ForNode(VarSetNode varSetNode, ScopedDefineNode defineNode, IExpressionNode expression, IStatementNode statement, BlockNode block, Range range) : base(range) { VarSetNode = varSetNode; DefineNode = defineNode; Expression = expression; Statement = statement; Block = block; }
private IStatementNode ParseSimpleStatementNode(bool canHaveLabel = false) { var token = this.NextToken(); while (token != null && token.Type == TokenType.NewLine) { token = this.NextToken(); } if (token == null) { return(null); } if (token.Type == TokenType.Name) { IStatementNode stmt = this.TryParseNameStatement(token.Value); if (stmt != null) { return(stmt); } } this.PushToken(token); if (token.Type == TokenType.Delimiter && token.Value == "{") { return(this.ParseStatementBlock()); } IExpressionNode node = this.ParseExpressionNode(); if (node == null) { return(null); } AssignmentNode anode = this.TryParseAssignmentNode(node); if (anode != null) { return(anode); } if (this.TryParseToken(TokenType.Operator, "<-")) { var cmdnode = new SendNode(node, this.ParseExpressionNode()); return(cmdnode); } var cmd = new ExpressionStatementNode(node); return(cmd); }
public override Node VisitBlock(DeltinScriptParser.BlockContext context) { IStatementNode[] statements = new IStatementNode[context.statement().Length]; for (int i = 0; i < statements.Length; i++) { statements[i] = (IStatementNode)VisitStatement(context.statement()[i]); } var node = new BlockNode(statements, Range.GetRange(context)); CheckRange(node); return(node); }
protected override void Visit(IStatementNode node) { var trace = (StatementTrace)node; if (isFirstStatementInGroup) { Pad(sb, indent); } sb.Append(node.Text).Append("(").Append(trace.Outcome).Append(")"); foreach (var tracing in trace.Tracings) { sb.AppendLine(); Pad(sb, indent); sb.Append("!").Append(tracing); } sb.AppendLine(); isFirstStatementInGroup = false; }
public override Node VisitFor(DeltinScriptParser.ForContext context) { Node node; BlockNode block = (BlockNode)VisitBlock(context.block()); if (context.IN() != null) { IExpressionNode array = (IExpressionNode)Visit(context.expr()); string variable = context.PART().GetText(); node = new ForEachNode(variable, array, block, Range.GetRange(context)); } else { VarSetNode varSet = null; if (context.varset() != null) { varSet = (VarSetNode)VisitVarset(context.varset()); } ScopedDefineNode defineNode = null; if (context.define() != null) { defineNode = (ScopedDefineNode)VisitDefine(context.define()); } IExpressionNode expression = null; if (context.expr() != null) { expression = (IExpressionNode)VisitExpr(context.expr()); } IStatementNode statement = null; if (context.statement() != null) { statement = (IStatementNode)VisitStatement(context.statement()); } node = new ForNode(varSet, defineNode, expression, statement, block, Range.GetRange(context)); } CheckRange(node); return(node); }
private IStatementNode ParseForNode() { if (this.TryPeekToken(TokenType.Delimiter, "{")) { return(new ForNode(null, null, null, this.ParseStatementBlock())); } IExpressionNode expr = null; if (this.TryParseToken(TokenType.Delimiter, ";")) { expr = this.ParseExpressionNode(); this.ParseToken(TokenType.Delimiter, ";"); if (this.TryPeekToken(TokenType.Delimiter, "{")) { return(new ForNode(null, expr, null, this.ParseStatementBlock())); } IStatementNode poststmt = this.ParseSimpleStatementNode(); return(new ForNode(null, expr, poststmt, this.ParseStatementBlock())); } IStatementNode initstmt = this.ParseSimpleStatementNode(); if (this.TryParseToken(TokenType.Delimiter, ";")) { expr = this.ParseExpressionNode(); this.ParseToken(TokenType.Delimiter, ";"); IStatementNode poststmt = null; if (!this.TryPeekToken(TokenType.Delimiter, "{")) { poststmt = this.ParseSimpleStatementNode(); } return(new ForNode(initstmt, expr, poststmt, this.ParseStatementBlock())); } expr = ((ExpressionStatementNode)initstmt).ExpressionNode; return(new ForNode(expr, this.ParseStatementBlock())); }
public void AppendStatement(IStatementNode newStatement) { _statements.Add(newStatement); }
public virtual void visit(IStatementNode value) { }
public IfNode(IExpressionNode expression, IStatementNode block) : this(null, expression, block) { }
public LabelNode(string label, IStatementNode statement) { this.label = label; this.statement = statement; }
public IfNode(IStatementNode statement, IExpressionNode expression, IStatementNode thenNode) : this(statement, expression, thenNode, null) { }
public ForNode(IExpressionNode expression, IStatementNode body) : this(null, expression, null, body) { }
public virtual void visit(IStatementNode value) { }
protected override void Visit(IStatementNode node) { linker.Link((StatementNode)node, scopes.Peek(), false); }
//перевод statement-а private void ConvertStatement(IStatementNode value) { make_next_spoint = true; if (save_debug_info /*&& !(value is IForNode)*/) MarkSequencePoint(value.Location); make_next_spoint = false; value.visit(this); make_next_spoint = true; //нужно для очистки стека после вызова функции в качестве процедуры //ssyy добавил //если вызов конструктора предка, то стек не очищаем if (!( (value is IFunctionCallNode) && ((IFunctionCallNode)value).last_result_function_call || (value is ICompiledConstructorCall) && !((ICompiledConstructorCall)value).new_obj_awaited() || (value is ICommonConstructorCall) && !((ICommonConstructorCall)value).new_obj_awaited() )) //\ssyy if ((value is IFunctionCallNode) && !(value is IBasicFunctionCallNode)) { IFunctionCallNode fc = value as IFunctionCallNode; if (fc.function.return_value_type != null) { ICompiledTypeNode ct = fc.function.return_value_type as ICompiledTypeNode; if ((ct == null) || (ct != null && (ct.compiled_type != TypeFactory.VoidType))) il.Emit(OpCodes.Pop); } } }
public void VisitStatement(IStatementNode node) { _visitor.Visit(node); }
private bool BeginOnForNode(IStatementNode value) { //if (value is IForNode) return true; IStatementsListNode stats = value as IStatementsListNode; if (stats == null) return false; if (stats.statements.Length == 0) return false; //if (stats.statements[0] is IForNode) return true; return false; }
//перевод тела private void ConvertBody(IStatementNode body) { if (!(body is IStatementsListNode) && save_debug_info && body.Location != null) if (body.Location.begin_line_num == 0xFFFFFF) MarkSequencePoint(il, body.Location); body.visit(this); OptMakeExitLabel(); }
protected virtual void Visit(IStatementNode node) { }
public void VisitStatement(IStatementNode node) { node.AcceptStatementVisitor(this); }
protected virtual void VisitDefaultStatement(IStatementNode node) { }
protected override void Visit(IStatementNode node) { Pad(sb, indent); sb.Append(node.Text); sb.Append("\r\n"); }
public virtual void VisitStatement(IStatementNode node) { if (node is CreateTableNode) VisitCreateTable((CreateTableNode) node); if (node is CreateViewNode) VisitCreateView((CreateViewNode) node); if (node is CreateTriggerNode) { VisitCreateTrigger((CreateTriggerNode) node); } else if (node is SelectStatementNode) { VisitSelect((SelectStatementNode) node); } else if (node is UpdateStatementNode) { VisitUpdate((UpdateStatementNode) node); } else if (node is InsertStatementNode) { VisitInsert((InsertStatementNode) node); } }
public void visit(IStatementNode value) { // abstract ISemanticNodeConverter.SourceTextBuilder.AddNodeInToStack(""); }
public void visit(IStatementNode value) { }
public static BlockNode ToBlock(IStatementNode stmt) => new BlockNode().Return(x => x.Statements.Add(stmt)).R(stmt);
void ParseStatement(ScopeGroup scope, IStatementNode statement, Var returnVar, bool isLast) { switch (statement) { // Method case MethodNode methodNode: Element method = ParseMethod(scope, methodNode, false); if (method != null) { Actions.Add(method); } return; // Variable set case VarSetNode varSetNode: ParseVarset(scope, varSetNode); return; // For case ForEachNode forEachNode: { ContinueSkip.Setup(); // The action the for loop starts on. int forActionStartIndex = Actions.Count() - 1; ScopeGroup forGroup = scope.Child(); // Create the for's temporary variable. DefinedVar forTempVar = VarCollection.AssignDefinedVar( scopeGroup: forGroup, name: forEachNode.Variable, isGlobal: IsGlobal, range: forEachNode.Range ); // Reset the counter. Actions.Add(forTempVar.SetVariable(new V_Number(0))); // Parse the for's block. ParseBlock(forGroup, forEachNode.Block, false, returnVar); // Add the for's finishing elements Actions.Add(forTempVar.SetVariable( // Indent the index by 1. Element.Part <V_Add> ( forTempVar.GetVariable(), new V_Number(1) ) )); ContinueSkip.SetSkipCount(forActionStartIndex); // The target array in the for statement. Element forArrayElement = ParseExpression(scope, forEachNode.Array); Actions.Add(Element.Part <A_LoopIf>( // Loop if the for condition is still true. Element.Part <V_Compare> ( forTempVar.GetVariable(), EnumData.GetEnumValue(Operators.LessThan), Element.Part <V_CountOf>(forArrayElement) ) )); ContinueSkip.ResetSkip(); return; } // For case ForNode forNode: { ContinueSkip.Setup(); // The action the for loop starts on. int forActionStartIndex = Actions.Count() - 1; ScopeGroup forGroup = scope.Child(); // Set the variable if (forNode.VarSetNode != null) { ParseVarset(scope, forNode.VarSetNode); } if (forNode.DefineNode != null) { ParseDefine(scope, forNode.DefineNode); } // Parse the for's block. ParseBlock(forGroup, forNode.Block, false, returnVar); Element expression = null; if (forNode.Expression != null) { expression = ParseExpression(forGroup, forNode.Expression); } // Check the expression if (forNode.Expression != null) // If it has an expression { // Parse the statement if (forNode.Statement != null) { ParseStatement(forGroup, forNode.Statement, returnVar, false); } ContinueSkip.SetSkipCount(forActionStartIndex); Actions.Add(Element.Part <A_LoopIf>(expression)); } // If there is no expression but there is a statement, parse the statement. else if (forNode.Statement != null) { ParseStatement(forGroup, forNode.Statement, returnVar, false); ContinueSkip.SetSkipCount(forActionStartIndex); // Add the loop Actions.Add(Element.Part <A_Loop>()); } ContinueSkip.ResetSkip(); return; } // While case WhileNode whileNode: { ContinueSkip.Setup(); // The action the while loop starts on. int whileStartIndex = Actions.Count() - 2; ScopeGroup whileGroup = scope.Child(); ParseBlock(whileGroup, whileNode.Block, false, returnVar); ContinueSkip.SetSkipCount(whileStartIndex); // Add the loop-if Element expression = ParseExpression(scope, whileNode.Expression); Actions.Add(Element.Part <A_LoopIf>(expression)); ContinueSkip.ResetSkip(); return; } // If case IfNode ifNode: { A_SkipIf if_SkipIf = new A_SkipIf(); Actions.Add(if_SkipIf); var ifScope = scope.Child(); // Parse the if body. ParseBlock(ifScope, ifNode.IfData.Block, false, returnVar); // Determines if the "Skip" action after the if block will be created. // Only if there is if-else or else statements. bool addIfSkip = ifNode.ElseIfData.Length > 0 || ifNode.ElseBlock != null; // Update the initial SkipIf's skip count now that we know the number of actions the if block has. // Add one to the body length if a Skip action is going to be added. if_SkipIf.ParameterValues = new IWorkshopTree[] { Element.Part <V_Not>(ParseExpression(scope, ifNode.IfData.Expression)), new V_Number(Actions.Count - 1 - Actions.IndexOf(if_SkipIf) + (addIfSkip ? 1 : 0)) }; // Create the "Skip" action. A_Skip if_Skip = new A_Skip(); if (addIfSkip) { Actions.Add(if_Skip); } // Parse else-ifs A_Skip[] elseif_Skips = new A_Skip[ifNode.ElseIfData.Length]; // The ElseIf's skips for (int i = 0; i < ifNode.ElseIfData.Length; i++) { // Create the SkipIf action for the else if. A_SkipIf elseif_SkipIf = new A_SkipIf(); Actions.Add(elseif_SkipIf); // Parse the else-if body. var elseifScope = scope.Child(); ParseBlock(elseifScope, ifNode.ElseIfData[i].Block, false, returnVar); // Determines if the "Skip" action after the else-if block will be created. // Only if there is additional if-else or else statements. bool addIfElseSkip = i < ifNode.ElseIfData.Length - 1 || ifNode.ElseBlock != null; // Set the SkipIf's parameters. elseif_SkipIf.ParameterValues = new IWorkshopTree[] { Element.Part <V_Not>(ParseExpression(scope, ifNode.ElseIfData[i].Expression)), new V_Number(Actions.Count - 1 - Actions.IndexOf(elseif_SkipIf) + (addIfElseSkip ? 1 : 0)) }; // Create the "Skip" action for the else-if. if (addIfElseSkip) { elseif_Skips[i] = new A_Skip(); Actions.Add(elseif_Skips[i]); } } // Parse else body. if (ifNode.ElseBlock != null) { var elseScope = scope.Child(); ParseBlock(elseScope, ifNode.ElseBlock, false, returnVar); } // Replace dummy skip with real skip now that we know the length of the if, if-else, and else's bodies. // Replace if's dummy. if_Skip.ParameterValues = new IWorkshopTree[] { new V_Number(Actions.Count - 1 - Actions.IndexOf(if_Skip)) }; // Replace else-if's dummy. for (int i = 0; i < elseif_Skips.Length; i++) { if (elseif_Skips[i] != null) { elseif_Skips[i].ParameterValues = new IWorkshopTree[] { new V_Number(Actions.Count - 1 - Actions.IndexOf(elseif_Skips[i])) }; } } return; } // Return case ReturnNode returnNode: if (returnNode.Value != null) { Element result = ParseExpression(scope, returnNode.Value); if (returnVar != null) { Actions.Add(returnVar.SetVariable(result)); } } if (!isLast) { A_Skip returnSkip = new A_Skip(); Actions.Add(returnSkip); ReturnSkips.Add(returnSkip); } return; // Define case ScopedDefineNode defineNode: ParseDefine(scope, defineNode); return; } }
private bool contains_only_if(IStatementNode stmt) { return stmt is IIfNode || stmt is ISwitchNode || stmt is IStatementsListNode && (stmt as IStatementsListNode).statements.Length == 1 && ((stmt as IStatementsListNode).statements[0] is IIfNode || (stmt as IStatementsListNode).statements[0] is ISwitchNode); }
public IStatementNode AppendStatement(IStatementNode statement) { statement.Parent = this; _statements.Add(statement); return(statement); }