public override object Visit(BinaryOperatorExpression expression, object data) { CodeBinaryOperatorType op = CodeBinaryOperatorType.Add; switch (expression.Op) { case BinaryOperatorType.Add: op = CodeBinaryOperatorType.Add; break; case BinaryOperatorType.BitwiseAnd: op = CodeBinaryOperatorType.BitwiseAnd; break; case BinaryOperatorType.BitwiseOr: op = CodeBinaryOperatorType.BitwiseOr; break; case BinaryOperatorType.LogicalAnd: op = CodeBinaryOperatorType.BooleanAnd; break; case BinaryOperatorType.LogicalOr: op = CodeBinaryOperatorType.BooleanOr; break; case BinaryOperatorType.Divide: op = CodeBinaryOperatorType.Divide; break; case BinaryOperatorType.GreaterThan: op = CodeBinaryOperatorType.GreaterThan; break; case BinaryOperatorType.GreaterThanOrEqual: op = CodeBinaryOperatorType.GreaterThanOrEqual; break; case BinaryOperatorType.Equality: op = CodeBinaryOperatorType.IdentityEquality; break; case BinaryOperatorType.InEquality: op = CodeBinaryOperatorType.IdentityInequality; break; case BinaryOperatorType.LessThan: op = CodeBinaryOperatorType.LessThan; break; case BinaryOperatorType.LessThanOrEqual: op = CodeBinaryOperatorType.LessThanOrEqual; break; case BinaryOperatorType.Modulus: op = CodeBinaryOperatorType.Modulus; break; case BinaryOperatorType.Multiply: op = CodeBinaryOperatorType.Multiply; break; case BinaryOperatorType.Subtract: op = CodeBinaryOperatorType.Subtract; break; case BinaryOperatorType.ValueEquality: op = CodeBinaryOperatorType.ValueEquality; break; case BinaryOperatorType.ShiftLeft: // CodeDOM suxx op = CodeBinaryOperatorType.Multiply; break; case BinaryOperatorType.ShiftRight: // CodeDOM suxx op = CodeBinaryOperatorType.Multiply; break; case BinaryOperatorType.IS: op = CodeBinaryOperatorType.IdentityEquality; break; case BinaryOperatorType.AS: op = CodeBinaryOperatorType.IdentityEquality; break; case BinaryOperatorType.ExclusiveOr: // CodeDOM suxx op = CodeBinaryOperatorType.BitwiseAnd; break; } return new CodeBinaryOperatorExpression((CodeExpression)expression.Left.AcceptVisitor(this, data), op, (CodeExpression)expression.Right.AcceptVisitor(this, data)); }
public override object Visit(BinaryOperatorExpression expression, object data) { Console.WriteLine(expression.ToString()); return expression.AcceptChildren(this, data); }
public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) { DebugOutput(binaryOperatorExpression); string op = null; string left = binaryOperatorExpression.Left.AcceptVisitor(this, data).ToString(); string right = binaryOperatorExpression.Right.AcceptVisitor(this, data).ToString(); switch (binaryOperatorExpression.Op) { case BinaryOperatorType.Add: op = " + "; break; case BinaryOperatorType.Subtract: op = " - "; break; case BinaryOperatorType.Multiply: op = " * "; break; case BinaryOperatorType.Divide: op = " / "; break; case BinaryOperatorType.Modulus: op = " Mod "; break; case BinaryOperatorType.ShiftLeft: op = " << "; break; case BinaryOperatorType.ShiftRight: op = " >> "; break; case BinaryOperatorType.BitwiseAnd: op = " And "; break; case BinaryOperatorType.BitwiseOr: op = " Or "; break; case BinaryOperatorType.ExclusiveOr: op = " Xor "; break; case BinaryOperatorType.LogicalAnd: op = " AndAlso "; break; case BinaryOperatorType.LogicalOr: op = " OrElse "; break; case BinaryOperatorType.AS: return String.Concat("CType(ConversionHelpers.AsWorkaround(", left, ", GetType(", right, ")), ", right, ")"); case BinaryOperatorType.IS: return String.Concat("TypeOf ", left, " Is ", right); case BinaryOperatorType.Equality: op = " = "; if (right == "Nothing") { op = " Is "; } break; case BinaryOperatorType.GreaterThan: op = " > "; break; case BinaryOperatorType.GreaterThanOrEqual: op = " >= "; break; case BinaryOperatorType.InEquality: if (right == "Nothing") { return String.Concat("Not (", left, " Is ", right, ")"); } else { return String.Concat("Not (", left, " = ", right, ")"); } case BinaryOperatorType.LessThan: op = " < "; break; case BinaryOperatorType.LessThanOrEqual: op = " <= "; break; } return String.Concat(left, op, right); }
public virtual object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) { binaryOperatorExpression.Left.AcceptVisitor(this, data); return binaryOperatorExpression.Right.AcceptVisitor(this, data); }
public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) { // TODO : Operators return binaryOperatorExpression.Left.AcceptVisitor(this, data); }
void AdditiveExpr( #line 1996 "cs.ATG" ref Expression outExpr) { #line 1998 "cs.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; MultiplicativeExpr( #line 2002 "cs.ATG" ref outExpr); while (la.kind == 4 || la.kind == 5) { if (la.kind == 4) { lexer.NextToken(); #line 2005 "cs.ATG" op = BinaryOperatorType.Add; } else { lexer.NextToken(); #line 2006 "cs.ATG" op = BinaryOperatorType.Subtract; } UnaryExpr( #line 2008 "cs.ATG" out expr); MultiplicativeExpr( #line 2008 "cs.ATG" ref expr); #line 2008 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } }
void MultiplicativeExpr( #line 2012 "cs.ATG" ref Expression outExpr) { #line 2014 "cs.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; while (la.kind == 6 || la.kind == 7 || la.kind == 8) { if (la.kind == 6) { lexer.NextToken(); #line 2020 "cs.ATG" op = BinaryOperatorType.Multiply; } else if (la.kind == 7) { lexer.NextToken(); #line 2021 "cs.ATG" op = BinaryOperatorType.Divide; } else { lexer.NextToken(); #line 2022 "cs.ATG" op = BinaryOperatorType.Modulus; } UnaryExpr( #line 2024 "cs.ATG" out expr); #line 2024 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } }
void RelationalExpr( #line 1955 "cs.ATG" ref Expression outExpr) { #line 1957 "cs.ATG" TypeReference type; Expression expr; BinaryOperatorType op = BinaryOperatorType.None; ShiftExpr( #line 1962 "cs.ATG" ref outExpr); while (StartOf(28)) { if (StartOf(29)) { if (la.kind == 21) { lexer.NextToken(); #line 1965 "cs.ATG" op = BinaryOperatorType.LessThan; } else if (la.kind == 20) { lexer.NextToken(); #line 1966 "cs.ATG" op = BinaryOperatorType.GreaterThan; } else if (la.kind == 34) { lexer.NextToken(); #line 1967 "cs.ATG" op = BinaryOperatorType.LessThanOrEqual; } else if (la.kind == 33) { lexer.NextToken(); #line 1968 "cs.ATG" op = BinaryOperatorType.GreaterThanOrEqual; } else SynErr(185); UnaryExpr( #line 1970 "cs.ATG" out expr); ShiftExpr( #line 1970 "cs.ATG" ref expr); #line 1970 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } else { if (la.kind == 84) { lexer.NextToken(); #line 1973 "cs.ATG" op = BinaryOperatorType.IS; } else if (la.kind == 49) { lexer.NextToken(); #line 1974 "cs.ATG" op = BinaryOperatorType.AS; } else SynErr(186); Type( #line 1976 "cs.ATG" out type); #line 1976 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, new TypeReferenceExpression(type)); } } }
void ShiftExpr( #line 1980 "cs.ATG" ref Expression outExpr) { #line 1982 "cs.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; AdditiveExpr( #line 1986 "cs.ATG" ref outExpr); while (la.kind == 35 || la.kind == 36) { if (la.kind == 35) { lexer.NextToken(); #line 1989 "cs.ATG" op = BinaryOperatorType.ShiftLeft; } else { lexer.NextToken(); #line 1990 "cs.ATG" op = BinaryOperatorType.ShiftRight; } UnaryExpr( #line 1992 "cs.ATG" out expr); AdditiveExpr( #line 1992 "cs.ATG" ref expr); #line 1992 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } }
void AndExpr( #line 1933 "cs.ATG" ref Expression outExpr) { #line 1934 "cs.ATG" Expression expr; EqualityExpr( #line 1936 "cs.ATG" ref outExpr); while (la.kind == 26) { lexer.NextToken(); UnaryExpr( #line 1936 "cs.ATG" out expr); EqualityExpr( #line 1936 "cs.ATG" ref expr); #line 1936 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr); } }
void EqualityExpr( #line 1939 "cs.ATG" ref Expression outExpr) { #line 1941 "cs.ATG" Expression expr; BinaryOperatorType op = BinaryOperatorType.None; RelationalExpr( #line 1945 "cs.ATG" ref outExpr); while (la.kind == 31 || la.kind == 32) { if (la.kind == 32) { lexer.NextToken(); #line 1948 "cs.ATG" op = BinaryOperatorType.InEquality; } else { lexer.NextToken(); #line 1949 "cs.ATG" op = BinaryOperatorType.Equality; } UnaryExpr( #line 1951 "cs.ATG" out expr); RelationalExpr( #line 1951 "cs.ATG" ref expr); #line 1951 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, op, expr); } }
void ExclusiveOrExpr( #line 1927 "cs.ATG" ref Expression outExpr) { #line 1928 "cs.ATG" Expression expr; AndExpr( #line 1930 "cs.ATG" ref outExpr); while (la.kind == 28) { lexer.NextToken(); UnaryExpr( #line 1930 "cs.ATG" out expr); AndExpr( #line 1930 "cs.ATG" ref expr); #line 1930 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr); } }
void InclusiveOrExpr( #line 1921 "cs.ATG" ref Expression outExpr) { #line 1922 "cs.ATG" Expression expr; ExclusiveOrExpr( #line 1924 "cs.ATG" ref outExpr); while (la.kind == 27) { lexer.NextToken(); UnaryExpr( #line 1924 "cs.ATG" out expr); ExclusiveOrExpr( #line 1924 "cs.ATG" ref expr); #line 1924 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr); } }
void ConditionalAndExpr( #line 1915 "cs.ATG" ref Expression outExpr) { #line 1916 "cs.ATG" Expression expr; InclusiveOrExpr( #line 1918 "cs.ATG" ref outExpr); while (la.kind == 23) { lexer.NextToken(); UnaryExpr( #line 1918 "cs.ATG" out expr); InclusiveOrExpr( #line 1918 "cs.ATG" ref expr); #line 1918 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr); } }
void ConditionalOrExpr( #line 1909 "cs.ATG" ref Expression outExpr) { #line 1910 "cs.ATG" Expression expr; ConditionalAndExpr( #line 1912 "cs.ATG" ref outExpr); while (la.kind == 24) { lexer.NextToken(); UnaryExpr( #line 1912 "cs.ATG" out expr); ConditionalAndExpr( #line 1912 "cs.ATG" ref expr); #line 1912 "cs.ATG" outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr); } }
public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data) { binaryOperatorExpression.Left.AcceptVisitor(this, data); outputFormatter.Space(); switch (binaryOperatorExpression.Op) { case BinaryOperatorType.Add: outputFormatter.PrintToken(Tokens.Plus); break; case BinaryOperatorType.Subtract: outputFormatter.PrintToken(Tokens.Minus); break; case BinaryOperatorType.Multiply: outputFormatter.PrintToken(Tokens.Times); break; case BinaryOperatorType.Divide: outputFormatter.PrintToken(Tokens.Div); break; case BinaryOperatorType.Modulus: outputFormatter.PrintToken(Tokens.Mod); break; case BinaryOperatorType.ShiftLeft: outputFormatter.PrintToken(Tokens.ShiftLeft); break; case BinaryOperatorType.ShiftRight: outputFormatter.PrintToken(Tokens.ShiftRight); break; case BinaryOperatorType.BitwiseAnd: outputFormatter.PrintToken(Tokens.BitwiseAnd); break; case BinaryOperatorType.BitwiseOr: outputFormatter.PrintToken(Tokens.BitwiseOr); break; case BinaryOperatorType.ExclusiveOr: outputFormatter.PrintToken(Tokens.Xor); break; case BinaryOperatorType.LogicalAnd: outputFormatter.PrintToken(Tokens.LogicalAnd); break; case BinaryOperatorType.LogicalOr: outputFormatter.PrintToken(Tokens.LogicalOr); break; case BinaryOperatorType.AS: outputFormatter.PrintToken(Tokens.As); break; case BinaryOperatorType.IS: outputFormatter.PrintToken(Tokens.Is); break; case BinaryOperatorType.Equality: outputFormatter.PrintToken(Tokens.Equal); break; case BinaryOperatorType.GreaterThan: outputFormatter.PrintToken(Tokens.GreaterThan); break; case BinaryOperatorType.GreaterThanOrEqual: outputFormatter.PrintToken(Tokens.GreaterEqual); break; case BinaryOperatorType.InEquality: outputFormatter.PrintToken(Tokens.NotEqual); break; case BinaryOperatorType.LessThan: outputFormatter.PrintToken(Tokens.LessThan); break; case BinaryOperatorType.LessThanOrEqual: outputFormatter.PrintToken(Tokens.LessEqual); break; } outputFormatter.Space(); binaryOperatorExpression.Right.AcceptVisitor(this, data); return null; }