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