reverseddepthfirstadapter.java

来自「有关编译器的编译器.」· Java 代码 · 共 1,254 行 · 第 1/2 页

  {
    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.getRPar() != null)
    {
      node.getRPar().apply(this);
    }
    if(node.getRegExp() != null)
    {
      node.getRegExp().apply(this);
    }
    if(node.getLPar() != null)
    {
      node.getLPar().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.getRBkt() != null)
    {
      node.getRBkt().apply(this);
    }
    if(node.getRight() != null)
    {
      node.getRight().apply(this);
    }
    if(node.getBinOp() != null)
    {
      node.getBinOp().apply(this);
    }
    if(node.getLeft() != null)
    {
      node.getLeft().apply(this);
    }
    if(node.getLBkt() != null)
    {
      node.getLBkt().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.getRBkt() != null)
    {
      node.getRBkt().apply(this);
    }
    if(node.getRight() != null)
    {
      node.getRight().apply(this);
    }
    if(node.getDDot() != null)
    {
      node.getDDot().apply(this);
    }
    if(node.getLeft() != null)
    {
      node.getLeft().apply(this);
    }
    if(node.getLBkt() != null)
    {
      node.getLBkt().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);
    if(node.getPlus() != null)
    {
      node.getPlus().apply(this);
    }
    outAPlusBinOp(node);
  }

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

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

  public void caseAMinusBinOp(AMinusBinOp node)
  {
    inAMinusBinOp(node);
    if(node.getMinus() != null)
    {
      node.getMinus().apply(this);
    }
    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);
      }
    }
    if(node.getProductions() != null)
    {
      node.getProductions().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);
    if(node.getSemicolon() != null)
    {
      node.getSemicolon().apply(this);
    }
    if(node.getAlts() != null)
    {
      node.getAlts().apply(this);
    }
    if(node.getEqual() != null)
    {
      node.getEqual().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    outAProd(node);
  }

  public void inAAlts(AAlts node)
  {
    defaultIn(node);
  }

  public void outAAlts(AAlts node)
  {
    defaultOut(node);
  }

  public void caseAAlts(AAlts node)
  {
    inAAlts(node);
    {
      Object temp[] = node.getAlts().toArray();
      for(int i = temp.length - 1; i >= 0; i--)
      {
        ((PAltsTail) temp[i]).apply(this);
      }
    }
    if(node.getAlt() != null)
    {
      node.getAlt().apply(this);
    }
    outAAlts(node);
  }

  public void inAAltsTail(AAltsTail node)
  {
    defaultIn(node);
  }

  public void outAAltsTail(AAltsTail node)
  {
    defaultOut(node);
  }

  public void caseAAltsTail(AAltsTail node)
  {
    inAAltsTail(node);
    if(node.getAlt() != null)
    {
      node.getAlt().apply(this);
    }
    if(node.getBar() != null)
    {
      node.getBar().apply(this);
    }
    outAAltsTail(node);
  }

  public void inAParsedAlt(AParsedAlt node)
  {
    defaultIn(node);
  }

  public void outAParsedAlt(AParsedAlt node)
  {
    defaultOut(node);
  }

  public void caseAParsedAlt(AParsedAlt node)
  {
    inAParsedAlt(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);
    }
    outAParsedAlt(node);
  }

  public void inAIgnoredAlt(AIgnoredAlt node)
  {
    defaultIn(node);
  }

  public void outAIgnoredAlt(AIgnoredAlt node)
  {
    defaultOut(node);
  }

  public void caseAIgnoredAlt(AIgnoredAlt node)
  {
    inAIgnoredAlt(node);
    if(node.getRPar() != null)
    {
      node.getRPar().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);
    }
    if(node.getLPar() != null)
    {
      node.getLPar().apply(this);
    }
    outAIgnoredAlt(node);
  }

  public void inAAltName(AAltName node)
  {
    defaultIn(node);
  }

  public void outAAltName(AAltName node)
  {
    defaultOut(node);
  }

  public void caseAAltName(AAltName node)
  {
    inAAltName(node);
    if(node.getRBrace() != null)
    {
      node.getRBrace().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getLBrace() != null)
    {
      node.getLBrace().apply(this);
    }
    outAAltName(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 inAElemName(AElemName node)
  {
    defaultIn(node);
  }

  public void outAElemName(AElemName node)
  {
    defaultOut(node);
  }

  public void caseAElemName(AElemName node)
  {
    inAElemName(node);
    if(node.getColon() != null)
    {
      node.getColon().apply(this);
    }
    if(node.getRBkt() != null)
    {
      node.getRBkt().apply(this);
    }
    if(node.getId() != null)
    {
      node.getId().apply(this);
    }
    if(node.getLBkt() != null)
    {
      node.getLBkt().apply(this);
    }
    outAElemName(node);
  }

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

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

  public void caseATokenSpecifier(ATokenSpecifier node)
  {
    inATokenSpecifier(node);
    if(node.getDot() != null)
    {
      node.getDot().apply(this);
    }
    if(node.getTokenSpecifier() != null)
    {
      node.getTokenSpecifier().apply(this);
    }
    outATokenSpecifier(node);
  }

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

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

  public void caseAProductionSpecifier(AProductionSpecifier node)
  {
    inAProductionSpecifier(node);
    if(node.getDot() != null)
    {
      node.getDot().apply(this);
    }
    if(node.getProductionSpecifier() != null)
    {
      node.getProductionSpecifier().apply(this);
    }
    outAProductionSpecifier(node);
  }
}