ReversedDepthFirstAdapter.java :  » Parser » sablecc » org » sablecc » sablecc » analysis » Java Open Source

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

package org.sablecc.sablecc.analysis;

import org.sablecc.sablecc.node.*;

public class ReversedDepthFirstAdapter 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.getEOF().apply(this);
    node.getPGrammar().apply(this);
    outStart(node);
  }

  public void inAGrammar(AGrammar node)
  {
    defaultIn(node);
  }

  public void outAGrammar(AGrammar node)
  {
    defaultOut(node);
  }

  public void caseAGrammar(AGrammar node)
  {
    inAGrammar(node);
    if(node.getAst() != null)
    {
      node.getAst().apply(this);
    }
    if(node.getProductions() != null)
    {
      node.getProductions().apply(this);
    }
    if(node.getIgnTokens() != null)
    {
      node.getIgnTokens().apply(this);
    }
    if(node.getTokens() != null)
    {
      node.getTokens().apply(this);
    }
    if(node.getStates() != null)
    {
      node.getStates().apply(this);
    }
    if(node.getHelpers() != null)
    {
      node.getHelpers().apply(this);
    }
    {
      Object temp[] = node.getPackage().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((TPkgId) temp[i]).apply(this);
      }
    }
    outAGrammar(node);
  }

  public void inAHelpers(AHelpers node)
  {
    defaultIn(node);
  }

  public void outAHelpers(AHelpers node)
  {
    defaultOut(node);
  }

  public void caseAHelpers(AHelpers node)
  {
    inAHelpers(node);
    {
      Object temp[] = node.getHelperDefs().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PHelperDef) temp[i]).apply(this);
      }
    }
    outAHelpers(node);
  }

  public void inAHelperDef(AHelperDef node)
  {
    defaultIn(node);
  }

  public void outAHelperDef(AHelperDef node)
  {
    defaultOut(node);
  }

  public void caseAHelperDef(AHelperDef node)
  {
    inAHelperDef(node);
    if(node.getRegExp() != null)
    {
      node.getRegExp().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAHelperDef(node);
  }

  public void inAStates(AStates node)
  {
    defaultIn(node);
  }

  public void outAStates(AStates node)
  {
    defaultOut(node);
  }

  public void caseAStates(AStates node)
  {
    inAStates(node);
    {
      Object temp[] = node.getListId().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((TId) temp[i]).apply(this);
      }
    }
    outAStates(node);
  }

  public void inATokens(ATokens node)
  {
    defaultIn(node);
  }

  public void outATokens(ATokens node)
  {
    defaultOut(node);
  }

  public void caseATokens(ATokens node)
  {
    inATokens(node);
    {
      Object temp[] = node.getTokenDefs().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PTokenDef) temp[i]).apply(this);
      }
    }
    outATokens(node);
  }

  public void inATokenDef(ATokenDef node)
  {
    defaultIn(node);
  }

  public void outATokenDef(ATokenDef node)
  {
    defaultOut(node);
  }

  public void caseATokenDef(ATokenDef node)
  {
    inATokenDef(node);
    if(node.getLookAhead() != null)
    {
      node.getLookAhead().apply(this);
    }
    if(node.getSlash() != null)
    {
      node.getSlash().apply(this);
    }
    if(node.getRegExp() != null)
    {
      node.getRegExp().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getStateList() != null)
    {
      node.getStateList().apply(this);
    }
    outATokenDef(node);
  }

  public void inAStateList(AStateList node)
  {
    defaultIn(node);
  }

  public void outAStateList(AStateList node)
  {
    defaultOut(node);
  }

  public void caseAStateList(AStateList node)
  {
    inAStateList(node);
    {
      Object temp[] = node.getStateLists().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PStateListTail) temp[i]).apply(this);
      }
    }
    if(node.getTransition() != null)
    {
      node.getTransition().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAStateList(node);
  }

  public void inAStateListTail(AStateListTail node)
  {
    defaultIn(node);
  }

  public void outAStateListTail(AStateListTail node)
  {
    defaultOut(node);
  }

  public void caseAStateListTail(AStateListTail node)
  {
    inAStateListTail(node);
    if(node.getTransition() != null)
    {
      node.getTransition().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAStateListTail(node);
  }

  public void inATransition(ATransition node)
  {
    defaultIn(node);
  }

  public void outATransition(ATransition node)
  {
    defaultOut(node);
  }

  public void caseATransition(ATransition node)
  {
    inATransition(node);
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outATransition(node);
  }

  public void inAIgnTokens(AIgnTokens node)
  {
    defaultIn(node);
  }

  public void outAIgnTokens(AIgnTokens node)
  {
    defaultOut(node);
  }

  public void caseAIgnTokens(AIgnTokens node)
  {
    inAIgnTokens(node);
    {
      Object temp[] = node.getListId().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((TId) temp[i]).apply(this);
      }
    }
    outAIgnTokens(node);
  }

  public void inARegExp(ARegExp node)
  {
    defaultIn(node);
  }

  public void outARegExp(ARegExp node)
  {
    defaultOut(node);
  }

  public void caseARegExp(ARegExp node)
  {
    inARegExp(node);
    {
      Object temp[] = node.getConcats().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PConcat) temp[i]).apply(this);
      }
    }
    outARegExp(node);
  }

  public void inAConcat(AConcat node)
  {
    defaultIn(node);
  }

  public void outAConcat(AConcat node)
  {
    defaultOut(node);
  }

  public void caseAConcat(AConcat node)
  {
    inAConcat(node);
    {
      Object temp[] = node.getUnExps().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PUnExp) temp[i]).apply(this);
      }
    }
    outAConcat(node);
  }

  public void inAUnExp(AUnExp node)
  {
    defaultIn(node);
  }

  public void outAUnExp(AUnExp node)
  {
    defaultOut(node);
  }

  public void caseAUnExp(AUnExp node)
  {
    inAUnExp(node);
    if(node.getUnOp() != null)
    {
      node.getUnOp().apply(this);
    }
    if(node.getBasic() != null)
    {
      node.getBasic().apply(this);
    }
    outAUnExp(node);
  }

  public void inACharBasic(ACharBasic node)
  {
    defaultIn(node);
  }

  public void outACharBasic(ACharBasic node)
  {
    defaultOut(node);
  }

  public void caseACharBasic(ACharBasic node)
  {
    inACharBasic(node);
    if(node.getChar() != null)
    {
      node.getChar().apply(this);
    }
    outACharBasic(node);
  }

  public void inASetBasic(ASetBasic node)
  {
    defaultIn(node);
  }

  public void outASetBasic(ASetBasic node)
  {
    defaultOut(node);
  }

  public void caseASetBasic(ASetBasic node)
  {
    inASetBasic(node);
    if(node.getSet() != null)
    {
      node.getSet().apply(this);
    }
    outASetBasic(node);
  }

  public void inAStringBasic(AStringBasic node)
  {
    defaultIn(node);
  }

  public void outAStringBasic(AStringBasic node)
  {
    defaultOut(node);
  }

  public void caseAStringBasic(AStringBasic node)
  {
    inAStringBasic(node);
    if(node.getString() != null)
    {
      node.getString().apply(this);
    }
    outAStringBasic(node);
  }

  public void inAIdBasic(AIdBasic node)
  {
    defaultIn(node);
  }

  public void outAIdBasic(AIdBasic node)
  {
    defaultOut(node);
  }

  public void caseAIdBasic(AIdBasic node)
  {
    inAIdBasic(node);
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAIdBasic(node);
  }

  public void inARegExpBasic(ARegExpBasic node)
  {
    defaultIn(node);
  }

  public void outARegExpBasic(ARegExpBasic node)
  {
    defaultOut(node);
  }

  public void caseARegExpBasic(ARegExpBasic node)
  {
    inARegExpBasic(node);
    if(node.getRegExp() != null)
    {
      node.getRegExp().apply(this);
    }
    outARegExpBasic(node);
  }

  public void inACharChar(ACharChar node)
  {
    defaultIn(node);
  }

  public void outACharChar(ACharChar node)
  {
    defaultOut(node);
  }

  public void caseACharChar(ACharChar node)
  {
    inACharChar(node);
    if(node.getChar() != null)
    {
      node.getChar().apply(this);
    }
    outACharChar(node);
  }

  public void inADecChar(ADecChar node)
  {
    defaultIn(node);
  }

  public void outADecChar(ADecChar node)
  {
    defaultOut(node);
  }

  public void caseADecChar(ADecChar node)
  {
    inADecChar(node);
    if(node.getDecChar() != null)
    {
      node.getDecChar().apply(this);
    }
    outADecChar(node);
  }

  public void inAHexChar(AHexChar node)
  {
    defaultIn(node);
  }

  public void outAHexChar(AHexChar node)
  {
    defaultOut(node);
  }

  public void caseAHexChar(AHexChar node)
  {
    inAHexChar(node);
    if(node.getHexChar() != null)
    {
      node.getHexChar().apply(this);
    }
    outAHexChar(node);
  }

  public void inAOperationSet(AOperationSet node)
  {
    defaultIn(node);
  }

  public void outAOperationSet(AOperationSet node)
  {
    defaultOut(node);
  }

  public void caseAOperationSet(AOperationSet node)
  {
    inAOperationSet(node);
    if(node.getRight() != null)
    {
      node.getRight().apply(this);
    }
    if(node.getBinOp() != null)
    {
      node.getBinOp().apply(this);
    }
    if(node.getLeft() != null)
    {
      node.getLeft().apply(this);
    }
    outAOperationSet(node);
  }

  public void inAIntervalSet(AIntervalSet node)
  {
    defaultIn(node);
  }

  public void outAIntervalSet(AIntervalSet node)
  {
    defaultOut(node);
  }

  public void caseAIntervalSet(AIntervalSet node)
  {
    inAIntervalSet(node);
    if(node.getRight() != null)
    {
      node.getRight().apply(this);
    }
    if(node.getLeft() != null)
    {
      node.getLeft().apply(this);
    }
    outAIntervalSet(node);
  }

  public void inAStarUnOp(AStarUnOp node)
  {
    defaultIn(node);
  }

  public void outAStarUnOp(AStarUnOp node)
  {
    defaultOut(node);
  }

  public void caseAStarUnOp(AStarUnOp node)
  {
    inAStarUnOp(node);
    if(node.getStar() != null)
    {
      node.getStar().apply(this);
    }
    outAStarUnOp(node);
  }

  public void inAQMarkUnOp(AQMarkUnOp node)
  {
    defaultIn(node);
  }

  public void outAQMarkUnOp(AQMarkUnOp node)
  {
    defaultOut(node);
  }

  public void caseAQMarkUnOp(AQMarkUnOp node)
  {
    inAQMarkUnOp(node);
    if(node.getQMark() != null)
    {
      node.getQMark().apply(this);
    }
    outAQMarkUnOp(node);
  }

  public void inAPlusUnOp(APlusUnOp node)
  {
    defaultIn(node);
  }

  public void outAPlusUnOp(APlusUnOp node)
  {
    defaultOut(node);
  }

  public void caseAPlusUnOp(APlusUnOp node)
  {
    inAPlusUnOp(node);
    if(node.getPlus() != null)
    {
      node.getPlus().apply(this);
    }
    outAPlusUnOp(node);
  }

  public void inAPlusBinOp(APlusBinOp node)
  {
    defaultIn(node);
  }

  public void outAPlusBinOp(APlusBinOp node)
  {
    defaultOut(node);
  }

  public void caseAPlusBinOp(APlusBinOp node)
  {
    inAPlusBinOp(node);
    outAPlusBinOp(node);
  }

  public void inAMinusBinOp(AMinusBinOp node)
  {
    defaultIn(node);
  }

  public void outAMinusBinOp(AMinusBinOp node)
  {
    defaultOut(node);
  }

  public void caseAMinusBinOp(AMinusBinOp node)
  {
    inAMinusBinOp(node);
    outAMinusBinOp(node);
  }

  public void inAProductions(AProductions node)
  {
    defaultIn(node);
  }

  public void outAProductions(AProductions node)
  {
    defaultOut(node);
  }

  public void caseAProductions(AProductions node)
  {
    inAProductions(node);
    {
      Object temp[] = node.getProds().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PProd) temp[i]).apply(this);
      }
    }
    outAProductions(node);
  }

  public void inAProd(AProd node)
  {
    defaultIn(node);
  }

  public void outAProd(AProd node)
  {
    defaultOut(node);
  }

  public void caseAProd(AProd node)
  {
    inAProd(node);
    {
      Object temp[] = node.getAlts().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PAlt) temp[i]).apply(this);
      }
    }
    {
      Object temp[] = node.getProdTransform().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PElem) temp[i]).apply(this);
      }
    }
    if(node.getArrow() != null)
    {
      node.getArrow().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAProd(node);
  }

  public void inAAlt(AAlt node)
  {
    defaultIn(node);
  }

  public void outAAlt(AAlt node)
  {
    defaultOut(node);
  }

  public void caseAAlt(AAlt node)
  {
    inAAlt(node);
    if(node.getAltTransform() != null)
    {
      node.getAltTransform().apply(this);
    }
    {
      Object temp[] = node.getElems().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PElem) temp[i]).apply(this);
      }
    }
    if(node.getAltName() != null)
    {
      node.getAltName().apply(this);
    }
    outAAlt(node);
  }

  public void inAAltTransform(AAltTransform node)
  {
    defaultIn(node);
  }

  public void outAAltTransform(AAltTransform node)
  {
    defaultOut(node);
  }

  public void caseAAltTransform(AAltTransform node)
  {
    inAAltTransform(node);
    if(node.getRBrace() != null)
    {
      node.getRBrace().apply(this);
    }
    {
      Object temp[] = node.getTerms().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PTerm) temp[i]).apply(this);
      }
    }
    if(node.getLBrace() != null)
    {
      node.getLBrace().apply(this);
    }
    outAAltTransform(node);
  }

  public void inANewTerm(ANewTerm node)
  {
    defaultIn(node);
  }

  public void outANewTerm(ANewTerm node)
  {
    defaultOut(node);
  }

  public void caseANewTerm(ANewTerm node)
  {
    inANewTerm(node);
    {
      Object temp[] = node.getParams().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PTerm) temp[i]).apply(this);
      }
    }
    if(node.getLPar() != null)
    {
      node.getLPar().apply(this);
    }
    if(node.getProdName() != null)
    {
      node.getProdName().apply(this);
    }
    outANewTerm(node);
  }

  public void inAListTerm(AListTerm node)
  {
    defaultIn(node);
  }

  public void outAListTerm(AListTerm node)
  {
    defaultOut(node);
  }

  public void caseAListTerm(AListTerm node)
  {
    inAListTerm(node);
    {
      Object temp[] = node.getListTerms().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PListTerm) temp[i]).apply(this);
      }
    }
    if(node.getLBkt() != null)
    {
      node.getLBkt().apply(this);
    }
    outAListTerm(node);
  }

  public void inASimpleTerm(ASimpleTerm node)
  {
    defaultIn(node);
  }

  public void outASimpleTerm(ASimpleTerm node)
  {
    defaultOut(node);
  }

  public void caseASimpleTerm(ASimpleTerm node)
  {
    inASimpleTerm(node);
    if(node.getSimpleTermTail() != null)
    {
      node.getSimpleTermTail().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getSpecifier() != null)
    {
      node.getSpecifier().apply(this);
    }
    outASimpleTerm(node);
  }

  public void inANullTerm(ANullTerm node)
  {
    defaultIn(node);
  }

  public void outANullTerm(ANullTerm node)
  {
    defaultOut(node);
  }

  public void caseANullTerm(ANullTerm node)
  {
    inANullTerm(node);
    outANullTerm(node);
  }

  public void inANewListTerm(ANewListTerm node)
  {
    defaultIn(node);
  }

  public void outANewListTerm(ANewListTerm node)
  {
    defaultOut(node);
  }

  public void caseANewListTerm(ANewListTerm node)
  {
    inANewListTerm(node);
    {
      Object temp[] = node.getParams().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PTerm) temp[i]).apply(this);
      }
    }
    if(node.getLPar() != null)
    {
      node.getLPar().apply(this);
    }
    if(node.getProdName() != null)
    {
      node.getProdName().apply(this);
    }
    outANewListTerm(node);
  }

  public void inASimpleListTerm(ASimpleListTerm node)
  {
    defaultIn(node);
  }

  public void outASimpleListTerm(ASimpleListTerm node)
  {
    defaultOut(node);
  }

  public void caseASimpleListTerm(ASimpleListTerm node)
  {
    inASimpleListTerm(node);
    if(node.getSimpleTermTail() != null)
    {
      node.getSimpleTermTail().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getSpecifier() != null)
    {
      node.getSpecifier().apply(this);
    }
    outASimpleListTerm(node);
  }

  public void inAProdName(AProdName node)
  {
    defaultIn(node);
  }

  public void outAProdName(AProdName node)
  {
    defaultOut(node);
  }

  public void caseAProdName(AProdName node)
  {
    inAProdName(node);
    if(node.getProdNameTail() != null)
    {
      node.getProdNameTail().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAProdName(node);
  }

  public void inAElem(AElem node)
  {
    defaultIn(node);
  }

  public void outAElem(AElem node)
  {
    defaultOut(node);
  }

  public void caseAElem(AElem node)
  {
    inAElem(node);
    if(node.getUnOp() != null)
    {
      node.getUnOp().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getSpecifier() != null)
    {
      node.getSpecifier().apply(this);
    }
    if(node.getElemName() != null)
    {
      node.getElemName().apply(this);
    }
    outAElem(node);
  }

  public void inATokenSpecifier(ATokenSpecifier node)
  {
    defaultIn(node);
  }

  public void outATokenSpecifier(ATokenSpecifier node)
  {
    defaultOut(node);
  }

  public void caseATokenSpecifier(ATokenSpecifier node)
  {
    inATokenSpecifier(node);
    outATokenSpecifier(node);
  }

  public void inAProductionSpecifier(AProductionSpecifier node)
  {
    defaultIn(node);
  }

  public void outAProductionSpecifier(AProductionSpecifier node)
  {
    defaultOut(node);
  }

  public void caseAProductionSpecifier(AProductionSpecifier node)
  {
    inAProductionSpecifier(node);
    outAProductionSpecifier(node);
  }

  public void inAAst(AAst node)
  {
    defaultIn(node);
  }

  public void outAAst(AAst node)
  {
    defaultOut(node);
  }

  public void caseAAst(AAst node)
  {
    inAAst(node);
    {
      Object temp[] = node.getProds().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PAstProd) temp[i]).apply(this);
      }
    }
    outAAst(node);
  }

  public void inAAstProd(AAstProd node)
  {
    defaultIn(node);
  }

  public void outAAstProd(AAstProd node)
  {
    defaultOut(node);
  }

  public void caseAAstProd(AAstProd node)
  {
    inAAstProd(node);
    {
      Object temp[] = node.getAlts().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PAstAlt) temp[i]).apply(this);
      }
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAAstProd(node);
  }

  public void inAAstAlt(AAstAlt node)
  {
    defaultIn(node);
  }

  public void outAAstAlt(AAstAlt node)
  {
    defaultOut(node);
  }

  public void caseAAstAlt(AAstAlt node)
  {
    inAAstAlt(node);
    {
      Object temp[] = node.getElems().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PElem) temp[i]).apply(this);
      }
    }
    if(node.getAltName() != null)
    {
      node.getAltName().apply(this);
    }
    outAAstAlt(node);
  }
}