public ForStatement(Expression left, Expression list, Statement body, Statement else_) { _left = left; _list = list; _body = body; _else = else_; }
public RaiseStatement(Expression exceptionType, Expression exceptionValue, Expression traceBack, Expression cause) { _type = exceptionType; _value = exceptionValue; _traceback = traceBack; _cause = cause; }
public SliceExpression(Expression start, Expression stop, Expression step, bool stepProvided) { _sliceStart = start; _sliceStop = stop; _sliceStep = step; _stepProvided = stepProvided; }
public AndExpression(Expression left, Expression right) { _left = left; _right = right; StartIndex = left.StartIndex; EndIndex = right.EndIndex; }
public BinaryExpression(JOperator op, Expression left, Expression right) { Contract.Assert(left != null); Contract.Assert(right != null); if (op == JOperator.None) throw new ArgumentException("bad operator"); _op = op; _left = left; _right = right; StartIndex = left.StartIndex; EndIndex = right.EndIndex; }
internal void AppendCodeString(StringBuilder res, JAst ast, CodeFormattingOptions format, string start, string end, Expression item) { if (!String.IsNullOrEmpty(start)) { format.ReflowComment(res, this.GetProceedingWhiteSpace(ast)); res.Append(start); } item.AppendCodeString(res, ast, format); for (int i = 0; i < Iterators.Count; i++) { Iterators[i].AppendCodeString(res, ast, format); } if (!String.IsNullOrEmpty(end)) { res.Append(this.GetSecondWhiteSpace(ast)); res.Append(end); } }
private ErrorExpression Error(string verbatimImage = null, Expression preceeding = null) { var res = new ErrorExpression(verbatimImage, preceeding); res.SetLoc(GetStart(), GetEnd()); return res; }
private Expression AddTrailers(Expression ret) { return AddTrailers(ret, true); }
// trailer: '(' [ arglist_genexpr ] ')' | '[' subscriptlist ']' | '.' NAME private Expression AddTrailers(Expression ret, bool allowGeneratorExpression) { bool prevAllow = _allowIncomplete; try { _allowIncomplete = true; while (true) { switch (PeekToken().Kind) { case TokenKind.LeftParenthesis: if (!allowGeneratorExpression) return ret; NextToken(); string whitespace = _tokenWhiteSpace; List<string> commaWhiteSpace; bool ateTerminator; Arg[] args = FinishArgListOrGenExpr(out commaWhiteSpace, out ateTerminator); string closeParenWhiteSpace = _tokenWhiteSpace; CallExpression call; if (args != null) { call = FinishCallExpr(ret, args); } else { call = new CallExpression(ret, new Arg[0]); } if (_verbatim) { AddPreceedingWhiteSpace(call, whitespace); AddSecondPreceedingWhiteSpace(call, closeParenWhiteSpace); if (commaWhiteSpace != null) { AddListWhiteSpace(call, commaWhiteSpace.ToArray()); } if (!ateTerminator) { AddErrorMissingCloseGrouping(call); } } call.SetLoc(ret.StartIndex, GetEnd()); ret = call; break; case TokenKind.LeftBracket: NextToken(); whitespace = _tokenWhiteSpace; Expression index = ParseSubscriptList(out ateTerminator); IndexExpression ie = new IndexExpression(ret, index); string finishWhiteSpace = _tokenWhiteSpace; ie.SetLoc(ret.StartIndex, GetEnd()); if (_verbatim) { AddPreceedingWhiteSpace(ie, whitespace); AddSecondPreceedingWhiteSpace(ie, finishWhiteSpace); if (!ateTerminator) { AddErrorMissingCloseGrouping(ie); } } ret = ie; break; case TokenKind.Dot: NextToken(); whitespace = _tokenWhiteSpace; var name = ReadNameMaybeNone(); string nameWhitespace = _tokenWhiteSpace; MemberExpression fe = MakeMember(ret, name); fe.SetLoc(ret.StartIndex, GetStart(), GetEnd()); if (_verbatim) { AddPreceedingWhiteSpace(fe, whitespace); AddSecondPreceedingWhiteSpace(fe, nameWhitespace); if (!name.HasName) { AddErrorIsIncompleteNode(fe); } } ret = fe; break; case TokenKind.Constant: // abc.1, abc"", abc 1L, abc 0j ReportSyntaxError("invalid syntax"); ret = Error(_verbatim ? _lookaheadWhiteSpace + _lookahead.Token.VerbatimImage : null, ret); NextToken(); break; default: return ret; } } } finally { _allowIncomplete = prevAllow; } }
private Expression ParseTestListAsExpr(Expression expr) { List<string> itemWhiteSpace; bool trailingComma; List<Expression> l = ParseTestListAsExpr(expr, out itemWhiteSpace, out trailingComma); return MakeTupleOrExpr(l, itemWhiteSpace, trailingComma, parenFreeTuple: true); }
private List<Expression> ParseTestListAsExpr(Expression expr, out List<string> itemWhiteSpace, out bool trailingComma) { var l = new List<Expression>(); itemWhiteSpace = MakeWhiteSpaceList(); if (expr != null) { l.Add(expr); if (itemWhiteSpace != null) { Debug.Assert(_token.Token.Kind == TokenKind.Comma); itemWhiteSpace.Add(_tokenWhiteSpace); } } trailingComma = true; while (true) { if (NeverTestToken(PeekToken())) break; l.Add(ParseExpression()); if (!MaybeEat(TokenKind.Comma)) { trailingComma = false; break; } if (itemWhiteSpace != null) { itemWhiteSpace.Add(_tokenWhiteSpace); } } return l; }
public WhileStatement(Expression test, Statement body, Statement else_) { _test = test; _body = body; _else = else_; }
private Expression FinishExpressionListAsExpr(Expression expr) { var start = GetStart(); bool trailingComma = true; List<Expression> l = new List<Expression>(); List<string> itemWhiteSpace = MakeWhiteSpaceList(); if (itemWhiteSpace != null) { itemWhiteSpace.Add(_tokenWhiteSpace); } l.Add(expr); while (true) { if (NeverTestToken(PeekToken())) break; expr = ParseExpression(); l.Add(expr); if (!MaybeEat(TokenKind.Comma)) { trailingComma = false; break; } if (itemWhiteSpace != null) { itemWhiteSpace.Add(_tokenWhiteSpace); } trailingComma = true; } Expression ret = MakeTupleOrExpr(l, itemWhiteSpace, trailingComma); ret.SetLoc(start, GetEnd()); return ret; }
public ErrorExpression(string verbatimImage, Expression preceeding) { _preceeding = preceeding; _verbatimImage = verbatimImage; }
public ParenthesisExpression(Expression expression) { _expression = expression; }
private Expression FinishSlice(Expression e0, int start) { Expression e1 = null; Expression e2 = null; bool stepProvided = false; Debug.Assert(_token.Token.Kind == TokenKind.Colon); string colonWhiteSpace = _tokenWhiteSpace; string secondColonWhiteSpace = null; switch (PeekToken().Kind) { case TokenKind.Comma: case TokenKind.RightBracket: break; case TokenKind.Colon: // x[?::?] stepProvided = true; NextToken(); secondColonWhiteSpace = _tokenWhiteSpace; e2 = ParseSliceEnd(); break; default: // x[?:val:?] e1 = ParseExpression(); if (MaybeEat(TokenKind.Colon)) { secondColonWhiteSpace = _tokenWhiteSpace; stepProvided = true; e2 = ParseSliceEnd(); } break; } SliceExpression ret = new SliceExpression(e0, e1, e2, stepProvided); if (_verbatim) { AddPreceedingWhiteSpace(ret, colonWhiteSpace); if (secondColonWhiteSpace != null) { AddSecondPreceedingWhiteSpace(ret, secondColonWhiteSpace); } } ret.SetLoc(start, GetEnd()); return ret; }
private MemberExpression MakeMember(Expression target, Name name) { var res = new MemberExpression(target, name.RealName); AddVerbatimName(name, res); return res; }
// comp_iter '}' private SetComprehension FinishSetComp(Expression item, out bool ateTerminator) { ComprehensionIterator[] iters = ParseCompIter(); ateTerminator = Eat(TokenKind.RightBrace); return new SetComprehension(item, iters); }
// list_iter ']' private ListComprehension FinishListComp(Expression item, out bool ateRightBracket) { ComprehensionIterator[] iters = ParseListCompIter(); ateRightBracket = Eat(TokenKind.RightBracket); return new ListComprehension(item, iters); }
private Arg FinishKeywordArgument(Expression t) { Debug.Assert(_token.Token.Kind == TokenKind.Assign); string equalWhiteSpace = _tokenWhiteSpace; NameExpression n = t as NameExpression; string name; if (n == null) { ReportSyntaxError(t.StartIndex, t.EndIndex, "expected name"); name = null; } else { name = n.Name; } Expression val = ParseExpression(); Arg arg = new Arg(t, val); arg.SetLoc(t.StartIndex, val.EndIndex); if (_verbatim) { AddPreceedingWhiteSpace(arg, equalWhiteSpace); } // we're losing the name expression... return arg; }
public TryStatementHandler(Expression test, Expression target, Statement body) { _test = test; _target = target; _body = body; }
private Statement FinishAssignments(Expression right) { List<Expression> left = null; List<string> assignWhiteSpace = MakeWhiteSpaceList(); Expression singleLeft = null; while (MaybeEat(TokenKind.Assign)) { if (assignWhiteSpace != null) { assignWhiteSpace.Add(_tokenWhiteSpace); } string assignError = right.CheckAssign(); if (assignError != null) { ReportSyntaxError(right.StartIndex, right.EndIndex, assignError, ErrorCodes.SyntaxError | ErrorCodes.NoCaret); } if (singleLeft == null) { singleLeft = right; } else { if (left == null) { left = new List<Expression>(); left.Add(singleLeft); } left.Add(right); } if (_langVersion >= JLanguageVersion.V71 && MaybeEat(TokenKind.KeywordYield)) { right = ParseYieldExpression(); } else { right = ParseTestListAsExpr(); } } AssignmentStatement assign; if (left != null) { Debug.Assert(left.Count > 0); assign = new AssignmentStatement(left.ToArray(), right); assign.SetLoc(left[0].StartIndex, right.EndIndex); } else { Debug.Assert(singleLeft != null); assign = new AssignmentStatement(new[] { singleLeft }, right); assign.SetLoc(singleLeft.StartIndex, right.EndIndex); } if (assignWhiteSpace != null) { AddListWhiteSpace(assign, assignWhiteSpace.ToArray()); } return assign; }
public ConditionalExpression(Expression testExpression, Expression trueExpression, Expression falseExpression) { this._testExpr = testExpression; this._trueExpr = trueExpression; this._falseExpr = falseExpression; }
//print_stmt: 'print' ( [ expression (',' expression)* [','] ] | '>>' expression [ (',' expression)+ [','] ] ) private PrintStatement ParsePrintStmt() { Eat(TokenKind.KeywordPrint); string printWhiteSpace = _tokenWhiteSpace; var start = GetStart(); Expression dest = null; PrintStatement ret; string rightShiftWhiteSpace = null; string theCommaWhiteSpace = null; bool needNonEmptyTestList = false; int end = 0; if (MaybeEat(TokenKind.RightShift)) { rightShiftWhiteSpace = _tokenWhiteSpace; dest = ParseExpression(); if (MaybeEat(TokenKind.Comma)) { theCommaWhiteSpace = _tokenWhiteSpace; needNonEmptyTestList = true; end = GetEnd(); } else { ret = new PrintStatement(dest, new Expression[0], false); if (_verbatim) { AddPreceedingWhiteSpace(ret, printWhiteSpace); AddSecondPreceedingWhiteSpace(ret, rightShiftWhiteSpace); } ret.SetLoc(start, GetEnd()); return ret; } } bool trailingComma = false; List<string> commaWhiteSpace = null; Expression[] exprs; if (!NeverTestToken(PeekToken())) { var expr = ParseExpression(); if (!MaybeEat(TokenKind.Comma)) { exprs = new[] { expr }; } else { List<Expression> exprList = ParseTestListAsExpr(expr, out commaWhiteSpace, out trailingComma); exprs = exprList.ToArray(); } } else { if (needNonEmptyTestList) { ReportSyntaxError(start, end, "print statement expected expression to be printed"); exprs = new[] { Error("") }; } else { exprs = new Expression[0]; } } ret = new PrintStatement(dest, exprs, trailingComma); if (_verbatim) { AddPreceedingWhiteSpace(ret, printWhiteSpace); AddSecondPreceedingWhiteSpace(ret, rightShiftWhiteSpace); AddThirdPreceedingWhiteSpace(ret, theCommaWhiteSpace); if (commaWhiteSpace != null) { AddListWhiteSpace(ret, commaWhiteSpace.ToArray()); } } ret.SetLoc(start, GetEnd()); return ret; }
private Expression ParseConditionalTest(Expression trueExpr) { string ifWhiteSpace = _tokenWhiteSpace; Expression expr = ParseOrTest(); bool ateElse = Eat(TokenKind.KeywordElse); string elseWhiteSpace; Expression falseExpr; if (ateElse) { elseWhiteSpace = _tokenWhiteSpace; falseExpr = ParseExpression(); } else { elseWhiteSpace = null; falseExpr = Error(""); } var res = new ConditionalExpression(expr, trueExpr, falseExpr); if (_verbatim) { AddPreceedingWhiteSpace(res, ifWhiteSpace); AddSecondPreceedingWhiteSpace(res, elseWhiteSpace); if (!ateElse) { AddErrorIsIncompleteNode(res); } } return res; }
private CallExpression FinishCallExpr(Expression target, params Arg[] args) { bool hasArgsTuple = false; bool hasKeywordDict = false; int keywordCount = 0; int extraArgs = 0; foreach (Arg arg in args) { if (arg.Name == null) { if (hasArgsTuple || hasKeywordDict || keywordCount > 0) { ReportSyntaxError(arg.StartIndex, arg.EndIndex, "non-keyword arg after keyword arg"); } } else if (arg.Name == "*") { if (hasArgsTuple || hasKeywordDict) { ReportSyntaxError(arg.StartIndex, arg.EndIndex, "only one * allowed"); } hasArgsTuple = true; extraArgs++; } else if (arg.Name == "**") { if (hasKeywordDict) { ReportSyntaxError(arg.StartIndex, arg.EndIndex, "only one ** allowed"); } hasKeywordDict = true; extraArgs++; } else { if (hasKeywordDict) { ReportSyntaxError(arg.StartIndex, arg.EndIndex, "keywords must come before ** args"); } keywordCount++; } } return new CallExpression(target, args); }
public SetComprehension(Expression item, ComprehensionIterator[] iterators) { _item = item; _iterators = iterators; }
// genexpr_for ::= "for" target_list "in" or_test [comp_iter] // // "for" has NOT been eaten before entering this method private Expression ParseGeneratorExpression(Expression expr, string rightParenWhiteSpace = null) { ComprehensionIterator[] iters = ParseCompIter(); GeneratorExpression ret = new GeneratorExpression(expr, iters); ret.SetLoc(expr.StartIndex, GetEnd()); return ret; }
public DelStatement(Expression[] expressions) { _expressions = expressions; }
private Expression ParseLambdaHelperEnd(FunctionDefinition func, Expression expr, string whitespace, string colonWhiteSpace, List<string> commaWhiteSpace, bool ateTerminator) { // Pep 342 in J 2.5 allows Yield Expressions, which can occur inside a Lambda body. // In this case, the lambda is a generator and will yield it's final result instead of just return it. Statement body; if (func.IsGenerator) { YieldExpression y = new YieldExpression(expr); y.SetLoc(expr.IndexSpan); body = new ExpressionStatement(y); } else { body = new ReturnStatement(expr); } body.SetLoc(expr.StartIndex, expr.EndIndex); FunctionDefinition func2 = PopFunction(); System.Diagnostics.Debug.Assert(func == func2); func.SetBody(body); func.EndIndex = GetEnd(); LambdaExpression ret = new LambdaExpression(func); func.SetLoc(func.IndexSpan); ret.SetLoc(func.IndexSpan); if (_verbatim) { AddPreceedingWhiteSpace(ret, whitespace); AddSecondPreceedingWhiteSpace(ret, colonWhiteSpace); AddListWhiteSpace(ret, commaWhiteSpace.ToArray()); if (!ateTerminator) { AddErrorIsIncompleteNode(ret); } } return ret; }