public Expression Visit(ParserBinaryOp op)
{
Expression leftExpr = op.Left.Accept(this);
Expression rightExpr = op.Right.Accept(this);
switch (op.OpType)
{
case ParserBinaryOpType.Add:
return(new NumBinaryOp(NumBinOps.Add, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.Mul:
return(new NumBinaryOp(NumBinOps.Mul, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.And:
return(new LogicAnd(leftExpr as LogicExpression, rightExpr as LogicExpression));
case ParserBinaryOpType.Or:
return(new LogicOr(leftExpr as LogicExpression, rightExpr as LogicExpression));
case ParserBinaryOpType.EQ:
return(new NumRelation(NumRels.EQ, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.NEQ:
return(new NumRelation(NumRels.NEQ, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.GT:
return(new NumRelation(NumRels.GT, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.LT:
return(new NumRelation(NumRels.LT, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.GTE:
return(new NumRelation(NumRels.GTE, leftExpr as NumExpression, rightExpr as NumExpression));
case ParserBinaryOpType.LTE:
return(new NumRelation(NumRels.LTE, leftExpr as NumExpression, rightExpr as NumExpression));
default:
break;
}
throw new ArgumentException("Unknown binary operation");
}
public ParserType Visit(ParserBinaryOp op)
{
ParserType leftType = op.Left.Accept(this);
ParserType rightType = op.Right.Accept(this);
if (leftType.Typ != rightType.Typ)
{
throw new ArgumentException(String.Format("Types in a binary operation must be the same. Left: {0} Right: {0}",
leftType.ToString(), rightType.ToString()));
}
switch (op.OpType)
{
case ParserBinaryOpType.Add:
if (leftType.Flags.HasFlag(ParserTypeFlags.Number) && leftType.Flags.HasFlag(ParserTypeFlags.Number))
{
op.Type = leftType;
return(leftType);
}
else
{
throw new ArgumentException("Cannot Add these expressions");
}
case ParserBinaryOpType.Mul:
if (leftType.Flags.HasFlag(ParserTypeFlags.Number) && leftType.Flags.HasFlag(ParserTypeFlags.Number))
{
op.Type = leftType;
return(leftType);
}
else
{
throw new ArgumentException("Cannot Multiply these expressions");
}
case ParserBinaryOpType.And:
if (leftType.Flags.HasFlag(ParserTypeFlags.Logic) && leftType.Flags.HasFlag(ParserTypeFlags.Logic))
{
op.Type = leftType;
return(leftType);
}
else
{
throw new ArgumentException("Cannot & these expressions");
}
case ParserBinaryOpType.Or:
if (leftType.Flags.HasFlag(ParserTypeFlags.Logic) && leftType.Flags.HasFlag(ParserTypeFlags.Logic))
{
op.Type = leftType;
return(leftType);
}
else
{
throw new ArgumentException("Cannot | these expressions");
}
case ParserBinaryOpType.EQ:
if (leftType.Flags.HasFlag(ParserTypeFlags.Discrete) && leftType.Flags.HasFlag(ParserTypeFlags.Discrete))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot == these expressions");
}
case ParserBinaryOpType.NEQ:
if (leftType.Flags.HasFlag(ParserTypeFlags.Hausdorff) && leftType.Flags.HasFlag(ParserTypeFlags.Hausdorff))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot != these expressions");
}
case ParserBinaryOpType.GT:
if (leftType.Flags.HasFlag(ParserTypeFlags.StrictOrder) && leftType.Flags.HasFlag(ParserTypeFlags.StrictOrder))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot > these expressions");
}
case ParserBinaryOpType.LT:
if (leftType.Flags.HasFlag(ParserTypeFlags.StrictOrder) && leftType.Flags.HasFlag(ParserTypeFlags.StrictOrder))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot < these expressions");
}
case ParserBinaryOpType.GTE:
if (leftType.Flags.HasFlag(ParserTypeFlags.LooseOrder) && leftType.Flags.HasFlag(ParserTypeFlags.LooseOrder))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot >= these expressions");
}
case ParserBinaryOpType.LTE:
if (leftType.Flags.HasFlag(ParserTypeFlags.LooseOrder) && leftType.Flags.HasFlag(ParserTypeFlags.LooseOrder))
{
ParserType logicType = new ParserLogicType();
op.Type = logicType;
return(logicType);
}
else
{
throw new ArgumentException("Cannot <= these expressions");
}
default:
throw new ArgumentException("Unknown Binary Operation");
}
}
