DepthFirstAdapter.java :  » Science » jmatlab » org » jmatlab » analysis » Java Open Source

/* This file was generated by SableCC (http://www.sablecc.org/). */

package org.jmatlab.analysis;

import java.util.*;
import org.jmatlab.node.*;

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

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

    public void defaultIn(Node node)
    {
    }

    public void defaultOut(Node node)
    {
    }

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

    public void inAProgramStart(AProgramStart node)
    {
        defaultIn(node);
    }

    public void outAProgramStart(AProgramStart node)
    {
        defaultOut(node);
    }

    public void caseAProgramStart(AProgramStart node)
    {
        inAProgramStart(node);
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        outAProgramStart(node);
    }

    public void inAFunctionStart(AFunctionStart node)
    {
        defaultIn(node);
    }

    public void outAFunctionStart(AFunctionStart node)
    {
        defaultOut(node);
    }

    public void caseAFunctionStart(AFunctionStart node)
    {
        inAFunctionStart(node);
        if(node.getFunctionDef() != null)
        {
            node.getFunctionDef().apply(this);
        }
        outAFunctionStart(node);
    }

    public void inAFunctionFunctionDef(AFunctionFunctionDef node)
    {
        defaultIn(node);
    }

    public void outAFunctionFunctionDef(AFunctionFunctionDef node)
    {
        defaultOut(node);
    }

    public void caseAFunctionFunctionDef(AFunctionFunctionDef node)
    {
        inAFunctionFunctionDef(node);
        if(node.getFunction() != null)
        {
            node.getFunction().apply(this);
        }
        if(node.getLSquareBracket() != null)
        {
            node.getLSquareBracket().apply(this);
        }
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getRSquareBracket() != null)
        {
            node.getRSquareBracket().apply(this);
        }
        if(node.getAssignop() != null)
        {
            node.getAssignop().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAFunctionFunctionDef(node);
    }

    public void inAIdentifierFunctionDef(AIdentifierFunctionDef node)
    {
        defaultIn(node);
    }

    public void outAIdentifierFunctionDef(AIdentifierFunctionDef node)
    {
        defaultOut(node);
    }

    public void caseAIdentifierFunctionDef(AIdentifierFunctionDef node)
    {
        inAIdentifierFunctionDef(node);
        if(node.getFunction() != null)
        {
            node.getFunction().apply(this);
        }
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getAssignop() != null)
        {
            node.getAssignop().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getVariables() != null)
        {
            node.getVariables().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAIdentifierFunctionDef(node);
    }

    public void inAProcedureFunctionDef(AProcedureFunctionDef node)
    {
        defaultIn(node);
    }

    public void outAProcedureFunctionDef(AProcedureFunctionDef node)
    {
        defaultOut(node);
    }

    public void caseAProcedureFunctionDef(AProcedureFunctionDef node)
    {
        inAProcedureFunctionDef(node);
        if(node.getFunction() != null)
        {
            node.getFunction().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getVariables() != null)
        {
            node.getVariables().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAProcedureFunctionDef(node);
    }

    public void inASimpleFunctionDef(ASimpleFunctionDef node)
    {
        defaultIn(node);
    }

    public void outASimpleFunctionDef(ASimpleFunctionDef node)
    {
        defaultOut(node);
    }

    public void caseASimpleFunctionDef(ASimpleFunctionDef node)
    {
        inASimpleFunctionDef(node);
        if(node.getFunction() != null)
        {
            node.getFunction().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outASimpleFunctionDef(node);
    }

    public void inASingleVariables(ASingleVariables node)
    {
        defaultIn(node);
    }

    public void outASingleVariables(ASingleVariables node)
    {
        defaultOut(node);
    }

    public void caseASingleVariables(ASingleVariables node)
    {
        inASingleVariables(node);
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        outASingleVariables(node);
    }

    public void inAMultipleVariables(AMultipleVariables node)
    {
        defaultIn(node);
    }

    public void outAMultipleVariables(AMultipleVariables node)
    {
        defaultOut(node);
    }

    public void caseAMultipleVariables(AMultipleVariables node)
    {
        inAMultipleVariables(node);
        if(node.getVariables() != null)
        {
            node.getVariables().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        outAMultipleVariables(node);
    }

    public void inAExpressionStatementStatement(AExpressionStatementStatement node)
    {
        defaultIn(node);
    }

    public void outAExpressionStatementStatement(AExpressionStatementStatement node)
    {
        defaultOut(node);
    }

    public void caseAExpressionStatementStatement(AExpressionStatementStatement node)
    {
        inAExpressionStatementStatement(node);
        if(node.getExpressionStatement() != null)
        {
            node.getExpressionStatement().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAExpressionStatementStatement(node);
    }

    public void inAReturnStatementStatement(AReturnStatementStatement node)
    {
        defaultIn(node);
    }

    public void outAReturnStatementStatement(AReturnStatementStatement node)
    {
        defaultOut(node);
    }

    public void caseAReturnStatementStatement(AReturnStatementStatement node)
    {
        inAReturnStatementStatement(node);
        if(node.getReturn() != null)
        {
            node.getReturn().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAReturnStatementStatement(node);
    }

    public void inAIfStatement(AIfStatement node)
    {
        defaultIn(node);
    }

    public void outAIfStatement(AIfStatement node)
    {
        defaultOut(node);
    }

    public void caseAIfStatement(AIfStatement node)
    {
        inAIfStatement(node);
        if(node.getIfStatement() != null)
        {
            node.getIfStatement().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAIfStatement(node);
    }

    public void inAWhileStatement(AWhileStatement node)
    {
        defaultIn(node);
    }

    public void outAWhileStatement(AWhileStatement node)
    {
        defaultOut(node);
    }

    public void caseAWhileStatement(AWhileStatement node)
    {
        inAWhileStatement(node);
        if(node.getWhileStatement() != null)
        {
            node.getWhileStatement().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAWhileStatement(node);
    }

    public void inAForStatement(AForStatement node)
    {
        defaultIn(node);
    }

    public void outAForStatement(AForStatement node)
    {
        defaultOut(node);
    }

    public void caseAForStatement(AForStatement node)
    {
        inAForStatement(node);
        if(node.getForStatement() != null)
        {
            node.getForStatement().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAForStatement(node);
    }

    public void inACommandStatement(ACommandStatement node)
    {
        defaultIn(node);
    }

    public void outACommandStatement(ACommandStatement node)
    {
        defaultOut(node);
    }

    public void caseACommandStatement(ACommandStatement node)
    {
        inACommandStatement(node);
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outACommandStatement(node);
    }

    public void inAQuestionStatement(AQuestionStatement node)
    {
        defaultIn(node);
    }

    public void outAQuestionStatement(AQuestionStatement node)
    {
        defaultOut(node);
    }

    public void caseAQuestionStatement(AQuestionStatement node)
    {
        inAQuestionStatement(node);
        if(node.getQuestion() != null)
        {
            node.getQuestion().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAQuestionStatement(node);
    }

    public void inASwitchStatement(ASwitchStatement node)
    {
        defaultIn(node);
    }

    public void outASwitchStatement(ASwitchStatement node)
    {
        defaultOut(node);
    }

    public void caseASwitchStatement(ASwitchStatement node)
    {
        inASwitchStatement(node);
        if(node.getSwitchStatement() != null)
        {
            node.getSwitchStatement().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outASwitchStatement(node);
    }

    public void inAGlobalStatement(AGlobalStatement node)
    {
        defaultIn(node);
    }

    public void outAGlobalStatement(AGlobalStatement node)
    {
        defaultOut(node);
    }

    public void caseAGlobalStatement(AGlobalStatement node)
    {
        inAGlobalStatement(node);
        if(node.getGlobal() != null)
        {
            node.getGlobal().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        outAGlobalStatement(node);
    }

    public void inASwitchSwitchStatement(ASwitchSwitchStatement node)
    {
        defaultIn(node);
    }

    public void outASwitchSwitchStatement(ASwitchSwitchStatement node)
    {
        defaultOut(node);
    }

    public void caseASwitchSwitchStatement(ASwitchSwitchStatement node)
    {
        inASwitchSwitchStatement(node);
        if(node.getSwitch() != null)
        {
            node.getSwitch().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        {
            Object temp[] = node.getCaseStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PCaseStatement) temp[i]).apply(this);
            }
        }
        if(node.getOtherwiseStatement() != null)
        {
            node.getOtherwiseStatement().apply(this);
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outASwitchSwitchStatement(node);
    }

    public void inACaseCaseStatement(ACaseCaseStatement node)
    {
        defaultIn(node);
    }

    public void outACaseCaseStatement(ACaseCaseStatement node)
    {
        defaultOut(node);
    }

    public void caseACaseCaseStatement(ACaseCaseStatement node)
    {
        inACaseCaseStatement(node);
        if(node.getCase() != null)
        {
            node.getCase().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        outACaseCaseStatement(node);
    }

    public void inAOtherwiseOtherwiseStatement(AOtherwiseOtherwiseStatement node)
    {
        defaultIn(node);
    }

    public void outAOtherwiseOtherwiseStatement(AOtherwiseOtherwiseStatement node)
    {
        defaultOut(node);
    }

    public void caseAOtherwiseOtherwiseStatement(AOtherwiseOtherwiseStatement node)
    {
        inAOtherwiseOtherwiseStatement(node);
        if(node.getOtherwise() != null)
        {
            node.getOtherwise().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        outAOtherwiseOtherwiseStatement(node);
    }

    public void inAIfIfStatement(AIfIfStatement node)
    {
        defaultIn(node);
    }

    public void outAIfIfStatement(AIfIfStatement node)
    {
        defaultOut(node);
    }

    public void caseAIfIfStatement(AIfIfStatement node)
    {
        inAIfIfStatement(node);
        if(node.getIf() != null)
        {
            node.getIf().apply(this);
        }
        if(node.getConditionalExpression() != null)
        {
            node.getConditionalExpression().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getIfStatementLast() != null)
        {
            node.getIfStatementLast().apply(this);
        }
        outAIfIfStatement(node);
    }

    public void inAEndIfStatementLast(AEndIfStatementLast node)
    {
        defaultIn(node);
    }

    public void outAEndIfStatementLast(AEndIfStatementLast node)
    {
        defaultOut(node);
    }

    public void caseAEndIfStatementLast(AEndIfStatementLast node)
    {
        inAEndIfStatementLast(node);
        if(node.getIfStatementEnd() != null)
        {
            node.getIfStatementEnd().apply(this);
        }
        outAEndIfStatementLast(node);
    }

    public void inAElseIfStatementLast(AElseIfStatementLast node)
    {
        defaultIn(node);
    }

    public void outAElseIfStatementLast(AElseIfStatementLast node)
    {
        defaultOut(node);
    }

    public void caseAElseIfStatementLast(AElseIfStatementLast node)
    {
        inAElseIfStatementLast(node);
        if(node.getElseStatement() != null)
        {
            node.getElseStatement().apply(this);
        }
        outAElseIfStatementLast(node);
    }

    public void inAElseifIfStatementLast(AElseifIfStatementLast node)
    {
        defaultIn(node);
    }

    public void outAElseifIfStatementLast(AElseifIfStatementLast node)
    {
        defaultOut(node);
    }

    public void caseAElseifIfStatementLast(AElseifIfStatementLast node)
    {
        inAElseifIfStatementLast(node);
        if(node.getElseIfStatement() != null)
        {
            node.getElseIfStatement().apply(this);
        }
        outAElseifIfStatementLast(node);
    }

    public void inAElseElseStatement(AElseElseStatement node)
    {
        defaultIn(node);
    }

    public void outAElseElseStatement(AElseElseStatement node)
    {
        defaultOut(node);
    }

    public void caseAElseElseStatement(AElseElseStatement node)
    {
        inAElseElseStatement(node);
        if(node.getElse() != null)
        {
            node.getElse().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getIfStatementEnd() != null)
        {
            node.getIfStatementEnd().apply(this);
        }
        outAElseElseStatement(node);
    }

    public void inAElseifElseIfStatement(AElseifElseIfStatement node)
    {
        defaultIn(node);
    }

    public void outAElseifElseIfStatement(AElseifElseIfStatement node)
    {
        defaultOut(node);
    }

    public void caseAElseifElseIfStatement(AElseifElseIfStatement node)
    {
        inAElseifElseIfStatement(node);
        if(node.getElseif() != null)
        {
            node.getElseif().apply(this);
        }
        if(node.getConditionalExpression() != null)
        {
            node.getConditionalExpression().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getIfStatementLast() != null)
        {
            node.getIfStatementLast().apply(this);
        }
        outAElseifElseIfStatement(node);
    }

    public void inAEndIfStatementEnd(AEndIfStatementEnd node)
    {
        defaultIn(node);
    }

    public void outAEndIfStatementEnd(AEndIfStatementEnd node)
    {
        defaultOut(node);
    }

    public void caseAEndIfStatementEnd(AEndIfStatementEnd node)
    {
        inAEndIfStatementEnd(node);
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAEndIfStatementEnd(node);
    }

    public void inAWhileWhileStatement(AWhileWhileStatement node)
    {
        defaultIn(node);
    }

    public void outAWhileWhileStatement(AWhileWhileStatement node)
    {
        defaultOut(node);
    }

    public void caseAWhileWhileStatement(AWhileWhileStatement node)
    {
        inAWhileWhileStatement(node);
        if(node.getWhile() != null)
        {
            node.getWhile().apply(this);
        }
        if(node.getConditionalExpression() != null)
        {
            node.getConditionalExpression().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAWhileWhileStatement(node);
    }

    public void inAForForStatement(AForForStatement node)
    {
        defaultIn(node);
    }

    public void outAForForStatement(AForForStatement node)
    {
        defaultOut(node);
    }

    public void caseAForForStatement(AForForStatement node)
    {
        inAForForStatement(node);
        if(node.getFor() != null)
        {
            node.getFor().apply(this);
        }
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getAssignop() != null)
        {
            node.getAssignop().apply(this);
        }
        if(node.getRangeExpression() != null)
        {
            node.getRangeExpression().apply(this);
        }
        {
            Object temp[] = node.getStatement().toArray();
            for(int i = 0; i < temp.length; i++)
            {
                ((PStatement) temp[i]).apply(this);
            }
        }
        if(node.getEnd() != null)
        {
            node.getEnd().apply(this);
        }
        outAForForStatement(node);
    }

    public void inARange2RangeExpression(ARange2RangeExpression node)
    {
        defaultIn(node);
    }

    public void outARange2RangeExpression(ARange2RangeExpression node)
    {
        defaultOut(node);
    }

    public void caseARange2RangeExpression(ARange2RangeExpression node)
    {
        inARange2RangeExpression(node);
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        outARange2RangeExpression(node);
    }

    public void inARange3RangeExpression(ARange3RangeExpression node)
    {
        defaultIn(node);
    }

    public void outARange3RangeExpression(ARange3RangeExpression node)
    {
        defaultOut(node);
    }

    public void caseARange3RangeExpression(ARange3RangeExpression node)
    {
        inARange3RangeExpression(node);
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getM1() != null)
        {
            node.getM1().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getM2() != null)
        {
            node.getM2().apply(this);
        }
        if(node.getN3() != null)
        {
            node.getN3().apply(this);
        }
        outARange3RangeExpression(node);
    }

    public void inAColonRangeExpression(AColonRangeExpression node)
    {
        defaultIn(node);
    }

    public void outAColonRangeExpression(AColonRangeExpression node)
    {
        defaultOut(node);
    }

    public void caseAColonRangeExpression(AColonRangeExpression node)
    {
        inAColonRangeExpression(node);
        if(node.getColon() != null)
        {
            node.getColon().apply(this);
        }
        outAColonRangeExpression(node);
    }

    public void inAExpressionStatement(AExpressionStatement node)
    {
        defaultIn(node);
    }

    public void outAExpressionStatement(AExpressionStatement node)
    {
        defaultOut(node);
    }

    public void caseAExpressionStatement(AExpressionStatement node)
    {
        inAExpressionStatement(node);
        if(node.getStatementExpression() != null)
        {
            node.getStatementExpression().apply(this);
        }
        outAExpressionStatement(node);
    }

    public void inAAssignmentStatementExpression(AAssignmentStatementExpression node)
    {
        defaultIn(node);
    }

    public void outAAssignmentStatementExpression(AAssignmentStatementExpression node)
    {
        defaultOut(node);
    }

    public void caseAAssignmentStatementExpression(AAssignmentStatementExpression node)
    {
        inAAssignmentStatementExpression(node);
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outAAssignmentStatementExpression(node);
    }

    public void inAMethodInvocationStatementExpression(AMethodInvocationStatementExpression node)
    {
        defaultIn(node);
    }

    public void outAMethodInvocationStatementExpression(AMethodInvocationStatementExpression node)
    {
        defaultOut(node);
    }

    public void caseAMethodInvocationStatementExpression(AMethodInvocationStatementExpression node)
    {
        inAMethodInvocationStatementExpression(node);
        if(node.getMethodInvocation() != null)
        {
            node.getMethodInvocation().apply(this);
        }
        outAMethodInvocationStatementExpression(node);
    }

    public void inAAssignmentExpressionExpression(AAssignmentExpressionExpression node)
    {
        defaultIn(node);
    }

    public void outAAssignmentExpressionExpression(AAssignmentExpressionExpression node)
    {
        defaultOut(node);
    }

    public void caseAAssignmentExpressionExpression(AAssignmentExpressionExpression node)
    {
        inAAssignmentExpressionExpression(node);
        if(node.getAssignmentExpression() != null)
        {
            node.getAssignmentExpression().apply(this);
        }
        outAAssignmentExpressionExpression(node);
    }

    public void inAConditionalExpressionAssignmentExpression(AConditionalExpressionAssignmentExpression node)
    {
        defaultIn(node);
    }

    public void outAConditionalExpressionAssignmentExpression(AConditionalExpressionAssignmentExpression node)
    {
        defaultOut(node);
    }

    public void caseAConditionalExpressionAssignmentExpression(AConditionalExpressionAssignmentExpression node)
    {
        inAConditionalExpressionAssignmentExpression(node);
        if(node.getConditionalExpression() != null)
        {
            node.getConditionalExpression().apply(this);
        }
        outAConditionalExpressionAssignmentExpression(node);
    }

    public void inAAssignmentAssignmentExpression(AAssignmentAssignmentExpression node)
    {
        defaultIn(node);
    }

    public void outAAssignmentAssignmentExpression(AAssignmentAssignmentExpression node)
    {
        defaultOut(node);
    }

    public void caseAAssignmentAssignmentExpression(AAssignmentAssignmentExpression node)
    {
        inAAssignmentAssignmentExpression(node);
        if(node.getAssignment() != null)
        {
            node.getAssignment().apply(this);
        }
        outAAssignmentAssignmentExpression(node);
    }

    public void inANameAssignment(ANameAssignment node)
    {
        defaultIn(node);
    }

    public void outANameAssignment(ANameAssignment node)
    {
        defaultOut(node);
    }

    public void caseANameAssignment(ANameAssignment node)
    {
        inANameAssignment(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDotIdentifier() != null)
        {
            node.getDotIdentifier().apply(this);
        }
        if(node.getAssignmentOperator() != null)
        {
            node.getAssignmentOperator().apply(this);
        }
        if(node.getAssignmentExpression() != null)
        {
            node.getAssignmentExpression().apply(this);
        }
        outANameAssignment(node);
    }

    public void inAElementAssignment(AElementAssignment node)
    {
        defaultIn(node);
    }

    public void outAElementAssignment(AElementAssignment node)
    {
        defaultOut(node);
    }

    public void caseAElementAssignment(AElementAssignment node)
    {
        inAElementAssignment(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        if(node.getDotIdentifier() != null)
        {
            node.getDotIdentifier().apply(this);
        }
        if(node.getAssignmentOperator() != null)
        {
            node.getAssignmentOperator().apply(this);
        }
        if(node.getAssignmentExpression() != null)
        {
            node.getAssignmentExpression().apply(this);
        }
        outAElementAssignment(node);
    }

    public void inAMatrixAssignment(AMatrixAssignment node)
    {
        defaultIn(node);
    }

    public void outAMatrixAssignment(AMatrixAssignment node)
    {
        defaultOut(node);
    }

    public void caseAMatrixAssignment(AMatrixAssignment node)
    {
        inAMatrixAssignment(node);
        if(node.getMatrix() != null)
        {
            node.getMatrix().apply(this);
        }
        if(node.getAssignmentOperator() != null)
        {
            node.getAssignmentOperator().apply(this);
        }
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        outAMatrixAssignment(node);
    }

    public void inAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        defaultIn(node);
    }

    public void outAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        defaultOut(node);
    }

    public void caseAAssignAssignmentOperator(AAssignAssignmentOperator node)
    {
        inAAssignAssignmentOperator(node);
        if(node.getAssignop() != null)
        {
            node.getAssignop().apply(this);
        }
        outAAssignAssignmentOperator(node);
    }

    public void inAConditionalOrExpressionConditionalExpression(AConditionalOrExpressionConditionalExpression node)
    {
        defaultIn(node);
    }

    public void outAConditionalOrExpressionConditionalExpression(AConditionalOrExpressionConditionalExpression node)
    {
        defaultOut(node);
    }

    public void caseAConditionalOrExpressionConditionalExpression(AConditionalOrExpressionConditionalExpression node)
    {
        inAConditionalOrExpressionConditionalExpression(node);
        if(node.getConditionalOrExpression() != null)
        {
            node.getConditionalOrExpression().apply(this);
        }
        outAConditionalOrExpressionConditionalExpression(node);
    }

    public void inAConditionalAndExpressionConditionalOrExpression(AConditionalAndExpressionConditionalOrExpression node)
    {
        defaultIn(node);
    }

    public void outAConditionalAndExpressionConditionalOrExpression(AConditionalAndExpressionConditionalOrExpression node)
    {
        defaultOut(node);
    }

    public void caseAConditionalAndExpressionConditionalOrExpression(AConditionalAndExpressionConditionalOrExpression node)
    {
        inAConditionalAndExpressionConditionalOrExpression(node);
        if(node.getConditionalAndExpression() != null)
        {
            node.getConditionalAndExpression().apply(this);
        }
        outAConditionalAndExpressionConditionalOrExpression(node);
    }

    public void inAConditionalOrExpressionConditionalOrExpression(AConditionalOrExpressionConditionalOrExpression node)
    {
        defaultIn(node);
    }

    public void outAConditionalOrExpressionConditionalOrExpression(AConditionalOrExpressionConditionalOrExpression node)
    {
        defaultOut(node);
    }

    public void caseAConditionalOrExpressionConditionalOrExpression(AConditionalOrExpressionConditionalOrExpression node)
    {
        inAConditionalOrExpressionConditionalOrExpression(node);
        if(node.getConditionalOrExpression() != null)
        {
            node.getConditionalOrExpression().apply(this);
        }
        if(node.getOr() != null)
        {
            node.getOr().apply(this);
        }
        if(node.getConditionalAndExpression() != null)
        {
            node.getConditionalAndExpression().apply(this);
        }
        outAConditionalOrExpressionConditionalOrExpression(node);
    }

    public void inAInclusiveOrExpressionConditionalAndExpression(AInclusiveOrExpressionConditionalAndExpression node)
    {
        defaultIn(node);
    }

    public void outAInclusiveOrExpressionConditionalAndExpression(AInclusiveOrExpressionConditionalAndExpression node)
    {
        defaultOut(node);
    }

    public void caseAInclusiveOrExpressionConditionalAndExpression(AInclusiveOrExpressionConditionalAndExpression node)
    {
        inAInclusiveOrExpressionConditionalAndExpression(node);
        if(node.getInclusiveOrExpression() != null)
        {
            node.getInclusiveOrExpression().apply(this);
        }
        outAInclusiveOrExpressionConditionalAndExpression(node);
    }

    public void inAConditionalAndExpressionConditionalAndExpression(AConditionalAndExpressionConditionalAndExpression node)
    {
        defaultIn(node);
    }

    public void outAConditionalAndExpressionConditionalAndExpression(AConditionalAndExpressionConditionalAndExpression node)
    {
        defaultOut(node);
    }

    public void caseAConditionalAndExpressionConditionalAndExpression(AConditionalAndExpressionConditionalAndExpression node)
    {
        inAConditionalAndExpressionConditionalAndExpression(node);
        if(node.getConditionalAndExpression() != null)
        {
            node.getConditionalAndExpression().apply(this);
        }
        if(node.getAnd() != null)
        {
            node.getAnd().apply(this);
        }
        if(node.getInclusiveOrExpression() != null)
        {
            node.getInclusiveOrExpression().apply(this);
        }
        outAConditionalAndExpressionConditionalAndExpression(node);
    }

    public void inAExclusiveOrExpressionInclusiveOrExpression(AExclusiveOrExpressionInclusiveOrExpression node)
    {
        defaultIn(node);
    }

    public void outAExclusiveOrExpressionInclusiveOrExpression(AExclusiveOrExpressionInclusiveOrExpression node)
    {
        defaultOut(node);
    }

    public void caseAExclusiveOrExpressionInclusiveOrExpression(AExclusiveOrExpressionInclusiveOrExpression node)
    {
        inAExclusiveOrExpressionInclusiveOrExpression(node);
        if(node.getExclusiveOrExpression() != null)
        {
            node.getExclusiveOrExpression().apply(this);
        }
        outAExclusiveOrExpressionInclusiveOrExpression(node);
    }

    public void inAAndExpressionExclusiveOrExpression(AAndExpressionExclusiveOrExpression node)
    {
        defaultIn(node);
    }

    public void outAAndExpressionExclusiveOrExpression(AAndExpressionExclusiveOrExpression node)
    {
        defaultOut(node);
    }

    public void caseAAndExpressionExclusiveOrExpression(AAndExpressionExclusiveOrExpression node)
    {
        inAAndExpressionExclusiveOrExpression(node);
        if(node.getAndExpression() != null)
        {
            node.getAndExpression().apply(this);
        }
        outAAndExpressionExclusiveOrExpression(node);
    }

    public void inAEqualityExpressionAndExpression(AEqualityExpressionAndExpression node)
    {
        defaultIn(node);
    }

    public void outAEqualityExpressionAndExpression(AEqualityExpressionAndExpression node)
    {
        defaultOut(node);
    }

    public void caseAEqualityExpressionAndExpression(AEqualityExpressionAndExpression node)
    {
        inAEqualityExpressionAndExpression(node);
        if(node.getEqualityExpression() != null)
        {
            node.getEqualityExpression().apply(this);
        }
        outAEqualityExpressionAndExpression(node);
    }

    public void inARelationalExpressionEqualityExpression(ARelationalExpressionEqualityExpression node)
    {
        defaultIn(node);
    }

    public void outARelationalExpressionEqualityExpression(ARelationalExpressionEqualityExpression node)
    {
        defaultOut(node);
    }

    public void caseARelationalExpressionEqualityExpression(ARelationalExpressionEqualityExpression node)
    {
        inARelationalExpressionEqualityExpression(node);
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        outARelationalExpressionEqualityExpression(node);
    }

    public void inAEqEqualityExpression(AEqEqualityExpression node)
    {
        defaultIn(node);
    }

    public void outAEqEqualityExpression(AEqEqualityExpression node)
    {
        defaultOut(node);
    }

    public void caseAEqEqualityExpression(AEqEqualityExpression node)
    {
        inAEqEqualityExpression(node);
        if(node.getEqualityExpression() != null)
        {
            node.getEqualityExpression().apply(this);
        }
        if(node.getEq() != null)
        {
            node.getEq().apply(this);
        }
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        outAEqEqualityExpression(node);
    }

    public void inANeqEqualityExpression(ANeqEqualityExpression node)
    {
        defaultIn(node);
    }

    public void outANeqEqualityExpression(ANeqEqualityExpression node)
    {
        defaultOut(node);
    }

    public void caseANeqEqualityExpression(ANeqEqualityExpression node)
    {
        inANeqEqualityExpression(node);
        if(node.getEqualityExpression() != null)
        {
            node.getEqualityExpression().apply(this);
        }
        if(node.getNgeq() != null)
        {
            node.getNgeq().apply(this);
        }
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        outANeqEqualityExpression(node);
    }

    public void inAShiftExpressionRelationalExpression(AShiftExpressionRelationalExpression node)
    {
        defaultIn(node);
    }

    public void outAShiftExpressionRelationalExpression(AShiftExpressionRelationalExpression node)
    {
        defaultOut(node);
    }

    public void caseAShiftExpressionRelationalExpression(AShiftExpressionRelationalExpression node)
    {
        inAShiftExpressionRelationalExpression(node);
        if(node.getShiftExpression() != null)
        {
            node.getShiftExpression().apply(this);
        }
        outAShiftExpressionRelationalExpression(node);
    }

    public void inALtRelationalExpression(ALtRelationalExpression node)
    {
        defaultIn(node);
    }

    public void outALtRelationalExpression(ALtRelationalExpression node)
    {
        defaultOut(node);
    }

    public void caseALtRelationalExpression(ALtRelationalExpression node)
    {
        inALtRelationalExpression(node);
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        if(node.getLt() != null)
        {
            node.getLt().apply(this);
        }
        if(node.getShiftExpression() != null)
        {
            node.getShiftExpression().apply(this);
        }
        outALtRelationalExpression(node);
    }

    public void inAGtRelationalExpression(AGtRelationalExpression node)
    {
        defaultIn(node);
    }

    public void outAGtRelationalExpression(AGtRelationalExpression node)
    {
        defaultOut(node);
    }

    public void caseAGtRelationalExpression(AGtRelationalExpression node)
    {
        inAGtRelationalExpression(node);
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        if(node.getGt() != null)
        {
            node.getGt().apply(this);
        }
        if(node.getShiftExpression() != null)
        {
            node.getShiftExpression().apply(this);
        }
        outAGtRelationalExpression(node);
    }

    public void inALteqRelationalExpression(ALteqRelationalExpression node)
    {
        defaultIn(node);
    }

    public void outALteqRelationalExpression(ALteqRelationalExpression node)
    {
        defaultOut(node);
    }

    public void caseALteqRelationalExpression(ALteqRelationalExpression node)
    {
        inALteqRelationalExpression(node);
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        if(node.getLteq() != null)
        {
            node.getLteq().apply(this);
        }
        if(node.getShiftExpression() != null)
        {
            node.getShiftExpression().apply(this);
        }
        outALteqRelationalExpression(node);
    }

    public void inAGteqRelationalExpression(AGteqRelationalExpression node)
    {
        defaultIn(node);
    }

    public void outAGteqRelationalExpression(AGteqRelationalExpression node)
    {
        defaultOut(node);
    }

    public void caseAGteqRelationalExpression(AGteqRelationalExpression node)
    {
        inAGteqRelationalExpression(node);
        if(node.getRelationalExpression() != null)
        {
            node.getRelationalExpression().apply(this);
        }
        if(node.getGteq() != null)
        {
            node.getGteq().apply(this);
        }
        if(node.getShiftExpression() != null)
        {
            node.getShiftExpression().apply(this);
        }
        outAGteqRelationalExpression(node);
    }

    public void inAAdditiveExpressionShiftExpression(AAdditiveExpressionShiftExpression node)
    {
        defaultIn(node);
    }

    public void outAAdditiveExpressionShiftExpression(AAdditiveExpressionShiftExpression node)
    {
        defaultOut(node);
    }

    public void caseAAdditiveExpressionShiftExpression(AAdditiveExpressionShiftExpression node)
    {
        inAAdditiveExpressionShiftExpression(node);
        if(node.getAdditiveExpression() != null)
        {
            node.getAdditiveExpression().apply(this);
        }
        outAAdditiveExpressionShiftExpression(node);
    }

    public void inARangeShiftExpression(ARangeShiftExpression node)
    {
        defaultIn(node);
    }

    public void outARangeShiftExpression(ARangeShiftExpression node)
    {
        defaultOut(node);
    }

    public void caseARangeShiftExpression(ARangeShiftExpression node)
    {
        inARangeShiftExpression(node);
        if(node.getRangeExpression() != null)
        {
            node.getRangeExpression().apply(this);
        }
        outARangeShiftExpression(node);
    }

    public void inAMultiplicativeExpressionAdditiveExpression(AMultiplicativeExpressionAdditiveExpression node)
    {
        defaultIn(node);
    }

    public void outAMultiplicativeExpressionAdditiveExpression(AMultiplicativeExpressionAdditiveExpression node)
    {
        defaultOut(node);
    }

    public void caseAMultiplicativeExpressionAdditiveExpression(AMultiplicativeExpressionAdditiveExpression node)
    {
        inAMultiplicativeExpressionAdditiveExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        outAMultiplicativeExpressionAdditiveExpression(node);
    }

    public void inAPlusAdditiveExpression(APlusAdditiveExpression node)
    {
        defaultIn(node);
    }

    public void outAPlusAdditiveExpression(APlusAdditiveExpression node)
    {
        defaultOut(node);
    }

    public void caseAPlusAdditiveExpression(APlusAdditiveExpression node)
    {
        inAPlusAdditiveExpression(node);
        if(node.getAdditiveExpression() != null)
        {
            node.getAdditiveExpression().apply(this);
        }
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        outAPlusAdditiveExpression(node);
    }

    public void inAMinusAdditiveExpression(AMinusAdditiveExpression node)
    {
        defaultIn(node);
    }

    public void outAMinusAdditiveExpression(AMinusAdditiveExpression node)
    {
        defaultOut(node);
    }

    public void caseAMinusAdditiveExpression(AMinusAdditiveExpression node)
    {
        inAMinusAdditiveExpression(node);
        if(node.getAdditiveExpression() != null)
        {
            node.getAdditiveExpression().apply(this);
        }
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        outAMinusAdditiveExpression(node);
    }

    public void inAPowerExpressionMultiplicativeExpression(APowerExpressionMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outAPowerExpressionMultiplicativeExpression(APowerExpressionMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseAPowerExpressionMultiplicativeExpression(APowerExpressionMultiplicativeExpression node)
    {
        inAPowerExpressionMultiplicativeExpression(node);
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outAPowerExpressionMultiplicativeExpression(node);
    }

    public void inAMultMultiplicativeExpression(AMultMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outAMultMultiplicativeExpression(AMultMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseAMultMultiplicativeExpression(AMultMultiplicativeExpression node)
    {
        inAMultMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getMult() != null)
        {
            node.getMult().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outAMultMultiplicativeExpression(node);
    }

    public void inADotMultMultiplicativeExpression(ADotMultMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outADotMultMultiplicativeExpression(ADotMultMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseADotMultMultiplicativeExpression(ADotMultMultiplicativeExpression node)
    {
        inADotMultMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getMult() != null)
        {
            node.getMult().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outADotMultMultiplicativeExpression(node);
    }

    public void inADivMultiplicativeExpression(ADivMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outADivMultiplicativeExpression(ADivMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseADivMultiplicativeExpression(ADivMultiplicativeExpression node)
    {
        inADivMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getRightDiv() != null)
        {
            node.getRightDiv().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outADivMultiplicativeExpression(node);
    }

    public void inADotDivMultiplicativeExpression(ADotDivMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outADotDivMultiplicativeExpression(ADotDivMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseADotDivMultiplicativeExpression(ADotDivMultiplicativeExpression node)
    {
        inADotDivMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getDot() != null)
        {
            node.getDot().apply(this);
        }
        if(node.getRightDiv() != null)
        {
            node.getRightDiv().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outADotDivMultiplicativeExpression(node);
    }

    public void inALeftDivMultiplicativeExpression(ALeftDivMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outALeftDivMultiplicativeExpression(ALeftDivMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseALeftDivMultiplicativeExpression(ALeftDivMultiplicativeExpression node)
    {
        inALeftDivMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getLeftDiv() != null)
        {
            node.getLeftDiv().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outALeftDivMultiplicativeExpression(node);
    }

    public void inAModMultiplicativeExpression(AModMultiplicativeExpression node)
    {
        defaultIn(node);
    }

    public void outAModMultiplicativeExpression(AModMultiplicativeExpression node)
    {
        defaultOut(node);
    }

    public void caseAModMultiplicativeExpression(AModMultiplicativeExpression node)
    {
        inAModMultiplicativeExpression(node);
        if(node.getMultiplicativeExpression() != null)
        {
            node.getMultiplicativeExpression().apply(this);
        }
        if(node.getMod() != null)
        {
            node.getMod().apply(this);
        }
        if(node.getUnaryExpression() != null)
        {
            node.getUnaryExpression().apply(this);
        }
        outAModMultiplicativeExpression(node);
    }

    public void inAPlusUnaryExpression(APlusUnaryExpression node)
    {
        defaultIn(node);
    }

    public void outAPlusUnaryExpression(APlusUnaryExpression node)
    {
        defaultOut(node);
    }

    public void caseAPlusUnaryExpression(APlusUnaryExpression node)
    {
        inAPlusUnaryExpression(node);
        if(node.getPlus() != null)
        {
            node.getPlus().apply(this);
        }
        if(node.getPowerExpression() != null)
        {
            node.getPowerExpression().apply(this);
        }
        outAPlusUnaryExpression(node);
    }

    public void inAMinusUnaryExpression(AMinusUnaryExpression node)
    {
        defaultIn(node);
    }

    public void outAMinusUnaryExpression(AMinusUnaryExpression node)
    {
        defaultOut(node);
    }

    public void caseAMinusUnaryExpression(AMinusUnaryExpression node)
    {
        inAMinusUnaryExpression(node);
        if(node.getMinus() != null)
        {
            node.getMinus().apply(this);
        }
        if(node.getPowerExpression() != null)
        {
            node.getPowerExpression().apply(this);
        }
        outAMinusUnaryExpression(node);
    }

    public void inAPowerUnaryExpression(APowerUnaryExpression node)
    {
        defaultIn(node);
    }

    public void outAPowerUnaryExpression(APowerUnaryExpression node)
    {
        defaultOut(node);
    }

    public void caseAPowerUnaryExpression(APowerUnaryExpression node)
    {
        inAPowerUnaryExpression(node);
        if(node.getPowerExpression() != null)
        {
            node.getPowerExpression().apply(this);
        }
        outAPowerUnaryExpression(node);
    }

    public void inAUnaryPowerExpression(AUnaryPowerExpression node)
    {
        defaultIn(node);
    }

    public void outAUnaryPowerExpression(AUnaryPowerExpression node)
    {
        defaultOut(node);
    }

    public void caseAUnaryPowerExpression(AUnaryPowerExpression node)
    {
        inAUnaryPowerExpression(node);
        if(node.getUnaryExpressionNotPlusMinus() != null)
        {
            node.getUnaryExpressionNotPlusMinus().apply(this);
        }
        outAUnaryPowerExpression(node);
    }

    public void inAPowerPowerExpression(APowerPowerExpression node)
    {
        defaultIn(node);
    }

    public void outAPowerPowerExpression(APowerPowerExpression node)
    {
        defaultOut(node);
    }

    public void caseAPowerPowerExpression(APowerPowerExpression node)
    {
        inAPowerPowerExpression(node);
        if(node.getPowerExpression() != null)
        {
            node.getPowerExpression().apply(this);
        }
        if(node.getPower() != null)
        {
            node.getPower().apply(this);
        }
        if(node.getUnaryExpressionNotPlusMinus() != null)
        {
            node.getUnaryExpressionNotPlusMinus().apply(this);
        }
        outAPowerPowerExpression(node);
    }

    public void inADotPowerPowerExpression(ADotPowerPowerExpression node)
    {
        defaultIn(node);
    }

    public void outADotPowerPowerExpression(ADotPowerPowerExpression node)
    {
        defaultOut(node);
    }

    public void caseADotPowerPowerExpression(ADotPowerPowerExpression node)
    {
        inADotPowerPowerExpression(node);
        if(node.getPowerExpression() != null)
        {
            node.getPowerExpression().apply(this);
        }
        if(node.getDotPower() != null)
        {
            node.getDotPower().apply(this);
        }
        if(node.getUnaryExpressionNotPlusMinus() != null)
        {
            node.getUnaryExpressionNotPlusMinus().apply(this);
        }
        outADotPowerPowerExpression(node);
    }

    public void inAPostfixExpressionUnaryExpressionNotPlusMinus(APostfixExpressionUnaryExpressionNotPlusMinus node)
    {
        defaultIn(node);
    }

    public void outAPostfixExpressionUnaryExpressionNotPlusMinus(APostfixExpressionUnaryExpressionNotPlusMinus node)
    {
        defaultOut(node);
    }

    public void caseAPostfixExpressionUnaryExpressionNotPlusMinus(APostfixExpressionUnaryExpressionNotPlusMinus node)
    {
        inAPostfixExpressionUnaryExpressionNotPlusMinus(node);
        if(node.getPostfixExpression() != null)
        {
            node.getPostfixExpression().apply(this);
        }
        outAPostfixExpressionUnaryExpressionNotPlusMinus(node);
    }

    public void inAComplementUnaryExpressionNotPlusMinus(AComplementUnaryExpressionNotPlusMinus node)
    {
        defaultIn(node);
    }

    public void outAComplementUnaryExpressionNotPlusMinus(AComplementUnaryExpressionNotPlusMinus node)
    {
        defaultOut(node);
    }

    public void caseAComplementUnaryExpressionNotPlusMinus(AComplementUnaryExpressionNotPlusMinus node)
    {
        inAComplementUnaryExpressionNotPlusMinus(node);
        if(node.getComplement() != null)
        {
            node.getComplement().apply(this);
        }
        if(node.getPostfixExpression() != null)
        {
            node.getPostfixExpression().apply(this);
        }
        outAComplementUnaryExpressionNotPlusMinus(node);
    }

    public void inAPrimaryPostfixExpression(APrimaryPostfixExpression node)
    {
        defaultIn(node);
    }

    public void outAPrimaryPostfixExpression(APrimaryPostfixExpression node)
    {
        defaultOut(node);
    }

    public void caseAPrimaryPostfixExpression(APrimaryPostfixExpression node)
    {
        inAPrimaryPostfixExpression(node);
        if(node.getPrimary() != null)
        {
            node.getPrimary().apply(this);
        }
        outAPrimaryPostfixExpression(node);
    }

    public void inANamePostfixExpression(ANamePostfixExpression node)
    {
        defaultIn(node);
    }

    public void outANamePostfixExpression(ANamePostfixExpression node)
    {
        defaultOut(node);
    }

    public void caseANamePostfixExpression(ANamePostfixExpression node)
    {
        inANamePostfixExpression(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        outANamePostfixExpression(node);
    }

    public void inAPrimePostfixExpression(APrimePostfixExpression node)
    {
        defaultIn(node);
    }

    public void outAPrimePostfixExpression(APrimePostfixExpression node)
    {
        defaultOut(node);
    }

    public void caseAPrimePostfixExpression(APrimePostfixExpression node)
    {
        inAPrimePostfixExpression(node);
        if(node.getPostfixExpression() != null)
        {
            node.getPostfixExpression().apply(this);
        }
        if(node.getDotPrime() != null)
        {
            node.getDotPrime().apply(this);
        }
        outAPrimePostfixExpression(node);
    }

    public void inAIdentifierName(AIdentifierName node)
    {
        defaultIn(node);
    }

    public void outAIdentifierName(AIdentifierName node)
    {
        defaultOut(node);
    }

    public void caseAIdentifierName(AIdentifierName node)
    {
        inAIdentifierName(node);
        if(node.getIdentifier() != null)
        {
            node.getIdentifier().apply(this);
        }
        outAIdentifierName(node);
    }

    public void inAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        defaultIn(node);
    }

    public void outAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        defaultOut(node);
    }

    public void caseAPrimaryNoNewArrayPrimary(APrimaryNoNewArrayPrimary node)
    {
        inAPrimaryNoNewArrayPrimary(node);
        if(node.getPrimaryNoNewArray() != null)
        {
            node.getPrimaryNoNewArray().apply(this);
        }
        outAPrimaryNoNewArrayPrimary(node);
    }

    public void inALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseALiteralPrimaryNoNewArray(ALiteralPrimaryNoNewArray node)
    {
        inALiteralPrimaryNoNewArray(node);
        if(node.getLiteral() != null)
        {
            node.getLiteral().apply(this);
        }
        outALiteralPrimaryNoNewArray(node);
    }

    public void inALParenthesePrimaryNoNewArray(ALParenthesePrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outALParenthesePrimaryNoNewArray(ALParenthesePrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseALParenthesePrimaryNoNewArray(ALParenthesePrimaryNoNewArray node)
    {
        inALParenthesePrimaryNoNewArray(node);
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        outALParenthesePrimaryNoNewArray(node);
    }

    public void inAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseAMethodInvocationPrimaryNoNewArray(AMethodInvocationPrimaryNoNewArray node)
    {
        inAMethodInvocationPrimaryNoNewArray(node);
        if(node.getMethodInvocation() != null)
        {
            node.getMethodInvocation().apply(this);
        }
        outAMethodInvocationPrimaryNoNewArray(node);
    }

    public void inAMatrixPrimaryNoNewArray(AMatrixPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outAMatrixPrimaryNoNewArray(AMatrixPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseAMatrixPrimaryNoNewArray(AMatrixPrimaryNoNewArray node)
    {
        inAMatrixPrimaryNoNewArray(node);
        if(node.getMatrix() != null)
        {
            node.getMatrix().apply(this);
        }
        outAMatrixPrimaryNoNewArray(node);
    }

    public void inAStructurePrimaryNoNewArray(AStructurePrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outAStructurePrimaryNoNewArray(AStructurePrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseAStructurePrimaryNoNewArray(AStructurePrimaryNoNewArray node)
    {
        inAStructurePrimaryNoNewArray(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getDotIdentifier() != null)
        {
            node.getDotIdentifier().apply(this);
        }
        outAStructurePrimaryNoNewArray(node);
    }

    public void inANewStructurePrimaryNoNewArray(ANewStructurePrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outANewStructurePrimaryNoNewArray(ANewStructurePrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseANewStructurePrimaryNoNewArray(ANewStructurePrimaryNoNewArray node)
    {
        inANewStructurePrimaryNoNewArray(node);
        if(node.getStruct() != null)
        {
            node.getStruct().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getStructVars() != null)
        {
            node.getStructVars().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        outANewStructurePrimaryNoNewArray(node);
    }

    public void inACellPrimaryNoNewArray(ACellPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outACellPrimaryNoNewArray(ACellPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseACellPrimaryNoNewArray(ACellPrimaryNoNewArray node)
    {
        inACellPrimaryNoNewArray(node);
        if(node.getCell() != null)
        {
            node.getCell().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        outACellPrimaryNoNewArray(node);
    }

    public void inACellElementPrimaryNoNewArray(ACellElementPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outACellElementPrimaryNoNewArray(ACellElementPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseACellElementPrimaryNoNewArray(ACellElementPrimaryNoNewArray node)
    {
        inACellElementPrimaryNoNewArray(node);
        if(node.getLCurlyBracket() != null)
        {
            node.getLCurlyBracket().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        if(node.getRCurlyBracket() != null)
        {
            node.getRCurlyBracket().apply(this);
        }
        outACellElementPrimaryNoNewArray(node);
    }

    public void inACellOnePrimaryNoNewArray(ACellOnePrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outACellOnePrimaryNoNewArray(ACellOnePrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseACellOnePrimaryNoNewArray(ACellOnePrimaryNoNewArray node)
    {
        inACellOnePrimaryNoNewArray(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLCurlyBracket() != null)
        {
            node.getLCurlyBracket().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        if(node.getRCurlyBracket() != null)
        {
            node.getRCurlyBracket().apply(this);
        }
        outACellOnePrimaryNoNewArray(node);
    }

    public void inACellTwoPrimaryNoNewArray(ACellTwoPrimaryNoNewArray node)
    {
        defaultIn(node);
    }

    public void outACellTwoPrimaryNoNewArray(ACellTwoPrimaryNoNewArray node)
    {
        defaultOut(node);
    }

    public void caseACellTwoPrimaryNoNewArray(ACellTwoPrimaryNoNewArray node)
    {
        inACellTwoPrimaryNoNewArray(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLCurlyBracket() != null)
        {
            node.getLCurlyBracket().apply(this);
        }
        if(node.getN1() != null)
        {
            node.getN1().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getN2() != null)
        {
            node.getN2().apply(this);
        }
        if(node.getRCurlyBracket() != null)
        {
            node.getRCurlyBracket().apply(this);
        }
        outACellTwoPrimaryNoNewArray(node);
    }

    public void inASingleStructVars(ASingleStructVars node)
    {
        defaultIn(node);
    }

    public void outASingleStructVars(ASingleStructVars node)
    {
        defaultOut(node);
    }

    public void caseASingleStructVars(ASingleStructVars node)
    {
        inASingleStructVars(node);
        if(node.getStringLiteral() != null)
        {
            node.getStringLiteral().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outASingleStructVars(node);
    }

    public void inAMultipleStructVars(AMultipleStructVars node)
    {
        defaultIn(node);
    }

    public void outAMultipleStructVars(AMultipleStructVars node)
    {
        defaultOut(node);
    }

    public void caseAMultipleStructVars(AMultipleStructVars node)
    {
        inAMultipleStructVars(node);
        if(node.getStructVars() != null)
        {
            node.getStructVars().apply(this);
        }
        if(node.getC1() != null)
        {
            node.getC1().apply(this);
        }
        if(node.getStringLiteral() != null)
        {
            node.getStringLiteral().apply(this);
        }
        if(node.getC2() != null)
        {
            node.getC2().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outAMultipleStructVars(node);
    }

    public void inAMatrixMatrix(AMatrixMatrix node)
    {
        defaultIn(node);
    }

    public void outAMatrixMatrix(AMatrixMatrix node)
    {
        defaultOut(node);
    }

    public void caseAMatrixMatrix(AMatrixMatrix node)
    {
        inAMatrixMatrix(node);
        if(node.getLSquareBracket() != null)
        {
            node.getLSquareBracket().apply(this);
        }
        if(node.getRows() != null)
        {
            node.getRows().apply(this);
        }
        if(node.getRSquareBracket() != null)
        {
            node.getRSquareBracket().apply(this);
        }
        outAMatrixMatrix(node);
    }

    public void inASingleRows(ASingleRows node)
    {
        defaultIn(node);
    }

    public void outASingleRows(ASingleRows node)
    {
        defaultOut(node);
    }

    public void caseASingleRows(ASingleRows node)
    {
        inASingleRows(node);
        if(node.getRow() != null)
        {
            node.getRow().apply(this);
        }
        outASingleRows(node);
    }

    public void inAMultipleRows(AMultipleRows node)
    {
        defaultIn(node);
    }

    public void outAMultipleRows(AMultipleRows node)
    {
        defaultOut(node);
    }

    public void caseAMultipleRows(AMultipleRows node)
    {
        inAMultipleRows(node);
        if(node.getRows() != null)
        {
            node.getRows().apply(this);
        }
        if(node.getSemicolon() != null)
        {
            node.getSemicolon().apply(this);
        }
        if(node.getRow() != null)
        {
            node.getRow().apply(this);
        }
        outAMultipleRows(node);
    }

    public void inASingleRow(ASingleRow node)
    {
        defaultIn(node);
    }

    public void outASingleRow(ASingleRow node)
    {
        defaultOut(node);
    }

    public void caseASingleRow(ASingleRow node)
    {
        inASingleRow(node);
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outASingleRow(node);
    }

    public void inAMultipleRow(AMultipleRow node)
    {
        defaultIn(node);
    }

    public void outAMultipleRow(AMultipleRow node)
    {
        defaultOut(node);
    }

    public void caseAMultipleRow(AMultipleRow node)
    {
        inAMultipleRow(node);
        if(node.getRow() != null)
        {
            node.getRow().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outAMultipleRow(node);
    }

    public void inANameMethodInvocation(ANameMethodInvocation node)
    {
        defaultIn(node);
    }

    public void outANameMethodInvocation(ANameMethodInvocation node)
    {
        defaultOut(node);
    }

    public void caseANameMethodInvocation(ANameMethodInvocation node)
    {
        inANameMethodInvocation(node);
        if(node.getName() != null)
        {
            node.getName().apply(this);
        }
        if(node.getLParen() != null)
        {
            node.getLParen().apply(this);
        }
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getRParen() != null)
        {
            node.getRParen().apply(this);
        }
        if(node.getDotIdentifier() != null)
        {
            node.getDotIdentifier().apply(this);
        }
        outANameMethodInvocation(node);
    }

    public void inAExpressionArgumentList(AExpressionArgumentList node)
    {
        defaultIn(node);
    }

    public void outAExpressionArgumentList(AExpressionArgumentList node)
    {
        defaultOut(node);
    }

    public void caseAExpressionArgumentList(AExpressionArgumentList node)
    {
        inAExpressionArgumentList(node);
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outAExpressionArgumentList(node);
    }

    public void inAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        defaultIn(node);
    }

    public void outAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        defaultOut(node);
    }

    public void caseAArgumentListArgumentList(AArgumentListArgumentList node)
    {
        inAArgumentListArgumentList(node);
        if(node.getArgumentList() != null)
        {
            node.getArgumentList().apply(this);
        }
        if(node.getComma() != null)
        {
            node.getComma().apply(this);
        }
        if(node.getExpression() != null)
        {
            node.getExpression().apply(this);
        }
        outAArgumentListArgumentList(node);
    }

    public void inAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        defaultIn(node);
    }

    public void outAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        defaultOut(node);
    }

    public void caseAIntegerLiteralLiteral(AIntegerLiteralLiteral node)
    {
        inAIntegerLiteralLiteral(node);
        if(node.getIntegerLiteral() != null)
        {
            node.getIntegerLiteral().apply(this);
        }
        outAIntegerLiteralLiteral(node);
    }

    public void inAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        defaultIn(node);
    }

    public void outAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        defaultOut(node);
    }

    public void caseAFloatingPointLiteralLiteral(AFloatingPointLiteralLiteral node)
    {
        inAFloatingPointLiteralLiteral(node);
        if(node.getFloatingPointLiteral() != null)
        {
            node.getFloatingPointLiteral().apply(this);
        }
        outAFloatingPointLiteralLiteral(node);
    }

    public void inABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        defaultIn(node);
    }

    public void outABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        defaultOut(node);
    }

    public void caseABooleanLiteralLiteral(ABooleanLiteralLiteral node)
    {
        inABooleanLiteralLiteral(node);
        if(node.getBooleanLiteral() != null)
        {
            node.getBooleanLiteral().apply(this);
        }
        outABooleanLiteralLiteral(node);
    }

    public void inAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        defaultIn(node);
    }

    public void outAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        defaultOut(node);
    }

    public void caseAStringLiteralLiteral(AStringLiteralLiteral node)
    {
        inAStringLiteralLiteral(node);
        if(node.getStringLiteral() != null)
        {
            node.getStringLiteral().apply(this);
        }
        outAStringLiteralLiteral(node);
    }

    public void inAImaginaryLiteralLiteral(AImaginaryLiteralLiteral node)
    {
        defaultIn(node);
    }

    public void outAImaginaryLiteralLiteral(AImaginaryLiteralLiteral node)
    {
        defaultOut(node);
    }

    public void caseAImaginaryLiteralLiteral(AImaginaryLiteralLiteral node)
    {
        inAImaginaryLiteralLiteral(node);
        if(node.getImaginaryLiteral() != null)
        {
            node.getImaginaryLiteral().apply(this);
        }
        outAImaginaryLiteralLiteral(node);
    }

    public void inAStringStringLiteral(AStringStringLiteral node)
    {
        defaultIn(node);
    }

    public void outAStringStringLiteral(AStringStringLiteral node)
    {
        defaultOut(node);
    }

    public void caseAStringStringLiteral(AStringStringLiteral node)
    {
        inAStringStringLiteral(node);
        if(node.getString() != null)
        {
            node.getString().apply(this);
        }
        outAStringStringLiteral(node);
    }

    public void inAImaginaryImaginaryLiteral(AImaginaryImaginaryLiteral node)
    {
        defaultIn(node);
    }

    public void outAImaginaryImaginaryLiteral(AImaginaryImaginaryLiteral node)
    {
        defaultOut(node);
    }

    public void caseAImaginaryImaginaryLiteral(AImaginaryImaginaryLiteral node)
    {
        inAImaginaryImaginaryLiteral(node);
        if(node.getImaginaryNumber() != null)
        {
            node.getImaginaryNumber().apply(this);
        }
        outAImaginaryImaginaryLiteral(node);
    }

    public void inATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        defaultIn(node);
    }

    public void outATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        defaultOut(node);
    }

    public void caseATrueBooleanLiteral(ATrueBooleanLiteral node)
    {
        inATrueBooleanLiteral(node);
        if(node.getTrue() != null)
        {
            node.getTrue().apply(this);
        }
        outATrueBooleanLiteral(node);
    }

    public void inAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        defaultIn(node);
    }

    public void outAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        defaultOut(node);
    }

    public void caseAFalseBooleanLiteral(AFalseBooleanLiteral node)
    {
        inAFalseBooleanLiteral(node);
        if(node.getFalse() != null)
        {
            node.getFalse().apply(this);
        }
        outAFalseBooleanLiteral(node);
    }

    public void inADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        defaultIn(node);
    }

    public void outADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        defaultOut(node);
    }

    public void caseADecimalIntegerLiteral(ADecimalIntegerLiteral node)
    {
        inADecimalIntegerLiteral(node);
        if(node.getDecimalIntegerLiteral() != null)
        {
            node.getDecimalIntegerLiteral().apply(this);
        }
        outADecimalIntegerLiteral(node);
    }
}