public void Visit(PyAst.SuiteStatement node) { foreach (var stmt in node.Statements) { Visit(stmt); } }
private static mod ConvertToAST(SuiteStatement suite, string kind) { ContractUtils.RequiresNotNull(suite, "suite"); ContractUtils.RequiresNotNull(kind, "kind"); switch (kind) { case "exec": return new Module(suite); case "eval": return new Expression(suite); case "single": return new Interactive(suite); default: throw new ArgumentException("kind must be 'exec' or 'eval' or 'single'"); } }
private string FindSelfNames() { SuiteStatement stmts = Body as SuiteStatement; if (stmts == null) { return(""); } foreach (Statement stmt in stmts.Statements) { if (stmt is FunctionDefinition def && def.Name == "__init__") { return(string.Join(",", SelfNameFinder.FindNames(def))); } } return(""); }
public override bool Walk(SuiteStatement node) { node.Parent = _currentScope; return base.Walk(node); }
public override bool Walk(SuiteStatement node) { var parent = Parent(); CommonWalk(node); BeginScopeLevel(); if (!(parent is ClassDefinition)) { BeginIndent(); } if (parent is ForStatement) { ForStatement fors = (ForStatement)parent; if (fors.Else == node) { BeginIndent(); } } if (parent is WhileStatement) { WhileStatement whiles = (WhileStatement)parent; if (whiles.ElseStatement == node) { BeginIndent(); } } return true; }
// SuiteStatement public override bool Walk(SuiteStatement node) { node.Parent = _currentScope; return(base.Walk(node)); }
//simple_stmt: small_stmt (';' small_stmt)* [';'] Newline private Statement ParseSimpleStmt() { Statement s = ParseSmallStmt(); if (MaybeEat(TokenKind.Semicolon)) { SourceLocation start = s.Start; List<Statement> l = new List<Statement>(); l.Add(s); while (true) { if (MaybeEat(TokenKind.NewLine)) break; l.Add(ParseSmallStmt()); if (!MaybeEat(TokenKind.Semicolon)) { Eat(TokenKind.NewLine); break; } if (MaybeEat(TokenKind.EndOfFile)) break; // error recovery } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(start, GetEnd()); return ret; } else { if(!Eat(TokenKind.NewLine)) { // error handling, make sure we're making forward progress NextToken(); } return s; } }
public override void PostWalk(SuiteStatement node) { var tmp = tree.Pop(); bool isClassSuite = tree.Peek() is ClassDefinition; tree.Push(tmp); if (!isClassSuite) { List<string> statements = new List<string>(); for (int i = 0; i < node.Statements.Count; i++) { if (node.Statements[i] is ImportStatement) { continue; } string c = Content(); if (!String.IsNullOrWhiteSpace(c)) { statements.Add(c); } } statements.Reverse(); if (statements.Count > 0) { Content(String.Join("\n", statements)); } else { Content(""); } } var parent = Parent(); if (!(parent is ClassDefinition)) { EndIndent(); } EndScopeLevel(); CommonPostWalk(node, true); if (parent is ForStatement) { ForStatement fors = (ForStatement)parent; if (fors.Else == node) { EndIndent(); } } if (parent is WhileStatement) { WhileStatement whiles = (WhileStatement)parent; if (whiles.ElseStatement == node) { EndIndent(); } } }
internal Module(SuiteStatement suite) : this() { _body = ConvertStatements(suite); }
//simple_stmt: small_stmt (';' small_stmt)* [';'] Newline private Statement ParseSimpleStmt() { Statement s = ParseSmallStmt(); if (MaybeEat(TokenKind.Semicolon)) { Location start = s.Start; List<Statement> l = new List<Statement>(); l.Add(s); while (true) { if (MaybeEat(TokenKind.NewLine)) break; l.Add(ParseSmallStmt()); if (!MaybeEat(TokenKind.Semicolon)) { Eat(TokenKind.NewLine); break; } if (MaybeEat(TokenKind.EndOfFile)) break; // error recovery } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(GetExternal(), start, GetEnd()); return ret; } else { Eat(TokenKind.NewLine); return s; } }
public static string Format(SuiteStatement node) { return(string.Join("\r\n", node.Statements.Select(s => Format(s)).ToArray())); }
//suite: simple_stmt NEWLINE | Newline INDENT stmt+ DEDENT private Statement ParseSuite() { if (!EatNoEof(TokenKind.Colon)) { // improve error handling... return ErrorStmt(); } TokenWithSpan cur = _lookahead; List<Statement> l = new List<Statement>(); // we only read a real NewLine here because we need to adjust error reporting // for the interpreter. if (MaybeEat(TokenKind.NewLine)) { CheckSuiteEofError(cur); // for error reporting we track the NL tokens and report the error on // the last one. This matches CPython. cur = _lookahead; while (PeekToken(TokenKind.NLToken)) { cur = _lookahead; NextToken(); } if (!MaybeEat(TokenKind.Indent)) { // no indent? report the indentation error. if (cur.Token.Kind == TokenKind.Dedent) { ReportSyntaxError(_lookahead.Span.Start, _lookahead.Span.End, "expected an indented block", ErrorCodes.SyntaxError | ErrorCodes.IncompleteStatement); } else { ReportSyntaxError(cur, ErrorCodes.IndentationError); } return ErrorStmt(); } while (true) { Statement s = ParseStmt(); l.Add(s); if (MaybeEat(TokenKind.Dedent)) break; if (PeekToken().Kind == TokenKind.EndOfFile) { ReportSyntaxError("unexpected end of file"); break; // error handling } } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(_globalParent, stmts[0].StartIndex, stmts[stmts.Length - 1].EndIndex); return ret; } else { // simple_stmt NEWLINE // ParseSimpleStmt takes care of the NEWLINE Statement s = ParseSimpleStmt(); return s; } }
public override bool Walk(SuiteStatement node) { return !FoundSlots; }
public override bool Walk(SuiteStatement node) { return true; }
public virtual void PostWalk(SuiteStatement node) { }
// SuiteStatement public virtual bool Walk(SuiteStatement node) { return true; }
//suite: simple_stmt NEWLINE | Newline INDENT stmt+ DEDENT private Statement ParseSuite() { EatNoEof(TokenKind.Colon); Location start = GetStart(); List<Statement> l = new List<Statement>(); if (MaybeEat(TokenKind.NewLine)) { if (!MaybeEat(TokenKind.Indent)) { ReportSyntaxError(NextToken(), ErrorCodes.IndentationError); } while (true) { Statement s = ParseStmt(); l.Add(s); if (MaybeEat(TokenKind.Dedent)) break; if (MaybeEat(TokenKind.EndOfFile)) break; // error recovery } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(GetExternal(), start, GetEnd()); return ret; } else { // simple_stmt NEWLINE // ParseSimpleStmt takes care of the NEWLINE Statement s = ParseSimpleStmt(); return s; } }
internal Expression(SuiteStatement suite) : this() { _body = Convert(((ExpressionStatement)suite.Statements[0]).Expression); }
//simple_stmt: small_stmt (';' small_stmt)* [';'] Newline private Statement ParseSimpleStmt() { Statement s = ParseSmallStmt(); if (MaybeEat(TokenKind.Semicolon)) { var start = s.StartIndex; List<Statement> l = new List<Statement>(); l.Add(s); while (true) { if (MaybeEatNewLine() || MaybeEat(TokenKind.EndOfFile)) { break; } l.Add(ParseSmallStmt()); if (MaybeEat(TokenKind.EndOfFile)) { // implies a new line break; } else if (!MaybeEat(TokenKind.Semicolon)) { EatNewLine(); break; } } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(_globalParent, start, stmts[stmts.Length - 1].EndIndex); return ret; } else if (!MaybeEat(TokenKind.EndOfFile) && !EatNewLine()) { // error handling, make sure we're making forward progress NextToken(); } return s; }
internal Interactive(SuiteStatement suite) : this() { _body = ConvertStatements(suite); }
public override bool Walk(SuiteStatement node) { writer.WriteLine("Suite"); return base.Walk(node); }
public void PostWalk(SuiteStatement node) { PostProcess(node); }
//single_input: Newline | simple_stmt | compound_stmt Newline //eval_input: testlist Newline* ENDMARKER //file_input: (Newline | stmt)* ENDMARKER public Statement ParseFileInput() { List<Statement> l = new List<Statement>(); // // A future statement must appear near the top of the module. // The only lines that can appear before a future statement are: // - the module docstring (if any), // - comments, // - blank lines, and // - other future statements. // while (MaybeEat(TokenKind.NewLine)) ; if (PeekToken(TokenKind.Constant)) { Statement s = ParseStmt(); l.Add(s); fromFutureAllowed = false; if (s is ExpressionStatement) { ConstantExpression ce = ((ExpressionStatement)s).Expression as ConstantExpression; if (ce != null && ce.Value is string) { // doc string fromFutureAllowed = true; } } } while (MaybeEat(TokenKind.NewLine)) ; // from __future__ if (fromFutureAllowed) { while (PeekToken(Tokens.KeywordFromToken)) { Statement s = ParseStmt(); l.Add(s); if (s is FromImportStatement) { FromImportStatement fis = (FromImportStatement)s; if (!fis.IsFromFuture) { // end of from __future__ break; } } } } // the end of from __future__ sequence fromFutureAllowed = false; while (true) { if (MaybeEat(TokenKind.EndOfFile)) break; if (MaybeEat(TokenKind.NewLine)) continue; Statement s = ParseStmt(); l.Add(s); } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); Location start = new Location(); start.Column = start.Line = 1; ret.SetLoc(GetExternal(), start, GetEnd()); return ret; }
private PythonAst ParseFileWorker(bool makeModule, bool returnValue) { _globalParent = new PythonAst(makeModule, _languageFeatures, false, _context); StartParsing(); List<Statement> l = new List<Statement>(); // // A future statement must appear near the top of the module. // The only lines that can appear before a future statement are: // - the module docstring (if any), // - comments, // - blank lines, and // - other future statements. // MaybeEatNewLine(); if (PeekToken(TokenKind.Constant)) { Statement s = ParseStmt(); l.Add(s); _fromFutureAllowed = false; ExpressionStatement es = s as ExpressionStatement; if (es != null) { ConstantExpression ce = es.Expression as ConstantExpression; if (ce != null && ce.Value is string) { // doc string _fromFutureAllowed = true; } } } MaybeEatNewLine(); // from __future__ if (_fromFutureAllowed) { while (PeekToken(Tokens.KeywordFromToken)) { Statement s = ParseStmt(); l.Add(s); FromImportStatement fis = s as FromImportStatement; if (fis != null && !fis.IsFromFuture) { // end of from __future__ break; } } } // the end of from __future__ sequence _fromFutureAllowed = false; while (true) { if (MaybeEat(TokenKind.EndOfFile)) break; if (MaybeEatNewLine()) continue; Statement s = ParseStmt(); l.Add(s); } Statement[] stmts = l.ToArray(); if (returnValue && stmts.Length > 0) { ExpressionStatement exprStmt = stmts[stmts.Length - 1] as ExpressionStatement; if (exprStmt != null) { var retStmt = new ReturnStatement(exprStmt.Expression); stmts[stmts.Length - 1] = retStmt; retStmt.SetLoc(_globalParent, exprStmt.Expression.IndexSpan); } } SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(_globalParent, 0, GetEnd()); return FinishParsing(ret); }
// SuiteStatement public bool Walk(SuiteStatement node) { return Process(node); }
/// <summary> /// Helper function for calculating all of the drop down entries that are available /// in the given suite statement. Called to calculate both the members of top-level /// code and class bodies. /// </summary> private static ReadOnlyCollection<DropDownEntryInfo> CalculateEntries(SuiteStatement suite) { List<DropDownEntryInfo> newEntries = new List<DropDownEntryInfo>(); if (suite != null) { foreach (Statement stmt in suite.Statements) { if (stmt is ClassDefinition || stmt is FunctionDefinition) { newEntries.Add(new DropDownEntryInfo(stmt)); } } } newEntries.Sort(ComparisonFunction); return new ReadOnlyCollection<DropDownEntryInfo>(newEntries); }
//suite: simple_stmt NEWLINE | Newline INDENT stmt+ DEDENT private Statement ParseSuite() { if (!EatNoEof(TokenKind.Colon)) { // improve error handling... return new ExpressionStatement(new ErrorExpression()); } List<Statement> l = new List<Statement>(); if (MaybeEat(TokenKind.NewLine)) { if (!MaybeEat(TokenKind.Indent)) { ReportSyntaxError(_lookahead, ErrorCodes.IndentationError); return new ExpressionStatement(new ErrorExpression()); } while (true) { Statement s = ParseStmt(); l.Add(s); if (MaybeEat(TokenKind.Dedent)) break; if (PeekToken().Kind == TokenKind.EndOfFile) { ReportSyntaxError("unexpected end of file"); break; // error handling } } Statement[] stmts = l.ToArray(); SuiteStatement ret = new SuiteStatement(stmts); ret.SetLoc(stmts[0].Start, stmts[stmts.Length - 1].End); return ret; } else { // simple_stmt NEWLINE // ParseSimpleStmt takes care of the NEWLINE Statement s = ParseSimpleStmt(); return s; } }