ExprVisitorBase
namespace Microsoft.CSharp.RuntimeBinder.Semantics
{
internal abstract class ExprVisitorBase
{
protected Expr Visit(Expr pExpr)
{
if (pExpr != null)
return Dispatch(pExpr);
return null;
}
protected virtual Expr Dispatch(Expr pExpr)
{
switch (pExpr.Kind) {
case ExpressionKind.BinaryOp:
return VisitBINOP(pExpr as ExprBinOp);
case ExpressionKind.UnaryOp:
return VisitUNARYOP(pExpr as ExprUnaryOp);
case ExpressionKind.Assignment:
return VisitASSIGNMENT(pExpr as ExprAssignment);
case ExpressionKind.List:
return VisitLIST(pExpr as ExprList);
case ExpressionKind.ArrayIndex:
return VisitARRAYINDEX(pExpr as ExprArrayIndex);
case ExpressionKind.Call:
return VisitCALL(pExpr as ExprCall);
case ExpressionKind.Field:
return VisitFIELD(pExpr as ExprField);
case ExpressionKind.Local:
return VisitLOCAL(pExpr as ExprLocal);
case ExpressionKind.Constant:
return VisitCONSTANT(pExpr as ExprConstant);
case ExpressionKind.Class:
return pExpr;
case ExpressionKind.Property:
return VisitPROP(pExpr as ExprProperty);
case ExpressionKind.Multi:
return VisitMULTI(pExpr as ExprMulti);
case ExpressionKind.MultiGet:
return VisitMULTIGET(pExpr as ExprMultiGet);
case ExpressionKind.Wrap:
return VisitWRAP(pExpr as ExprWrap);
case ExpressionKind.Concat:
return VisitCONCAT(pExpr as ExprConcat);
case ExpressionKind.ArrayInit:
return VisitARRINIT(pExpr as ExprArrayInit);
case ExpressionKind.Cast:
return VisitCAST(pExpr as ExprCast);
case ExpressionKind.UserDefinedConversion:
return VisitUSERDEFINEDCONVERSION(pExpr as ExprUserDefinedConversion);
case ExpressionKind.TypeOf:
return VisitTYPEOF(pExpr as ExprTypeOf);
case ExpressionKind.ZeroInit:
return VisitZEROINIT(pExpr as ExprZeroInit);
case ExpressionKind.UserLogicalOp:
return VisitUSERLOGOP(pExpr as ExprUserLogicalOp);
case ExpressionKind.MemberGroup:
return VisitMEMGRP(pExpr as ExprMemberGroup);
case ExpressionKind.FieldInfo:
return VisitFIELDINFO(pExpr as ExprFieldInfo);
case ExpressionKind.MethodInfo:
return VisitMETHODINFO(pExpr as ExprMethodInfo);
case ExpressionKind.EqualsParam:
return VisitEQUALS(pExpr as ExprBinOp);
case ExpressionKind.Compare:
return VisitCOMPARE(pExpr as ExprBinOp);
case ExpressionKind.NotEq:
return VisitNE(pExpr as ExprBinOp);
case ExpressionKind.LessThan:
return VisitLT(pExpr as ExprBinOp);
case ExpressionKind.LessThanOrEqual:
return VisitLE(pExpr as ExprBinOp);
case ExpressionKind.GreaterThan:
return VisitGT(pExpr as ExprBinOp);
case ExpressionKind.GreaterThanOrEqual:
return VisitGE(pExpr as ExprBinOp);
case ExpressionKind.Add:
return VisitADD(pExpr as ExprBinOp);
case ExpressionKind.Subtract:
return VisitSUB(pExpr as ExprBinOp);
case ExpressionKind.Multiply:
return VisitMUL(pExpr as ExprBinOp);
case ExpressionKind.Divide:
return VisitDIV(pExpr as ExprBinOp);
case ExpressionKind.Modulo:
return VisitMOD(pExpr as ExprBinOp);
case ExpressionKind.BitwiseAnd:
return VisitBITAND(pExpr as ExprBinOp);
case ExpressionKind.BitwiseOr:
return VisitBITOR(pExpr as ExprBinOp);
case ExpressionKind.BitwiseExclusiveOr:
return VisitBITXOR(pExpr as ExprBinOp);
case ExpressionKind.LeftShirt:
return VisitLSHIFT(pExpr as ExprBinOp);
case ExpressionKind.RightShift:
return VisitRSHIFT(pExpr as ExprBinOp);
case ExpressionKind.LogicalAnd:
return VisitLOGAND(pExpr as ExprBinOp);
case ExpressionKind.LogicalOr:
return VisitLOGOR(pExpr as ExprBinOp);
case ExpressionKind.Sequence:
return VisitSEQUENCE(pExpr as ExprBinOp);
case ExpressionKind.Save:
return VisitSAVE(pExpr as ExprBinOp);
case ExpressionKind.Swap:
return VisitSWAP(pExpr as ExprBinOp);
case ExpressionKind.Indir:
return VisitINDIR(pExpr as ExprBinOp);
case ExpressionKind.StringEq:
return VisitSTRINGEQ(pExpr as ExprBinOp);
case ExpressionKind.StringNotEq:
return VisitSTRINGNE(pExpr as ExprBinOp);
case ExpressionKind.DelegateEq:
return VisitDELEGATEEQ(pExpr as ExprBinOp);
case ExpressionKind.DelegateNotEq:
return VisitDELEGATENE(pExpr as ExprBinOp);
case ExpressionKind.DelegateAdd:
return VisitDELEGATEADD(pExpr as ExprBinOp);
case ExpressionKind.DelegateSubtract:
return VisitDELEGATESUB(pExpr as ExprBinOp);
case ExpressionKind.Eq:
return VisitEQ(pExpr as ExprBinOp);
case ExpressionKind.True:
return VisitTRUE(pExpr as ExprUnaryOp);
case ExpressionKind.False:
return VisitFALSE(pExpr as ExprUnaryOp);
case ExpressionKind.Inc:
return VisitINC(pExpr as ExprUnaryOp);
case ExpressionKind.Dec:
return VisitDEC(pExpr as ExprUnaryOp);
case ExpressionKind.LogicalNot:
return VisitLOGNOT(pExpr as ExprUnaryOp);
case ExpressionKind.Negate:
return VisitNEG(pExpr as ExprUnaryOp);
case ExpressionKind.UnaryPlus:
return VisitUPLUS(pExpr as ExprUnaryOp);
case ExpressionKind.BitwiseNot:
return VisitBITNOT(pExpr as ExprUnaryOp);
case ExpressionKind.Addr:
return VisitADDR(pExpr as ExprUnaryOp);
case ExpressionKind.DecimalNegate:
return VisitDECIMALNEG(pExpr as ExprUnaryOp);
case ExpressionKind.DecimalInc:
return VisitDECIMALINC(pExpr as ExprUnaryOp);
case ExpressionKind.DecimalDec:
return VisitDECIMALDEC(pExpr as ExprUnaryOp);
default:
throw Error.InternalCompilerError();
}
}
private void VisitChildren(Expr pExpr)
{
switch (pExpr.Kind) {
case ExpressionKind.NoOp:
case ExpressionKind.Local:
case ExpressionKind.Class:
case ExpressionKind.MultiGet:
case ExpressionKind.Wrap:
case ExpressionKind.TypeOf:
case ExpressionKind.ZeroInit:
case ExpressionKind.FieldInfo:
case ExpressionKind.MethodInfo:
break;
case ExpressionKind.List: {
ExprList exprList = (ExprList)pExpr;
Expr optionalNextListNode;
while (true) {
exprList.OptionalElement = Visit(exprList.OptionalElement);
optionalNextListNode = exprList.OptionalNextListNode;
if (optionalNextListNode == null)
return;
ExprList exprList2 = optionalNextListNode as ExprList;
if (exprList2 == null)
break;
exprList = exprList2;
}
exprList.OptionalNextListNode = Visit(optionalNextListNode);
break;
}
case ExpressionKind.Assignment: {
Expr expr2 = (pExpr as ExprAssignment).LHS = Visit((pExpr as ExprAssignment).LHS);
expr2 = ((pExpr as ExprAssignment).RHS = Visit((pExpr as ExprAssignment).RHS));
break;
}
case ExpressionKind.ArrayIndex: {
Expr expr2 = (pExpr as ExprArrayIndex).Array = Visit((pExpr as ExprArrayIndex).Array);
expr2 = ((pExpr as ExprArrayIndex).Index = Visit((pExpr as ExprArrayIndex).Index));
break;
}
case ExpressionKind.UnaryOp:
case ExpressionKind.True:
case ExpressionKind.False:
case ExpressionKind.Inc:
case ExpressionKind.Dec:
case ExpressionKind.LogicalNot:
case ExpressionKind.Negate:
case ExpressionKind.UnaryPlus:
case ExpressionKind.BitwiseNot:
case ExpressionKind.Addr:
case ExpressionKind.DecimalNegate:
case ExpressionKind.DecimalInc:
case ExpressionKind.DecimalDec: {
Expr expr2 = (pExpr as ExprUnaryOp).Child = Visit((pExpr as ExprUnaryOp).Child);
break;
}
case ExpressionKind.UserLogicalOp: {
Expr expr2 = (pExpr as ExprUserLogicalOp).TrueFalseCall = Visit((pExpr as ExprUserLogicalOp).TrueFalseCall);
expr2 = Visit((pExpr as ExprUserLogicalOp).OperatorCall);
(pExpr as ExprUserLogicalOp).OperatorCall = (expr2 as ExprCall);
expr2 = ((pExpr as ExprUserLogicalOp).FirstOperandToExamine = Visit((pExpr as ExprUserLogicalOp).FirstOperandToExamine));
break;
}
case ExpressionKind.Cast: {
Expr expr2 = (pExpr as ExprCast).Argument = Visit((pExpr as ExprCast).Argument);
break;
}
case ExpressionKind.UserDefinedConversion: {
Expr expr2 = (pExpr as ExprUserDefinedConversion).UserDefinedCall = Visit((pExpr as ExprUserDefinedConversion).UserDefinedCall);
break;
}
case ExpressionKind.MemberGroup: {
Expr expr2 = (pExpr as ExprMemberGroup).OptionalObject = Visit((pExpr as ExprMemberGroup).OptionalObject);
break;
}
case ExpressionKind.Call: {
Expr expr2 = (pExpr as ExprCall).OptionalArguments = Visit((pExpr as ExprCall).OptionalArguments);
expr2 = Visit((pExpr as ExprCall).MemberGroup);
(pExpr as ExprCall).MemberGroup = (expr2 as ExprMemberGroup);
break;
}
case ExpressionKind.Property: {
Expr expr2 = (pExpr as ExprProperty).OptionalArguments = Visit((pExpr as ExprProperty).OptionalArguments);
expr2 = Visit((pExpr as ExprProperty).MemberGroup);
(pExpr as ExprProperty).MemberGroup = (expr2 as ExprMemberGroup);
break;
}
case ExpressionKind.Field: {
Expr expr2 = (pExpr as ExprField).OptionalObject = Visit((pExpr as ExprField).OptionalObject);
break;
}
case ExpressionKind.Constant: {
Expr expr2 = (pExpr as ExprConstant).OptionalConstructorCall = Visit((pExpr as ExprConstant).OptionalConstructorCall);
break;
}
case ExpressionKind.Multi: {
Expr expr2 = (pExpr as ExprMulti).Left = Visit((pExpr as ExprMulti).Left);
expr2 = ((pExpr as ExprMulti).Operator = Visit((pExpr as ExprMulti).Operator));
break;
}
case ExpressionKind.Concat: {
Expr expr2 = (pExpr as ExprConcat).FirstArgument = Visit((pExpr as ExprConcat).FirstArgument);
expr2 = ((pExpr as ExprConcat).SecondArgument = Visit((pExpr as ExprConcat).SecondArgument));
break;
}
case ExpressionKind.ArrayInit: {
Expr expr2 = (pExpr as ExprArrayInit).OptionalArguments = Visit((pExpr as ExprArrayInit).OptionalArguments);
expr2 = ((pExpr as ExprArrayInit).OptionalArgumentDimensions = Visit((pExpr as ExprArrayInit).OptionalArgumentDimensions));
break;
}
default: {
Expr expr2 = (pExpr as ExprBinOp).OptionalLeftChild = Visit((pExpr as ExprBinOp).OptionalLeftChild);
expr2 = ((pExpr as ExprBinOp).OptionalRightChild = Visit((pExpr as ExprBinOp).OptionalRightChild));
break;
}
}
}
protected virtual Expr VisitEXPR(Expr pExpr)
{
VisitChildren(pExpr);
return 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 VisitARRAYINDEX(ExprArrayIndex pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual Expr VisitUNARYOP(ExprUnaryOp pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual Expr VisitUSERLOGOP(ExprUserLogicalOp 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(ExprMemberGroup pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual Expr VisitCALL(ExprCall pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual Expr VisitPROP(ExprProperty pExpr)
{
return VisitEXPR(pExpr);
}
protected virtual Expr VisitFIELD(ExprField 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 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(ExprArrayInit 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 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 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);
}
}
}