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.Concat:
// CodeDOM suxx
op = CodeBinaryOperatorType.Add;
break;
case BinaryOperatorType.BooleanAnd:
op = CodeBinaryOperatorType.BooleanAnd;
break;
case BinaryOperatorType.BooleanOr:
op = CodeBinaryOperatorType.BooleanOr;
break;
case BinaryOperatorType.Divide:
op = CodeBinaryOperatorType.Divide;
break;
case BinaryOperatorType.DivideInteger:
// CodeDOM suxx
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.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.Like:
// CodeDOM suxx
op = CodeBinaryOperatorType.IdentityEquality;
break;
case BinaryOperatorType.ExclusiveOr:
// CodeDOM suxx
op = CodeBinaryOperatorType.BitwiseOr;
break;
}
return new CodeBinaryOperatorExpression((CodeExpression)expression.Left.AcceptVisitor(this, data),
op,
(CodeExpression)expression.Right.AcceptVisitor(this, data));
}
void AdditiveExpr(
#line 1667 "VBNET.ATG"
out Expression outExpr) {
#line 1669 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
MultiplicativeExpr(
#line 1672 "VBNET.ATG"
out outExpr);
while (la.kind == 14 || la.kind == 15 || la.kind == 19) {
if (la.kind == 14) {
lexer.NextToken();
#line 1675 "VBNET.ATG"
op = BinaryOperatorType.Add;
} else if (la.kind == 15) {
lexer.NextToken();
#line 1676 "VBNET.ATG"
op = BinaryOperatorType.Subtract;
} else {
lexer.NextToken();
#line 1677 "VBNET.ATG"
op = BinaryOperatorType.Concat;
}
MultiplicativeExpr(
#line 1679 "VBNET.ATG"
out expr);
#line 1679 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void MultiplicativeExpr(
#line 1683 "VBNET.ATG"
out Expression outExpr) {
#line 1685 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
UnaryExpr(
#line 1688 "VBNET.ATG"
out outExpr);
while (StartOf(24)) {
if (la.kind == 16) {
lexer.NextToken();
#line 1691 "VBNET.ATG"
op = BinaryOperatorType.Multiply;
} else if (la.kind == 17) {
lexer.NextToken();
#line 1692 "VBNET.ATG"
op = BinaryOperatorType.Divide;
} else if (la.kind == 18) {
lexer.NextToken();
#line 1693 "VBNET.ATG"
op = BinaryOperatorType.DivideInteger;
} else if (la.kind == 121) {
lexer.NextToken();
#line 1694 "VBNET.ATG"
op = BinaryOperatorType.Modulus;
} else {
lexer.NextToken();
#line 1695 "VBNET.ATG"
op = BinaryOperatorType.Power;
}
UnaryExpr(
#line 1697 "VBNET.ATG"
out expr);
#line 1697 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void RelationalExpr(
#line 1631 "VBNET.ATG"
out Expression outExpr) {
#line 1633 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ShiftExpr(
#line 1636 "VBNET.ATG"
out outExpr);
while (StartOf(22)) {
if (StartOf(23)) {
if (la.kind == 28) {
lexer.NextToken();
#line 1639 "VBNET.ATG"
op = BinaryOperatorType.LessThan;
} else if (la.kind == 27) {
lexer.NextToken();
#line 1640 "VBNET.ATG"
op = BinaryOperatorType.GreaterThan;
} else if (la.kind == 31) {
lexer.NextToken();
#line 1641 "VBNET.ATG"
op = BinaryOperatorType.LessThanOrEqual;
} else if (la.kind == 30) {
lexer.NextToken();
#line 1642 "VBNET.ATG"
op = BinaryOperatorType.GreaterThanOrEqual;
} else SynErr(223);
ShiftExpr(
#line 1644 "VBNET.ATG"
out expr);
#line 1644 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
} else {
lexer.NextToken();
#line 1647 "VBNET.ATG"
op = BinaryOperatorType.IS;
Expr(
#line 1648 "VBNET.ATG"
out expr);
#line 1648 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
}
void ShiftExpr(
#line 1652 "VBNET.ATG"
out Expression outExpr) {
#line 1654 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
AdditiveExpr(
#line 1657 "VBNET.ATG"
out outExpr);
while (la.kind == 32 || la.kind == 33) {
if (la.kind == 32) {
lexer.NextToken();
#line 1660 "VBNET.ATG"
op = BinaryOperatorType.ShiftLeft;
} else {
lexer.NextToken();
#line 1661 "VBNET.ATG"
op = BinaryOperatorType.ShiftRight;
}
AdditiveExpr(
#line 1663 "VBNET.ATG"
out expr);
#line 1663 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void AndExpr(
#line 1601 "VBNET.ATG"
out Expression outExpr) {
#line 1602 "VBNET.ATG"
Expression expr;
NotExpr(
#line 1603 "VBNET.ATG"
out outExpr);
while (la.kind == 46) {
lexer.NextToken();
NotExpr(
#line 1603 "VBNET.ATG"
out expr);
#line 1603 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr);
}
}
void EqualityExpr(
#line 1615 "VBNET.ATG"
out Expression outExpr) {
#line 1617 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
RelationalExpr(
#line 1620 "VBNET.ATG"
out outExpr);
while (la.kind == 11 || la.kind == 29 || la.kind == 117) {
if (la.kind == 29) {
lexer.NextToken();
#line 1623 "VBNET.ATG"
op = BinaryOperatorType.InEquality;
} else if (la.kind == 11) {
lexer.NextToken();
#line 1624 "VBNET.ATG"
op = BinaryOperatorType.Equality;
} else {
lexer.NextToken();
#line 1625 "VBNET.ATG"
op = BinaryOperatorType.Like;
}
RelationalExpr(
#line 1627 "VBNET.ATG"
out expr);
#line 1627 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void InclusiveOrExpr(
#line 1591 "VBNET.ATG"
out Expression outExpr) {
#line 1592 "VBNET.ATG"
Expression expr;
ExclusiveOrExpr(
#line 1593 "VBNET.ATG"
out outExpr);
while (la.kind == 187) {
lexer.NextToken();
ExclusiveOrExpr(
#line 1593 "VBNET.ATG"
out expr);
#line 1593 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr);
}
}
void ExclusiveOrExpr(
#line 1596 "VBNET.ATG"
out Expression outExpr) {
#line 1597 "VBNET.ATG"
Expression expr;
AndExpr(
#line 1598 "VBNET.ATG"
out outExpr);
while (la.kind == 139) {
lexer.NextToken();
AndExpr(
#line 1598 "VBNET.ATG"
out expr);
#line 1598 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr);
}
}
void ConditionalAndExpr(
#line 1586 "VBNET.ATG"
out Expression outExpr) {
#line 1587 "VBNET.ATG"
Expression expr;
InclusiveOrExpr(
#line 1588 "VBNET.ATG"
out outExpr);
while (la.kind == 47) {
lexer.NextToken();
InclusiveOrExpr(
#line 1588 "VBNET.ATG"
out expr);
#line 1588 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BooleanAnd, expr);
}
}
void ConditionalOrExpr(
#line 1581 "VBNET.ATG"
out Expression outExpr) {
#line 1582 "VBNET.ATG"
Expression expr;
ConditionalAndExpr(
#line 1583 "VBNET.ATG"
out outExpr);
while (la.kind == 140) {
lexer.NextToken();
ConditionalAndExpr(
#line 1583 "VBNET.ATG"
out expr);
#line 1583 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BooleanOr, expr);
}
}
public 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.Concat:
op = " + ";
break;
case BinaryOperatorType.Add:
op = " + ";
break;
case BinaryOperatorType.Subtract:
op = " - ";
break;
case BinaryOperatorType.Multiply:
op = " * ";
break;
case BinaryOperatorType.DivideInteger:
case BinaryOperatorType.Divide:
op = " / ";
break;
case BinaryOperatorType.Modulus:
op = " % ";
break;
case BinaryOperatorType.ShiftLeft:
op = " << ";
break;
case BinaryOperatorType.ShiftRight:
op = " >> ";
break;
case BinaryOperatorType.BitwiseAnd:
op = " & ";
break;
case BinaryOperatorType.BitwiseOr:
op = " | ";
break;
case BinaryOperatorType.ExclusiveOr:
op = " ^ ";
break;
case BinaryOperatorType.BooleanAnd:
op = " && ";
break;
case BinaryOperatorType.BooleanOr:
op = " || ";
break;
case BinaryOperatorType.Equality:
op = " == ";
break;
case BinaryOperatorType.GreaterThan:
op = " > ";
break;
case BinaryOperatorType.GreaterThanOrEqual:
op = " >= ";
break;
case BinaryOperatorType.InEquality:
op = " != ";
break;
case BinaryOperatorType.LessThan:
op = " < ";
break;
case BinaryOperatorType.IS:
op = " == ";
break;
case BinaryOperatorType.LessThanOrEqual:
op = " <= ";
break;
case BinaryOperatorType.Power:
return "Math.Pow(" + left + ", " + right + ")";
default:
throw new Exception("Unknown binary operator:" + binaryOperatorExpression.Op);
}
return String.Concat(left,
op,
right);
}
public virtual object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
{
// visit but can't give back 2 values
binaryOperatorExpression.Left.AcceptVisitor(this, data);
binaryOperatorExpression.Right.AcceptVisitor(this, data);
return data;
}
public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
{
// TODO : Operators
return binaryOperatorExpression.Left.AcceptVisitor(this, data);
}
