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