public override void OnExpressionStatement(ExpressionStatement node) { var e = node as ExpressionStatement; if(null!=e && e.Expression is BinaryExpression){ Visit(e.Expression as BinaryExpression); } }
override public void LeaveExpressionStatement(ExpressionStatement node) { // allow interactive evaluation of closures (see booish) var converted = ConvertExpression(node.Expression); if (converted != null) node.Expression = converted; }
public override void LeaveExpressionStatement(ExpressionStatement node) { IntegerLiteralExpression literal = node.Expression as IntegerLiteralExpression; if (null == literal) return; AssertLiteralInRange(literal, GetExpressionType(literal)); }
public static TypeMember Lift(ExpressionStatement stmt) { var e = stmt.Expression; var closure = e as BlockExpression; if (closure != null) return TypeMember.Lift(closure); throw new NotImplementedException(stmt.ToCodeString()); }
public override void OnExpressionStatement(ExpressionStatement es) { if (es.Expression is MethodInvocationExpression) es.Expression = ReplaceExpression(es.Expression); else if (es.Expression is BinaryExpression) { BinaryExpression expression = (BinaryExpression)es.Expression; expression.Right = ReplaceExpression(expression.Right); } }
public override void OnExpressionStatement(ExpressionStatement node) { base.OnExpressionStatement(node); base.EnsureDocumentInitialized(node); Expression expression = node.get_Expression(); SourceLocation self = base.doc.TokenSourceLocationFollowing(BooExtensions.AsLexicalInfo(expression.get_EndSourceLocation(), null), ";"); if (self != null) { node.set_EndSourceLocation(BooExtensions.OffsetedBy(self, 0, -2)); } }
static void ReplaceWithInitializer(DeclarationStatement decl) { if (decl.Initializer == null) { decl.ReplaceBy(null); } else { ExpressionStatement statement = new ExpressionStatement(decl.LexicalInfo); statement.Expression = new BinaryExpression(decl.LexicalInfo, BinaryOperatorType.Assign, new ReferenceExpression(decl.Declaration.LexicalInfo, decl.Declaration.Name), decl.Initializer); decl.ReplaceBy(statement); } }
public void Expression_statement_is_transformed() { LiteralExpression exp = new StringLiteralExpression("arg1"); ExpressionStatement doStuffStatement = new ExpressionStatement(exp); MacroStatement fixture = new MacroStatement(new LexicalInfo("test", 1, 1)); fixture.Name = "DoStuff"; fixture.Block = new Block(); fixture.Block.Add(doStuffStatement); BlockToArgumentsTransformer transformer = new BlockToArgumentsTransformer("DoStuff"); transformer.Visit(fixture); Assert.AreEqual(exp, fixture.Arguments[0]); Assert.IsFalse(fixture.Block.HasStatements, "MacroStatement block should be empty after transformation."); }
public override void OnExpressionStatement(ExpressionStatement node) { if (node.Expression is LiteralExpression) { CurrentText.AppendLine( node.Expression.expand()); } else if(node.Expression is UnaryExpression){ var u = node.Expression as UnaryExpression; if(u.Operator==UnaryOperatorType.UnaryNegation){ CurrentText.Append("-"); CurrentText.Append(u.Operand.ToCodeString()); } }else if(node.Expression is ExpressionInterpolationExpression){ CurrentText.Append(node.Expression.expand()); } else{ base.OnExpressionStatement(node); } }
public void MacroStatement_with_block_is_transformed_to_MethodInvocationExpression() { const string methodInBlockName = "some_method"; const string doStuff = "DoStuff"; Expression argInBlockExpression = new StringLiteralExpression("argInBlock"); Statement argInBlockStatement = new ExpressionStatement(argInBlockExpression); MacroStatement statementInBlock = GetMacroStatement(methodInBlockName, argInBlockStatement); MacroStatement doStuffStatement = GetMacroStatement(doStuff, statementInBlock); BlockToArgumentsTransformer transformer = new BlockToArgumentsTransformer(doStuff, methodInBlockName); transformer.Visit(doStuffStatement); MethodInvocationExpression mie = doStuffStatement.Arguments[0] as MethodInvocationExpression; Assert.IsNotNull(mie, "Could not cast argument one of MacroStatement to MethodInvocationExpression."); Assert.AreEqual(methodInBlockName, (mie.Target as ReferenceExpression).Name); Assert.IsAssignableFrom(typeof (BlockExpression), mie.Arguments[0]); }
public override void OnExpressionStatement(ExpressionStatement node) { if(isWrite(node.Expression)) { var arg = get_arg(node.Expression); var first = arg; if (!(arg is ExpressionInterpolationExpression)) { arg = new ExpressionInterpolationExpression(); } var block = ((Block) node.ParentNode); var index = block.Statements.IndexOf(node); if(index==-1) return; while (true) { if (index > block.Statements.Count - 2) break; var next = block.Statements[index + 1]; if(!(next is ExpressionStatement))break; if(!isWrite(((ExpressionStatement)next).Expression)) break; block.Statements.Remove(next); var nextarg = get_arg(((ExpressionStatement) next).Expression); if (nextarg is ExpressionInterpolationExpression) { foreach (var e in ((ExpressionInterpolationExpression)nextarg).Expressions) { ((ExpressionInterpolationExpression)arg).Expressions.Add(e); } } else { ((ExpressionInterpolationExpression) arg).Expressions.Add(nextarg); } } if(((ExpressionInterpolationExpression)arg).Expressions.Count>0) { if (first != arg) { ((ExpressionInterpolationExpression) arg).Expressions.Insert(0, first); } set_arg(node.Expression, arg); } } }
public override void LeaveExpressionStatement(ExpressionStatement node) { // if the type of the inner expression is not // void we need to pop its return value to leave // the stack sane DiscardValueOnStack(); }
//throws RecognitionException, TokenStreamException protected ExpressionStatement expression_stmt() { ExpressionStatement s; s = null; Expression e = null; try { // for error handling e=assignment_expression(); if (0==inputState.guessing) { s = new ExpressionStatement(e); } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "expression_stmt"); recover(ex,tokenSet_21_); } else { throw ex; } } return s; }
public override bool EnterExpressionStatement(ExpressionStatement node) { EmitDebugInfo(node); return true; }
public override void LeaveExpressionStatement(ExpressionStatement node) { // allow interactive evaluation of closures (see booish) Expression converted = ConvertExpression(node.Expression); if (null != converted) { node.Expression = converted; } }
//throws RecognitionException, TokenStreamException protected Statement assignment_or_method_invocation_with_block_stmt() { Statement stmt; IToken op = null; stmt = null; Expression lhs = null; Expression rhs = null; StatementModifier modifier = null; BinaryOperatorType binaryOperator = BinaryOperatorType.None; IToken token = null; try { // for error handling lhs=slicing_expression(); { switch ( LA(1) ) { case DEF: case DO: case COLON: { { lhs=method_invocation_block(lhs); if (0==inputState.guessing) { stmt = new ExpressionStatement(lhs); } } break; } case ASSIGN: { { { op = LT(1); match(ASSIGN); if (0==inputState.guessing) { token = op; binaryOperator = OperatorParser.ParseAssignment(op.getText()); } { switch ( LA(1) ) { case DEF: case DO: case COLON: { rhs=callable_expression(); break; } case ESEPARATOR: case CAST: case CHAR: case FALSE: case NOT: case NULL: case SELF: case SUPER: case TRUE: case TYPEOF: case ID: case TRIPLE_QUOTED_STRING: case LPAREN: case DOUBLE_QUOTED_STRING: case SINGLE_QUOTED_STRING: case LBRACK: case SUBTRACT: case COMMA: case SPLICE_BEGIN: case DOT: case MULTIPLY: case LBRACE: case QQ_BEGIN: case LONG: case INCREMENT: case DECREMENT: case ONES_COMPLEMENT: case INT: case RE_LITERAL: case DOUBLE: case FLOAT: case TIMESPAN: { { rhs=array_or_expression(); { switch ( LA(1) ) { case DEF: case DO: case COLON: { rhs=method_invocation_block(rhs); break; } case IF: case UNLESS: case WHILE: { { modifier=stmt_modifier(); eos(); } break; } case EOF: case EOS: case NEWLINE: { eos(); break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } if (0==inputState.guessing) { stmt = new ExpressionStatement( new BinaryExpression(SourceLocationFactory.ToLexicalInfo(token), binaryOperator, lhs, rhs)); stmt.Modifier = modifier; } } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_79_); } else { throw ex; } } return stmt; }
protected Statement closure_expression_stmt() //throws RecognitionException, TokenStreamException { Statement s; s = null; Expression e = null; try { // for error handling e=array_or_expression(); if (0==inputState.guessing) { s = new ExpressionStatement(e); } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "closure_expression_stmt"); recover(ex,tokenSet_90_); } else { throw ex; } } return s; }
public override void LeaveExpressionStatement(ExpressionStatement node) { // if the type of the inner expression is not // void we need to pop its return value to leave // the stack sane DiscardValueOnStack(); AssertStackIsEmpty("stack must be empty after a statement! Offending statement: '" + node.ToCodeString() + "'"); }
public override void OnExpressionStatement(ExpressionStatement node) { base.OnExpressionStatement(node); lastExpressionStatement = node; }
public override void OnExpressionStatement(ExpressionStatement node) { WriteIndented(); Visit(node.Expression); Visit(node.Modifier); WriteLine(); }
public object VisitExpressionStatement(ExpressionStatement statementExpression, object data) { B.ExpressionStatement st = new B.ExpressionStatement(GetLexicalInfo(statementExpression)); st.Expression = ConvertExpression(statementExpression.Expression); return(st); }
public override void OnExpressionStatement(ExpressionStatement node) { _expression = null; node.Expression.Accept(this); if (_expression != null) _statements.Add(new CodeExpressionStatement(_expression)); }
public override void OnExpressionStatement(ExpressionStatement node) { if (!_checked) return; base.OnExpressionStatement(node); IntegerLiteralExpression literal = node.Expression as IntegerLiteralExpression; if (null == literal) return; AssertLiteralInRange(literal, GetExpressionType(literal)); }
public override void OnExpressionStatement(ExpressionStatement node) { base.OnExpressionStatement(node); this.Expression = node.Expression; }
public override void LeaveExpressionStatement(ExpressionStatement node) { LeaveStatement(node); }
protected Statement assignment_or_method_invocation_with_block_stmt() //throws RecognitionException, TokenStreamException { Statement stmt; IToken op = null; stmt = null; Expression lhs = null; Expression rhs = null; StatementModifier modifier = null; BinaryOperatorType binaryOperator = BinaryOperatorType.None; IToken token = null; try { // for error handling lhs=slicing_expression(); { switch ( LA(1) ) { case DEF: case DO: case COLON: { { lhs=method_invocation_block(lhs); if (0==inputState.guessing) { stmt = new ExpressionStatement(lhs); } } break; } case ASSIGN: { { { op = LT(1); match(ASSIGN); if (0==inputState.guessing) { token = op; binaryOperator = OperatorParser.ParseAssignment(op.getText()); } { if (((tokenSet_70_.member(LA(1))) && (tokenSet_92_.member(LA(2))))&&(_compact)) { rhs=array_or_expression(); } else { bool synPredMatched492 = false; if (((LA(1)==DEF||LA(1)==DO||LA(1)==COLON))) { int _m492 = mark(); synPredMatched492 = true; inputState.guessing++; try { { switch ( LA(1) ) { case COLON: { match(COLON); break; } case DEF: { match(DEF); break; } case DO: { match(DO); break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } catch (RecognitionException) { synPredMatched492 = false; } rewind(_m492); inputState.guessing--; } if ( synPredMatched492 ) { rhs=callable_expression(); } else if ((tokenSet_70_.member(LA(1))) && (tokenSet_93_.member(LA(2)))) { { rhs=array_or_expression(); { switch ( LA(1) ) { case DEF: case DO: case COLON: { rhs=method_invocation_block(rhs); break; } case IF: case UNLESS: case WHILE: { { modifier=stmt_modifier(); eos(); } break; } case EOL: case EOS: { eos(); break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } } else { throw new NoViableAltException(LT(1), getFilename()); } } } } if (0==inputState.guessing) { stmt = new ExpressionStatement( new BinaryExpression(ToLexicalInfo(token), binaryOperator, lhs, rhs)); stmt.Modifier = modifier; } } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "assignment_or_method_invocation_with_block_stmt"); recover(ex,tokenSet_84_); } else { throw ex; } } return stmt; }
public object VisitExpressionStatement(ExpressionStatement statementExpression, object data) { B.ExpressionStatement st = new B.ExpressionStatement(GetLexicalInfo(statementExpression)); st.Expression = ConvertExpression(statementExpression.Expression); return st; }
protected Statement assignment_or_method_invocation() //throws RecognitionException, TokenStreamException { Statement stmt; IToken op = null; stmt = null; Expression lhs = null; Expression rhs = null; StatementModifier modifier = null; BinaryOperatorType binaryOperator = BinaryOperatorType.None; IToken token = null; try { // for error handling lhs=slicing_expression(); { op = LT(1); match(ASSIGN); if (0==inputState.guessing) { token = op; binaryOperator = OperatorParser.ParseAssignment(op.getText()); } rhs=array_or_expression(); } if (0==inputState.guessing) { stmt = new ExpressionStatement( new BinaryExpression(ToLexicalInfo(token), binaryOperator, lhs, rhs)); stmt.Modifier = modifier; } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "assignment_or_method_invocation"); recover(ex,tokenSet_19_); } else { throw ex; } } return stmt; }
public override void OnExpressionStatement(ExpressionStatement node) { EmitDebugInfo(node); base.OnExpressionStatement(node); // if the type of the inner expression is not // void we need to pop its return value to leave // the stack sane DiscardValueOnStack(); }
public override void LeaveExpressionStatement(ExpressionStatement node) { AssertHasSideEffect(node.Expression); }
override public object Clone() { ExpressionStatement clone = new ExpressionStatement(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone(); if (null != _modifier) { clone._modifier = _modifier.Clone() as StatementModifier; clone._modifier.InitializeParent(clone); } if (null != _expression) { clone._expression = _expression.Clone() as Expression; clone._expression.InitializeParent(clone); } return clone; }