public override async Task WalkAsync(PythonWalkerAsync walker, CancellationToken cancellationToken = default) { if (await walker.WalkAsync(this, cancellationToken)) { if (Test != null) { await Test.WalkAsync(walker, cancellationToken); } if (Body != null) { await Body.WalkAsync(walker, cancellationToken); } if (ElseStatement != null) { await ElseStatement.WalkAsync(walker, cancellationToken); } } await walker.PostWalkAsync(this, cancellationToken); }
public override string ToCode() { var ret = "version"; if (VersionIdentifierOrLiteral != null) { ret += '(' + VersionIdentifierOrLiteral.ToString() + ')'; } if (ScopedStatement != null) { ret += ' ' + ScopedStatement.ToCode(); } if (ElseStatement != null) { ret += " else " + ElseStatement.ToCode(); } return(ret); }
public static CodeLine BuildCodeLine(string filename, int linenr, string codeline) { CodeLine result = null; Match m = line_regex.Match(codeline); if (m.Success) { string sCommand = m.Groups["command"].Value; int pos = m.Length; switch (sCommand) { case DoStatement.keyword: result = new DoStatement(linenr, m, codeline); break; case WhileStatement.keyword: result = new WhileStatement(linenr, m, codeline); break; case IfStatement.keyword: result = new IfStatement(linenr, m, codeline); break; case ElseStatement.keyword: result = new ElseStatement(linenr, m, codeline); break; case ElseIfStatement.keyword: result = new ElseIfStatement(linenr, m, codeline); break; case EndIfStatement.keyword: result = new EndIfStatement(linenr, m, codeline); break; case ErrorMessage.keyword: result = new ErrorMessage(linenr, m, codeline); break; case InfoMessage.keyword: result = new InfoMessage(linenr, m, codeline); break; case LoopStatement.keyword: result = new LoopStatement(linenr, m, codeline); break; case BreakStatement.keyword: result = new BreakStatement(linenr, m, codeline); break; case ReturnStatement.keyword: result = new ReturnStatement(linenr, m, codeline); break; case ExitStatement.keyword: result = new ExitStatement(linenr, m, codeline); break; case VarDeclaration.keyword: result = new VarDeclaration(linenr, m, codeline); break; case GlobalVarDeclaration.keyword: result = new GlobalVarDeclaration(linenr, m, codeline); break; case FunctionDeclaration.keyword: result = new FunctionDeclaration(linenr, m, codeline); break; case EndFunctionDeclaration.keyword: result = new EndFunctionDeclaration(linenr, m, codeline); break; case Include.keyword: result = new Include(linenr, m, codeline); break; } } // Misschien is het een comment? if (result == null) { m = cmmt_regex.Match(codeline); if (m.Success) { result = new Comment(linenr, m, codeline); } } if (result == null) { m = ass_regex.Match(codeline); if (m.Success) { result = new Assignment(linenr, m, codeline); } } if (result == null) { m = vfc_regex.Match(codeline); if (m.Success) { result = new VoidFunctionCall(linenr, m, codeline); } } if (result == null && codeline.Trim() == "@") { m = cmm2_regex.Match(codeline); if (m.Success) { result = new Comment(linenr, m, codeline); } } if (result == null) { // Anders zal het een gewone tekst regel zijn? Met evt een paar expressies erin result = new CodeLine(linenr, codeline); } result._filename = filename; return(result); }
public override object VisitAsmline(Z80AsmParser.AsmlineContext context) { CurrentLabel = null; CurrentLabelColon = false; CurrentComment = null; LabelSpan = null; KeywordSpan = null; CommentSpan = null; IssueToEmit = null; IsFieldAssignment = false; NumberSpans = null; IdentifierSpans = null; StringSpans = null; FunctionSpans = null; SemiVarSpans = null; MacroParamSpans = null; MacroParamNames = null; SemiVarSpans = null; StatementSpans = null; OperandSpans = null; MnemonicSpans = null; if (context?.Start == null || context.Stop == null) { return(null); } var startIndex = context.start.StartIndex; var stopIndex = context.stop.StopIndex; CurrentSourceText = InputStream.GetText(new Interval(startIndex, stopIndex)); CurrentSourceLine = context.Start.Line; FirstColumn = context.Start.Column; FirstPosition = context.Start.StartIndex; LastPosition = context.Stop.StopIndex; object mainInstructionPart = null; // --- Obtain label var labelCtx = context.label(); if (labelCtx != null) { CurrentLabel = labelCtx.GetChild(0).NormalizeToken(); CurrentLabelColon = labelCtx.COLON() != null; LabelSpan = new TextSpan(labelCtx.Start.StartIndex, labelCtx.Start.StopIndex + 1); } // --- Obtain line body/directive var lineBodyCtx = context.lineBody(); if (lineBodyCtx != null) { // --- Special case, when a macro parameters is used as the main line LastInstructionPos = lineBodyCtx.Stop.StopIndex; var macroParamCtx = lineBodyCtx.macroParam(); if (macroParamCtx != null) { VisitMacroParam(macroParamCtx); mainInstructionPart = new MacroParamLine(macroParamCtx.IDENTIFIER()?.NormalizeToken()); } else { mainInstructionPart = VisitLineBody(context.lineBody()); } } else if (context.directive() != null) { mainInstructionPart = VisitDirective(context.directive()); } // --- Obtain comment if (context.comment() != null) { var commentCtx = context.comment(); CurrentComment = commentCtx.GetText(); CommentSpan = new TextSpan(commentCtx.Start.StartIndex, commentCtx.Stop.StopIndex + 1); } // --- Now, we have every part of the line, and create some special main instruction part if (context.exception != null) { mainInstructionPart = new ParserErrorLine(); } else if (mainInstructionPart == null && (CurrentLabel != null || CurrentComment != null)) { mainInstructionPart = new NoInstructionLine(); if (CurrentLabel != null && !CurrentLabelColon) { var statementFound = true; switch (CurrentLabel.ToLower()) { case "continue": mainInstructionPart = new ContinueStatement(); break; case "break": mainInstructionPart = new BreakStatement(); break; case "endm": case "mend": mainInstructionPart = new MacroEndStatement(); break; case "endl": case "lend": mainInstructionPart = new LoopEndStatement(); break; case "proc": mainInstructionPart = new ProcStatement(); break; case "endp": case "pend": mainInstructionPart = new ProcEndStatement(); break; case "repeat": mainInstructionPart = new RepeatStatement(); break; case "endw": case "wend": mainInstructionPart = new WhileEndStatement(); break; case "ends": mainInstructionPart = new StructEndStatement(); break; case "else": mainInstructionPart = new ElseStatement(); break; case "endif": mainInstructionPart = new IfEndStatement(); break; default: statementFound = false; break; } if (statementFound) { KeywordSpan = new TextSpan(context.Start.StartIndex, context.Start.StopIndex + 1); CurrentLabel = null; } } } return(mainInstructionPart is SourceLineBase sourceLine ? AddLine(sourceLine, context) : mainInstructionPart); }
public void Evaluate(List <Step> evaluationSteps) { for (int index = 0; index < evaluationSteps.Count; index++) { Step evalStep = evaluationSteps[index]; // .Type() can only be "VAR_DECLARE", "VAR_CHANGE", "FUNC_CALL", "IF_STATEMENT", "WHILE_LOOP" // It could also be "ELSE_STATEMENT", but we should only check for that DIRECTLY after an IF_STATEMENT if (evalStep.Type().Equals("IF_STATEMENT")) { // Evaluate if statement - contains OPERAND1, OPERAND2, COMPARISON, codeBlockContents IfStatement ifState = (IfStatement)evalStep; // Cast as we know it is now an IfStatement obj bool conditionResult = CompareExpressions(ifState.GetOp1(), ifState.GetOp2(), ifState.GetComparator()); bool hasElse = index + 1 < evaluationSteps.Count && evaluationSteps[index + 1].Type().Equals("ELSE_STATEMENT"); // No chance of index out of range error as set to False before reaching it if (conditionResult) // If the 'IfStatement' condition is TRUE { Evaluate(ifState.GetCBContents()); // 'run' the contents of the if statement - this is RECURSIVE if (hasElse) { evaluationSteps.RemoveAt(index + 1); } // If we have an ELSE_STATEMENT after this, we need to remove it as the IF_STATEMENT has triggered (therefore the ELSE will not be triggered). } else if (hasElse) { // If the CONDITION is FALSE and the next Step obj is an ELSE_STATEMENT type ElseStatement elseState = (ElseStatement)evaluationSteps[index + 1]; // Cast to else Evaluate(elseState.GetCBContents()); // 'run' the contents of the else (RECURSION) evaluationSteps.RemoveAt(index + 1); // Remove ELSE_STATEMENT as we have used it and do not want to go over it again. } } else if (evalStep.Type().Equals("WHILE_LOOP")) { WhileLoop whileLoop = (WhileLoop)evalStep; // Similar to if statement evaluation though no need to set a 'condition' variable because that condition may change // Basically just reusing the C# while loop with the template of the Interpreted one while (CompareExpressions(whileLoop.GetOp1(), whileLoop.GetOp2(), whileLoop.GetComparator())) { // While the condition is true, evaluate code inside Evaluate(whileLoop.GetCBContents()); } } else if (evalStep.Type().Equals("VAR_DECLARE")) // Declare a variable in the variableScope { VarDeclare varDecl = (VarDeclare)evalStep; // Cast as we know it's a VarDeclare obj if (variableScope.ContainsKey(varDecl.GetName())) { throw new DeclareError(); } // If scope already has a variable that name, you cannot redeclare it as it already exists. // Potential endpoint if variable exists - entire program will stop (crash). Token varExpr = ResolveExpression(varDecl.Value()); if (!varExpr.Type().Equals(varDecl.GetVarType())) { throw new TypeError(); } // Value of variable does not match type with declared one. e.g 'int x = "Hello";' variableScope.Add(varDecl.GetName(), varExpr); // Type of variable can be found out by the .Type() of the key's Token. // e.g 'int x = 1 + 2;' // if we want to find variable 'x' type, we find variableScope[x].Type() which will return 'number', with variableScope[x].Value() being '3' } else if (evalStep.Type().Equals("VAR_CHANGE")) // Change a pre-existing variable { VarChange varChan = (VarChange)evalStep; // Cast as we know it is a VarChange obj if (!variableScope.ContainsKey(varChan.GetName())) { throw new ReferenceError(); } // If variable is NOT in the variableScope then we cannot change it as it doesn't exist. // Potential endpoint for program crash string varType = variableScope[varChan.GetName()].Type(); Token newValue = ResolveExpression(varChan.Value()); if (!varType.Equals(newValue.Type())) { throw new TypeError(); } // If the new value of the variable is not the right type, then crash. // Potential endpoint // e.g int x = 0; x = "hi"; will cause this error variableScope[varChan.GetName()] = newValue; // Assign new value (Token) } else if (evalStep.Type().Equals("FUNC_CALL")) // Call a function { FuncCall functionCall = (FuncCall)evalStep; // Cast as we know it is a FuncCall obj now if (!functionCall.GetName().Equals("inputstr") && !functionCall.GetName().Equals("inputint")) // If NOT calling 'input' function { CallFunction(functionCall.GetName(), ResolveExpression(functionCall.GetArguments())); // Call function with name and *resolved* list of arguments // Resolve function always outputs a single token which is the result of an expression (list of tokens) being evaluated } else // SPECIAL CASE: Calling inputStr or inputInt functions indicates that the 'argument' is NOT an expression to be resolved, but rather a variable name to store input value in. // This means functionCall.Argumnets() will only have 1 token: { CallFunction(functionCall.GetName(), functionCall.GetArguments()[0]); // Pass in first value in Arguments as there only should be one - the variable to be input to } } else { throw new SyntaxError(); // Unrecognised Step, crash program. } } }
public override XElement ToXML() { var conditionXml = new XElement("Condition"); if (IsComparison) { if (IsComparisonToConstant) { conditionXml.Add(new XElement("Type", "ComparisonToConstant")); } else if (IsComparisonToVariable) { conditionXml.Add(new XElement("Type", "ComparisonToVariable")); } if (this.SelectedVariable != null && this.SelectedVariable.LinkedVariable != null) { conditionXml.Add(new XElement("Left", this.SelectedVariable.LinkedVarId)); } if (this.IsEquals) { conditionXml.Add(new XElement("Comparison", "EQ")); } else if (this.IsNotEquals) { conditionXml.Add(new XElement("Comparison", "NEQ")); } else if (this.IsLessThan) { conditionXml.Add(new XElement("Comparison", "LT")); } else if (this.IsLessThanOrEqualTo) { conditionXml.Add(new XElement("Comparison", "LTE")); } else if (this.IsGreaterThan) { conditionXml.Add(new XElement("Comparison", "GT")); } else if (this.IsGreaterThanOrEqualTo) { conditionXml.Add(new XElement("Comparison", "GTE")); } if (this.IsComparisonToVariable && this.VariableToCompare != null && this.VariableToCompare.LinkedVariable != null) { conditionXml.Add(new XElement("Right", this.VariableToCompare.LinkedVarId)); if (this.IsDateTime) { conditionXml.Add(new XElement("VarType", "DateTime")); } else if (this.IsNumber) { conditionXml.Add(new XElement("VarType", "Number")); } else if (this.IsString) { conditionXml.Add(new XElement("VarType", "String")); } } if (this.IsComparisonToConstant) { if (this.IsDateTime) { conditionXml.Add(new XElement("Right", this.DateTimeToCompareTo.ToString())); conditionXml.Add(new XElement("VarType", "DateTime")); } else if (this.IsNumber) { conditionXml.Add(new XElement("Right", this.NumberToCompareTo.ToString())); conditionXml.Add(new XElement("VarType", "Number")); } else if (this.IsString) { conditionXml.Add(new XElement("Right", this.StringToCompareTo)); conditionXml.Add(new XElement("VarType", "String")); } } } if (ItemIsNotNull) { conditionXml.Add(new XElement("Type", "ItemIsNotNull")); conditionXml.Add(new XElement("VarRef", this.SelectedVariable.LinkedVarId)); } if (ItemIsClass) { conditionXml.Add(new XElement("Type", "ItemIsClass")); conditionXml.Add(new XElement("VarRef", this.SelectedVariable.LinkedVarId)); conditionXml.Add(new XElement("ClassName", this.SelectedClassName)); } if (PlayerHasItem) { conditionXml.Add(new XElement("Type", "PlayerHasItem")); conditionXml.Add(new XElement("ItemRef", this.SelectedItem.LinkedItemId)); } return(new XElement("If", conditionXml, new XElement("Then", ThenStatement.ToXML()), new XElement("Else", ElseStatement.ToXML()))); }
private void CheckStatementCurlyBracketPlacement(Element element, Statement statement) { Param.AssertNotNull(element, "element"); Param.AssertNotNull(statement, "statement"); switch (statement.StatementType) { case StatementType.Else: // Check that there is nothing between the starting else keyword and the opening bracket. this.CheckChainedStatementCurlyBracketPlacement(element, statement); this.CheckBlockStatementsCurlyBracketPlacement(element, statement); // Check that there is nothing between the closing bracket and the else keyword of the attached else statement. ElseStatement elseStatement = (ElseStatement)statement; if (elseStatement.AttachedElseStatement != null) { this.CheckTrailingStatementCurlyBracketPlacement(element, statement); } break; case StatementType.Catch: case StatementType.Finally: // Check that there is nothing between the starting catch or finally keyword and the opening bracket. this.CheckChainedStatementCurlyBracketPlacement(element, statement); this.CheckBlockStatementsCurlyBracketPlacement(element, statement); break; case StatementType.If: this.CheckBlockStatementsCurlyBracketPlacement(element, statement); // Check that there is nothing between the closing bracket and the else keyword of the attached else statement. IfStatement ifStatement = (IfStatement)statement; if (ifStatement.AttachedElseStatement != null) { this.CheckTrailingStatementCurlyBracketPlacement(element, statement); } break; case StatementType.Try: // Check that there is nothing between the starting try keyword and the opening bracket. this.CheckBlockStatementsCurlyBracketPlacement(element, statement); TryStatement tryStatement = (TryStatement)statement; if (tryStatement.FinallyStatement != null || (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0)) { // There is something attached to the end of this try statement. Check that there is nothing between // the closing bracket of the try statement and the start of the attached statement. this.CheckTrailingStatementCurlyBracketPlacement(element, tryStatement); } if (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0) { CatchStatement[] catchStatementArray = new CatchStatement[tryStatement.CatchStatements.Count]; tryStatement.CatchStatements.CopyTo(catchStatementArray, 0); for (int i = 0; i < catchStatementArray.Length; ++i) { if (catchStatementArray.Length > i + 1 || tryStatement.FinallyStatement != null) { // There is something attached to the end of this catch statement, either another catch or a finally. // Check that there is nothing between the closing bracket of this catch statement and the start of the attached // statement. this.CheckTrailingStatementCurlyBracketPlacement(element, catchStatementArray[i]); } } } break; case StatementType.Checked: case StatementType.Fixed: case StatementType.For: case StatementType.Foreach: case StatementType.Lock: case StatementType.Switch: case StatementType.Unchecked: case StatementType.Unsafe: case StatementType.Using: case StatementType.While: // Check that there is nothing between the starting keyword and the opening bracket. this.CheckBlockStatementsCurlyBracketPlacement(element, statement); break; case StatementType.DoWhile: this.CheckBlockStatementsCurlyBracketPlacement(element, statement); this.CheckTrailingStatementCurlyBracketPlacement(element, statement); break; default: break; } }
protected abstract void VisitElse(ElseStatement statement);
public void Visit(ElseStatement l) { _level -= _templatetabs; Format(l); _level += _templatetabs; }
public void Visit(ElseStatement l) { VisitStatementComment(l); }