// ** Batch Generated with DemeterF

// ** This file was generated with DemFGen (vers:05/23/2010)

package edu.neu.ccs.demeterf.demfgen.traversals;

import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.lib.*;
import edu.neu.ccs.demeterf.demfgen.*;
import edu.neu.ccs.demeterf.demfgen.dgp.DGPFunc;
import edu.neu.ccs.demeterf.demfgen.traversals.Travs;
import edu.neu.ccs.demeterf.demfgen.pcdgp.PCDGPFunc;
import edu.neu.ccs.demeterf.dispatch.*;
import edu.neu.ccs.demeterf.*;
import edu.neu.ccs.demeterf.demfgen.ClassHier.InhrtPair;
import edu.neu.ccs.demeterf.demfgen.DemFGenMain;
import java.io.*;
import java.io.FileInputStream;
import edu.neu.ccs.demeterf.util.Util;
import edu.neu.ccs.demeterf.util.CLI;
import edu.neu.ccs.demeterf.demfgen.classes.Package;
import edu.neu.ccs.demeterf.demfgen.DemFGenMain;
import edu.neu.ccs.demeterf.demfgen.classes.*;

public class JJGenTrav {
   private ParseGen.JJProd func;
   public JJGenTrav(ParseGen.JJProd f){ func = f; }

   public String traverse(final TypeDef _h, final DoGen _targ_){ return traverseTypeDef(_h, _targ_); }

   public DoGen traverseYesGen(final YesGen _h, final DoGen _targ_){
        return func.combine((DoGen)_h);
   }
   public String traverseUseParams(final UseParams _h, final DoGen _targ_){
        String _types = traverseNETypeUseList(_h.getTypes(), _targ_);
        return func.combine((UseParams)_h,(String)_types);
   }
   public String traverseTypeUseParams(final TypeUseParams _h, final DoGen _targ_){
        if(_h instanceof UseParams) return traverseUseParams((UseParams)_h, _targ_);
        if(_h instanceof EmptyUseParams) return traverseEmptyUseParams((EmptyUseParams)_h, _targ_);
        else throw new RuntimeException("Unknown TypeUseParams Variant");
   }
   public String traverseTypeUseList(final TypeUseList _h, final DoGen _targ_){
        if(_h instanceof TypeUseCons) return traverseTypeUseCons((TypeUseCons)_h, _targ_);
        if(_h instanceof TypeUseEmpty) return traverseTypeUseEmpty((TypeUseEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown TypeUseList Variant");
   }
   public String traverseTypeUseEmpty(final TypeUseEmpty _h, final DoGen _targ_){
        return func.combine((TypeUseEmpty)_h);
   }
   public String traverseTypeUseCons(final TypeUseCons _h, final DoGen _targ_){
        String _first = traverseTypeUse(_h.getFirst(), _targ_);
        String _rest = traverseTypeUseList(_h.getRest(), _targ_);
        return func.combine((TypeUseCons)_h,(String)_first, (String)_rest);
   }
   public String traverseTypeUse(final TypeUse _h, final DoGen _targ_){
        ident _name = _h.getName();
        String _tparams = traverseTypeUseParams(_h.getTparams(), _targ_);
        return func.combine((TypeUse)_h,(ident)_name, (String)_tparams, (DoGen)_targ_);
   }
   public String traverseTypeDefParams(final TypeDefParams _h, final DoGen _targ_){
        if(_h instanceof DefParams) return traverseDefParams((DefParams)_h, _targ_);
        if(_h instanceof EmptyDefParams) return traverseEmptyDefParams((EmptyDefParams)_h, _targ_);
        else throw new RuntimeException("Unknown TypeDefParams Variant");
   }
   public String traverseTypeDef(final TypeDef _h, final DoGen _targ_){
        if(_h instanceof IntfcDef) return traverseIntfcDef((IntfcDef)_h, _targ_);
        if(_h instanceof ClassDef) return traverseClassDef((ClassDef)_h, _targ_);
        else throw new RuntimeException("Unknown TypeDef Variant");
   }
   public String traverseTheEOF(final TheEOF _h, final DoGen _targ_){
        return func.combine((TheEOF)_h);
   }
   public String traverseSyntax(final Syntax _h, final DoGen _targ_){
        if(_h instanceof AddSpace) return traverseAddSpace((AddSpace)_h, _targ_);
        if(_h instanceof AddTab) return traverseAddTab((AddTab)_h, _targ_);
        if(_h instanceof AddLine) return traverseAddLine((AddLine)_h, _targ_);
        if(_h instanceof AddReturn) return traverseAddReturn((AddReturn)_h, _targ_);
        if(_h instanceof Plus) return traversePlus((Plus)_h, _targ_);
        if(_h instanceof Minus) return traverseMinus((Minus)_h, _targ_);
        if(_h instanceof AddToken) return traverseAddToken((AddToken)_h, _targ_);
        if(_h instanceof TheEOF) return traverseTheEOF((TheEOF)_h, _targ_);
        else throw new RuntimeException("Unknown Syntax Variant");
   }
   public List<String> traverseSubtypeList(final SubtypeList _h, final DoGen _targ_){
        if(_h instanceof SubtypeCons) return traverseSubtypeCons((SubtypeCons)_h, _targ_);
        if(_h instanceof SubtypeEmpty) return traverseSubtypeEmpty((SubtypeEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown SubtypeList Variant");
   }
   public List<String> traverseSubtypeEmpty(final SubtypeEmpty _h, final DoGen _targ_){
        return func.combine((SubtypeEmpty)_h);
   }
   public List<String> traverseSubtypeCons(final SubtypeCons _h, final DoGen _targ_){
        String _first = traverseTypeUse(_h.getFirst(), _targ_);
        List<String> _rest = traverseSubtypeList(_h.getRest(), _targ_);
        return func.combine((SubtypeCons)_h,(String)_first, (List<String>)_rest);
   }
   public String traversePlus(final Plus _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }
   public List<String> traversePESubtypeList(final PESubtypeList _h, final DoGen _targ_){        if(_h instanceof NESubtypeList) return traverseNESubtypeList((NESubtypeList)_h, _targ_);
        if(_h instanceof SubtypeEmpty) return traverseSubtypeEmpty((SubtypeEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown PESubtypeList Variant");
   }
   public DoGen traverseNoParse(final NoParse _h, final DoGen _targ_){
        return func.combine((DoGen)_h);
   }
   public String traverseNoImpl(final NoImpl _h, final DoGen _targ_){
        return func.combine((Impl)_h);
   }
   public DoGen traverseNoGen(final NoGen _h, final DoGen _targ_){
        return func.combine((DoGen)_h);
   }
   public String traverseNoBound(final NoBound _h, final DoGen _targ_){
        return func.combine((Bound)_h);
   }
   public String traverseNameList(final NameList _h, final DoGen _targ_){
        if(_h instanceof NameCons) return traverseNameCons((NameCons)_h, _targ_);
        if(_h instanceof NameEmpty) return traverseNameEmpty((NameEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown NameList Variant");
   }
   public String traverseNameEmpty(final NameEmpty _h, final DoGen _targ_){
        return func.combine((NameEmpty)_h);
   }
   public String traverseNameDef(final NameDef _h, final DoGen _targ_){
        ident _id = _h.getId();
        String _bnd = traverseBound(_h.getBnd(), _targ_);
        return func.combine((NameDef)_h,(ident)_id, (String)_bnd);
   }
   public String traverseNameCons(final NameCons _h, final DoGen _targ_){
        String _first = traverseNameDef(_h.getFirst(), _targ_);
        String _rest = traverseNameList(_h.getRest(), _targ_);
        return func.combine((NameCons)_h,(String)_first, (String)_rest);
   }
   public String traverseNETypeUseList(final NETypeUseList _h, final DoGen _targ_){
        String _first = traverseTypeUse(_h.getFirst(), _targ_);
        String _rest = traverseTypeUseList(_h.getRest(), _targ_);
        return func.combine((NETypeUseList)_h,(String)_first, (String)_rest);
   }
   public List<String> traverseNESubtypeList(final NESubtypeList _h, final DoGen _targ_){
        String _first = traverseTypeUse(_h.getFirst(), _targ_);
        List<String> _rest = traverseSubtypeList(_h.getRest(), _targ_);
        return func.combine((NESubtypeList)_h,(String)_first, (List<String>)_rest);
   }
   public String traverseNENameList(final NENameList _h, final DoGen _targ_){
        String _first = traverseNameDef(_h.getFirst(), _targ_);
        String _rest = traverseNameList(_h.getRest(), _targ_);
        return func.combine((NENameList)_h,(String)_first, (String)_rest);
   }
   public String traverseMinus(final Minus _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }
   public String traverseIntfcDef(final IntfcDef _h, final DoGen _targ_){
        DoGen _gen = traverseDoGen(_h.getGen(), _targ_);
        ident _name = _h.getName();
        String _tparams = traverseTypeDefParams(_h.getTparams(), _targ_);
        List<String> _subtypes = traversePESubtypeList(_h.getSubtypes(), _targ_);
        return func.combine((TypeDef)_h,(DoGen)_gen, (ident)_name, (String)_tparams, (List<String>)_subtypes);
   }
   public String traverseIntfImpl(final IntfImpl _h, final DoGen _targ_){
        String _intf = traverseNETypeUseList(_h.getIntf(), _targ_);
        return func.combine((Impl)_h);
   }
   public String traverseImpl(final Impl _h, final DoGen _targ_){
        if(_h instanceof IntfImpl) return traverseIntfImpl((IntfImpl)_h, _targ_);
        if(_h instanceof NoImpl) return traverseNoImpl((NoImpl)_h, _targ_);
        else throw new RuntimeException("Unknown Impl Variant");
   }
   public Object traverseFieldOrSyntax(final FieldOrSyntax _h, final DoGen _targ_){
        if(_h instanceof Field) return traverseField((Field)_h, _targ_);
        if(_h instanceof Syntax) return traverseSyntax((Syntax)_h, _targ_);
        else throw new RuntimeException("Unknown FieldOrSyntax Variant");
   }
   public StrLTrip traverseFieldList(final FieldList _h, final DoGen _targ_){
        if(_h instanceof FieldCons) return traverseFieldCons((FieldCons)_h, _targ_);
        if(_h instanceof FieldEmpty) return traverseFieldEmpty((FieldEmpty)_h, _targ_);
        else throw new RuntimeException("Unknown FieldList Variant");
   }
   public StrLTrip traverseFieldEmpty(final FieldEmpty _h, final DoGen _targ_){
        return func.combine((FieldEmpty)_h);
   }
   public StrLTrip traverseFieldCons(final FieldCons _h, final DoGen _targ_){
        Object _first = traverseFieldOrSyntax(_h.getFirst(), _targ_);
        StrLTrip _rest = traverseFieldList(_h.getRest(), _targ_);
        if((_first instanceof StrLTrip.StrTrip)){

            return func.combine((FieldList)_h,(StrLTrip.StrTrip)_first, (StrLTrip)_rest);
        }else{
            return func.combine((FieldList)_h,(String)_first, (StrLTrip)_rest);
        }
   }
   public StrLTrip.StrTrip traverseField(final Field _h, final DoGen _targ_){
        ident _name = _h.getName();
        String _type = traverseTypeUse(_h.getType(), _targ_);
        return func.combine((Field)_h,(ident)_name, (String)_type);
   }
   public DoGen traverseExtern(final Extern _h, final DoGen _targ_){
        return func.combine((DoGen)_h);
   }
   public String traverseEmptyUseParams(final EmptyUseParams _h, final DoGen _targ_){
        return func.combine((EmptyUseParams)_h);
   }
   public String traverseEmptyDefParams(final EmptyDefParams _h, final DoGen _targ_){
        return func.combine((EmptyDefParams)_h);
   }
   public DoGen traverseDoGen(final DoGen _h, final DoGen _targ_){
        if(_h instanceof NoParse) return traverseNoParse((NoParse)_h, _targ_);
        if(_h instanceof NoGen) return traverseNoGen((NoGen)_h, _targ_);
        if(_h instanceof Extern) return traverseExtern((Extern)_h, _targ_);
        if(_h instanceof YesGen) return traverseYesGen((YesGen)_h, _targ_);
        else throw new RuntimeException("Unknown DoGen Variant");
   }
   public String traverseDefParams(final DefParams _h, final DoGen _targ_){
        String _types = traverseNENameList(_h.getTypes(), _targ_);
        return func.combine((DefParams)_h,(String)_types);
   }
   public String traverseClassDef(final ClassDef _h, final DoGen _targ_){
        DoGen _gen = traverseDoGen(_h.getGen(), func.update(_h, new ClassDef.gen()));
        ident _name = _h.getName();
        String _tparams = traverseTypeDefParams(_h.getTparams(), func.update(_h, new ClassDef.tparams()));
        List<String> _subtypes = traversePESubtypeList(_h.getSubtypes(), func.update(_h, new ClassDef.subtypes()));
        StrLTrip _fields = traverseFieldList(_h.getFields(), func.update(_h, new ClassDef.fields()));
        String _ext = traverseImpl(_h.getExt(), func.update(_h, new ClassDef.ext()));
        return func.combine((ClassDef)_h,(DoGen)_gen, (ident)_name, (String)_tparams, (List<String>)_subtypes, (StrLTrip)_fields);
   }
   public String traverseClassBound(final ClassBound _h, final DoGen _targ_){
        String _bound = traverseTypeUse(_h.getBound(), _targ_);
        return func.combine((Bound)_h);
   }
   public String traverseBound(final Bound _h, final DoGen _targ_){
        if(_h instanceof ClassBound) return traverseClassBound((ClassBound)_h, _targ_);
        if(_h instanceof NoBound) return traverseNoBound((NoBound)_h, _targ_);
        else throw new RuntimeException("Unknown Bound Variant");
   }
   public String traverseAddToken(final AddToken _h, final DoGen _targ_){
        String _str = _h.getStr();
        return func.combine((AddToken)_h,(String)_str);
   }
   public String traverseAddTab(final AddTab _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }
   public String traverseAddSpace(final AddSpace _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }
   public String traverseAddReturn(final AddReturn _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }
   public String traverseAddLine(final AddLine _h, final DoGen _targ_){
        return func.combine((Syntax)_h);
   }

}