1 // Licensed to the .NET Foundation under one or more agreements. 2 // The .NET Foundation licenses this file to you under the MIT license. 3 // See the LICENSE file in the project root for more information. 4 5 using System.Diagnostics; 6 7 namespace Microsoft.CSharp.RuntimeBinder.Semantics 8 { 9 internal abstract class ExprVisitorBase 10 { Visit(Expr pExpr)11 public Expr Visit(Expr pExpr) 12 { 13 if (pExpr == null) 14 { 15 return null; 16 } 17 18 Expr pResult; 19 if (IsCachedExpr(pExpr, out pResult)) 20 { 21 return pResult; 22 } 23 24 return CacheExprMapping(pExpr, Dispatch(pExpr)); 25 } 26 IsCachedExpr(Expr pExpr, out Expr pTransformedExpr)27 private bool IsCachedExpr(Expr pExpr, out Expr pTransformedExpr) 28 { 29 pTransformedExpr = null; 30 return false; 31 } 32 33 ///////////////////////////////////////////////////////////////////////////////// 34 CacheExprMapping(Expr pExpr, Expr pTransformedExpr)35 private Expr CacheExprMapping(Expr pExpr, Expr pTransformedExpr) 36 { 37 return pTransformedExpr; 38 } 39 Dispatch(Expr pExpr)40 protected virtual Expr Dispatch(Expr pExpr) 41 { 42 switch (pExpr.Kind) 43 { 44 case ExpressionKind.BinaryOp: 45 return VisitBINOP(pExpr as ExprBinOp); 46 case ExpressionKind.UnaryOp: 47 return VisitUNARYOP(pExpr as ExprUnaryOp); 48 case ExpressionKind.Assignment: 49 return VisitASSIGNMENT(pExpr as ExprAssignment); 50 case ExpressionKind.List: 51 return VisitLIST(pExpr as ExprList); 52 case ExpressionKind.ArrayIndex: 53 return VisitARRAYINDEX(pExpr as ExprArrayIndex); 54 case ExpressionKind.Call: 55 return VisitCALL(pExpr as ExprCall); 56 case ExpressionKind.Field: 57 return VisitFIELD(pExpr as ExprField); 58 case ExpressionKind.Local: 59 return VisitLOCAL(pExpr as ExprLocal); 60 case ExpressionKind.Constant: 61 return VisitCONSTANT(pExpr as ExprConstant); 62 case ExpressionKind.Class: 63 return pExpr; 64 case ExpressionKind.Property: 65 return VisitPROP(pExpr as ExprProperty); 66 case ExpressionKind.Multi: 67 return VisitMULTI(pExpr as ExprMulti); 68 case ExpressionKind.MultiGet: 69 return VisitMULTIGET(pExpr as ExprMultiGet); 70 case ExpressionKind.Wrap: 71 return VisitWRAP(pExpr as ExprWrap); 72 case ExpressionKind.Concat: 73 return VisitCONCAT(pExpr as ExprConcat); 74 case ExpressionKind.ArrayInit: 75 return VisitARRINIT(pExpr as ExprArrayInit); 76 case ExpressionKind.Cast: 77 return VisitCAST(pExpr as ExprCast); 78 case ExpressionKind.UserDefinedConversion: 79 return VisitUSERDEFINEDCONVERSION(pExpr as ExprUserDefinedConversion); 80 case ExpressionKind.TypeOf: 81 return VisitTYPEOF(pExpr as ExprTypeOf); 82 case ExpressionKind.ZeroInit: 83 return VisitZEROINIT(pExpr as ExprZeroInit); 84 case ExpressionKind.UserLogicalOp: 85 return VisitUSERLOGOP(pExpr as ExprUserLogicalOp); 86 case ExpressionKind.MemberGroup: 87 return VisitMEMGRP(pExpr as ExprMemberGroup); 88 case ExpressionKind.FieldInfo: 89 return VisitFIELDINFO(pExpr as ExprFieldInfo); 90 case ExpressionKind.MethodInfo: 91 return VisitMETHODINFO(pExpr as ExprMethodInfo); 92 93 // Binary operators 94 case ExpressionKind.EqualsParam: 95 return VisitEQUALS(pExpr as ExprBinOp); 96 case ExpressionKind.Compare: 97 return VisitCOMPARE(pExpr as ExprBinOp); 98 case ExpressionKind.NotEq: 99 return VisitNE(pExpr as ExprBinOp); 100 case ExpressionKind.LessThan: 101 return VisitLT(pExpr as ExprBinOp); 102 case ExpressionKind.LessThanOrEqual: 103 return VisitLE(pExpr as ExprBinOp); 104 case ExpressionKind.GreaterThan: 105 return VisitGT(pExpr as ExprBinOp); 106 case ExpressionKind.GreaterThanOrEqual: 107 return VisitGE(pExpr as ExprBinOp); 108 case ExpressionKind.Add: 109 return VisitADD(pExpr as ExprBinOp); 110 case ExpressionKind.Subtract: 111 return VisitSUB(pExpr as ExprBinOp); 112 case ExpressionKind.Multiply: 113 return VisitMUL(pExpr as ExprBinOp); 114 case ExpressionKind.Divide: 115 return VisitDIV(pExpr as ExprBinOp); 116 case ExpressionKind.Modulo: 117 return VisitMOD(pExpr as ExprBinOp); 118 case ExpressionKind.BitwiseAnd: 119 return VisitBITAND(pExpr as ExprBinOp); 120 case ExpressionKind.BitwiseOr: 121 return VisitBITOR(pExpr as ExprBinOp); 122 case ExpressionKind.BitwiseExclusiveOr: 123 return VisitBITXOR(pExpr as ExprBinOp); 124 case ExpressionKind.LeftShirt: 125 return VisitLSHIFT(pExpr as ExprBinOp); 126 case ExpressionKind.RightShift: 127 return VisitRSHIFT(pExpr as ExprBinOp); 128 case ExpressionKind.LogicalAnd: 129 return VisitLOGAND(pExpr as ExprBinOp); 130 case ExpressionKind.LogicalOr: 131 return VisitLOGOR(pExpr as ExprBinOp); 132 case ExpressionKind.Sequence: 133 return VisitSEQUENCE(pExpr as ExprBinOp); 134 case ExpressionKind.Save: 135 return VisitSAVE(pExpr as ExprBinOp); 136 case ExpressionKind.Swap: 137 return VisitSWAP(pExpr as ExprBinOp); 138 case ExpressionKind.Indir: 139 return VisitINDIR(pExpr as ExprBinOp); 140 case ExpressionKind.StringEq: 141 return VisitSTRINGEQ(pExpr as ExprBinOp); 142 case ExpressionKind.StringNotEq: 143 return VisitSTRINGNE(pExpr as ExprBinOp); 144 case ExpressionKind.DelegateEq: 145 return VisitDELEGATEEQ(pExpr as ExprBinOp); 146 case ExpressionKind.DelegateNotEq: 147 return VisitDELEGATENE(pExpr as ExprBinOp); 148 case ExpressionKind.DelegateAdd: 149 return VisitDELEGATEADD(pExpr as ExprBinOp); 150 case ExpressionKind.DelegateSubtract: 151 return VisitDELEGATESUB(pExpr as ExprBinOp); 152 case ExpressionKind.Eq: 153 return VisitEQ(pExpr as ExprBinOp); 154 155 // Unary operators 156 case ExpressionKind.True: 157 return VisitTRUE(pExpr as ExprUnaryOp); 158 case ExpressionKind.False: 159 return VisitFALSE(pExpr as ExprUnaryOp); 160 case ExpressionKind.Inc: 161 return VisitINC(pExpr as ExprUnaryOp); 162 case ExpressionKind.Dec: 163 return VisitDEC(pExpr as ExprUnaryOp); 164 case ExpressionKind.LogicalNot: 165 return VisitLOGNOT(pExpr as ExprUnaryOp); 166 case ExpressionKind.Negate: 167 return VisitNEG(pExpr as ExprUnaryOp); 168 case ExpressionKind.UnaryPlus: 169 return VisitUPLUS(pExpr as ExprUnaryOp); 170 case ExpressionKind.BitwiseNot: 171 return VisitBITNOT(pExpr as ExprUnaryOp); 172 case ExpressionKind.Addr: 173 return VisitADDR(pExpr as ExprUnaryOp); 174 case ExpressionKind.DecimalNegate: 175 return VisitDECIMALNEG(pExpr as ExprUnaryOp); 176 case ExpressionKind.DecimalInc: 177 return VisitDECIMALINC(pExpr as ExprUnaryOp); 178 case ExpressionKind.DecimalDec: 179 return VisitDECIMALDEC(pExpr as ExprUnaryOp); 180 default: 181 throw Error.InternalCompilerError(); 182 } 183 } 184 VisitChildren(Expr pExpr)185 private void VisitChildren(Expr pExpr) 186 { 187 Debug.Assert(pExpr != null); 188 189 Expr exprRet; 190 191 switch (pExpr.Kind) 192 { 193 case ExpressionKind.List: 194 195 // Lists are a special case. We treat a list not as a 196 // binary node but rather as a node with n children. 197 ExprList list = (ExprList)pExpr; 198 while (true) 199 { 200 list.OptionalElement = Visit(list.OptionalElement); 201 Expr nextNode = list.OptionalNextListNode; 202 if (nextNode == null) 203 { 204 return; 205 } 206 207 if (!(nextNode is ExprList next)) 208 { 209 list.OptionalNextListNode = Visit(nextNode); 210 return; 211 } 212 213 list = next; 214 } 215 216 case ExpressionKind.Assignment: 217 exprRet = Visit((pExpr as ExprAssignment).LHS); 218 Debug.Assert(exprRet != null); 219 (pExpr as ExprAssignment).LHS = exprRet; 220 exprRet = Visit((pExpr as ExprAssignment).RHS); 221 Debug.Assert(exprRet != null); 222 (pExpr as ExprAssignment).RHS = exprRet; 223 break; 224 225 case ExpressionKind.ArrayIndex: 226 exprRet = Visit((pExpr as ExprArrayIndex).Array); 227 Debug.Assert(exprRet != null); 228 (pExpr as ExprArrayIndex).Array = exprRet; 229 exprRet = Visit((pExpr as ExprArrayIndex).Index); 230 Debug.Assert(exprRet != null); 231 (pExpr as ExprArrayIndex).Index = exprRet; 232 break; 233 234 case ExpressionKind.UnaryOp: 235 case ExpressionKind.True: 236 case ExpressionKind.False: 237 case ExpressionKind.Inc: 238 case ExpressionKind.Dec: 239 case ExpressionKind.LogicalNot: 240 case ExpressionKind.Negate: 241 case ExpressionKind.UnaryPlus: 242 case ExpressionKind.BitwiseNot: 243 case ExpressionKind.Addr: 244 case ExpressionKind.DecimalNegate: 245 case ExpressionKind.DecimalInc: 246 case ExpressionKind.DecimalDec: 247 exprRet = Visit((pExpr as ExprUnaryOp).Child); 248 Debug.Assert(exprRet != null); 249 (pExpr as ExprUnaryOp).Child = exprRet; 250 break; 251 252 case ExpressionKind.UserLogicalOp: 253 exprRet = Visit((pExpr as ExprUserLogicalOp).TrueFalseCall); 254 Debug.Assert(exprRet != null); 255 (pExpr as ExprUserLogicalOp).TrueFalseCall = exprRet; 256 exprRet = Visit((pExpr as ExprUserLogicalOp).OperatorCall); 257 Debug.Assert(exprRet != null); 258 (pExpr as ExprUserLogicalOp).OperatorCall = exprRet as ExprCall; 259 exprRet = Visit((pExpr as ExprUserLogicalOp).FirstOperandToExamine); 260 Debug.Assert(exprRet != null); 261 (pExpr as ExprUserLogicalOp).FirstOperandToExamine = exprRet; 262 break; 263 264 case ExpressionKind.TypeOf: 265 break; 266 267 case ExpressionKind.Cast: 268 exprRet = Visit((pExpr as ExprCast).Argument); 269 Debug.Assert(exprRet != null); 270 (pExpr as ExprCast).Argument = exprRet; 271 break; 272 273 case ExpressionKind.UserDefinedConversion: 274 exprRet = Visit((pExpr as ExprUserDefinedConversion).UserDefinedCall); 275 Debug.Assert(exprRet != null); 276 (pExpr as ExprUserDefinedConversion).UserDefinedCall = exprRet; 277 break; 278 279 case ExpressionKind.ZeroInit: 280 break; 281 282 case ExpressionKind.MemberGroup: 283 284 // The object expression. NULL for a static invocation. 285 exprRet = Visit((pExpr as ExprMemberGroup).OptionalObject); 286 (pExpr as ExprMemberGroup).OptionalObject = exprRet; 287 break; 288 289 case ExpressionKind.Call: 290 exprRet = Visit((pExpr as ExprCall).OptionalArguments); 291 (pExpr as ExprCall).OptionalArguments = exprRet; 292 exprRet = Visit((pExpr as ExprCall).MemberGroup); 293 Debug.Assert(exprRet != null); 294 (pExpr as ExprCall).MemberGroup = exprRet as ExprMemberGroup; 295 break; 296 297 case ExpressionKind.Property: 298 exprRet = Visit((pExpr as ExprProperty).OptionalArguments); 299 (pExpr as ExprProperty).OptionalArguments = exprRet; 300 exprRet = Visit((pExpr as ExprProperty).MemberGroup); 301 Debug.Assert(exprRet != null); 302 (pExpr as ExprProperty).MemberGroup = exprRet as ExprMemberGroup; 303 break; 304 305 case ExpressionKind.Field: 306 exprRet = Visit((pExpr as ExprField).OptionalObject); 307 (pExpr as ExprField).OptionalObject = exprRet; 308 break; 309 310 case ExpressionKind.Constant: 311 312 // Used for when we zeroinit 0 parameter constructors for structs/enums. 313 exprRet = Visit((pExpr as ExprConstant).OptionalConstructorCall); 314 (pExpr as ExprConstant).OptionalConstructorCall = exprRet; 315 break; 316 317 /************************************************************************************************* 318 TYPEEXPRs defined: 319 320 The following exprs are used to represent the results of type binding, and are defined as follows: 321 322 TYPEARGUMENTS - This wraps the type arguments for a class. It contains the TypeArray* which is 323 associated with the AggregateType for the instantiation of the class. 324 325 TYPEORNAMESPACE - This is the base class for this set of Exprs. When binding a type, the result 326 must be a type or a namespace. This Expr encapsulates that fact. The lhs member is the Expr 327 tree that was bound to resolve the type or namespace. 328 329 TYPEORNAMESPACEERROR - This is the error class for the type or namespace exprs when we don't know 330 what to bind it to. 331 332 The following two exprs all have a TYPEORNAMESPACE child, which is their fundamental type: 333 POINTERTYPE - This wraps the sym for the pointer type. 334 NULLABLETYPE - This wraps the sym for the nullable type. 335 336 CLASS - This represents an instantiation of a class. 337 338 NSPACE - This represents a namespace, which is the intermediate step when attempting to bind 339 a qualified name. 340 341 ALIAS - This represents an alias 342 343 *************************************************************************************************/ 344 345 case ExpressionKind.Multi: 346 exprRet = Visit((pExpr as ExprMulti).Left); 347 Debug.Assert(exprRet != null); 348 (pExpr as ExprMulti).Left = exprRet; 349 exprRet = Visit((pExpr as ExprMulti).Operator); 350 Debug.Assert(exprRet != null); 351 (pExpr as ExprMulti).Operator = exprRet; 352 break; 353 354 case ExpressionKind.Concat: 355 exprRet = Visit((pExpr as ExprConcat).FirstArgument); 356 Debug.Assert(exprRet != null); 357 (pExpr as ExprConcat).FirstArgument = exprRet; 358 exprRet = Visit((pExpr as ExprConcat).SecondArgument); 359 Debug.Assert(exprRet != null); 360 (pExpr as ExprConcat).SecondArgument = exprRet; 361 break; 362 363 case ExpressionKind.ArrayInit: 364 exprRet = Visit((pExpr as ExprArrayInit).OptionalArguments); 365 (pExpr as ExprArrayInit).OptionalArguments = exprRet; 366 exprRet = Visit((pExpr as ExprArrayInit).OptionalArgumentDimensions); 367 (pExpr as ExprArrayInit).OptionalArgumentDimensions = exprRet; 368 break; 369 370 case ExpressionKind.Local: 371 case ExpressionKind.Class: 372 case ExpressionKind.MultiGet: 373 case ExpressionKind.Wrap: 374 case ExpressionKind.NoOp: 375 case ExpressionKind.FieldInfo: 376 case ExpressionKind.MethodInfo: 377 break; 378 379 default: 380 pExpr.AssertIsBin(); 381 exprRet = Visit((pExpr as ExprBinOp).OptionalLeftChild); 382 (pExpr as ExprBinOp).OptionalLeftChild = exprRet; 383 exprRet = Visit((pExpr as ExprBinOp).OptionalRightChild); 384 (pExpr as ExprBinOp).OptionalRightChild = exprRet; 385 break; 386 } 387 } 388 VisitEXPR(Expr pExpr)389 protected virtual Expr VisitEXPR(Expr pExpr) 390 { 391 VisitChildren(pExpr); 392 return pExpr; 393 } VisitBINOP(ExprBinOp pExpr)394 protected virtual Expr VisitBINOP(ExprBinOp pExpr) 395 { 396 return VisitEXPR(pExpr); 397 } VisitLIST(ExprList pExpr)398 protected virtual Expr VisitLIST(ExprList pExpr) 399 { 400 return VisitEXPR(pExpr); 401 } VisitASSIGNMENT(ExprAssignment pExpr)402 protected virtual Expr VisitASSIGNMENT(ExprAssignment pExpr) 403 { 404 return VisitEXPR(pExpr); 405 } 406 VisitARRAYINDEX(ExprArrayIndex pExpr)407 protected virtual Expr VisitARRAYINDEX(ExprArrayIndex pExpr) 408 { 409 return VisitEXPR(pExpr); 410 } 411 VisitUNARYOP(ExprUnaryOp pExpr)412 protected virtual Expr VisitUNARYOP(ExprUnaryOp pExpr) 413 { 414 return VisitEXPR(pExpr); 415 } VisitUSERLOGOP(ExprUserLogicalOp pExpr)416 protected virtual Expr VisitUSERLOGOP(ExprUserLogicalOp pExpr) 417 { 418 return VisitEXPR(pExpr); 419 } VisitTYPEOF(ExprTypeOf pExpr)420 protected virtual Expr VisitTYPEOF(ExprTypeOf pExpr) 421 { 422 return VisitEXPR(pExpr); 423 } VisitCAST(ExprCast pExpr)424 protected virtual Expr VisitCAST(ExprCast pExpr) 425 { 426 return VisitEXPR(pExpr); 427 } VisitUSERDEFINEDCONVERSION(ExprUserDefinedConversion pExpr)428 protected virtual Expr VisitUSERDEFINEDCONVERSION(ExprUserDefinedConversion pExpr) 429 { 430 return VisitEXPR(pExpr); 431 } VisitZEROINIT(ExprZeroInit pExpr)432 protected virtual Expr VisitZEROINIT(ExprZeroInit pExpr) 433 { 434 return VisitEXPR(pExpr); 435 } VisitMEMGRP(ExprMemberGroup pExpr)436 protected virtual Expr VisitMEMGRP(ExprMemberGroup pExpr) 437 { 438 return VisitEXPR(pExpr); 439 } VisitCALL(ExprCall pExpr)440 protected virtual Expr VisitCALL(ExprCall pExpr) 441 { 442 return VisitEXPR(pExpr); 443 } VisitPROP(ExprProperty pExpr)444 protected virtual Expr VisitPROP(ExprProperty pExpr) 445 { 446 return VisitEXPR(pExpr); 447 } VisitFIELD(ExprField pExpr)448 protected virtual Expr VisitFIELD(ExprField pExpr) 449 { 450 return VisitEXPR(pExpr); 451 } VisitLOCAL(ExprLocal pExpr)452 protected virtual Expr VisitLOCAL(ExprLocal pExpr) 453 { 454 return VisitEXPR(pExpr); 455 } VisitCONSTANT(ExprConstant pExpr)456 protected virtual Expr VisitCONSTANT(ExprConstant pExpr) 457 { 458 return VisitEXPR(pExpr); 459 } VisitMULTIGET(ExprMultiGet pExpr)460 protected virtual Expr VisitMULTIGET(ExprMultiGet pExpr) 461 { 462 return VisitEXPR(pExpr); 463 } VisitMULTI(ExprMulti pExpr)464 protected virtual Expr VisitMULTI(ExprMulti pExpr) 465 { 466 return VisitEXPR(pExpr); 467 } VisitWRAP(ExprWrap pExpr)468 protected virtual Expr VisitWRAP(ExprWrap pExpr) 469 { 470 return VisitEXPR(pExpr); 471 } VisitCONCAT(ExprConcat pExpr)472 protected virtual Expr VisitCONCAT(ExprConcat pExpr) 473 { 474 return VisitEXPR(pExpr); 475 } VisitARRINIT(ExprArrayInit pExpr)476 protected virtual Expr VisitARRINIT(ExprArrayInit pExpr) 477 { 478 return VisitEXPR(pExpr); 479 } 480 VisitFIELDINFO(ExprFieldInfo pExpr)481 protected virtual Expr VisitFIELDINFO(ExprFieldInfo pExpr) 482 { 483 return VisitEXPR(pExpr); 484 } VisitMETHODINFO(ExprMethodInfo pExpr)485 protected virtual Expr VisitMETHODINFO(ExprMethodInfo pExpr) 486 { 487 return VisitEXPR(pExpr); 488 } VisitEQUALS(ExprBinOp pExpr)489 protected virtual Expr VisitEQUALS(ExprBinOp pExpr) 490 { 491 return VisitBINOP(pExpr); 492 } VisitCOMPARE(ExprBinOp pExpr)493 protected virtual Expr VisitCOMPARE(ExprBinOp pExpr) 494 { 495 return VisitBINOP(pExpr); 496 } VisitEQ(ExprBinOp pExpr)497 protected virtual Expr VisitEQ(ExprBinOp pExpr) 498 { 499 return VisitBINOP(pExpr); 500 } VisitNE(ExprBinOp pExpr)501 protected virtual Expr VisitNE(ExprBinOp pExpr) 502 { 503 return VisitBINOP(pExpr); 504 } VisitLE(ExprBinOp pExpr)505 protected virtual Expr VisitLE(ExprBinOp pExpr) 506 { 507 return VisitBINOP(pExpr); 508 } VisitGE(ExprBinOp pExpr)509 protected virtual Expr VisitGE(ExprBinOp pExpr) 510 { 511 return VisitBINOP(pExpr); 512 } VisitADD(ExprBinOp pExpr)513 protected virtual Expr VisitADD(ExprBinOp pExpr) 514 { 515 return VisitBINOP(pExpr); 516 } VisitSUB(ExprBinOp pExpr)517 protected virtual Expr VisitSUB(ExprBinOp pExpr) 518 { 519 return VisitBINOP(pExpr); 520 } VisitDIV(ExprBinOp pExpr)521 protected virtual Expr VisitDIV(ExprBinOp pExpr) 522 { 523 return VisitBINOP(pExpr); 524 } VisitBITAND(ExprBinOp pExpr)525 protected virtual Expr VisitBITAND(ExprBinOp pExpr) 526 { 527 return VisitBINOP(pExpr); 528 } VisitBITOR(ExprBinOp pExpr)529 protected virtual Expr VisitBITOR(ExprBinOp pExpr) 530 { 531 return VisitBINOP(pExpr); 532 } VisitLSHIFT(ExprBinOp pExpr)533 protected virtual Expr VisitLSHIFT(ExprBinOp pExpr) 534 { 535 return VisitBINOP(pExpr); 536 } VisitLOGAND(ExprBinOp pExpr)537 protected virtual Expr VisitLOGAND(ExprBinOp pExpr) 538 { 539 return VisitBINOP(pExpr); 540 } VisitSEQUENCE(ExprBinOp pExpr)541 protected virtual Expr VisitSEQUENCE(ExprBinOp pExpr) 542 { 543 return VisitBINOP(pExpr); 544 } VisitSAVE(ExprBinOp pExpr)545 protected virtual Expr VisitSAVE(ExprBinOp pExpr) 546 { 547 return VisitBINOP(pExpr); 548 } VisitINDIR(ExprBinOp pExpr)549 protected virtual Expr VisitINDIR(ExprBinOp pExpr) 550 { 551 return VisitBINOP(pExpr); 552 } VisitSTRINGEQ(ExprBinOp pExpr)553 protected virtual Expr VisitSTRINGEQ(ExprBinOp pExpr) 554 { 555 return VisitBINOP(pExpr); 556 } VisitDELEGATEEQ(ExprBinOp pExpr)557 protected virtual Expr VisitDELEGATEEQ(ExprBinOp pExpr) 558 { 559 return VisitBINOP(pExpr); 560 } VisitDELEGATEADD(ExprBinOp pExpr)561 protected virtual Expr VisitDELEGATEADD(ExprBinOp pExpr) 562 { 563 return VisitBINOP(pExpr); 564 } 565 VisitLT(ExprBinOp pExpr)566 protected virtual Expr VisitLT(ExprBinOp pExpr) 567 { 568 return VisitBINOP(pExpr); 569 } VisitMUL(ExprBinOp pExpr)570 protected virtual Expr VisitMUL(ExprBinOp pExpr) 571 { 572 return VisitBINOP(pExpr); 573 } VisitBITXOR(ExprBinOp pExpr)574 protected virtual Expr VisitBITXOR(ExprBinOp pExpr) 575 { 576 return VisitBINOP(pExpr); 577 } VisitRSHIFT(ExprBinOp pExpr)578 protected virtual Expr VisitRSHIFT(ExprBinOp pExpr) 579 { 580 return VisitBINOP(pExpr); 581 } VisitLOGOR(ExprBinOp pExpr)582 protected virtual Expr VisitLOGOR(ExprBinOp pExpr) 583 { 584 return VisitBINOP(pExpr); 585 } VisitSTRINGNE(ExprBinOp pExpr)586 protected virtual Expr VisitSTRINGNE(ExprBinOp pExpr) 587 { 588 return VisitBINOP(pExpr); 589 } VisitDELEGATENE(ExprBinOp pExpr)590 protected virtual Expr VisitDELEGATENE(ExprBinOp pExpr) 591 { 592 return VisitBINOP(pExpr); 593 } VisitGT(ExprBinOp pExpr)594 protected virtual Expr VisitGT(ExprBinOp pExpr) 595 { 596 return VisitBINOP(pExpr); 597 } VisitMOD(ExprBinOp pExpr)598 protected virtual Expr VisitMOD(ExprBinOp pExpr) 599 { 600 return VisitBINOP(pExpr); 601 } VisitSWAP(ExprBinOp pExpr)602 protected virtual Expr VisitSWAP(ExprBinOp pExpr) 603 { 604 return VisitBINOP(pExpr); 605 } VisitDELEGATESUB(ExprBinOp pExpr)606 protected virtual Expr VisitDELEGATESUB(ExprBinOp pExpr) 607 { 608 return VisitBINOP(pExpr); 609 } VisitTRUE(ExprUnaryOp pExpr)610 protected virtual Expr VisitTRUE(ExprUnaryOp pExpr) 611 { 612 return VisitUNARYOP(pExpr); 613 } VisitINC(ExprUnaryOp pExpr)614 protected virtual Expr VisitINC(ExprUnaryOp pExpr) 615 { 616 return VisitUNARYOP(pExpr); 617 } VisitLOGNOT(ExprUnaryOp pExpr)618 protected virtual Expr VisitLOGNOT(ExprUnaryOp pExpr) 619 { 620 return VisitUNARYOP(pExpr); 621 } VisitNEG(ExprUnaryOp pExpr)622 protected virtual Expr VisitNEG(ExprUnaryOp pExpr) 623 { 624 return VisitUNARYOP(pExpr); 625 } VisitBITNOT(ExprUnaryOp pExpr)626 protected virtual Expr VisitBITNOT(ExprUnaryOp pExpr) 627 { 628 return VisitUNARYOP(pExpr); 629 } VisitADDR(ExprUnaryOp pExpr)630 protected virtual Expr VisitADDR(ExprUnaryOp pExpr) 631 { 632 return VisitUNARYOP(pExpr); 633 } VisitDECIMALNEG(ExprUnaryOp pExpr)634 protected virtual Expr VisitDECIMALNEG(ExprUnaryOp pExpr) 635 { 636 return VisitUNARYOP(pExpr); 637 } VisitDECIMALDEC(ExprUnaryOp pExpr)638 protected virtual Expr VisitDECIMALDEC(ExprUnaryOp pExpr) 639 { 640 return VisitUNARYOP(pExpr); 641 } VisitFALSE(ExprUnaryOp pExpr)642 protected virtual Expr VisitFALSE(ExprUnaryOp pExpr) 643 { 644 return VisitUNARYOP(pExpr); 645 } VisitDEC(ExprUnaryOp pExpr)646 protected virtual Expr VisitDEC(ExprUnaryOp pExpr) 647 { 648 return VisitUNARYOP(pExpr); 649 } VisitUPLUS(ExprUnaryOp pExpr)650 protected virtual Expr VisitUPLUS(ExprUnaryOp pExpr) 651 { 652 return VisitUNARYOP(pExpr); 653 } VisitDECIMALINC(ExprUnaryOp pExpr)654 protected virtual Expr VisitDECIMALINC(ExprUnaryOp pExpr) 655 { 656 return VisitUNARYOP(pExpr); 657 } 658 } 659 } 660