ExprVisitorBase
class ExprVisitorBase
namespace Microsoft.CSharp.RuntimeBinder.Semantics
{
internal class ExprVisitorBase
{
public EXPR Visit(EXPR pExpr)
{
if (pExpr == null)
return null;
if (IsCachedExpr(pExpr, out EXPR pTransformedExpr))
return pTransformedExpr;
if (pExpr.isSTMT())
return CacheExprMapping(pExpr, DispatchStatementList(pExpr.asSTMT()));
return CacheExprMapping(pExpr, Dispatch(pExpr));
}
protected EXPRSTMT DispatchStatementList(EXPRSTMT expr)
{
EXPRSTMT eXPRSTMT = expr;
EXPRSTMT eXPRSTMT2 = eXPRSTMT;
while (eXPRSTMT2 != null) {
EXPRSTMT optionalNextStatement = eXPRSTMT2.GetOptionalNextStatement();
EXPRSTMT eXPRSTMT3 = eXPRSTMT2;
eXPRSTMT2.SetOptionalNextStatement(null);
EXPR eXPR = Dispatch(eXPRSTMT2);
if (eXPRSTMT2 == eXPRSTMT)
eXPRSTMT = eXPR?.asSTMT();
else
eXPRSTMT2.SetOptionalNextStatement(eXPR?.asSTMT());
while (eXPRSTMT2.GetOptionalNextStatement() != null) {
eXPRSTMT2 = eXPRSTMT2.GetOptionalNextStatement();
}
eXPRSTMT2.SetOptionalNextStatement(optionalNextStatement);
}
return eXPRSTMT;
}
protected bool IsCachedExpr(EXPR pExpr, out EXPR pTransformedExpr)
{
pTransformedExpr = null;
return false;
}
protected EXPR CacheExprMapping(EXPR pExpr, EXPR pTransformedExpr)
{
return pTransformedExpr;
}
protected virtual EXPR Dispatch(EXPR pExpr)
{
switch (pExpr.kind) {
case ExpressionKind.EK_BLOCK:
return VisitBLOCK(pExpr as EXPRBLOCK);
case ExpressionKind.EK_RETURN:
return VisitRETURN(pExpr as EXPRRETURN);
case ExpressionKind.EK_BINOP:
return VisitBINOP(pExpr as EXPRBINOP);
case ExpressionKind.EK_UNARYOP:
return VisitUNARYOP(pExpr as EXPRUNARYOP);
case ExpressionKind.EK_ASSIGNMENT:
return VisitASSIGNMENT(pExpr as EXPRASSIGNMENT);
case ExpressionKind.EK_LIST:
return VisitLIST(pExpr as EXPRLIST);
case ExpressionKind.EK_QUESTIONMARK:
return VisitQUESTIONMARK(pExpr as EXPRQUESTIONMARK);
case ExpressionKind.EK_ARRAYINDEX:
return VisitARRAYINDEX(pExpr as EXPRARRAYINDEX);
case ExpressionKind.EK_ARRAYLENGTH:
return VisitARRAYLENGTH(pExpr as EXPRARRAYLENGTH);
case ExpressionKind.EK_CALL:
return VisitCALL(pExpr as EXPRCALL);
case ExpressionKind.EK_EVENT:
return VisitEVENT(pExpr as EXPREVENT);
case ExpressionKind.EK_FIELD:
return VisitFIELD(pExpr as EXPRFIELD);
case ExpressionKind.EK_LOCAL:
return VisitLOCAL(pExpr as EXPRLOCAL);
case ExpressionKind.EK_THISPOINTER:
return VisitTHISPOINTER(pExpr as EXPRTHISPOINTER);
case ExpressionKind.EK_CONSTANT:
return VisitCONSTANT(pExpr as EXPRCONSTANT);
case ExpressionKind.EK_TYPEARGUMENTS:
return VisitTYPEARGUMENTS(pExpr as EXPRTYPEARGUMENTS);
case ExpressionKind.EK_TYPEORNAMESPACE:
return VisitTYPEORNAMESPACE(pExpr as EXPRTYPEORNAMESPACE);
case ExpressionKind.EK_CLASS:
return VisitCLASS(pExpr as EXPRCLASS);
case ExpressionKind.EK_FUNCPTR:
return VisitFUNCPTR(pExpr as EXPRFUNCPTR);
case ExpressionKind.EK_PROP:
return VisitPROP(pExpr as EXPRPROP);
case ExpressionKind.EK_MULTI:
return VisitMULTI(pExpr as EXPRMULTI);
case ExpressionKind.EK_MULTIGET:
return VisitMULTIGET(pExpr as EXPRMULTIGET);
case ExpressionKind.EK_WRAP:
return VisitWRAP(pExpr as EXPRWRAP);
case ExpressionKind.EK_CONCAT:
return VisitCONCAT(pExpr as EXPRCONCAT);
case ExpressionKind.EK_ARRINIT:
return VisitARRINIT(pExpr as EXPRARRINIT);
case ExpressionKind.EK_CAST:
return VisitCAST(pExpr as EXPRCAST);
case ExpressionKind.EK_USERDEFINEDCONVERSION:
return VisitUSERDEFINEDCONVERSION(pExpr as EXPRUSERDEFINEDCONVERSION);
case ExpressionKind.EK_TYPEOF:
return VisitTYPEOF(pExpr as EXPRTYPEOF);
case ExpressionKind.EK_ZEROINIT:
return VisitZEROINIT(pExpr as EXPRZEROINIT);
case ExpressionKind.EK_USERLOGOP:
return VisitUSERLOGOP(pExpr as EXPRUSERLOGOP);
case ExpressionKind.EK_MEMGRP:
return VisitMEMGRP(pExpr as EXPRMEMGRP);
case ExpressionKind.EK_BOUNDLAMBDA:
return VisitBOUNDLAMBDA(pExpr as EXPRBOUNDLAMBDA);
case ExpressionKind.EK_UNBOUNDLAMBDA:
return VisitUNBOUNDLAMBDA(pExpr as EXPRUNBOUNDLAMBDA);
case ExpressionKind.EK_HOISTEDLOCALEXPR:
return VisitHOISTEDLOCALEXPR(pExpr as EXPRHOISTEDLOCALEXPR);
case ExpressionKind.EK_FIELDINFO:
return VisitFIELDINFO(pExpr as EXPRFIELDINFO);
case ExpressionKind.EK_METHODINFO:
return VisitMETHODINFO(pExpr as EXPRMETHODINFO);
case ExpressionKind.EK_EQUALS:
return VisitEQUALS(pExpr.asBIN());
case ExpressionKind.EK_COMPARE:
return VisitCOMPARE(pExpr.asBIN());
case ExpressionKind.EK_NE:
return VisitNE(pExpr.asBIN());
case ExpressionKind.EK_LT:
return VisitLT(pExpr.asBIN());
case ExpressionKind.EK_LE:
return VisitLE(pExpr.asBIN());
case ExpressionKind.EK_GT:
return VisitGT(pExpr.asBIN());
case ExpressionKind.EK_GE:
return VisitGE(pExpr.asBIN());
case ExpressionKind.EK_ADD:
return VisitADD(pExpr.asBIN());
case ExpressionKind.EK_SUB:
return VisitSUB(pExpr.asBIN());
case ExpressionKind.EK_MUL:
return VisitMUL(pExpr.asBIN());
case ExpressionKind.EK_DIV:
return VisitDIV(pExpr.asBIN());
case ExpressionKind.EK_MOD:
return VisitMOD(pExpr.asBIN());
case ExpressionKind.EK_BITAND:
return VisitBITAND(pExpr.asBIN());
case ExpressionKind.EK_BITOR:
return VisitBITOR(pExpr.asBIN());
case ExpressionKind.EK_BITXOR:
return VisitBITXOR(pExpr.asBIN());
case ExpressionKind.EK_LSHIFT:
return VisitLSHIFT(pExpr.asBIN());
case ExpressionKind.EK_RSHIFT:
return VisitRSHIFT(pExpr.asBIN());
case ExpressionKind.EK_LOGAND:
return VisitLOGAND(pExpr.asBIN());
case ExpressionKind.EK_LOGOR:
return VisitLOGOR(pExpr.asBIN());
case ExpressionKind.EK_SEQUENCE:
return VisitSEQUENCE(pExpr.asBIN());
case ExpressionKind.EK_SEQREV:
return VisitSEQREV(pExpr.asBIN());
case ExpressionKind.EK_SAVE:
return VisitSAVE(pExpr.asBIN());
case ExpressionKind.EK_SWAP:
return VisitSWAP(pExpr.asBIN());
case ExpressionKind.EK_INDIR:
return VisitINDIR(pExpr.asBIN());
case ExpressionKind.EK_STRINGEQ:
return VisitSTRINGEQ(pExpr.asBIN());
case ExpressionKind.EK_STRINGNE:
return VisitSTRINGNE(pExpr.asBIN());
case ExpressionKind.EK_DELEGATEEQ:
return VisitDELEGATEEQ(pExpr.asBIN());
case ExpressionKind.EK_DELEGATENE:
return VisitDELEGATENE(pExpr.asBIN());
case ExpressionKind.EK_DELEGATEADD:
return VisitDELEGATEADD(pExpr.asBIN());
case ExpressionKind.EK_DELEGATESUB:
return VisitDELEGATESUB(pExpr.asBIN());
case ExpressionKind.EK_EQ:
return VisitEQ(pExpr.asBIN());
case ExpressionKind.EK_TRUE:
return VisitTRUE(pExpr.asUnaryOperator());
case ExpressionKind.EK_FALSE:
return VisitFALSE(pExpr.asUnaryOperator());
case ExpressionKind.EK_INC:
return VisitINC(pExpr.asUnaryOperator());
case ExpressionKind.EK_DEC:
return VisitDEC(pExpr.asUnaryOperator());
case ExpressionKind.EK_LOGNOT:
return VisitLOGNOT(pExpr.asUnaryOperator());
case ExpressionKind.EK_NEG:
return VisitNEG(pExpr.asUnaryOperator());
case ExpressionKind.EK_UPLUS:
return VisitUPLUS(pExpr.asUnaryOperator());
case ExpressionKind.EK_BITNOT:
return VisitBITNOT(pExpr.asUnaryOperator());
case ExpressionKind.EK_ADDR:
return VisitADDR(pExpr.asUnaryOperator());
case ExpressionKind.EK_DECIMALNEG:
return VisitDECIMALNEG(pExpr.asUnaryOperator());
case ExpressionKind.EK_DECIMALINC:
return VisitDECIMALINC(pExpr.asUnaryOperator());
case ExpressionKind.EK_DECIMALDEC:
return VisitDECIMALDEC(pExpr.asUnaryOperator());
default:
throw Error.InternalCompilerError();
}
}
protected void VisitChildren(EXPR pExpr)
{
EXPR eXPR = null;
if (!pExpr.isLIST()) {
switch (pExpr.kind) {
case ExpressionKind.EK_NOOP:
case ExpressionKind.EK_LOCAL:
case ExpressionKind.EK_THISPOINTER:
case ExpressionKind.EK_TYPEORNAMESPACE:
case ExpressionKind.EK_CLASS:
case ExpressionKind.EK_FUNCPTR:
case ExpressionKind.EK_MULTIGET:
case ExpressionKind.EK_WRAP:
case ExpressionKind.EK_UNBOUNDLAMBDA:
case ExpressionKind.EK_HOISTEDLOCALEXPR:
case ExpressionKind.EK_FIELDINFO:
case ExpressionKind.EK_METHODINFO:
break;
default:
if (!pExpr.isUnaryOperator())
goto case ExpressionKind.EK_BINOP;
goto case ExpressionKind.EK_UNARYOP;
case ExpressionKind.EK_BINOP:
eXPR = Visit((pExpr as EXPRBINOP).GetOptionalLeftChild());
(pExpr as EXPRBINOP).SetOptionalLeftChild(eXPR);
eXPR = Visit((pExpr as EXPRBINOP).GetOptionalRightChild());
(pExpr as EXPRBINOP).SetOptionalRightChild(eXPR);
break;
case ExpressionKind.EK_LIST:
eXPR = Visit((pExpr as EXPRLIST).GetOptionalElement());
(pExpr as EXPRLIST).SetOptionalElement(eXPR);
eXPR = Visit((pExpr as EXPRLIST).GetOptionalNextListNode());
(pExpr as EXPRLIST).SetOptionalNextListNode(eXPR);
break;
case ExpressionKind.EK_ASSIGNMENT:
eXPR = Visit((pExpr as EXPRASSIGNMENT).GetLHS());
(pExpr as EXPRASSIGNMENT).SetLHS(eXPR);
eXPR = Visit((pExpr as EXPRASSIGNMENT).GetRHS());
(pExpr as EXPRASSIGNMENT).SetRHS(eXPR);
break;
case ExpressionKind.EK_QUESTIONMARK:
eXPR = Visit((pExpr as EXPRQUESTIONMARK).GetTestExpression());
(pExpr as EXPRQUESTIONMARK).SetTestExpression(eXPR);
eXPR = Visit((pExpr as EXPRQUESTIONMARK).GetConsequence());
(pExpr as EXPRQUESTIONMARK).SetConsequence(eXPR as EXPRBINOP);
break;
case ExpressionKind.EK_ARRAYINDEX:
eXPR = Visit((pExpr as EXPRARRAYINDEX).GetArray());
(pExpr as EXPRARRAYINDEX).SetArray(eXPR);
eXPR = Visit((pExpr as EXPRARRAYINDEX).GetIndex());
(pExpr as EXPRARRAYINDEX).SetIndex(eXPR);
break;
case ExpressionKind.EK_ARRAYLENGTH:
eXPR = Visit((pExpr as EXPRARRAYLENGTH).GetArray());
(pExpr as EXPRARRAYLENGTH).SetArray(eXPR);
break;
case ExpressionKind.EK_UNARYOP:
eXPR = ((pExpr as EXPRUNARYOP).Child = Visit((pExpr as EXPRUNARYOP).Child));
break;
case ExpressionKind.EK_USERLOGOP:
eXPR = ((pExpr as EXPRUSERLOGOP).TrueFalseCall = Visit((pExpr as EXPRUSERLOGOP).TrueFalseCall));
eXPR = Visit((pExpr as EXPRUSERLOGOP).OperatorCall);
(pExpr as EXPRUSERLOGOP).OperatorCall = (eXPR as EXPRCALL);
eXPR = ((pExpr as EXPRUSERLOGOP).FirstOperandToExamine = Visit((pExpr as EXPRUSERLOGOP).FirstOperandToExamine));
break;
case ExpressionKind.EK_TYPEOF:
eXPR = Visit((pExpr as EXPRTYPEOF).GetSourceType());
(pExpr as EXPRTYPEOF).SetSourceType(eXPR as EXPRTYPEORNAMESPACE);
break;
case ExpressionKind.EK_CAST:
eXPR = Visit((pExpr as EXPRCAST).GetArgument());
(pExpr as EXPRCAST).SetArgument(eXPR);
eXPR = Visit((pExpr as EXPRCAST).GetDestinationType());
(pExpr as EXPRCAST).SetDestinationType(eXPR as EXPRTYPEORNAMESPACE);
break;
case ExpressionKind.EK_USERDEFINEDCONVERSION:
eXPR = ((pExpr as EXPRUSERDEFINEDCONVERSION).UserDefinedCall = Visit((pExpr as EXPRUSERDEFINEDCONVERSION).UserDefinedCall));
break;
case ExpressionKind.EK_ZEROINIT:
eXPR = ((pExpr as EXPRZEROINIT).OptionalArgument = Visit((pExpr as EXPRZEROINIT).OptionalArgument));
eXPR = ((pExpr as EXPRZEROINIT).OptionalConstructorCall = Visit((pExpr as EXPRZEROINIT).OptionalConstructorCall));
break;
case ExpressionKind.EK_BLOCK:
eXPR = Visit((pExpr as EXPRBLOCK).GetOptionalStatements());
(pExpr as EXPRBLOCK).SetOptionalStatements(eXPR as EXPRSTMT);
break;
case ExpressionKind.EK_MEMGRP:
eXPR = Visit((pExpr as EXPRMEMGRP).GetOptionalObject());
(pExpr as EXPRMEMGRP).SetOptionalObject(eXPR);
break;
case ExpressionKind.EK_CALL:
eXPR = Visit((pExpr as EXPRCALL).GetOptionalArguments());
(pExpr as EXPRCALL).SetOptionalArguments(eXPR);
eXPR = Visit((pExpr as EXPRCALL).GetMemberGroup());
(pExpr as EXPRCALL).SetMemberGroup(eXPR as EXPRMEMGRP);
break;
case ExpressionKind.EK_PROP:
eXPR = Visit((pExpr as EXPRPROP).GetOptionalArguments());
(pExpr as EXPRPROP).SetOptionalArguments(eXPR);
eXPR = Visit((pExpr as EXPRPROP).GetMemberGroup());
(pExpr as EXPRPROP).SetMemberGroup(eXPR as EXPRMEMGRP);
break;
case ExpressionKind.EK_FIELD:
eXPR = Visit((pExpr as EXPRFIELD).GetOptionalObject());
(pExpr as EXPRFIELD).SetOptionalObject(eXPR);
break;
case ExpressionKind.EK_EVENT:
eXPR = ((pExpr as EXPREVENT).OptionalObject = Visit((pExpr as EXPREVENT).OptionalObject));
break;
case ExpressionKind.EK_RETURN:
eXPR = Visit((pExpr as EXPRRETURN).GetOptionalObject());
(pExpr as EXPRRETURN).SetOptionalObject(eXPR);
break;
case ExpressionKind.EK_CONSTANT:
eXPR = Visit((pExpr as EXPRCONSTANT).GetOptionalConstructorCall());
(pExpr as EXPRCONSTANT).SetOptionalConstructorCall(eXPR);
break;
case ExpressionKind.EK_TYPEARGUMENTS:
eXPR = Visit((pExpr as EXPRTYPEARGUMENTS).GetOptionalElements());
(pExpr as EXPRTYPEARGUMENTS).SetOptionalElements(eXPR);
break;
case ExpressionKind.EK_MULTI:
eXPR = Visit((pExpr as EXPRMULTI).GetLeft());
(pExpr as EXPRMULTI).SetLeft(eXPR);
eXPR = Visit((pExpr as EXPRMULTI).GetOperator());
(pExpr as EXPRMULTI).SetOperator(eXPR);
break;
case ExpressionKind.EK_CONCAT:
eXPR = Visit((pExpr as EXPRCONCAT).GetFirstArgument());
(pExpr as EXPRCONCAT).SetFirstArgument(eXPR);
eXPR = Visit((pExpr as EXPRCONCAT).GetSecondArgument());
(pExpr as EXPRCONCAT).SetSecondArgument(eXPR);
break;
case ExpressionKind.EK_ARRINIT:
eXPR = Visit((pExpr as EXPRARRINIT).GetOptionalArguments());
(pExpr as EXPRARRINIT).SetOptionalArguments(eXPR);
eXPR = Visit((pExpr as EXPRARRINIT).GetOptionalArgumentDimensions());
(pExpr as EXPRARRINIT).SetOptionalArgumentDimensions(eXPR);
break;
case ExpressionKind.EK_BOUNDLAMBDA:
eXPR = Visit((pExpr as EXPRBOUNDLAMBDA).OptionalBody);
(pExpr as EXPRBOUNDLAMBDA).OptionalBody = (eXPR as EXPRBLOCK);
break;
}
} else {
EXPRLIST eXPRLIST = pExpr.asLIST();
while (true) {
eXPRLIST.SetOptionalElement(Visit(eXPRLIST.GetOptionalElement()));
if (eXPRLIST.GetOptionalNextListNode() == null)
return;
if (!eXPRLIST.GetOptionalNextListNode().isLIST())
break;
eXPRLIST = eXPRLIST.GetOptionalNextListNode().asLIST();
}
eXPRLIST.SetOptionalNextListNode(Visit(eXPRLIST.GetOptionalNextListNode()));
}
}
protected virtual EXPR VisitEXPR(EXPR pExpr)
{
VisitChildren(pExpr);
return pExpr;
}
protected virtual EXPR VisitBLOCK(EXPRBLOCK pExpr)
{
return VisitSTMT(pExpr);
}
protected virtual EXPR VisitTHISPOINTER(EXPRTHISPOINTER pExpr)
{
return VisitLOCAL(pExpr);
}
protected virtual EXPR VisitRETURN(EXPRRETURN pExpr)
{
return VisitSTMT(pExpr);
}
protected virtual EXPR VisitCLASS(EXPRCLASS pExpr)
{
return VisitTYPEORNAMESPACE(pExpr);
}
protected virtual EXPR VisitSTMT(EXPRSTMT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitBINOP(EXPRBINOP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitLIST(EXPRLIST pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitASSIGNMENT(EXPRASSIGNMENT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitQUESTIONMARK(EXPRQUESTIONMARK pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitARRAYINDEX(EXPRARRAYINDEX pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitARRAYLENGTH(EXPRARRAYLENGTH pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitUNARYOP(EXPRUNARYOP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitUSERLOGOP(EXPRUSERLOGOP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitTYPEOF(EXPRTYPEOF pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitCAST(EXPRCAST pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitUSERDEFINEDCONVERSION(EXPRUSERDEFINEDCONVERSION pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitZEROINIT(EXPRZEROINIT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitMEMGRP(EXPRMEMGRP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitCALL(EXPRCALL pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitPROP(EXPRPROP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitFIELD(EXPRFIELD pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitEVENT(EXPREVENT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitLOCAL(EXPRLOCAL pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitCONSTANT(EXPRCONSTANT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitTYPEARGUMENTS(EXPRTYPEARGUMENTS pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitTYPEORNAMESPACE(EXPRTYPEORNAMESPACE pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitFUNCPTR(EXPRFUNCPTR pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitMULTIGET(EXPRMULTIGET pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitMULTI(EXPRMULTI pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitWRAP(EXPRWRAP pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitCONCAT(EXPRCONCAT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitARRINIT(EXPRARRINIT pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitBOUNDLAMBDA(EXPRBOUNDLAMBDA pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitUNBOUNDLAMBDA(EXPRUNBOUNDLAMBDA pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitHOISTEDLOCALEXPR(EXPRHOISTEDLOCALEXPR pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitFIELDINFO(EXPRFIELDINFO pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitMETHODINFO(EXPRMETHODINFO pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual EXPR VisitEQUALS(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitCOMPARE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitEQ(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitNE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitLE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitGE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitADD(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSUB(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitDIV(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitBITAND(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitBITOR(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitLSHIFT(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitLOGAND(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSEQUENCE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSAVE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitINDIR(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSTRINGEQ(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitDELEGATEEQ(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitDELEGATEADD(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitRANGE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitLT(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitMUL(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitBITXOR(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitRSHIFT(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitLOGOR(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSEQREV(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSTRINGNE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitDELEGATENE(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitGT(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitMOD(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitSWAP(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitDELEGATESUB(EXPRBINOP pExpr)
{
return VisitBINOP(pExpr);
}
protected virtual EXPR VisitTRUE(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitINC(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitLOGNOT(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitNEG(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitBITNOT(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitADDR(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitDECIMALNEG(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitDECIMALDEC(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitFALSE(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitDEC(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitUPLUS(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
protected virtual EXPR VisitDECIMALINC(EXPRUNARYOP pExpr)
{
return VisitUNARYOP(pExpr);
}
}
}