internal UnaryExpression(ExpressionType nodeType, Expression expression, Type type, MethodInfo method)
{
_operand = expression;
_method = method;
_nodeType = nodeType;
_type = type;
}
public static Operator Create(ExpressionType expressionType)
{
if (!OperatorMap.ContainsKey(expressionType))
throw new NotSupportedException(ExceptionMessages.LambdaOperator_OperatorTypeIsNotSupported.Inject(expressionType));
return OperatorMap[expressionType].Invoke();
}
public static Expression CreateBinaryExpression(ExpressionType expressionType, object lh, object rh)
{
Expression left = (Expression) ((lh is Expression) ? lh : Expression.Constant(lh));
Expression right = (Expression) ((rh is Expression) ? rh : Expression.Constant(rh));
switch (expressionType)
{
case ExpressionType.Add:
return Expression.Add(left, right);
case ExpressionType.Subtract:
return Expression.Subtract(left, right);
case ExpressionType.Multiply:
return Expression.Multiply(left, right);
case ExpressionType.Divide:
return Expression.Divide(left, right);
case ExpressionType.And:
return Expression.And(left, right);
case ExpressionType.AndAlso:
return Expression.AndAlso(left, right);
case ExpressionType.Or:
return Expression.Or(left, right);
case ExpressionType.OrElse:
return Expression.Or(left, right);
}
throw new ApplicationException("huh?");
}
internal BinaryExpression (ExpressionType node_type, Type type, Expression left, Expression right, MethodInfo method)
: base (node_type, type)
{
this.left = left;
this.right = right;
this.method = method;
}
private Expression Calculate(Expression expression, ExpressionType binaryType, bool constant)
{
if (binaryType == ExpressionType.NotEqual)
constant = !constant;
return constant ? expression : Expression.Not(expression);
}
/// <summary>
/// Initializes a new instance of the Expression class.
/// </summary>
/// <param name="proxy">Proxy object for the expression.</param>
/// <param name="type">The type of the expression.</param>
internal Expression(CodeUnitProxy proxy, ExpressionType type)
: base(proxy, (int)type)
{
Param.AssertNotNull(proxy, "proxy");
Param.Ignore(type);
CsLanguageService.Debug.Assert(System.Enum.IsDefined(typeof(ExpressionType), this.ExpressionType), "The type is invalid.");
}
internal static NewArrayExpression Make(ExpressionType nodeType, Type type, ReadOnlyCollection<Expression> expressions) {
if (nodeType == ExpressionType.NewArrayInit) {
return new NewArrayInitExpression(type, expressions);
} else {
return new NewArrayBoundsExpression(type, expressions);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ExtensionExpression"/> class with a custom <see cref="ExpressionType"/> value.
/// </summary>
/// <param name="type">The type of the value represented by the <see cref="ExtensionExpression"/>.</param>
/// <param name="nodeType">The <see cref="ExpressionType"/> value to use as this expression's <see cref="Expression.NodeType"/> value.
/// LINQ providers should use values starting from 150001 and above.</param>
protected ExtensionExpression (Type type, ExpressionType nodeType)
{
ArgumentUtility.CheckNotNull ("type", type);
_type = type;
_nodeType = nodeType;
}
internal UnaryExpression (ExpressionType node_type, Expression operand, Type type, MethodInfo method, bool is_lifted)
: base (node_type, type)
{
this.operand = operand;
this.method = method;
this.is_lifted = is_lifted;
}
protected MethodExpression(ExpressionType type, Expression objectReference, MethodSymbol method, Collection<Expression> parameters) :
base(type, (method.AssociatedType.Type == SymbolType.GenericParameter ? objectReference.EvaluatedType : method.AssociatedType),
SymbolFilter.Public | SymbolFilter.InstanceMembers) {
_method = method;
_objectReference = objectReference;
_parameters = (parameters == null) ? new Collection<Expression>() : parameters;
}
internal void AppendBinaryOperator(ExpressionType type)
{
switch (type)
{
case ExpressionType.And:
case ExpressionType.AndAlso:
this.LambdaExpression.Append(" && ");
break;
case ExpressionType.Or:
case ExpressionType.OrElse:
this.LambdaExpression.Append(" || ");
break;
case ExpressionType.Equal:
this.LambdaExpression.Append(" == ");
break;
case ExpressionType.NotEqual:
this.LambdaExpression.Append(" <> ");
break;
case ExpressionType.LessThan:
this.LambdaExpression.Append(" < ");
break;
case ExpressionType.LessThanOrEqual:
this.LambdaExpression.Append(" <= ");
break;
case ExpressionType.GreaterThan:
this.LambdaExpression.Append(" > ");
break;
case ExpressionType.GreaterThanOrEqual:
this.LambdaExpression.Append(" >= ");
break;
default:
throw new NotSupportedException($"The binary operator '{type}' is not supported");
}
}
//public bool IsLiftedToNull {
// get { return is_lifted && this.Type.IsNullable (); }
//}
UnaryExpression (ExpressionType nodeType, Expression operand, Type type, MethodInfo method, bool isLifted)
: base(nodeType, type)
{
Operand = operand;
Method = method;
IsLifted = isLifted;
}
public Expression Update(Expression target, Type type, ExpressionType @operator) {
if (Type.Equals(type) && ReferenceEquals(Target, target) && Operator == @operator) {
return this;
}
return AstExpression.Event(Target, _eventInfo, Operator, ParentScope, Visitor);
}
/// <summary>
/// 获取常量转换处理函数
/// </summary>
/// <param name="type">数据类型</param>
/// <returns>失败返回null</returns>
public action<converter, Expression> this[ExpressionType type]
{
get
{
return converters[(int)type];
}
}
internal UnaryExpression(ExpressionType nodeType, Expression expression, Type type, MethodInfo method)
{
Operand = expression;
Method = method;
NodeType = nodeType;
Type = type;
}
public static Operators ExpressionTypeToOperator(ExpressionType et) {
switch (et) {
case ExpressionType.Add: return Operators.Add;
case ExpressionType.And: return Operators.BitwiseAnd;
case ExpressionType.Divide: return Operators.Divide;
case ExpressionType.ExclusiveOr: return Operators.ExclusiveOr;
case ExpressionType.Modulo: return Operators.Mod;
case ExpressionType.Multiply: return Operators.Multiply;
case ExpressionType.Or: return Operators.BitwiseOr;
case ExpressionType.Power: return Operators.Power;
case ExpressionType.RightShift: return Operators.RightShift;
case ExpressionType.LeftShift: return Operators.LeftShift;
case ExpressionType.Subtract: return Operators.Subtract;
case ExpressionType.AddAssign: return Operators.InPlaceAdd;
case ExpressionType.AndAssign: return Operators.InPlaceBitwiseAnd;
case ExpressionType.DivideAssign: return Operators.InPlaceDivide;
case ExpressionType.ExclusiveOrAssign: return Operators.InPlaceExclusiveOr;
case ExpressionType.ModuloAssign: return Operators.InPlaceMod;
case ExpressionType.MultiplyAssign: return Operators.InPlaceMultiply;
case ExpressionType.OrAssign: return Operators.InPlaceBitwiseOr;
case ExpressionType.PowerAssign: return Operators.InPlacePower;
case ExpressionType.RightShiftAssign: return Operators.InPlaceRightShift;
case ExpressionType.LeftShiftAssign: return Operators.InPlaceLeftShift;
case ExpressionType.SubtractAssign: return Operators.InPlaceSubtract;
case ExpressionType.Equal: return Operators.Equals;
case ExpressionType.GreaterThan: return Operators.GreaterThan;
case ExpressionType.GreaterThanOrEqual: return Operators.GreaterThanOrEqual;
case ExpressionType.LessThan: return Operators.LessThan;
case ExpressionType.LessThanOrEqual: return Operators.LessThanOrEqual;
case ExpressionType.NotEqual: return Operators.NotEquals;
}
return Operators.None;
}
public static bool TryGet(ExpressionType expressionType, out CompareOperation compareOperation)
{
switch (expressionType) {
case ExpressionType.Equal:
compareOperation = CompareOperation.Equal;
return true;
case ExpressionType.NotEqual:
compareOperation = CompareOperation.NotEqual;
return true;
case ExpressionType.GreaterThan:
compareOperation = CompareOperation.GreaterThan;
return true;
case ExpressionType.GreaterThanOrEqual:
compareOperation = CompareOperation.GreaterThanOrEqual;
return true;
case ExpressionType.LessThan:
compareOperation = CompareOperation.LessThan;
return true;
case ExpressionType.LessThanOrEqual:
compareOperation = CompareOperation.LessThanOrEqual;
return true;
}
compareOperation = CompareOperation.Equal;
return false;
}
public void AddExpression(string[] keywords, string[] responses, string[] contexts,
ExpressionLocation location, ExpressionType type)
{
Expression newKey = new Expression(keywords, location, type, responses, contexts);
AddExpression(newKey);
}
internal Expression(ReportDefn r, ReportLink p, String xNode, ExpressionType et) : base(r, p)
{
_Source = xNode;
_Type = TypeCode.Empty;
_ExpectedType = et;
_Expr = null;
}
/// <summary>
/// 二元表达式
/// </summary>
/// <param name="left">左表达式</param>
/// <param name="right">右表达式</param>
/// <param name="method">运算符重载函数</param>
internal BinaryExpression(ExpressionType type, Expression left, Expression right, MethodInfo method)
{
NodeType = type;
Left = left.SimpleExpression;
Right = right.SimpleExpression;
Method = method;
}
protected OperandsMutableExpression(ExpressionType expressionType, Type type, IList<Expression> operands)
: base(expressionType, type)
{
if(operands==null)
operands = new Expression[0];
this.operands = new ReadOnlyCollection<Expression>(operands);
}
public BinaryOpNode(Node left, Node right, ExpressionType op)
: base(NodeType.BinaryOp)
{
Left = left;
Right = right;
Op = op;
}
internal UnaryExpression(ExpressionType nodeType, Expression expression, Type type, MethodInfo method)
{
this._operand = expression;
this._method = method;
this._nodeType = nodeType;
this._type = type;
}
public BinaryExpression(Expression left, Expression right, ExpressionType nodeType,
bool liftToNull, MethodInfo method) : base(nodeType)
{
Left = left;
Right = right;
Method = method;
}
/// <summary>
/// Constructor of the OperationOnIndexBinder object, representing "a.b (op)= c" operation.
/// </summary>
/// <param name="operation">Binary operation to be performed.</param>
/// <param name="name">Name of the member for the operation.</param>
/// <param name="ignoreCase">Ignore case of the member.</param>
protected UnaryOperationOnMemberBinder(ExpressionType operation, string name, bool ignoreCase) {
ContractUtils.RequiresNotNull(name, "name");
ContractUtils.Requires(UnaryOperationBinder.OperationIsValid(operation), "operation");
_operation = operation;
_name = name;
_ignoreCase = ignoreCase;
}
public static string ConvertBinaryTypeToSql(ExpressionType type)
{
switch (type)
{
case ExpressionType.GreaterThan:
return " > ";
case ExpressionType.GreaterThanOrEqual:
return " >= ";
case ExpressionType.LessThan:
return " < ";
case ExpressionType.LessThanOrEqual:
return " <= ";
case ExpressionType.And:
case ExpressionType.AndAlso:
return " AND ";
case ExpressionType.Or:
case ExpressionType.OrElse:
return " OR ";
case ExpressionType.Equal:
return " = ";
case ExpressionType.NotEqual:
return " <> ";
}
throw new NotImplementedException("The expression type: " + type);
}
private static String GetSymbolName(ExpressionType operation)
{
switch (operation)
{
case ExpressionType.Negate:
return "-";
case ExpressionType.UnaryPlus:
return "+";
case ExpressionType.NegateChecked:
return "-";
case ExpressionType.Not:
return "!";
case ExpressionType.Quote:
return "quote";
case ExpressionType.Decrement:
return "--";
case ExpressionType.Increment:
return "++";
case ExpressionType.PreIncrementAssign:
return "++=";
case ExpressionType.PreDecrementAssign:
return "--=";
case ExpressionType.PostIncrementAssign:
return "=++";
case ExpressionType.PostDecrementAssign:
return "=--";
case ExpressionType.OnesComplement:
return "~";
}
throw new NotSupportedException("YacqUnaryOperationBinder does not supports " + operation);
}
public UnaryExpression(ExpressionType nodeType, Expression operand, MethodInfo method, Type type) : base(nodeType)
{
Operand = operand;
Method = method;
this.type = type;
}
string _UniqueName; // unique name of expression; not always created
internal Expression(ReportDefn r, ReportLink p, XmlNode xNode, ExpressionType et) : base(r, p)
{
_Source=xNode.InnerText;
_Type = TypeCode.Empty;
_ExpectedType = et;
_Expr = null;
}
protected OperatorImplementation AddBinary(ExpressionType op, Type commonType,
BinaryOperatorMethod binaryMethod, UnaryOperatorMethod resultConverter) {
var key = new OperatorDispatchKey(op, commonType, commonType);
var impl = new OperatorImplementation(key, commonType, binaryMethod, null, null, resultConverter);
OperatorImplementations[key] = impl;
return impl;
}
internal Expression(ExpressionType type)
{
Type = type;
}
public TokenExpression(ExpressionType type, Token token) : base(type)
{
this.token = token;
}
private void EmitLift(ExpressionType nodeType, Type resultType, MethodCallExpression mc, ParameterExpression[] paramList, Expression[] argList)
{
Debug.Assert(TypeUtils.AreEquivalent(TypeUtils.GetNonNullableType(resultType), TypeUtils.GetNonNullableType(mc.Type)));
switch (nodeType)
{
default:
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
{
Label exit = _ilg.DefineLabel();
Label exitNull = _ilg.DefineLabel();
LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool));
for (int i = 0, n = paramList.Length; i < n; i++)
{
ParameterExpression v = paramList[i];
Expression arg = argList[i];
if (TypeUtils.IsNullableType(arg.Type))
{
_scope.AddLocal(this, v);
EmitAddress(arg, arg.Type);
_ilg.Emit(OpCodes.Dup);
_ilg.EmitHasValue(arg.Type);
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Stloc, anyNull);
_ilg.EmitGetValueOrDefault(arg.Type);
_scope.EmitSet(v);
}
else
{
_scope.AddLocal(this, v);
EmitExpression(arg);
if (!arg.Type.GetTypeInfo().IsValueType)
{
_ilg.Emit(OpCodes.Dup);
_ilg.Emit(OpCodes.Ldnull);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Stloc, anyNull);
}
_scope.EmitSet(v);
}
_ilg.Emit(OpCodes.Ldloc, anyNull);
_ilg.Emit(OpCodes.Brtrue, exitNull);
}
EmitMethodCallExpression(mc);
if (TypeUtils.IsNullableType(resultType) && !TypeUtils.AreEquivalent(resultType, mc.Type))
{
ConstructorInfo ci = resultType.GetConstructor(new Type[] { mc.Type });
_ilg.Emit(OpCodes.Newobj, ci);
}
_ilg.Emit(OpCodes.Br_S, exit);
_ilg.MarkLabel(exitNull);
if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type)))
{
if (resultType.GetTypeInfo().IsValueType)
{
LocalBuilder result = GetLocal(resultType);
_ilg.Emit(OpCodes.Ldloca, result);
_ilg.Emit(OpCodes.Initobj, resultType);
_ilg.Emit(OpCodes.Ldloc, result);
FreeLocal(result);
}
else
{
_ilg.Emit(OpCodes.Ldnull);
}
}
else
{
switch (nodeType)
{
case ExpressionType.LessThan:
case ExpressionType.LessThanOrEqual:
case ExpressionType.GreaterThan:
case ExpressionType.GreaterThanOrEqual:
_ilg.Emit(OpCodes.Ldc_I4_0);
break;
default:
throw Error.UnknownLiftType(nodeType);
}
}
_ilg.MarkLabel(exit);
return;
}
case ExpressionType.Equal:
case ExpressionType.NotEqual:
{
if (TypeUtils.AreEquivalent(resultType, TypeUtils.GetNullableType(mc.Type)))
{
goto default;
}
Label exit = _ilg.DefineLabel();
Label exitAllNull = _ilg.DefineLabel();
Label exitAnyNull = _ilg.DefineLabel();
LocalBuilder anyNull = _ilg.DeclareLocal(typeof(bool));
LocalBuilder allNull = _ilg.DeclareLocal(typeof(bool));
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Stloc, anyNull);
_ilg.Emit(OpCodes.Ldc_I4_1);
_ilg.Emit(OpCodes.Stloc, allNull);
for (int i = 0, n = paramList.Length; i < n; i++)
{
ParameterExpression v = paramList[i];
Expression arg = argList[i];
_scope.AddLocal(this, v);
if (TypeUtils.IsNullableType(arg.Type))
{
EmitAddress(arg, arg.Type);
_ilg.Emit(OpCodes.Dup);
_ilg.EmitHasValue(arg.Type);
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Dup);
_ilg.Emit(OpCodes.Ldloc, anyNull);
_ilg.Emit(OpCodes.Or);
_ilg.Emit(OpCodes.Stloc, anyNull);
_ilg.Emit(OpCodes.Ldloc, allNull);
_ilg.Emit(OpCodes.And);
_ilg.Emit(OpCodes.Stloc, allNull);
_ilg.EmitGetValueOrDefault(arg.Type);
}
else
{
EmitExpression(arg);
if (!arg.Type.GetTypeInfo().IsValueType)
{
_ilg.Emit(OpCodes.Dup);
_ilg.Emit(OpCodes.Ldnull);
_ilg.Emit(OpCodes.Ceq);
_ilg.Emit(OpCodes.Dup);
_ilg.Emit(OpCodes.Ldloc, anyNull);
_ilg.Emit(OpCodes.Or);
_ilg.Emit(OpCodes.Stloc, anyNull);
_ilg.Emit(OpCodes.Ldloc, allNull);
_ilg.Emit(OpCodes.And);
_ilg.Emit(OpCodes.Stloc, allNull);
}
else
{
_ilg.Emit(OpCodes.Ldc_I4_0);
_ilg.Emit(OpCodes.Stloc, allNull);
}
}
_scope.EmitSet(v);
}
_ilg.Emit(OpCodes.Ldloc, allNull);
_ilg.Emit(OpCodes.Brtrue, exitAllNull);
_ilg.Emit(OpCodes.Ldloc, anyNull);
_ilg.Emit(OpCodes.Brtrue, exitAnyNull);
EmitMethodCallExpression(mc);
if (TypeUtils.IsNullableType(resultType) && !TypeUtils.AreEquivalent(resultType, mc.Type))
{
ConstructorInfo ci = resultType.GetConstructor(new Type[] { mc.Type });
_ilg.Emit(OpCodes.Newobj, ci);
}
_ilg.Emit(OpCodes.Br_S, exit);
_ilg.MarkLabel(exitAllNull);
_ilg.EmitBoolean(nodeType == ExpressionType.Equal);
_ilg.Emit(OpCodes.Br_S, exit);
_ilg.MarkLabel(exitAnyNull);
_ilg.EmitBoolean(nodeType == ExpressionType.NotEqual);
_ilg.MarkLabel(exit);
return;
}
}
}
public AccessKeyExpression(ExpressionType type, List <string> accessor) : base(type)
{
this.AccessObj = accessor;
}
public FunctionExpression(ExpressionType type, List <string> accessor, List <Expression> parameters) :
base(type)
{
this.parameters = parameters;
this.AccessObj = accessor;
}
public FunctionExpression(ExpressionType type, Function fun) : base(type)
{
this.function = fun;
}
public FunctionExpression(ExpressionType type, string id, List <Expression> parameters) : base(type)
{
this.name = id;
this.parameters = parameters;
}
public ValueExpression(ExpressionType type, ExpressionValue value) : base(type)
{
this.Value = value;
}
public Expression(ExpressionType kind)
{
this.kind = kind;
}
public Expression(ExpressionType kind, ExpressionValue val)
{
this.kind = kind; this.value = val;
}
public PythonUnaryOperationBinder(PythonContext /*!*/ context, ExpressionType operation)
: base(operation)
{
_context = context;
}
public OperationExpression(ExpressionType type, Expression rhs, Expression lhs) : base(type)
{
this.rhs = rhs;
this.lhs = lhs;
}
/// <summary>
/// Performs the specified unary operator on the remote object.
/// </summary>
public ObjectHandle DoOperation(ExpressionType op, [NotNull] ObjectHandle target)
{
return(new ObjectHandle((object)DoOperation(op, GetLocalObject(target))));
}
/// <summary>
/// Performs the specified binary operator on the remote object.
/// </summary>
public ObjectHandle DoOperation(ExpressionType op, ObjectHandle target, ObjectHandle other)
{
return(new ObjectHandle((object)DoOperation(op, GetLocalObject(target), GetLocalObject(other))));
}
/// <summary>
/// Performs the generic binary operation on the specified targets and returns the result.
/// </summary>
public dynamic DoOperation(ExpressionType operation, object target, object other)
{
return(_ops.DoOperation <object, object, object>(operation, target, other));
}
/// <summary>
/// Peforms the generic binary operation on the specified strongly typed targets and returns
/// the strongly typed result.
/// </summary>
public TResult DoOperation <TTarget, TOther, TResult>(ExpressionType operation, TTarget target, TOther other)
{
return(_ops.DoOperation <TTarget, TOther, TResult>(operation, target, other));
}
protected virtual string GetOperator(ExpressionType type)
{
switch (type)
{
case ExpressionType.Not:
return("!");
case ExpressionType.Add:
case ExpressionType.AddChecked:
return("+");
case ExpressionType.Negate:
case ExpressionType.NegateChecked:
case ExpressionType.Subtract:
case ExpressionType.SubtractChecked:
return("-");
case ExpressionType.Multiply:
case ExpressionType.MultiplyChecked:
return("*");
case ExpressionType.Divide:
return("/");
case ExpressionType.Modulo:
return("%");
case ExpressionType.And:
return("&");
case ExpressionType.AndAlso:
return("&&");
case ExpressionType.Or:
return("|");
case ExpressionType.OrElse:
return("||");
case ExpressionType.LessThan:
return("<");
case ExpressionType.LessThanOrEqual:
return("<=");
case ExpressionType.GreaterThan:
return(">");
case ExpressionType.GreaterThanOrEqual:
return(">=");
case ExpressionType.Equal:
return("==");
case ExpressionType.NotEqual:
return("!=");
case ExpressionType.Coalesce:
return("??");
case ExpressionType.RightShift:
return(">>");
case ExpressionType.LeftShift:
return("<<");
case ExpressionType.ExclusiveOr:
return("^");
default:
return(null);
}
}
static string ToString(ExpressionType type)
{
switch (type)
{
case ExpressionType.Add:
return("+");
case ExpressionType.And:
return("&");
case ExpressionType.AndAlso:
return("&&");
case ExpressionType.Divide:
return("/");
case ExpressionType.Equal:
return("==");
case ExpressionType.GreaterThan:
return(">");
case ExpressionType.GreaterThanOrEqual:
return(">=");
case ExpressionType.LessThan:
return("<");
case ExpressionType.LessThanOrEqual:
return("<=");
case ExpressionType.Modulo:
return("%");
case ExpressionType.Multiply:
return("*");
case ExpressionType.Negate:
return("-");
case ExpressionType.Not:
return("!");
case ExpressionType.NotEqual:
return("!=");
case ExpressionType.Or:
return("|");
case ExpressionType.OrElse:
return("||");
case ExpressionType.Subtract:
return("-");
case ExpressionType.Coalesce:
return("??");
case ExpressionType.ExclusiveOr:
return("^");
default:
throw new NotImplementedException();
}
}
private Expression VisitVBCompilerServicesOperatorsCompareString(MethodCallExpression mex, ExpressionType expressionType, int comparisonValue)
{
if (comparisonValue == 0)
{
return(Expression.MakeBinary(
expressionType,
mex.Arguments[0],
mex.Arguments[1]));
}
return(null);
}
public virtual ExpressionRepresentationBase DeepCloneWithNodeType(ExpressionType nodeType)
{
throw new NotImplementedException("This method should be abstract. It was generated as virtual so that you aren't forced to override it when you create a new model that derives from this model. It will be overridden in the generated designer file.");
}
protected ExpressionFingerprint(ExpressionType nodeType, Type type)
{
NodeType = nodeType;
Type = type;
}
private Expression VisitVBCompilerServicesOperators(MethodCallExpression mex, ExpressionType expressionType, ConstantExpression constant)
{
if (mex.Method.Name == "CompareString" && constant.Type == typeof(Int32))
{
return(VisitVBCompilerServicesOperatorsCompareString(mex, expressionType, (int)constant.Value));
}
return(null);
}
public static bool IsDbExpression(this ExpressionType et)
{
return(((int)et) >= 1000);
}
internal BuiltinOperatorInfo(Type declaringType, ExpressionType op)
{
DeclaringType = declaringType;
expression = op;
}
public LuaBinaryOperationBinder(Lua lua, ExpressionType operation, bool isInteger)
: base(operation)
{
this.lua = lua;
this.isInteger = isInteger;
} // ctor
/// <summary>
/// Constructor with an <see cref="ExpressionType"/>, a <see cref="Type"/> and an <see cref="ExpressionConverter"/>.
/// </summary>
/// <param name="nodeType">The <see cref="ExpressionType"/> of the <see cref="Expression"/>.</param>
/// <param name="type">The <see cref="Type"/> of the <see cref="Expression"/>.</param>
/// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param>
private SerializableExpression(ExpressionType nodeType, Type type, ExpressionConverter expConverter)
: this()
{
NodeType = nodeType;
Type = InterLinqTypeSystem.Instance.GetInterLinqVersionOf <InterLinqType>(type);
}
public BinaryExpression(ExpressionType binaryOperator, NodeExpression left, NodeExpression right)
{
_binaryOperator = binaryOperator;
_left = left;
_right = right;
}
public ExpressionNode(ExpressionNode left, int right, ExpressionType expressionType)
{
this.left = left;
this.right = right;
this.expressionType = expressionType;
}
private static Tuple <CrawlType, CrawlType, ExpressionType> _tegnTegn(ExpressionType eType)
{
return(new Tuple <CrawlType, CrawlType, ExpressionType>(CrawlSimpleType.Tegn, CrawlSimpleType.Tegn, eType));
}
public LuaUnaryOperationBinder(Lua lua, ExpressionType operation)
: base(operation)
{
this.lua = lua;
} // ctor
