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;
}
