public ExprUserLogicalOp CreateUserLogOpError(CType type, Expr trueFalseCall, ExprCall operatorCall) { ExprUserLogicalOp rval = CreateUserLogOp(type, trueFalseCall, operatorCall); rval.SetError(); return(rval); }
public ExprUserLogicalOp CreateUserLogOpError(CType pType, Expr pCallTF, ExprCall pCallOp) { ExprUserLogicalOp rval = CreateUserLogOp(pType, pCallTF, pCallOp); rval.SetError(); return(rval); }
public ExprUserLogicalOp CreateUserLogOp(CType pType, Expr pCallTF, ExprCall pCallOp) { Debug.Assert(pCallTF != null); Debug.Assert(pCallOp != null); Debug.Assert(pCallOp.OptionalArguments != null); Debug.Assert(pCallOp.OptionalArguments.isLIST()); Debug.Assert(pCallOp.OptionalArguments.asLIST().OptionalElement != null); ExprUserLogicalOp rval = new ExprUserLogicalOp(); Expr leftChild = pCallOp.OptionalArguments.asLIST().OptionalElement; Debug.Assert(leftChild != null); if (leftChild.isWRAP()) { // In the EE case, we don't create WRAPEXPRs. leftChild = leftChild.asWRAP().OptionalExpression; Debug.Assert(leftChild != null); } rval.Kind = ExpressionKind.EK_USERLOGOP; rval.Type = pType; rval.Flags = EXPRFLAG.EXF_ASSGOP; rval.TrueFalseCall = pCallTF; rval.OperatorCall = pCallOp; rval.FirstOperandToExamine = leftChild; Debug.Assert(rval != null); return(rval); }
public ExprUserLogicalOp CreateUserLogOp(CType pType, Expr pCallTF, ExprCall pCallOp) { Debug.Assert(pCallTF != null); Debug.Assert((pCallOp?.OptionalArguments as ExprList)?.OptionalElement != null); ExprUserLogicalOp rval = new ExprUserLogicalOp(pType); Expr leftChild = ((ExprList)pCallOp.OptionalArguments).OptionalElement; Debug.Assert(leftChild != null); if (leftChild is ExprWrap wrap) { // In the EE case, we don't create WRAPEXPRs. leftChild = wrap.OptionalExpression; Debug.Assert(leftChild != null); } rval.Flags = EXPRFLAG.EXF_ASSGOP; rval.TrueFalseCall = pCallTF; rval.OperatorCall = pCallOp; rval.FirstOperandToExamine = leftChild; return(rval); }
private Expr GenerateUserDefinedBinaryOperator(ExprBinOp expr) { Debug.Assert(expr != null); PREDEFMETH pdm; switch (expr.Kind) { case ExpressionKind.LogicalOr: pdm = PREDEFMETH.PM_EXPRESSION_ORELSE_USER_DEFINED; break; case ExpressionKind.LogicalAnd: pdm = PREDEFMETH.PM_EXPRESSION_ANDALSO_USER_DEFINED; break; case ExpressionKind.LeftShirt: pdm = PREDEFMETH.PM_EXPRESSION_LEFTSHIFT_USER_DEFINED; break; case ExpressionKind.RightShift: pdm = PREDEFMETH.PM_EXPRESSION_RIGHTSHIFT_USER_DEFINED; break; case ExpressionKind.BitwiseExclusiveOr: pdm = PREDEFMETH.PM_EXPRESSION_EXCLUSIVEOR_USER_DEFINED; break; case ExpressionKind.BitwiseOr: pdm = PREDEFMETH.PM_EXPRESSION_OR_USER_DEFINED; break; case ExpressionKind.BitwiseAnd: pdm = PREDEFMETH.PM_EXPRESSION_AND_USER_DEFINED; break; case ExpressionKind.Modulo: pdm = PREDEFMETH.PM_EXPRESSION_MODULO_USER_DEFINED; break; case ExpressionKind.Divide: pdm = PREDEFMETH.PM_EXPRESSION_DIVIDE_USER_DEFINED; break; case ExpressionKind.StringEq: case ExpressionKind.StringNotEq: case ExpressionKind.DelegateEq: case ExpressionKind.DelegateNotEq: case ExpressionKind.Eq: case ExpressionKind.NotEq: case ExpressionKind.GreaterThanOrEqual: case ExpressionKind.GreaterThan: case ExpressionKind.LessThanOrEqual: case ExpressionKind.LessThan: return(GenerateUserDefinedComparisonOperator(expr)); case ExpressionKind.DelegateSubtract: case ExpressionKind.Subtract: pdm = expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_SUBTRACTCHECKED_USER_DEFINED : PREDEFMETH.PM_EXPRESSION_SUBTRACT_USER_DEFINED; break; case ExpressionKind.DelegateAdd: case ExpressionKind.Add: pdm = expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_ADDCHECKED_USER_DEFINED : PREDEFMETH.PM_EXPRESSION_ADD_USER_DEFINED; break; case ExpressionKind.Multiply: pdm = expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_MULTIPLYCHECKED_USER_DEFINED : PREDEFMETH.PM_EXPRESSION_MULTIPLY_USER_DEFINED; break; default: throw Error.InternalCompilerError(); } Expr p1 = expr.OptionalLeftChild; Expr p2 = expr.OptionalRightChild; Expr udcall = expr.OptionalUserDefinedCall; if (udcall != null) { Debug.Assert(udcall.Kind == ExpressionKind.Call || udcall.Kind == ExpressionKind.UserLogicalOp); if (udcall is ExprCall ascall) { ExprList args = (ExprList)ascall.OptionalArguments; Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); p1 = args.OptionalElement; p2 = args.OptionalNextListNode; } else { ExprUserLogicalOp userLogOp = udcall as ExprUserLogicalOp; Debug.Assert(userLogOp != null); ExprList args = (ExprList)userLogOp.OperatorCall.OptionalArguments; Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); p1 = ((ExprWrap)args.OptionalElement).OptionalExpression; p2 = args.OptionalNextListNode; } } p1 = Visit(p1); p2 = Visit(p2); FixLiftedUserDefinedBinaryOperators(expr, ref p1, ref p2); Expr methodInfo = GetExprFactory().CreateMethodInfo(expr.UserDefinedCallMethod); Expr call = GenerateCall(pdm, p1, p2, methodInfo); // Delegate add/subtract generates a call to Combine/Remove, which returns System.Delegate, // not the operand delegate CType. We must cast to the delegate CType. if (expr.Kind == ExpressionKind.DelegateSubtract || expr.Kind == ExpressionKind.DelegateAdd) { Expr pTypeOf = CreateTypeOf(expr.Type); return(GenerateCall(PREDEFMETH.PM_EXPRESSION_CONVERT, call, pTypeOf)); } return(call); }
protected virtual Expr VisitUSERLOGOP(ExprUserLogicalOp pExpr) { return(VisitEXPR(pExpr)); }