prerna.sablecc2.analysis.ReversedDepthFirstAdapter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of semoss Show documentation
SEMOSS
The newest version!
/* This file was generated by SableCC (http://www.sablecc.org/). */

package prerna.sablecc2.analysis;

import java.util.*;
import prerna.sablecc2.node.*;

public class ReversedDepthFirstAdapter extends AnalysisAdapter
{
    public void inStart(Start node)
    {
        defaultIn(node);
    }

    public void outStart(Start node)
    {
        defaultOut(node);
    }

    public void defaultIn(@SuppressWarnings("unused") Node node)
    {
        // Do nothing
    }

    public void defaultOut(@SuppressWarnings("unused") Node node)
    {
        // Do nothing
    }

    @Override
    public void caseStart(Start node)
    {
        inStart(node);
        node.getEOF().apply(this);
        node.getPConfiguration().apply(this);
        outStart(node);
    }

    public void inARoutineConfiguration(ARoutineConfiguration node)
    {
        defaultIn(node);
    }

    public void outARoutineConfiguration(ARoutineConfiguration node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARoutineConfiguration(ARoutineConfiguration node)
    {
        inARoutineConfiguration(node);
        {
            List copy = new ArrayList(node.getRoutine());
            Collections.reverse(copy);
            for(PRoutine e : copy)
            {
                e.apply(this);
            }
        }
        outARoutineConfiguration(node);
    }

    public void inAEmptyConfiguration(AEmptyConfiguration node)
    {
        defaultIn(node);
    }

    public void outAEmptyConfiguration(AEmptyConfiguration node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmptyConfiguration(AEmptyConfiguration node)
    {
        inAEmptyConfiguration(node);
        if(node.getEmptyroutine() != null)
        {
            node.getEmptyroutine().apply(this);
        }
        outAEmptyConfiguration(node);
    }

    public void inAOutputRoutine(AOutputRoutine node)
    {
        defaultIn(node);
    }

    public void outAOutputRoutine(AOutputRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOutputRoutine(AOutputRoutine node)
    {
        inAOutputRoutine(node);
        {
            List copy = new ArrayList(node.getSemicolon());
            Collections.reverse(copy);
            for(TSemicolon e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getScript() != null)
        {
            node.getScript().apply(this);
        }
        outAOutputRoutine(node);
    }

    public void inAAssignRoutine(AAssignRoutine node)
    {
        defaultIn(node);
    }

    public void outAAssignRoutine(AAssignRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAAssignRoutine(AAssignRoutine node)
    {
        inAAssignRoutine(node);
        {
            List copy = new ArrayList(node.getSemicolon());
            Collections.reverse(copy);
            for(TSemicolon e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outAAssignRoutine(node);
    }

    public void inAMetaRoutine(AMetaRoutine node)
    {
        defaultIn(node);
    }

    public void outAMetaRoutine(AMetaRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMetaRoutine(AMetaRoutine node)
    {
        inAMetaRoutine(node);
        {
            List copy = new ArrayList(node.getSemicolon());
            Collections.reverse(copy);
            for(TSemicolon e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMetaRoutine() != null)
        {
            node.getMetaRoutine().apply(this);
        }
        outAMetaRoutine(node);
    }

    public void inAMainCommentRoutine(AMainCommentRoutine node)
    {
        defaultIn(node);
    }

    public void outAMainCommentRoutine(AMainCommentRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMainCommentRoutine(AMainCommentRoutine node)
    {
        inAMainCommentRoutine(node);
        if(node.getComment() != null)
        {
            node.getComment().apply(this);
        }
        outAMainCommentRoutine(node);
    }

    public void inAEmptyroutine(AEmptyroutine node)
    {
        defaultIn(node);
    }

    public void outAEmptyroutine(AEmptyroutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmptyroutine(AEmptyroutine node)
    {
        inAEmptyroutine(node);
        {
            List copy = new ArrayList(node.getSemicolon());
            Collections.reverse(copy);
            for(TSemicolon e : copy)
            {
                e.apply(this);
            }
        }
        outAEmptyroutine(node);
    }

    public void inAScript(AScript node)
    {
        defaultIn(node);
    }

    public void outAScript(AScript node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAScript(AScript node)
    {
        inAScript(node);
        {
            List copy = new ArrayList(node.getOtherscript());
            Collections.reverse(copy);
            for(POtherscript e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        outAScript(node);
    }

    public void inAOtherscript(AOtherscript node)
    {
        defaultIn(node);
    }

    public void outAOtherscript(AOtherscript node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOtherscript(AOtherscript node)
    {
        inAOtherscript(node);
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        if(node.getCustom() != null)
        {
            node.getCustom().apply(this);
        }
        outAOtherscript(node);
    }

    public void inAAssignment(AAssignment node)
    {
        defaultIn(node);
    }

    public void outAAssignment(AAssignment node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAAssignment(AAssignment node)
    {
        inAAssignment(node);
        if(node.getScript() != null)
        {
            node.getScript().apply(this);
        }
        if(node.getEqual() != null)
        {
            node.getEqual().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAAssignment(node);
    }

    public void inAMetaScriptMetaRoutine(AMetaScriptMetaRoutine node)
    {
        defaultIn(node);
    }

    public void outAMetaScriptMetaRoutine(AMetaScriptMetaRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMetaScriptMetaRoutine(AMetaScriptMetaRoutine node)
    {
        inAMetaScriptMetaRoutine(node);
        if(node.getScript() != null)
        {
            node.getScript().apply(this);
        }
        if(node.getCustom() != null)
        {
            node.getCustom().apply(this);
        }
        if(node.getMeta() != null)
        {
            node.getMeta().apply(this);
        }
        outAMetaScriptMetaRoutine(node);
    }

    public void inAMetaAssignmentMetaRoutine(AMetaAssignmentMetaRoutine node)
    {
        defaultIn(node);
    }

    public void outAMetaAssignmentMetaRoutine(AMetaAssignmentMetaRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMetaAssignmentMetaRoutine(AMetaAssignmentMetaRoutine node)
    {
        inAMetaAssignmentMetaRoutine(node);
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        if(node.getCustom() != null)
        {
            node.getCustom().apply(this);
        }
        if(node.getMeta() != null)
        {
            node.getMeta().apply(this);
        }
        outAMetaAssignmentMetaRoutine(node);
    }

    public void inAMandatoryScriptchain(AMandatoryScriptchain node)
    {
        defaultIn(node);
    }

    public void outAMandatoryScriptchain(AMandatoryScriptchain node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMandatoryScriptchain(AMandatoryScriptchain node)
    {
        inAMandatoryScriptchain(node);
        {
            List copy = new ArrayList(node.getOtherscript());
            Collections.reverse(copy);
            for(POtherscript e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        outAMandatoryScriptchain(node);
    }

    public void inABaseSubExpr(ABaseSubExpr node)
    {
        defaultIn(node);
    }

    public void outABaseSubExpr(ABaseSubExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABaseSubExpr(ABaseSubExpr node)
    {
        inABaseSubExpr(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        outABaseSubExpr(node);
    }

    public void inABaseSubScript(ABaseSubScript node)
    {
        defaultIn(node);
    }

    public void outABaseSubScript(ABaseSubScript node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABaseSubScript(ABaseSubScript node)
    {
        inABaseSubScript(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        if(node.getMandatoryScriptchain() != null)
        {
            node.getMandatoryScriptchain().apply(this);
        }
        outABaseSubScript(node);
    }

    public void inABaseAssignment(ABaseAssignment node)
    {
        defaultIn(node);
    }

    public void outABaseAssignment(ABaseAssignment node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABaseAssignment(ABaseAssignment node)
    {
        inABaseAssignment(node);
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outABaseAssignment(node);
    }

    public void inASimpleSubRoutineOptions(ASimpleSubRoutineOptions node)
    {
        defaultIn(node);
    }

    public void outASimpleSubRoutineOptions(ASimpleSubRoutineOptions node)
    {
        defaultOut(node);
    }

    @Override
    public void caseASimpleSubRoutineOptions(ASimpleSubRoutineOptions node)
    {
        inASimpleSubRoutineOptions(node);
        if(node.getBaseSubExpr() != null)
        {
            node.getBaseSubExpr().apply(this);
        }
        outASimpleSubRoutineOptions(node);
    }

    public void inAChainSubRoutineOptions(AChainSubRoutineOptions node)
    {
        defaultIn(node);
    }

    public void outAChainSubRoutineOptions(AChainSubRoutineOptions node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAChainSubRoutineOptions(AChainSubRoutineOptions node)
    {
        inAChainSubRoutineOptions(node);
        if(node.getBaseSubScript() != null)
        {
            node.getBaseSubScript().apply(this);
        }
        outAChainSubRoutineOptions(node);
    }

    public void inAAssignmentSubRoutineOptions(AAssignmentSubRoutineOptions node)
    {
        defaultIn(node);
    }

    public void outAAssignmentSubRoutineOptions(AAssignmentSubRoutineOptions node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAAssignmentSubRoutineOptions(AAssignmentSubRoutineOptions node)
    {
        inAAssignmentSubRoutineOptions(node);
        if(node.getBaseAssignment() != null)
        {
            node.getBaseAssignment().apply(this);
        }
        outAAssignmentSubRoutineOptions(node);
    }

    public void inASubRoutine(ASubRoutine node)
    {
        defaultIn(node);
    }

    public void outASubRoutine(ASubRoutine node)
    {
        defaultOut(node);
    }

    @Override
    public void caseASubRoutine(ASubRoutine node)
    {
        inASubRoutine(node);
        {
            List copy = new ArrayList(node.getSubRoutineOptions());
            Collections.reverse(copy);
            for(PSubRoutineOptions e : copy)
            {
                e.apply(this);
            }
        }
        outASubRoutine(node);
    }

    public void inANormalMasterExpr(ANormalMasterExpr node)
    {
        defaultIn(node);
    }

    public void outANormalMasterExpr(ANormalMasterExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANormalMasterExpr(ANormalMasterExpr node)
    {
        inANormalMasterExpr(node);
        if(node.getExpr() != null)
        {
            node.getExpr().apply(this);
        }
        outANormalMasterExpr(node);
    }

    public void inAComparisonMasterExpr(AComparisonMasterExpr node)
    {
        defaultIn(node);
    }

    public void outAComparisonMasterExpr(AComparisonMasterExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAComparisonMasterExpr(AComparisonMasterExpr node)
    {
        inAComparisonMasterExpr(node);
        if(node.getComparisonExpr() != null)
        {
            node.getComparisonExpr().apply(this);
        }
        outAComparisonMasterExpr(node);
    }

    public void inABaseExprExpr(ABaseExprExpr node)
    {
        defaultIn(node);
    }

    public void outABaseExprExpr(ABaseExprExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABaseExprExpr(ABaseExprExpr node)
    {
        inABaseExprExpr(node);
        if(node.getBaseExpr() != null)
        {
            node.getBaseExpr().apply(this);
        }
        outABaseExprExpr(node);
    }

    public void inAEmbeddedRoutineExpr(AEmbeddedRoutineExpr node)
    {
        defaultIn(node);
    }

    public void outAEmbeddedRoutineExpr(AEmbeddedRoutineExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmbeddedRoutineExpr(AEmbeddedRoutineExpr node)
    {
        inAEmbeddedRoutineExpr(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getSubRoutine() != null)
        {
            node.getSubRoutine().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAEmbeddedRoutineExpr(node);
    }

    public void inAEmbeddedAssignmentExpr(AEmbeddedAssignmentExpr node)
    {
        defaultIn(node);
    }

    public void outAEmbeddedAssignmentExpr(AEmbeddedAssignmentExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmbeddedAssignmentExpr(AEmbeddedAssignmentExpr node)
    {
        inAEmbeddedAssignmentExpr(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAEmbeddedAssignmentExpr(node);
    }

    public void inAHelpExpr(AHelpExpr node)
    {
        defaultIn(node);
    }

    public void outAHelpExpr(AHelpExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAHelpExpr(AHelpExpr node)
    {
        inAHelpExpr(node);
        if(node.getHelpToken() != null)
        {
            node.getHelpToken().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAHelpExpr(node);
    }

    public void inACommentExpr(ACommentExpr node)
    {
        defaultIn(node);
    }

    public void outACommentExpr(ACommentExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseACommentExpr(ACommentExpr node)
    {
        inACommentExpr(node);
        if(node.getComment() != null)
        {
            node.getComment().apply(this);
        }
        outACommentExpr(node);
    }

    public void inAExprComponentBaseExpr(AExprComponentBaseExpr node)
    {
        defaultIn(node);
    }

    public void outAExprComponentBaseExpr(AExprComponentBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExprComponentBaseExpr(AExprComponentBaseExpr node)
    {
        inAExprComponentBaseExpr(node);
        if(node.getExprComponent() != null)
        {
            node.getExprComponent().apply(this);
        }
        outAExprComponentBaseExpr(node);
    }

    public void inAPlusBaseExpr(APlusBaseExpr node)
    {
        defaultIn(node);
    }

    public void outAPlusBaseExpr(APlusBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPlusBaseExpr(APlusBaseExpr node)
    {
        inAPlusBaseExpr(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outAPlusBaseExpr(node);
    }

    public void inAMinusBaseExpr(AMinusBaseExpr node)
    {
        defaultIn(node);
    }

    public void outAMinusBaseExpr(AMinusBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMinusBaseExpr(AMinusBaseExpr node)
    {
        inAMinusBaseExpr(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outAMinusBaseExpr(node);
    }

    public void inAMultBaseExpr(AMultBaseExpr node)
    {
        defaultIn(node);
    }

    public void outAMultBaseExpr(AMultBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMultBaseExpr(AMultBaseExpr node)
    {
        inAMultBaseExpr(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getMult() != null)
        {
            node.getMult().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outAMultBaseExpr(node);
    }

    public void inADivBaseExpr(ADivBaseExpr node)
    {
        defaultIn(node);
    }

    public void outADivBaseExpr(ADivBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseADivBaseExpr(ADivBaseExpr node)
    {
        inADivBaseExpr(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getDiv() != null)
        {
            node.getDiv().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outADivBaseExpr(node);
    }

    public void inAModBaseExpr(AModBaseExpr node)
    {
        defaultIn(node);
    }

    public void outAModBaseExpr(AModBaseExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAModBaseExpr(AModBaseExpr node)
    {
        inAModBaseExpr(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getMod() != null)
        {
            node.getMod().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outAModBaseExpr(node);
    }

    public void inATermExprComponent(ATermExprComponent node)
    {
        defaultIn(node);
    }

    public void outATermExprComponent(ATermExprComponent node)
    {
        defaultOut(node);
    }

    @Override
    public void caseATermExprComponent(ATermExprComponent node)
    {
        inATermExprComponent(node);
        if(node.getTerm() != null)
        {
            node.getTerm().apply(this);
        }
        outATermExprComponent(node);
    }

    public void inAPowerExprComponent(APowerExprComponent node)
    {
        defaultIn(node);
    }

    public void outAPowerExprComponent(APowerExprComponent node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPowerExprComponent(APowerExprComponent node)
    {
        inAPowerExprComponent(node);
        if(node.getPower() != null)
        {
            node.getPower().apply(this);
        }
        outAPowerExprComponent(node);
    }

    public void inAEmbeddedScriptchainExprComponent(AEmbeddedScriptchainExprComponent node)
    {
        defaultIn(node);
    }

    public void outAEmbeddedScriptchainExprComponent(AEmbeddedScriptchainExprComponent node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmbeddedScriptchainExprComponent(AEmbeddedScriptchainExprComponent node)
    {
        inAEmbeddedScriptchainExprComponent(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getMandatoryScriptchain() != null)
        {
            node.getMandatoryScriptchain().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAEmbeddedScriptchainExprComponent(node);
    }

    public void inAPower(APower node)
    {
        defaultIn(node);
    }

    public void outAPower(APower node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPower(APower node)
    {
        inAPower(node);
        if(node.getExponent() != null)
        {
            node.getExponent().apply(this);
        }
        if(node.getPow() != null)
        {
            node.getPow().apply(this);
        }
        if(node.getBase() != null)
        {
            node.getBase().apply(this);
        }
        outAPower(node);
    }

    public void inARegTermTerm(ARegTermTerm node)
    {
        defaultIn(node);
    }

    public void outARegTermTerm(ARegTermTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARegTermTerm(ARegTermTerm node)
    {
        inARegTermTerm(node);
        if(node.getRegTerm() != null)
        {
            node.getRegTerm().apply(this);
        }
        outARegTermTerm(node);
    }

    public void inANegTermTerm(ANegTermTerm node)
    {
        defaultIn(node);
    }

    public void outANegTermTerm(ANegTermTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANegTermTerm(ANegTermTerm node)
    {
        inANegTermTerm(node);
        if(node.getNegTerm() != null)
        {
            node.getNegTerm().apply(this);
        }
        outANegTermTerm(node);
    }

    public void inAPosTermTerm(APosTermTerm node)
    {
        defaultIn(node);
    }

    public void outAPosTermTerm(APosTermTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPosTermTerm(APosTermTerm node)
    {
        inAPosTermTerm(node);
        if(node.getPosTerm() != null)
        {
            node.getPosTerm().apply(this);
        }
        outAPosTermTerm(node);
    }

    public void inANegTerm(ANegTerm node)
    {
        defaultIn(node);
    }

    public void outANegTerm(ANegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANegTerm(ANegTerm node)
    {
        inANegTerm(node);
        if(node.getTerm() != null)
        {
            node.getTerm().apply(this);
        }
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        outANegTerm(node);
    }

    public void inAPosTerm(APosTerm node)
    {
        defaultIn(node);
    }

    public void outAPosTerm(APosTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPosTerm(APosTerm node)
    {
        inAPosTerm(node);
        if(node.getTerm() != null)
        {
            node.getTerm().apply(this);
        }
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        outAPosTerm(node);
    }

    public void inAScalarRegTerm(AScalarRegTerm node)
    {
        defaultIn(node);
    }

    public void outAScalarRegTerm(AScalarRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAScalarRegTerm(AScalarRegTerm node)
    {
        inAScalarRegTerm(node);
        if(node.getScalar() != null)
        {
            node.getScalar().apply(this);
        }
        outAScalarRegTerm(node);
    }

    public void inAMapRegTerm(AMapRegTerm node)
    {
        defaultIn(node);
    }

    public void outAMapRegTerm(AMapRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapRegTerm(AMapRegTerm node)
    {
        inAMapRegTerm(node);
        if(node.getMap() != null)
        {
            node.getMap().apply(this);
        }
        outAMapRegTerm(node);
    }

    public void inAFormulaRegTerm(AFormulaRegTerm node)
    {
        defaultIn(node);
    }

    public void outAFormulaRegTerm(AFormulaRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAFormulaRegTerm(AFormulaRegTerm node)
    {
        inAFormulaRegTerm(node);
        if(node.getFormula() != null)
        {
            node.getFormula().apply(this);
        }
        outAFormulaRegTerm(node);
    }

    public void inAOperationRegTerm(AOperationRegTerm node)
    {
        defaultIn(node);
    }

    public void outAOperationRegTerm(AOperationRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOperationRegTerm(AOperationRegTerm node)
    {
        inAOperationRegTerm(node);
        if(node.getOperation() != null)
        {
            node.getOperation().apply(this);
        }
        outAOperationRegTerm(node);
    }

    public void inARefRegTerm(ARefRegTerm node)
    {
        defaultIn(node);
    }

    public void outARefRegTerm(ARefRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARefRegTerm(ARefRegTerm node)
    {
        inARefRegTerm(node);
        if(node.getRcol() != null)
        {
            node.getRcol().apply(this);
        }
        outARefRegTerm(node);
    }

    public void inADotcolRegTerm(ADotcolRegTerm node)
    {
        defaultIn(node);
    }

    public void outADotcolRegTerm(ADotcolRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseADotcolRegTerm(ADotcolRegTerm node)
    {
        inADotcolRegTerm(node);
        if(node.getDotcol() != null)
        {
            node.getDotcol().apply(this);
        }
        outADotcolRegTerm(node);
    }

    public void inAJavaOpRegTerm(AJavaOpRegTerm node)
    {
        defaultIn(node);
    }

    public void outAJavaOpRegTerm(AJavaOpRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAJavaOpRegTerm(AJavaOpRegTerm node)
    {
        inAJavaOpRegTerm(node);
        if(node.getJavaOp() != null)
        {
            node.getJavaOp().apply(this);
        }
        outAJavaOpRegTerm(node);
    }

    public void inAListRegTerm(AListRegTerm node)
    {
        defaultIn(node);
    }

    public void outAListRegTerm(AListRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAListRegTerm(AListRegTerm node)
    {
        inAListRegTerm(node);
        if(node.getList() != null)
        {
            node.getList().apply(this);
        }
        outAListRegTerm(node);
    }

    public void inACsvRegTerm(ACsvRegTerm node)
    {
        defaultIn(node);
    }

    public void outACsvRegTerm(ACsvRegTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseACsvRegTerm(ACsvRegTerm node)
    {
        inACsvRegTerm(node);
        if(node.getGenRow() != null)
        {
            node.getGenRow().apply(this);
        }
        outACsvRegTerm(node);
    }

    public void inAFormula(AFormula node)
    {
        defaultIn(node);
    }

    public void outAFormula(AFormula node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAFormula(AFormula node)
    {
        inAFormula(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getExpr() != null)
        {
            node.getExpr().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAFormula(node);
    }

    public void inAEmptyList(AEmptyList node)
    {
        defaultIn(node);
    }

    public void outAEmptyList(AEmptyList node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAEmptyList(AEmptyList node)
    {
        inAEmptyList(node);
        if(node.getNoValuesList() != null)
        {
            node.getNoValuesList().apply(this);
        }
        outAEmptyList(node);
    }

    public void inAFilledList(AFilledList node)
    {
        defaultIn(node);
    }

    public void outAFilledList(AFilledList node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAFilledList(AFilledList node)
    {
        inAFilledList(node);
        if(node.getValuesList() != null)
        {
            node.getValuesList().apply(this);
        }
        outAFilledList(node);
    }

    public void inANoValuesList(ANoValuesList node)
    {
        defaultIn(node);
    }

    public void outANoValuesList(ANoValuesList node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANoValuesList(ANoValuesList node)
    {
        inANoValuesList(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outANoValuesList(node);
    }

    public void inAValuesList(AValuesList node)
    {
        defaultIn(node);
    }

    public void outAValuesList(AValuesList node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAValuesList(AValuesList node)
    {
        inAValuesList(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        {
            List copy = new ArrayList(node.getOtherExpr());
            Collections.reverse(copy);
            for(POtherExpr e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAValuesList(node);
    }

    public void inAOtherExpr(AOtherExpr node)
    {
        defaultIn(node);
    }

    public void outAOtherExpr(AOtherExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOtherExpr(AOtherExpr node)
    {
        inAOtherExpr(node);
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        outAOtherExpr(node);
    }

    public void inAOperation(AOperation node)
    {
        defaultIn(node);
    }

    public void outAOperation(AOperation node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOperation(AOperation node)
    {
        inAOperation(node);
        if(node.getAsop() != null)
        {
            node.getAsop().apply(this);
        }
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        {
            List copy = new ArrayList(node.getOtherOpInput());
            Collections.reverse(copy);
            for(POtherOpInput e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getOpInput() != null)
        {
            node.getOpInput().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAOperation(node);
    }

    public void inANounOpInput(ANounOpInput node)
    {
        defaultIn(node);
    }

    public void outANounOpInput(ANounOpInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANounOpInput(ANounOpInput node)
    {
        inANounOpInput(node);
        if(node.getNoun() != null)
        {
            node.getNoun().apply(this);
        }
        outANounOpInput(node);
    }

    public void inAInputOpInput(AInputOpInput node)
    {
        defaultIn(node);
    }

    public void outAInputOpInput(AInputOpInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAInputOpInput(AInputOpInput node)
    {
        inAInputOpInput(node);
        if(node.getColDef() != null)
        {
            node.getColDef().apply(this);
        }
        outAInputOpInput(node);
    }

    public void inAOtherOpInput(AOtherOpInput node)
    {
        defaultIn(node);
    }

    public void outAOtherOpInput(AOtherOpInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOtherOpInput(AOtherOpInput node)
    {
        inAOtherOpInput(node);
        if(node.getOpInput() != null)
        {
            node.getOpInput().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        outAOtherOpInput(node);
    }

    public void inAGenRow(AGenRow node)
    {
        defaultIn(node);
    }

    public void outAGenRow(AGenRow node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAGenRow(AGenRow node)
    {
        inAGenRow(node);
        if(node.getRBrac() != null)
        {
            node.getRBrac().apply(this);
        }
        {
            List copy = new ArrayList(node.getOthercol());
            Collections.reverse(copy);
            for(POthercol e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getColDef() != null)
        {
            node.getColDef().apply(this);
        }
        if(node.getLBrac() != null)
        {
            node.getLBrac().apply(this);
        }
        outAGenRow(node);
    }

    public void inAOthercol(AOthercol node)
    {
        defaultIn(node);
    }

    public void outAOthercol(AOthercol node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOthercol(AOthercol node)
    {
        inAOthercol(node);
        if(node.getColDef() != null)
        {
            node.getColDef().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        outAOthercol(node);
    }

    public void inAExprColDef(AExprColDef node)
    {
        defaultIn(node);
    }

    public void outAExprColDef(AExprColDef node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExprColDef(AExprColDef node)
    {
        inAExprColDef(node);
        if(node.getMasterExpr() != null)
        {
            node.getMasterExpr().apply(this);
        }
        outAExprColDef(node);
    }

    public void inAPropColDef(APropColDef node)
    {
        defaultIn(node);
    }

    public void outAPropColDef(APropColDef node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAPropColDef(APropColDef node)
    {
        inAPropColDef(node);
        if(node.getProp() != null)
        {
            node.getProp().apply(this);
        }
        outAPropColDef(node);
    }

    public void inARelationColDef(ARelationColDef node)
    {
        defaultIn(node);
    }

    public void outARelationColDef(ARelationColDef node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARelationColDef(ARelationColDef node)
    {
        inARelationColDef(node);
        if(node.getRelationship() != null)
        {
            node.getRelationship().apply(this);
        }
        outARelationColDef(node);
    }

    public void inANoun(ANoun node)
    {
        defaultIn(node);
    }

    public void outANoun(ANoun node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANoun(ANoun node)
    {
        inANoun(node);
        if(node.getGenRow() != null)
        {
            node.getGenRow().apply(this);
        }
        if(node.getEqual() != null)
        {
            node.getEqual().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outANoun(node);
    }

    public void inAProp(AProp node)
    {
        defaultIn(node);
    }

    public void outAProp(AProp node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAProp(AProp node)
    {
        inAProp(node);
        if(node.getScalar() != null)
        {
            node.getScalar().apply(this);
        }
        if(node.getEqual() != null)
        {
            node.getEqual().apply(this);
        }
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAProp(node);
    }

    public void inAAsop(AAsop node)
    {
        defaultIn(node);
    }

    public void outAAsop(AAsop node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAAsop(AAsop node)
    {
        inAAsop(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getGenRow() != null)
        {
            node.getGenRow().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        if(node.getAsOp() != null)
        {
            node.getAsOp().apply(this);
        }
        outAAsop(node);
    }

    public void inAExplicitRelationship(AExplicitRelationship node)
    {
        defaultIn(node);
    }

    public void outAExplicitRelationship(AExplicitRelationship node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExplicitRelationship(AExplicitRelationship node)
    {
        inAExplicitRelationship(node);
        if(node.getExplicitRel() != null)
        {
            node.getExplicitRel().apply(this);
        }
        outAExplicitRelationship(node);
    }

    public void inAExplicitComparatorRelationship(AExplicitComparatorRelationship node)
    {
        defaultIn(node);
    }

    public void outAExplicitComparatorRelationship(AExplicitComparatorRelationship node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExplicitComparatorRelationship(AExplicitComparatorRelationship node)
    {
        inAExplicitComparatorRelationship(node);
        if(node.getExplicitRelComparator() != null)
        {
            node.getExplicitRelComparator().apply(this);
        }
        outAExplicitComparatorRelationship(node);
    }

    public void inAImplicitRelationship(AImplicitRelationship node)
    {
        defaultIn(node);
    }

    public void outAImplicitRelationship(AImplicitRelationship node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAImplicitRelationship(AImplicitRelationship node)
    {
        inAImplicitRelationship(node);
        if(node.getImplicitRel() != null)
        {
            node.getImplicitRel().apply(this);
        }
        outAImplicitRelationship(node);
    }

    public void inAImplicitRel(AImplicitRel node)
    {
        defaultIn(node);
    }

    public void outAImplicitRel(AImplicitRel node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAImplicitRel(AImplicitRel node)
    {
        inAImplicitRel(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getRcol() != null)
        {
            node.getRcol().apply(this);
        }
        if(node.getComma2() != null)
        {
            node.getComma2().apply(this);
        }
        if(node.getRelType() != null)
        {
            node.getRelType().apply(this);
        }
        if(node.getComma1() != null)
        {
            node.getComma1().apply(this);
        }
        if(node.getLcol() != null)
        {
            node.getLcol().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAImplicitRel(node);
    }

    public void inAExplicitRelComparator(AExplicitRelComparator node)
    {
        defaultIn(node);
    }

    public void outAExplicitRelComparator(AExplicitRelComparator node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExplicitRelComparator(AExplicitRelComparator node)
    {
        inAExplicitRelComparator(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getComparator() != null)
        {
            node.getComparator().apply(this);
        }
        if(node.getComma3() != null)
        {
            node.getComma3().apply(this);
        }
        if(node.getRcol() != null)
        {
            node.getRcol().apply(this);
        }
        if(node.getComma2() != null)
        {
            node.getComma2().apply(this);
        }
        if(node.getRelType() != null)
        {
            node.getRelType().apply(this);
        }
        if(node.getComma1() != null)
        {
            node.getComma1().apply(this);
        }
        if(node.getLcol() != null)
        {
            node.getLcol().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAExplicitRelComparator(node);
    }

    public void inAExplicitRel(AExplicitRel node)
    {
        defaultIn(node);
    }

    public void outAExplicitRel(AExplicitRel node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAExplicitRel(AExplicitRel node)
    {
        inAExplicitRel(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getRelationshipName() != null)
        {
            node.getRelationshipName().apply(this);
        }
        if(node.getComma3() != null)
        {
            node.getComma3().apply(this);
        }
        if(node.getRcol() != null)
        {
            node.getRcol().apply(this);
        }
        if(node.getComma2() != null)
        {
            node.getComma2().apply(this);
        }
        if(node.getRelType() != null)
        {
            node.getRelType().apply(this);
        }
        if(node.getComma1() != null)
        {
            node.getComma1().apply(this);
        }
        if(node.getLcol() != null)
        {
            node.getLcol().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAExplicitRel(node);
    }

    public void inATermComparisonExpr(ATermComparisonExpr node)
    {
        defaultIn(node);
    }

    public void outATermComparisonExpr(ATermComparisonExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseATermComparisonExpr(ATermComparisonExpr node)
    {
        inATermComparisonExpr(node);
        if(node.getComparisonTerm() != null)
        {
            node.getComparisonTerm().apply(this);
        }
        outATermComparisonExpr(node);
    }

    public void inAComparisonGroupComparisonExpr(AComparisonGroupComparisonExpr node)
    {
        defaultIn(node);
    }

    public void outAComparisonGroupComparisonExpr(AComparisonGroupComparisonExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAComparisonGroupComparisonExpr(AComparisonGroupComparisonExpr node)
    {
        inAComparisonGroupComparisonExpr(node);
        if(node.getComparisonGroup() != null)
        {
            node.getComparisonGroup().apply(this);
        }
        outAComparisonGroupComparisonExpr(node);
    }

    public void inAComplexOrComparisonExpr(AComplexOrComparisonExpr node)
    {
        defaultIn(node);
    }

    public void outAComplexOrComparisonExpr(AComplexOrComparisonExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAComplexOrComparisonExpr(AComplexOrComparisonExpr node)
    {
        inAComplexOrComparisonExpr(node);
        if(node.getComparisonExpr() != null)
        {
            node.getComparisonExpr().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        if(node.getComparisonGroup() != null)
        {
            node.getComparisonGroup().apply(this);
        }
        outAComplexOrComparisonExpr(node);
    }

    public void inAComplexAndComparisonExpr(AComplexAndComparisonExpr node)
    {
        defaultIn(node);
    }

    public void outAComplexAndComparisonExpr(AComplexAndComparisonExpr node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAComplexAndComparisonExpr(AComplexAndComparisonExpr node)
    {
        inAComplexAndComparisonExpr(node);
        if(node.getComparisonExpr() != null)
        {
            node.getComparisonExpr().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        if(node.getComparisonGroup() != null)
        {
            node.getComparisonGroup().apply(this);
        }
        outAComplexAndComparisonExpr(node);
    }

    public void inABasicComparisonTerm(ABasicComparisonTerm node)
    {
        defaultIn(node);
    }

    public void outABasicComparisonTerm(ABasicComparisonTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABasicComparisonTerm(ABasicComparisonTerm node)
    {
        inABasicComparisonTerm(node);
        if(node.getBaseSimpleComparison() != null)
        {
            node.getBaseSimpleComparison().apply(this);
        }
        outABasicComparisonTerm(node);
    }

    public void inABasicAndComparisonTerm(ABasicAndComparisonTerm node)
    {
        defaultIn(node);
    }

    public void outABasicAndComparisonTerm(ABasicAndComparisonTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABasicAndComparisonTerm(ABasicAndComparisonTerm node)
    {
        inABasicAndComparisonTerm(node);
        if(node.getAndComparison() != null)
        {
            node.getAndComparison().apply(this);
        }
        outABasicAndComparisonTerm(node);
    }

    public void inABasicOrComparisonTerm(ABasicOrComparisonTerm node)
    {
        defaultIn(node);
    }

    public void outABasicOrComparisonTerm(ABasicOrComparisonTerm node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABasicOrComparisonTerm(ABasicOrComparisonTerm node)
    {
        inABasicOrComparisonTerm(node);
        if(node.getOrComparison() != null)
        {
            node.getOrComparison().apply(this);
        }
        outABasicOrComparisonTerm(node);
    }

    public void inAComparisonGroup(AComparisonGroup node)
    {
        defaultIn(node);
    }

    public void outAComparisonGroup(AComparisonGroup node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAComparisonGroup(AComparisonGroup node)
    {
        inAComparisonGroup(node);
        if(node.getRPar() != null)
        {
            node.getRPar().apply(this);
        }
        if(node.getComparisonExpr() != null)
        {
            node.getComparisonExpr().apply(this);
        }
        if(node.getLPar() != null)
        {
            node.getLPar().apply(this);
        }
        outAComparisonGroup(node);
    }

    public void inASimpleCaseAndComparison(ASimpleCaseAndComparison node)
    {
        defaultIn(node);
    }

    public void outASimpleCaseAndComparison(ASimpleCaseAndComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseASimpleCaseAndComparison(ASimpleCaseAndComparison node)
    {
        inASimpleCaseAndComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingAndComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outASimpleCaseAndComparison(node);
    }

    public void inALeftComplexAndComparison(ALeftComplexAndComparison node)
    {
        defaultIn(node);
    }

    public void outALeftComplexAndComparison(ALeftComplexAndComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseALeftComplexAndComparison(ALeftComplexAndComparison node)
    {
        inALeftComplexAndComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingAndComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outALeftComplexAndComparison(node);
    }

    public void inARightComplexAndComparison(ARightComplexAndComparison node)
    {
        defaultIn(node);
    }

    public void outARightComplexAndComparison(ARightComplexAndComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARightComplexAndComparison(ARightComplexAndComparison node)
    {
        inARightComplexAndComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingAndComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outARightComplexAndComparison(node);
    }

    public void inABothComplexAndComparison(ABothComplexAndComparison node)
    {
        defaultIn(node);
    }

    public void outABothComplexAndComparison(ABothComplexAndComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABothComplexAndComparison(ABothComplexAndComparison node)
    {
        inABothComplexAndComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingAndComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outABothComplexAndComparison(node);
    }

    public void inARepeatingAndComparison(ARepeatingAndComparison node)
    {
        defaultIn(node);
    }

    public void outARepeatingAndComparison(ARepeatingAndComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARepeatingAndComparison(ARepeatingAndComparison node)
    {
        inARepeatingAndComparison(node);
        if(node.getBaseSimpleComparison() != null)
        {
            node.getBaseSimpleComparison().apply(this);
        }
        if(node.getAndComparator() != null)
        {
            node.getAndComparator().apply(this);
        }
        outARepeatingAndComparison(node);
    }

    public void inASimpleCaseOrComparison(ASimpleCaseOrComparison node)
    {
        defaultIn(node);
    }

    public void outASimpleCaseOrComparison(ASimpleCaseOrComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseASimpleCaseOrComparison(ASimpleCaseOrComparison node)
    {
        inASimpleCaseOrComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingOrComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outASimpleCaseOrComparison(node);
    }

    public void inALeftComplexOrComparison(ALeftComplexOrComparison node)
    {
        defaultIn(node);
    }

    public void outALeftComplexOrComparison(ALeftComplexOrComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseALeftComplexOrComparison(ALeftComplexOrComparison node)
    {
        inALeftComplexOrComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingOrComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outALeftComplexOrComparison(node);
    }

    public void inARightComplexOrComparison(ARightComplexOrComparison node)
    {
        defaultIn(node);
    }

    public void outARightComplexOrComparison(ARightComplexOrComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARightComplexOrComparison(ARightComplexOrComparison node)
    {
        inARightComplexOrComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingOrComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outARightComplexOrComparison(node);
    }

    public void inABothComplexOrComparison(ABothComplexOrComparison node)
    {
        defaultIn(node);
    }

    public void outABothComplexOrComparison(ABothComplexOrComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABothComplexOrComparison(ABothComplexOrComparison node)
    {
        inABothComplexOrComparison(node);
        {
            List copy = new ArrayList(node.getMoreRight());
            Collections.reverse(copy);
            for(PRepeatingOrComparison e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outABothComplexOrComparison(node);
    }

    public void inARepeatingOrComparison(ARepeatingOrComparison node)
    {
        defaultIn(node);
    }

    public void outARepeatingOrComparison(ARepeatingOrComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARepeatingOrComparison(ARepeatingOrComparison node)
    {
        inARepeatingOrComparison(node);
        if(node.getBaseSimpleComparison() != null)
        {
            node.getBaseSimpleComparison().apply(this);
        }
        if(node.getOrComparator() != null)
        {
            node.getOrComparator().apply(this);
        }
        outARepeatingOrComparison(node);
    }

    public void inABaseSimpleComparison(ABaseSimpleComparison node)
    {
        defaultIn(node);
    }

    public void outABaseSimpleComparison(ABaseSimpleComparison node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABaseSimpleComparison(ABaseSimpleComparison node)
    {
        inABaseSimpleComparison(node);
        if(node.getRight() != null)
        {
            node.getRight().apply(this);
        }
        if(node.getComparator() != null)
        {
            node.getComparator().apply(this);
        }
        if(node.getLeft() != null)
        {
            node.getLeft().apply(this);
        }
        outABaseSimpleComparison(node);
    }

    public void inAJavaOp(AJavaOp node)
    {
        defaultIn(node);
    }

    public void outAJavaOp(AJavaOp node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAJavaOp(AJavaOp node)
    {
        inAJavaOp(node);
        if(node.getJava() != null)
        {
            node.getJava().apply(this);
        }
        outAJavaOp(node);
    }

    public void inARcol(ARcol node)
    {
        defaultIn(node);
    }

    public void outARcol(ARcol node)
    {
        defaultOut(node);
    }

    @Override
    public void caseARcol(ARcol node)
    {
        inARcol(node);
        if(node.getColumnName() != null)
        {
            node.getColumnName().apply(this);
        }
        if(node.getFrameprefix() != null)
        {
            node.getFrameprefix().apply(this);
        }
        outARcol(node);
    }

    public void inADotcol(ADotcol node)
    {
        defaultIn(node);
    }

    public void outADotcol(ADotcol node)
    {
        defaultOut(node);
    }

    @Override
    public void caseADotcol(ADotcol node)
    {
        inADotcol(node);
        if(node.getColumnName() != null)
        {
            node.getColumnName().apply(this);
        }
        if(node.getFrameid() != null)
        {
            node.getFrameid().apply(this);
        }
        outADotcol(node);
    }

    public void inAMap(AMap node)
    {
        defaultIn(node);
    }

    public void outAMap(AMap node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMap(AMap node)
    {
        inAMap(node);
        if(node.getRCurl() != null)
        {
            node.getRCurl().apply(this);
        }
        {
            List copy = new ArrayList(node.getOtherMapEntry());
            Collections.reverse(copy);
            for(POtherMapEntry e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMapEntry() != null)
        {
            node.getMapEntry().apply(this);
        }
        if(node.getLCurl() != null)
        {
            node.getLCurl().apply(this);
        }
        outAMap(node);
    }

    public void inAMapEntry(AMapEntry node)
    {
        defaultIn(node);
    }

    public void outAMapEntry(AMapEntry node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapEntry(AMapEntry node)
    {
        inAMapEntry(node);
        if(node.getVal() != null)
        {
            node.getVal().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getKey() != null)
        {
            node.getKey().apply(this);
        }
        outAMapEntry(node);
    }

    public void inAOtherMapEntry(AOtherMapEntry node)
    {
        defaultIn(node);
    }

    public void outAOtherMapEntry(AOtherMapEntry node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAOtherMapEntry(AOtherMapEntry node)
    {
        inAOtherMapEntry(node);
        if(node.getMapEntry() != null)
        {
            node.getMapEntry().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        outAOtherMapEntry(node);
    }

    public void inASimpleValues(ASimpleValues node)
    {
        defaultIn(node);
    }

    public void outASimpleValues(ASimpleValues node)
    {
        defaultOut(node);
    }

    @Override
    public void caseASimpleValues(ASimpleValues node)
    {
        inASimpleValues(node);
        if(node.getMapBaseInput() != null)
        {
            node.getMapBaseInput().apply(this);
        }
        outASimpleValues(node);
    }

    public void inAListValues(AListValues node)
    {
        defaultIn(node);
    }

    public void outAListValues(AListValues node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAListValues(AListValues node)
    {
        inAListValues(node);
        if(node.getMapList() != null)
        {
            node.getMapList().apply(this);
        }
        outAListValues(node);
    }

    public void inANestedMapValues(ANestedMapValues node)
    {
        defaultIn(node);
    }

    public void outANestedMapValues(ANestedMapValues node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANestedMapValues(ANestedMapValues node)
    {
        inANestedMapValues(node);
        if(node.getMap() != null)
        {
            node.getMap().apply(this);
        }
        outANestedMapValues(node);
    }

    public void inAMapOperationValues(AMapOperationValues node)
    {
        defaultIn(node);
    }

    public void outAMapOperationValues(AMapOperationValues node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapOperationValues(AMapOperationValues node)
    {
        inAMapOperationValues(node);
        if(node.getOperation() != null)
        {
            node.getOperation().apply(this);
        }
        outAMapOperationValues(node);
    }

    public void inAMapList(AMapList node)
    {
        defaultIn(node);
    }

    public void outAMapList(AMapList node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapList(AMapList node)
    {
        inAMapList(node);
        if(node.getRBrac() != null)
        {
            node.getRBrac().apply(this);
        }
        {
            List copy = new ArrayList(node.getMapListExtend());
            Collections.reverse(copy);
            for(PMapListExtend e : copy)
            {
                e.apply(this);
            }
        }
        if(node.getMapExtendedInput() != null)
        {
            node.getMapExtendedInput().apply(this);
        }
        if(node.getLBrac() != null)
        {
            node.getLBrac().apply(this);
        }
        outAMapList(node);
    }

    public void inAMapListExtend(AMapListExtend node)
    {
        defaultIn(node);
    }

    public void outAMapListExtend(AMapListExtend node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapListExtend(AMapListExtend node)
    {
        inAMapListExtend(node);
        if(node.getMapExtendedInput() != null)
        {
            node.getMapExtendedInput().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        outAMapListExtend(node);
    }

    public void inAWordMapKey(AWordMapKey node)
    {
        defaultIn(node);
    }

    public void outAWordMapKey(AWordMapKey node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAWordMapKey(AWordMapKey node)
    {
        inAWordMapKey(node);
        if(node.getWord() != null)
        {
            node.getWord().apply(this);
        }
        outAWordMapKey(node);
    }

    public void inAVarMapKey(AVarMapKey node)
    {
        defaultIn(node);
    }

    public void outAVarMapKey(AVarMapKey node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAVarMapKey(AVarMapKey node)
    {
        inAVarMapKey(node);
        if(node.getMapVar() != null)
        {
            node.getMapVar().apply(this);
        }
        outAVarMapKey(node);
    }

    public void inAListMapExtendedInput(AListMapExtendedInput node)
    {
        defaultIn(node);
    }

    public void outAListMapExtendedInput(AListMapExtendedInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAListMapExtendedInput(AListMapExtendedInput node)
    {
        inAListMapExtendedInput(node);
        if(node.getMapList() != null)
        {
            node.getMapList().apply(this);
        }
        outAListMapExtendedInput(node);
    }

    public void inAScalarMapExtendedInput(AScalarMapExtendedInput node)
    {
        defaultIn(node);
    }

    public void outAScalarMapExtendedInput(AScalarMapExtendedInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAScalarMapExtendedInput(AScalarMapExtendedInput node)
    {
        inAScalarMapExtendedInput(node);
        if(node.getMapBaseInput() != null)
        {
            node.getMapBaseInput().apply(this);
        }
        outAScalarMapExtendedInput(node);
    }

    public void inANestedMapMapExtendedInput(ANestedMapMapExtendedInput node)
    {
        defaultIn(node);
    }

    public void outANestedMapMapExtendedInput(ANestedMapMapExtendedInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANestedMapMapExtendedInput(ANestedMapMapExtendedInput node)
    {
        inANestedMapMapExtendedInput(node);
        if(node.getMap() != null)
        {
            node.getMap().apply(this);
        }
        outANestedMapMapExtendedInput(node);
    }

    public void inAMapVarMapBaseInput(AMapVarMapBaseInput node)
    {
        defaultIn(node);
    }

    public void outAMapVarMapBaseInput(AMapVarMapBaseInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapVarMapBaseInput(AMapVarMapBaseInput node)
    {
        inAMapVarMapBaseInput(node);
        if(node.getMapVar() != null)
        {
            node.getMapVar().apply(this);
        }
        outAMapVarMapBaseInput(node);
    }

    public void inANormalScalarMapBaseInput(ANormalScalarMapBaseInput node)
    {
        defaultIn(node);
    }

    public void outANormalScalarMapBaseInput(ANormalScalarMapBaseInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANormalScalarMapBaseInput(ANormalScalarMapBaseInput node)
    {
        inANormalScalarMapBaseInput(node);
        if(node.getScalar() != null)
        {
            node.getScalar().apply(this);
        }
        outANormalScalarMapBaseInput(node);
    }

    public void inAMapNegNumMapBaseInput(AMapNegNumMapBaseInput node)
    {
        defaultIn(node);
    }

    public void outAMapNegNumMapBaseInput(AMapNegNumMapBaseInput node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapNegNumMapBaseInput(AMapNegNumMapBaseInput node)
    {
        inAMapNegNumMapBaseInput(node);
        if(node.getMapNegNum() != null)
        {
            node.getMapNegNum().apply(this);
        }
        outAMapNegNumMapBaseInput(node);
    }

    public void inAMapVar(AMapVar node)
    {
        defaultIn(node);
    }

    public void outAMapVar(AMapVar node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapVar(AMapVar node)
    {
        inAMapVar(node);
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        if(node.getVar() != null)
        {
            node.getVar().apply(this);
        }
        if(node.getStart() != null)
        {
            node.getStart().apply(this);
        }
        outAMapVar(node);
    }

    public void inAMapNegNum(AMapNegNum node)
    {
        defaultIn(node);
    }

    public void outAMapNegNum(AMapNegNum node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAMapNegNum(AMapNegNum node)
    {
        inAMapNegNum(node);
        if(node.getDecimal() != null)
        {
            node.getDecimal().apply(this);
        }
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        outAMapNegNum(node);
    }

    public void inANumScalar(ANumScalar node)
    {
        defaultIn(node);
    }

    public void outANumScalar(ANumScalar node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANumScalar(ANumScalar node)
    {
        inANumScalar(node);
        if(node.getDecimal() != null)
        {
            node.getDecimal().apply(this);
        }
        outANumScalar(node);
    }

    public void inABooleanScalar(ABooleanScalar node)
    {
        defaultIn(node);
    }

    public void outABooleanScalar(ABooleanScalar node)
    {
        defaultOut(node);
    }

    @Override
    public void caseABooleanScalar(ABooleanScalar node)
    {
        inABooleanScalar(node);
        if(node.getBoolean() != null)
        {
            node.getBoolean().apply(this);
        }
        outABooleanScalar(node);
    }

    public void inANullScalar(ANullScalar node)
    {
        defaultIn(node);
    }

    public void outANullScalar(ANullScalar node)
    {
        defaultOut(node);
    }

    @Override
    public void caseANullScalar(ANullScalar node)
    {
        inANullScalar(node);
        if(node.getNull() != null)
        {
            node.getNull().apply(this);
        }
        outANullScalar(node);
    }

    public void inAWordOrIdScalar(AWordOrIdScalar node)
    {
        defaultIn(node);
    }

    public void outAWordOrIdScalar(AWordOrIdScalar node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAWordOrIdScalar(AWordOrIdScalar node)
    {
        inAWordOrIdScalar(node);
        if(node.getWordOrId() != null)
        {
            node.getWordOrId().apply(this);
        }
        outAWordOrIdScalar(node);
    }

    public void inAWordWordOrId(AWordWordOrId node)
    {
        defaultIn(node);
    }

    public void outAWordWordOrId(AWordWordOrId node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAWordWordOrId(AWordWordOrId node)
    {
        inAWordWordOrId(node);
        if(node.getWord() != null)
        {
            node.getWord().apply(this);
        }
        outAWordWordOrId(node);
    }

    public void inAIdWordOrId(AIdWordOrId node)
    {
        defaultIn(node);
    }

    public void outAIdWordOrId(AIdWordOrId node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAIdWordOrId(AIdWordOrId node)
    {
        inAIdWordOrId(node);
        if(node.getId() != null)
        {
            node.getId().apply(this);
        }
        outAIdWordOrId(node);
    }

    public void inAWholeDecimalDecimal(AWholeDecimalDecimal node)
    {
        defaultIn(node);
    }

    public void outAWholeDecimalDecimal(AWholeDecimalDecimal node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAWholeDecimalDecimal(AWholeDecimalDecimal node)
    {
        inAWholeDecimalDecimal(node);
        if(node.getWholeDecimal() != null)
        {
            node.getWholeDecimal().apply(this);
        }
        outAWholeDecimalDecimal(node);
    }

    public void inAFractionDecimalDecimal(AFractionDecimalDecimal node)
    {
        defaultIn(node);
    }

    public void outAFractionDecimalDecimal(AFractionDecimalDecimal node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAFractionDecimalDecimal(AFractionDecimalDecimal node)
    {
        inAFractionDecimalDecimal(node);
        if(node.getFractionDecimal() != null)
        {
            node.getFractionDecimal().apply(this);
        }
        outAFractionDecimalDecimal(node);
    }

    public void inAWholeDecimal(AWholeDecimal node)
    {
        defaultIn(node);
    }

    public void outAWholeDecimal(AWholeDecimal node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAWholeDecimal(AWholeDecimal node)
    {
        inAWholeDecimal(node);
        if(node.getFraction() != null)
        {
            node.getFraction().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getWhole() != null)
        {
            node.getWhole().apply(this);
        }
        outAWholeDecimal(node);
    }

    public void inAFractionDecimal(AFractionDecimal node)
    {
        defaultIn(node);
    }

    public void outAFractionDecimal(AFractionDecimal node)
    {
        defaultOut(node);
    }

    @Override
    public void caseAFractionDecimal(AFractionDecimal node)
    {
        inAFractionDecimal(node);
        if(node.getFraction() != null)
        {
            node.getFraction().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        outAFractionDecimal(node);
    }
}