org.sablecc.php4.analysis
Interface Analysis

All Superinterfaces:
Switch
All Known Implementing Classes:
AnalysisAdapter

public interface Analysis
extends Switch


Method Summary
 void caseAAddEqExpr(AAddEqExpr node)
           
 void caseAAndEqExpr(AAndEqExpr node)
           
 void caseAArgument(AArgument node)
           
 void caseAArrayElement(AArrayElement node)
           
 void caseAArrayExpr(AArrayExpr node)
           
 void caseAAssignExpr(AAssignExpr node)
           
 void caseAAssignrefExpr(AAssignrefExpr node)
           
 void caseABnotExpr(ABnotExpr node)
           
 void caseABoolExpr(ABoolExpr node)
           
 void caseABopAddExpr(ABopAddExpr node)
           
 void caseABopAndExpr(ABopAndExpr node)
           
 void caseABopBandExpr(ABopBandExpr node)
           
 void caseABopBorExpr(ABopBorExpr node)
           
 void caseABopBxorExpr(ABopBxorExpr node)
           
 void caseABopConExpr(ABopConExpr node)
           
 void caseABopDivExpr(ABopDivExpr node)
           
 void caseABopEqExpr(ABopEqExpr node)
           
 void caseABopGteqExpr(ABopGteqExpr node)
           
 void caseABopGtExpr(ABopGtExpr node)
           
 void caseABopIdentExpr(ABopIdentExpr node)
           
 void caseABopLteqExpr(ABopLteqExpr node)
           
 void caseABopLtExpr(ABopLtExpr node)
           
 void caseABopModExpr(ABopModExpr node)
           
 void caseABopMulExpr(ABopMulExpr node)
           
 void caseABopNeqExpr(ABopNeqExpr node)
           
 void caseABopNidentExpr(ABopNidentExpr node)
           
 void caseABopOrExpr(ABopOrExpr node)
           
 void caseABopShlExpr(ABopShlExpr node)
           
 void caseABopShrExpr(ABopShrExpr node)
           
 void caseABopSubExpr(ABopSubExpr node)
           
 void caseABopXorExpr(ABopXorExpr node)
           
 void caseABreakStatement(ABreakStatement node)
           
 void caseACastArrayExpr(ACastArrayExpr node)
           
 void caseACastBoolExpr(ACastBoolExpr node)
           
 void caseACastDoubleExpr(ACastDoubleExpr node)
           
 void caseACastIntExpr(ACastIntExpr node)
           
 void caseACastObjectExpr(ACastObjectExpr node)
           
 void caseACastStringExpr(ACastStringExpr node)
           
 void caseAClassStatement(AClassStatement node)
           
 void caseAConEqExpr(AConEqExpr node)
           
 void caseAConstantExpr(AConstantExpr node)
           
 void caseAContinueStatement(AContinueStatement node)
           
 void caseADeclareStatement(ADeclareStatement node)
           
 void caseADivEqExpr(ADivEqExpr node)
           
 void caseADoWhileStatement(ADoWhileStatement node)
           
 void caseADynamicStringExpr(ADynamicStringExpr node)
           
 void caseAEchoStatement(AEchoStatement node)
           
 void caseAEmptyListExpr(AEmptyListExpr node)
           
 void caseAExitStatement(AExitStatement node)
           
 void caseAExprListExpr(AExprListExpr node)
           
 void caseAExprStatement(AExprStatement node)
           
 void caseAFloatExpr(AFloatExpr node)
           
 void caseAForeachStatement(AForeachStatement node)
           
 void caseAForStatement(AForStatement node)
           
 void caseAFunctionArg(AFunctionArg node)
           
 void caseAFunctionExpr(AFunctionExpr node)
           
 void caseAFunctionStatement(AFunctionStatement node)
           
 void caseAGlobalStatement(AGlobalStatement node)
           
 void caseAGroupStatement(AGroupStatement node)
           
 void caseAHtmlStatement(AHtmlStatement node)
           
 void caseAIfStatement(AIfStatement node)
           
 void caseAIncludeExpr(AIncludeExpr node)
           
 void caseAIncludeOnceExpr(AIncludeOnceExpr node)
           
 void caseAIndexExpr(AIndexExpr node)
           
 void caseAIntegerExpr(AIntegerExpr node)
           
 void caseAKeyDeclareArg(AKeyDeclareArg node)
           
 void caseAListExpr(AListExpr node)
           
 void caseAModEqExpr(AModEqExpr node)
           
 void caseAMulEqExpr(AMulEqExpr node)
           
 void caseANameExpr(ANameExpr node)
           
 void caseANegExpr(ANegExpr node)
           
 void caseANewExpr(ANewExpr node)
           
 void caseANotExpr(ANotExpr node)
           
 void caseAOrEqExpr(AOrEqExpr node)
           
 void caseAPostDecrExpr(APostDecrExpr node)
           
 void caseAPostIncrExpr(APostIncrExpr node)
           
 void caseAPreDecrExpr(APreDecrExpr node)
           
 void caseAPreIncrExpr(APreIncrExpr node)
           
 void caseAPrintExpr(APrintExpr node)
           
 void caseAProgram(AProgram node)
           
 void caseAPropertyExpr(APropertyExpr node)
           
 void caseARequireExpr(ARequireExpr node)
           
 void caseARequireOnceExpr(ARequireOnceExpr node)
           
 void caseAReturnStatement(AReturnStatement node)
           
 void caseAShellExecExpr(AShellExecExpr node)
           
 void caseAShlEqExpr(AShlEqExpr node)
           
 void caseAShrEqExpr(AShrEqExpr node)
           
 void caseASilenceExpr(ASilenceExpr node)
           
 void caseAStaticStatement(AStaticStatement node)
           
 void caseAStringExpr(AStringExpr node)
           
 void caseAStringIndexExpr(AStringIndexExpr node)
           
 void caseASubEqExpr(ASubEqExpr node)
           
 void caseASwitchCase(ASwitchCase node)
           
 void caseASwitchStatement(ASwitchStatement node)
           
 void caseATernaryExpr(ATernaryExpr node)
           
 void caseAVariableExpr(AVariableExpr node)
           
 void caseAVarStatement(AVarStatement node)
           
 void caseAVarvarExpr(AVarvarExpr node)
           
 void caseAWhileStatement(AWhileStatement node)
           
 void caseAXorEqExpr(AXorEqExpr node)
           
 void caseEOF(EOF node)
           
 void caseStart(Start node)
           
 void caseTAmpEq(TAmpEq node)
           
 void caseTAmpersand(TAmpersand node)
           
 void caseTArray(TArray node)
           
 void caseTAs(TAs node)
           
 void caseTAt(TAt node)
           
 void caseTBacktickChunk(TBacktickChunk node)
           
 void caseTBacktickChunkHelper(TBacktickChunkHelper node)
           
 void caseTBacktickEnd(TBacktickEnd node)
           
 void caseTBacktickFromComplexCvar(TBacktickFromComplexCvar node)
           
 void caseTBacktickStart(TBacktickStart node)
           
 void caseTBacktickToComplexCvar(TBacktickToComplexCvar node)
           
 void caseTBar(TBar node)
           
 void caseTBarEq(TBarEq node)
           
 void caseTBlank(TBlank node)
           
 void caseTBoolean(TBoolean node)
           
 void caseTBopShLeft(TBopShLeft node)
           
 void caseTBopShRight(TBopShRight node)
           
 void caseTBreak(TBreak node)
           
 void caseTCaret(TCaret node)
           
 void caseTCaretEq(TCaretEq node)
           
 void caseTCase(TCase node)
           
 void caseTCastArray(TCastArray node)
           
 void caseTCastBool(TCastBool node)
           
 void caseTCastDouble(TCastDouble node)
           
 void caseTCastInt(TCastInt node)
           
 void caseTCastObject(TCastObject node)
           
 void caseTCastString(TCastString node)
           
 void caseTCastUnset(TCastUnset node)
           
 void caseTCodeEnd(TCodeEnd node)
           
 void caseTCodePrint(TCodePrint node)
           
 void caseTCodeStart(TCodeStart node)
           
 void caseTColon(TColon node)
           
 void caseTColoncolon(TColoncolon node)
           
 void caseTComma(TComma node)
           
 void caseTContinue(TContinue node)
           
 void caseTCopAnd(TCopAnd node)
           
 void caseTCopEq(TCopEq node)
           
 void caseTCopGt(TCopGt node)
           
 void caseTCopGteq(TCopGteq node)
           
 void caseTCopLeq(TCopLeq node)
           
 void caseTCopLt(TCopLt node)
           
 void caseTCopLteq(TCopLteq node)
           
 void caseTCopNeq(TCopNeq node)
           
 void caseTCopNleq(TCopNleq node)
           
 void caseTCopOr(TCopOr node)
           
 void caseTDeclare(TDeclare node)
           
 void caseTDefault(TDefault node)
           
 void caseTDiv(TDiv node)
           
 void caseTDo(TDo node)
           
 void caseTDollar(TDollar node)
           
 void caseTDot(TDot node)
           
 void caseTDotEq(TDotEq node)
           
 void caseTEcho(TEcho node)
           
 void caseTElse(TElse node)
           
 void caseTElseColon(TElseColon node)
           
 void caseTElseif(TElseif node)
           
 void caseTElseifColon(TElseifColon node)
           
 void caseTEndfor(TEndfor node)
           
 void caseTEndforeach(TEndforeach node)
           
 void caseTEndif(TEndif node)
           
 void caseTEndswitch(TEndswitch node)
           
 void caseTEndwhile(TEndwhile node)
           
 void caseTEqual(TEqual node)
           
 void caseTExclamation(TExclamation node)
           
 void caseTExit(TExit node)
           
 void caseTExtends(TExtends node)
           
 void caseTFloat(TFloat node)
           
 void caseTFor(TFor node)
           
 void caseTForeach(TForeach node)
           
 void caseTFunction(TFunction node)
           
 void caseTGlobal(TGlobal node)
           
 void caseTHeredocChunk(THeredocChunk node)
           
 void caseTHeredocChunkHelper(THeredocChunkHelper node)
           
 void caseTHeredocEnd(THeredocEnd node)
           
 void caseTHeredocFromComplexCvar(THeredocFromComplexCvar node)
           
 void caseTHeredocStart(THeredocStart node)
           
 void caseTHeredocToComplexCvar(THeredocToComplexCvar node)
           
 void caseTHtmldata(THtmldata node)
           
 void caseTIdentifier(TIdentifier node)
           
 void caseTIf(TIf node)
           
 void caseTIfColon(TIfColon node)
           
 void caseTInclude(TInclude node)
           
 void caseTIncludeOnce(TIncludeOnce node)
           
 void caseTInteger(TInteger node)
           
 void caseTLBrace(TLBrace node)
           
 void caseTLBracket(TLBracket node)
           
 void caseTList(TList node)
           
 void caseTLongComment(TLongComment node)
           
 void caseTLopAnd(TLopAnd node)
           
 void caseTLopOr(TLopOr node)
           
 void caseTLopXor(TLopXor node)
           
 void caseTLPar(TLPar node)
           
 void caseTMinus(TMinus node)
           
 void caseTMinusEq(TMinusEq node)
           
 void caseTMinusMinus(TMinusMinus node)
           
 void caseTMod(TMod node)
           
 void caseTNew(TNew node)
           
 void caseTPercEq(TPercEq node)
           
 void caseTPlus(TPlus node)
           
 void caseTPlusEq(TPlusEq node)
           
 void caseTPlusPlus(TPlusPlus node)
           
 void caseTPointAssoc(TPointAssoc node)
           
 void caseTPointElem(TPointElem node)
           
 void caseTPrint(TPrint node)
           
 void caseTQuest(TQuest node)
           
 void caseTRBrace(TRBrace node)
           
 void caseTRBracket(TRBracket node)
           
 void caseTRequire(TRequire node)
           
 void caseTRequireOnce(TRequireOnce node)
           
 void caseTReturn(TReturn node)
           
 void caseTRPar(TRPar node)
           
 void caseTSemicolon(TSemicolon node)
           
 void caseTShLEq(TShLEq node)
           
 void caseTShortComment(TShortComment node)
           
 void caseTShREq(TShREq node)
           
 void caseTSlashEq(TSlashEq node)
           
 void caseTStar(TStar node)
           
 void caseTStarEq(TStarEq node)
           
 void caseTStatic(TStatic node)
           
 void caseTStaticString(TStaticString node)
           
 void caseTStringArrayStatic(TStringArrayStatic node)
           
 void caseTStringArrayVar(TStringArrayVar node)
           
 void caseTStringChunk(TStringChunk node)
           
 void caseTStringChunkHelper(TStringChunkHelper node)
           
 void caseTStringCvarEnd(TStringCvarEnd node)
           
 void caseTStringCvarStart(TStringCvarStart node)
           
 void caseTStringEnd(TStringEnd node)
           
 void caseTStringFromComplexCvar(TStringFromComplexCvar node)
           
 void caseTStringObject(TStringObject node)
           
 void caseTStringStart(TStringStart node)
           
 void caseTStringToComplexCvar(TStringToComplexCvar node)
           
 void caseTStringVar(TStringVar node)
           
 void caseTSwitch(TSwitch node)
           
 void caseTTclass(TTclass node)
           
 void caseTTilde(TTilde node)
           
 void caseTVar(TVar node)
           
 void caseTVariable(TVariable node)
           
 void caseTWhile(TWhile node)
           
 Object getIn(Node node)
           
 Object getOut(Node node)
           
 void setIn(Node node, Object in)
           
 void setOut(Node node, Object out)
           
 

Method Detail

getIn

public Object getIn(Node node)

setIn

public void setIn(Node node,
                  Object in)

getOut

public Object getOut(Node node)

setOut

public void setOut(Node node,
                   Object out)

caseStart

public void caseStart(Start node)

caseAProgram

public void caseAProgram(AProgram node)

caseAHtmlStatement

public void caseAHtmlStatement(AHtmlStatement node)

caseAExprStatement

public void caseAExprStatement(AExprStatement node)

caseAEchoStatement

public void caseAEchoStatement(AEchoStatement node)

caseADeclareStatement

public void caseADeclareStatement(ADeclareStatement node)

caseAExitStatement

public void caseAExitStatement(AExitStatement node)

caseAReturnStatement

public void caseAReturnStatement(AReturnStatement node)

caseAGlobalStatement

public void caseAGlobalStatement(AGlobalStatement node)

caseAStaticStatement

public void caseAStaticStatement(AStaticStatement node)

caseAForStatement

public void caseAForStatement(AForStatement node)

caseAForeachStatement

public void caseAForeachStatement(AForeachStatement node)

caseAWhileStatement

public void caseAWhileStatement(AWhileStatement node)

caseADoWhileStatement

public void caseADoWhileStatement(ADoWhileStatement node)

caseASwitchStatement

public void caseASwitchStatement(ASwitchStatement node)

caseABreakStatement

public void caseABreakStatement(ABreakStatement node)

caseAContinueStatement

public void caseAContinueStatement(AContinueStatement node)

caseAIfStatement

public void caseAIfStatement(AIfStatement node)

caseAFunctionStatement

public void caseAFunctionStatement(AFunctionStatement node)

caseAClassStatement

public void caseAClassStatement(AClassStatement node)

caseAVarStatement

public void caseAVarStatement(AVarStatement node)

caseAGroupStatement

public void caseAGroupStatement(AGroupStatement node)

caseAIntegerExpr

public void caseAIntegerExpr(AIntegerExpr node)

caseAFloatExpr

public void caseAFloatExpr(AFloatExpr node)

caseABoolExpr

public void caseABoolExpr(ABoolExpr node)

caseAStringExpr

public void caseAStringExpr(AStringExpr node)

caseADynamicStringExpr

public void caseADynamicStringExpr(ADynamicStringExpr node)

caseAShellExecExpr

public void caseAShellExecExpr(AShellExecExpr node)

caseAConstantExpr

public void caseAConstantExpr(AConstantExpr node)

caseAArrayExpr

public void caseAArrayExpr(AArrayExpr node)

caseAPrintExpr

public void caseAPrintExpr(APrintExpr node)

caseAListExpr

public void caseAListExpr(AListExpr node)

caseAIncludeExpr

public void caseAIncludeExpr(AIncludeExpr node)

caseARequireExpr

public void caseARequireExpr(ARequireExpr node)

caseAIncludeOnceExpr

public void caseAIncludeOnceExpr(AIncludeOnceExpr node)

caseARequireOnceExpr

public void caseARequireOnceExpr(ARequireOnceExpr node)

caseATernaryExpr

public void caseATernaryExpr(ATernaryExpr node)

caseABopAddExpr

public void caseABopAddExpr(ABopAddExpr node)

caseABopSubExpr

public void caseABopSubExpr(ABopSubExpr node)

caseABopConExpr

public void caseABopConExpr(ABopConExpr node)

caseABopMulExpr

public void caseABopMulExpr(ABopMulExpr node)

caseABopDivExpr

public void caseABopDivExpr(ABopDivExpr node)

caseABopModExpr

public void caseABopModExpr(ABopModExpr node)

caseABopBandExpr

public void caseABopBandExpr(ABopBandExpr node)

caseABopBxorExpr

public void caseABopBxorExpr(ABopBxorExpr node)

caseABopBorExpr

public void caseABopBorExpr(ABopBorExpr node)

caseABopShlExpr

public void caseABopShlExpr(ABopShlExpr node)

caseABopShrExpr

public void caseABopShrExpr(ABopShrExpr node)

caseABopLtExpr

public void caseABopLtExpr(ABopLtExpr node)

caseABopGtExpr

public void caseABopGtExpr(ABopGtExpr node)

caseABopLteqExpr

public void caseABopLteqExpr(ABopLteqExpr node)

caseABopGteqExpr

public void caseABopGteqExpr(ABopGteqExpr node)

caseABopEqExpr

public void caseABopEqExpr(ABopEqExpr node)

caseABopNeqExpr

public void caseABopNeqExpr(ABopNeqExpr node)

caseABopIdentExpr

public void caseABopIdentExpr(ABopIdentExpr node)

caseABopNidentExpr

public void caseABopNidentExpr(ABopNidentExpr node)

caseABopAndExpr

public void caseABopAndExpr(ABopAndExpr node)

caseABopOrExpr

public void caseABopOrExpr(ABopOrExpr node)

caseABopXorExpr

public void caseABopXorExpr(ABopXorExpr node)

caseABnotExpr

public void caseABnotExpr(ABnotExpr node)

caseANotExpr

public void caseANotExpr(ANotExpr node)

caseANegExpr

public void caseANegExpr(ANegExpr node)

caseASilenceExpr

public void caseASilenceExpr(ASilenceExpr node)

caseAPostIncrExpr

public void caseAPostIncrExpr(APostIncrExpr node)

caseAPostDecrExpr

public void caseAPostDecrExpr(APostDecrExpr node)

caseAPreIncrExpr

public void caseAPreIncrExpr(APreIncrExpr node)

caseAPreDecrExpr

public void caseAPreDecrExpr(APreDecrExpr node)

caseACastIntExpr

public void caseACastIntExpr(ACastIntExpr node)

caseACastBoolExpr

public void caseACastBoolExpr(ACastBoolExpr node)

caseACastStringExpr

public void caseACastStringExpr(ACastStringExpr node)

caseACastObjectExpr

public void caseACastObjectExpr(ACastObjectExpr node)

caseACastArrayExpr

public void caseACastArrayExpr(ACastArrayExpr node)

caseACastDoubleExpr

public void caseACastDoubleExpr(ACastDoubleExpr node)

caseAVariableExpr

public void caseAVariableExpr(AVariableExpr node)

caseAIndexExpr

public void caseAIndexExpr(AIndexExpr node)

caseAStringIndexExpr

public void caseAStringIndexExpr(AStringIndexExpr node)

caseAPropertyExpr

public void caseAPropertyExpr(APropertyExpr node)

caseAVarvarExpr

public void caseAVarvarExpr(AVarvarExpr node)

caseANameExpr

public void caseANameExpr(ANameExpr node)

caseAAssignExpr

public void caseAAssignExpr(AAssignExpr node)

caseAAssignrefExpr

public void caseAAssignrefExpr(AAssignrefExpr node)

caseAAddEqExpr

public void caseAAddEqExpr(AAddEqExpr node)

caseASubEqExpr

public void caseASubEqExpr(ASubEqExpr node)

caseAConEqExpr

public void caseAConEqExpr(AConEqExpr node)

caseAMulEqExpr

public void caseAMulEqExpr(AMulEqExpr node)

caseADivEqExpr

public void caseADivEqExpr(ADivEqExpr node)

caseAModEqExpr

public void caseAModEqExpr(AModEqExpr node)

caseAAndEqExpr

public void caseAAndEqExpr(AAndEqExpr node)

caseAXorEqExpr

public void caseAXorEqExpr(AXorEqExpr node)

caseAOrEqExpr

public void caseAOrEqExpr(AOrEqExpr node)

caseAShlEqExpr

public void caseAShlEqExpr(AShlEqExpr node)

caseAShrEqExpr

public void caseAShrEqExpr(AShrEqExpr node)

caseANewExpr

public void caseANewExpr(ANewExpr node)

caseAFunctionExpr

public void caseAFunctionExpr(AFunctionExpr node)

caseAArrayElement

public void caseAArrayElement(AArrayElement node)

caseAArgument

public void caseAArgument(AArgument node)

caseASwitchCase

public void caseASwitchCase(ASwitchCase node)

caseAFunctionArg

public void caseAFunctionArg(AFunctionArg node)

caseAKeyDeclareArg

public void caseAKeyDeclareArg(AKeyDeclareArg node)

caseAExprListExpr

public void caseAExprListExpr(AExprListExpr node)

caseAEmptyListExpr

public void caseAEmptyListExpr(AEmptyListExpr node)

caseTCodePrint

public void caseTCodePrint(TCodePrint node)

caseTCodeStart

public void caseTCodeStart(TCodeStart node)

caseTHtmldata

public void caseTHtmldata(THtmldata node)

caseTCodeEnd

public void caseTCodeEnd(TCodeEnd node)

caseTIf

public void caseTIf(TIf node)

caseTElseif

public void caseTElseif(TElseif node)

caseTIfColon

public void caseTIfColon(TIfColon node)

caseTElseifColon

public void caseTElseifColon(TElseifColon node)

caseTEndif

public void caseTEndif(TEndif node)

caseTElse

public void caseTElse(TElse node)

caseTElseColon

public void caseTElseColon(TElseColon node)

caseTContinue

public void caseTContinue(TContinue node)

caseTForeach

public void caseTForeach(TForeach node)

caseTEndforeach

public void caseTEndforeach(TEndforeach node)

caseTFor

public void caseTFor(TFor node)

caseTAs

public void caseTAs(TAs node)

caseTEndfor

public void caseTEndfor(TEndfor node)

caseTWhile

public void caseTWhile(TWhile node)

caseTEndwhile

public void caseTEndwhile(TEndwhile node)

caseTDo

public void caseTDo(TDo node)

caseTSwitch

public void caseTSwitch(TSwitch node)

caseTCase

public void caseTCase(TCase node)

caseTDefault

public void caseTDefault(TDefault node)

caseTEndswitch

public void caseTEndswitch(TEndswitch node)

caseTBreak

public void caseTBreak(TBreak node)

caseTFunction

public void caseTFunction(TFunction node)

caseTReturn

public void caseTReturn(TReturn node)

caseTExit

public void caseTExit(TExit node)

caseTVar

public void caseTVar(TVar node)

caseTGlobal

public void caseTGlobal(TGlobal node)

caseTStatic

public void caseTStatic(TStatic node)

caseTTclass

public void caseTTclass(TTclass node)

caseTExtends

public void caseTExtends(TExtends node)

caseTNew

public void caseTNew(TNew node)

caseTArray

public void caseTArray(TArray node)

caseTList

public void caseTList(TList node)

caseTRequire

public void caseTRequire(TRequire node)

caseTRequireOnce

public void caseTRequireOnce(TRequireOnce node)

caseTInclude

public void caseTInclude(TInclude node)

caseTIncludeOnce

public void caseTIncludeOnce(TIncludeOnce node)

caseTEcho

public void caseTEcho(TEcho node)

caseTDeclare

public void caseTDeclare(TDeclare node)

caseTPrint

public void caseTPrint(TPrint node)

caseTBoolean

public void caseTBoolean(TBoolean node)

caseTHeredocStart

public void caseTHeredocStart(THeredocStart node)

caseTPlusEq

public void caseTPlusEq(TPlusEq node)

caseTMinusEq

public void caseTMinusEq(TMinusEq node)

caseTStarEq

public void caseTStarEq(TStarEq node)

caseTSlashEq

public void caseTSlashEq(TSlashEq node)

caseTDotEq

public void caseTDotEq(TDotEq node)

caseTPercEq

public void caseTPercEq(TPercEq node)

caseTCaretEq

public void caseTCaretEq(TCaretEq node)

caseTAmpEq

public void caseTAmpEq(TAmpEq node)

caseTBarEq

public void caseTBarEq(TBarEq node)

caseTShLEq

public void caseTShLEq(TShLEq node)

caseTShREq

public void caseTShREq(TShREq node)

caseTBopShLeft

public void caseTBopShLeft(TBopShLeft node)

caseTBopShRight

public void caseTBopShRight(TBopShRight node)

caseTPointAssoc

public void caseTPointAssoc(TPointAssoc node)

caseTPointElem

public void caseTPointElem(TPointElem node)

caseTCopEq

public void caseTCopEq(TCopEq node)

caseTCopLeq

public void caseTCopLeq(TCopLeq node)

caseTCopNleq

public void caseTCopNleq(TCopNleq node)

caseTCopLteq

public void caseTCopLteq(TCopLteq node)

caseTCopGteq

public void caseTCopGteq(TCopGteq node)

caseTCopLt

public void caseTCopLt(TCopLt node)

caseTCopGt

public void caseTCopGt(TCopGt node)

caseTCopNeq

public void caseTCopNeq(TCopNeq node)

caseTCopOr

public void caseTCopOr(TCopOr node)

caseTCopAnd

public void caseTCopAnd(TCopAnd node)

caseTLopOr

public void caseTLopOr(TLopOr node)

caseTLopAnd

public void caseTLopAnd(TLopAnd node)

caseTLopXor

public void caseTLopXor(TLopXor node)

caseTExclamation

public void caseTExclamation(TExclamation node)

caseTAmpersand

public void caseTAmpersand(TAmpersand node)

caseTBar

public void caseTBar(TBar node)

caseTCaret

public void caseTCaret(TCaret node)

caseTTilde

public void caseTTilde(TTilde node)

caseTEqual

public void caseTEqual(TEqual node)

caseTStar

public void caseTStar(TStar node)

caseTAt

public void caseTAt(TAt node)

caseTDiv

public void caseTDiv(TDiv node)

caseTMod

public void caseTMod(TMod node)

caseTPlusPlus

public void caseTPlusPlus(TPlusPlus node)

caseTMinusMinus

public void caseTMinusMinus(TMinusMinus node)

caseTPlus

public void caseTPlus(TPlus node)

caseTMinus

public void caseTMinus(TMinus node)

caseTLPar

public void caseTLPar(TLPar node)

caseTRPar

public void caseTRPar(TRPar node)

caseTLBrace

public void caseTLBrace(TLBrace node)

caseTRBrace

public void caseTRBrace(TRBrace node)

caseTLBracket

public void caseTLBracket(TLBracket node)

caseTRBracket

public void caseTRBracket(TRBracket node)

caseTSemicolon

public void caseTSemicolon(TSemicolon node)

caseTColon

public void caseTColon(TColon node)

caseTColoncolon

public void caseTColoncolon(TColoncolon node)

caseTDot

public void caseTDot(TDot node)

caseTComma

public void caseTComma(TComma node)

caseTDollar

public void caseTDollar(TDollar node)

caseTQuest

public void caseTQuest(TQuest node)

caseTCastInt

public void caseTCastInt(TCastInt node)

caseTCastDouble

public void caseTCastDouble(TCastDouble node)

caseTCastString

public void caseTCastString(TCastString node)

caseTCastArray

public void caseTCastArray(TCastArray node)

caseTCastObject

public void caseTCastObject(TCastObject node)

caseTCastBool

public void caseTCastBool(TCastBool node)

caseTCastUnset

public void caseTCastUnset(TCastUnset node)

caseTFloat

public void caseTFloat(TFloat node)

caseTInteger

public void caseTInteger(TInteger node)

caseTVariable

public void caseTVariable(TVariable node)

caseTIdentifier

public void caseTIdentifier(TIdentifier node)

caseTBlank

public void caseTBlank(TBlank node)

caseTShortComment

public void caseTShortComment(TShortComment node)

caseTLongComment

public void caseTLongComment(TLongComment node)

caseTStaticString

public void caseTStaticString(TStaticString node)

caseTStringStart

public void caseTStringStart(TStringStart node)

caseTStringEnd

public void caseTStringEnd(TStringEnd node)

caseTBacktickStart

public void caseTBacktickStart(TBacktickStart node)

caseTBacktickEnd

public void caseTBacktickEnd(TBacktickEnd node)

caseTStringToComplexCvar

public void caseTStringToComplexCvar(TStringToComplexCvar node)

caseTHeredocToComplexCvar

public void caseTHeredocToComplexCvar(THeredocToComplexCvar node)

caseTBacktickToComplexCvar

public void caseTBacktickToComplexCvar(TBacktickToComplexCvar node)

caseTStringVar

public void caseTStringVar(TStringVar node)

caseTStringArrayVar

public void caseTStringArrayVar(TStringArrayVar node)

caseTStringArrayStatic

public void caseTStringArrayStatic(TStringArrayStatic node)

caseTStringObject

public void caseTStringObject(TStringObject node)

caseTStringChunk

public void caseTStringChunk(TStringChunk node)

caseTStringChunkHelper

public void caseTStringChunkHelper(TStringChunkHelper node)

caseTHeredocChunk

public void caseTHeredocChunk(THeredocChunk node)

caseTHeredocChunkHelper

public void caseTHeredocChunkHelper(THeredocChunkHelper node)

caseTBacktickChunk

public void caseTBacktickChunk(TBacktickChunk node)

caseTBacktickChunkHelper

public void caseTBacktickChunkHelper(TBacktickChunkHelper node)

caseTStringCvarStart

public void caseTStringCvarStart(TStringCvarStart node)

caseTStringCvarEnd

public void caseTStringCvarEnd(TStringCvarEnd node)

caseTStringFromComplexCvar

public void caseTStringFromComplexCvar(TStringFromComplexCvar node)

caseTHeredocFromComplexCvar

public void caseTHeredocFromComplexCvar(THeredocFromComplexCvar node)

caseTBacktickFromComplexCvar

public void caseTBacktickFromComplexCvar(TBacktickFromComplexCvar node)

caseTHeredocEnd

public void caseTHeredocEnd(THeredocEnd node)

caseEOF

public void caseEOF(EOF node)