// ** 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 TypeCheckTrav { private TypeCheck func; public TypeCheckTrav(TypeCheck f){ func = f; } public List traverse(final List<CDFile> _h, final TypeCheck.Env _targ_){ return traverseList_CDFile_(_h, _targ_); } public YesGen traverseYesGen(final YesGen _h, final TypeCheck.Env _targ_){ return func.combine((YesGen)_h); } public UseParams traverseUseParams(final UseParams _h, final TypeCheck.Env _targ_){ NETypeUseList _types = traverseNETypeUseList(_h.getTypes(), _targ_); return func.combine((UseParams)_h,(NETypeUseList)_types); } public TypeUseParams traverseTypeUseParams(final TypeUseParams _h, final TypeCheck.Env _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 TypeUseList traverseTypeUseList(final TypeUseList _h, final TypeCheck.Env _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 TypeUseEmpty traverseTypeUseEmpty(final TypeUseEmpty _h, final TypeCheck.Env _targ_){ return func.combine((TypeUseEmpty)_h); } public TypeUseCons traverseTypeUseCons(final TypeUseCons _h, final TypeCheck.Env _targ_){ TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_); TypeUseList _rest = traverseTypeUseList(_h.getRest(), _targ_); return func.combine((TypeUseCons)_h,(TypeUse)_first, (TypeUseList)_rest); } public TypeUse traverseTypeUse(final TypeUse _h, final TypeCheck.Env _targ_){ ident _name = func.combine(_h.getName()); TypeUseParams _tparams = traverseTypeUseParams(_h.getTparams(), _targ_); return func.combine((TypeUse)_h,(ident)_name, (TypeUseParams)_tparams, (TypeCheck.Env)_targ_); } public TypeDefParams traverseTypeDefParams(final TypeDefParams _h, final TypeCheck.Env _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 TypeDefList traverseTypeDefList(final TypeDefList _h, final TypeCheck.Env _targ_){ if(_h instanceof TypeDefCons) return traverseTypeDefCons((TypeDefCons)_h, _targ_); if(_h instanceof TypeDefEmpty) return traverseTypeDefEmpty((TypeDefEmpty)_h, _targ_); else throw new RuntimeException("Unknown TypeDefList Variant"); } public TypeDefEmpty traverseTypeDefEmpty(final TypeDefEmpty _h, final TypeCheck.Env _targ_){ return func.combine((TypeDefEmpty)_h); } public TypeDefCons traverseTypeDefCons(final TypeDefCons _h, final TypeCheck.Env _targ_){ TypeDef _first = traverseTypeDef(_h.getFirst(), _targ_); TypeDefList _rest = traverseTypeDefList(_h.getRest(), _targ_); return func.combine((TypeDefCons)_h,(TypeDef)_first, (TypeDefList)_rest); } public TypeDef traverseTypeDef(final TypeDef _h, final TypeCheck.Env _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 TheEOF traverseTheEOF(final TheEOF _h, final TypeCheck.Env _targ_){ return func.combine((TheEOF)_h); } public Syntax traverseSyntax(final Syntax _h, final TypeCheck.Env _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 Object traverseSubtypeList(final SubtypeList _h, final TypeCheck.Env _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 SubtypeEmpty traverseSubtypeEmpty(final SubtypeEmpty _h, final TypeCheck.Env _targ_){ return func.combine((SubtypeEmpty)_h); } public SubtypeCons traverseSubtypeCons(final SubtypeCons _h, final TypeCheck.Env _targ_){ TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_); Object _rest = traverseSubtypeList(_h.getRest(), _targ_); return func.combine((SubtypeCons)_h,(TypeUse)_first, (SubtypeList)_rest); } public Plus traversePlus(final Plus _h, final TypeCheck.Env _targ_){ return func.combine((Plus)_h); } public PkgStar traversePkgStar(final PkgStar _h, final TypeCheck.Env _targ_){ return func.combine((PkgStar)_h); } public PkgList traversePkgList(final PkgList _h, final TypeCheck.Env _targ_){ if(_h instanceof PkgCons) return traversePkgCons((PkgCons)_h, _targ_); if(_h instanceof PkgStar) return traversePkgStar((PkgStar)_h, _targ_); if(_h instanceof PkgEmpty) return traversePkgEmpty((PkgEmpty)_h, _targ_); else throw new RuntimeException("Unknown PkgList Variant"); } public PkgEmpty traversePkgEmpty(final PkgEmpty _h, final TypeCheck.Env _targ_){ return func.combine((PkgEmpty)_h); } public PkgCons traversePkgCons(final PkgCons _h, final TypeCheck.Env _targ_){ ident _id = func.combine(_h.getId()); PkgList _rest = traversePkgList(_h.getRest(), _targ_); return func.combine((PkgCons)_h,(ident)_id, (PkgList)_rest); } public PackageDef traversePackageDef(final PackageDef _h, final TypeCheck.Env _targ_){ if(_h instanceof Package) return traversePackage((Package)_h, _targ_); if(_h instanceof NoPackage) return traverseNoPackage((NoPackage)_h, _targ_); else throw new RuntimeException("Unknown PackageDef Variant"); } public Package traversePackage(final Package _h, final TypeCheck.Env _targ_){ NEPkgList _pkg = traverseNEPkgList(_h.getPkg(), _targ_); return func.combine((Package)_h,(NEPkgList)_pkg); } public PESubtypeList traversePESubtypeList(final PESubtypeList _h, final TypeCheck.Env _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 NoParse traverseNoParse(final NoParse _h, final TypeCheck.Env _targ_){ return func.combine((NoParse)_h); } public NoPackage traverseNoPackage(final NoPackage _h, final TypeCheck.Env _targ_){ return func.combine((NoPackage)_h); } public NoLook traverseNoLook(final NoLook _h, final TypeCheck.Env _targ_){ return func.combine((NoLook)_h); } public NoImpl traverseNoImpl(final NoImpl _h, final TypeCheck.Env _targ_){ return func.combine((NoImpl)_h); } public NoGen traverseNoGen(final NoGen _h, final TypeCheck.Env _targ_){ return func.combine((NoGen)_h); } public NoDGPUse traverseNoDGPUse(final NoDGPUse _h, final TypeCheck.Env _targ_){ return func.combine((NoDGPUse)_h); } public NoBound traverseNoBound(final NoBound _h, final TypeCheck.Env _targ_){ return func.combine((NoBound)_h); } public NameList traverseNameList(final NameList _h, final TypeCheck.Env _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 NameEmpty traverseNameEmpty(final NameEmpty _h, final TypeCheck.Env _targ_){ return func.combine((NameEmpty)_h); } public NameDef traverseNameDef(final NameDef _h, final TypeCheck.Env _targ_){ ident _id = func.combine(_h.getId()); Bound _bnd = traverseBound(_h.getBnd(), _targ_); return func.combine((NameDef)_h,(ident)_id, (Bound)_bnd); } public NameCons traverseNameCons(final NameCons _h, final TypeCheck.Env _targ_){ NameDef _first = traverseNameDef(_h.getFirst(), _targ_); NameList _rest = traverseNameList(_h.getRest(), _targ_); return func.combine((NameCons)_h,(NameDef)_first, (NameList)_rest); } public NETypeUseList traverseNETypeUseList(final NETypeUseList _h, final TypeCheck.Env _targ_){ TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_); TypeUseList _rest = traverseTypeUseList(_h.getRest(), _targ_); return func.combine((NETypeUseList)_h,(TypeUse)_first, (TypeUseList)_rest); } public NESubtypeList traverseNESubtypeList(final NESubtypeList _h, final TypeCheck.Env _targ_){ TypeUse _first = traverseTypeUse(_h.getFirst(), _targ_); Object _rest = traverseSubtypeList(_h.getRest(), _targ_); return func.combine((NESubtypeList)_h,(TypeUse)_first, (SubtypeList)_rest); } public NEPkgList traverseNEPkgList(final NEPkgList _h, final TypeCheck.Env _targ_){ ident _id = func.combine(_h.getId()); PkgList _rest = traversePkgList(_h.getRest(), _targ_); return func.combine((NEPkgList)_h,(ident)_id, (PkgList)_rest); } public NENameList traverseNENameList(final NENameList _h, final TypeCheck.Env _targ_){ NameDef _first = traverseNameDef(_h.getFirst(), _targ_); NameList _rest = traverseNameList(_h.getRest(), _targ_); return func.combine((NENameList)_h,(NameDef)_first, (NameList)_rest); } public Minus traverseMinus(final Minus _h, final TypeCheck.Env _targ_){ return func.combine((Minus)_h); } public LookDef traverseLookDef(final LookDef _h, final TypeCheck.Env _targ_){ if(_h instanceof LookAhead) return traverseLookAhead((LookAhead)_h, _targ_); if(_h instanceof NoLook) return traverseNoLook((NoLook)_h, _targ_); else throw new RuntimeException("Unknown LookDef Variant"); } public LookAhead traverseLookAhead(final LookAhead _h, final TypeCheck.Env _targ_){ Integer _n = func.combine(_h.getN()); return func.combine((LookAhead)_h,(int)_n); } public List traverseList_CDFile_(final List<CDFile> _h, final TypeCheck.Env _targ_){ if(_h instanceof Cons) return traverseCons_CDFile_((Cons<CDFile>)_h, _targ_); if(_h instanceof Empty) return traverseEmpty_CDFile_((Empty<CDFile>)_h, _targ_); else throw new RuntimeException("Unknown List Variant"); } public IntfcDef traverseIntfcDef(final IntfcDef _h, final TypeCheck.Env _targ_){ DoGen _gen = traverseDoGen(_h.getGen(), func.update(_h, new IntfcDef.gen(), _targ_)); ident _name = func.combine(_h.getName()); TypeDefParams _tparams = traverseTypeDefParams(_h.getTparams(), func.update(_h, new IntfcDef.tparams(), _targ_)); PESubtypeList _subtypes = traversePESubtypeList(_h.getSubtypes(), func.update(_h, new IntfcDef.subtypes(), _targ_)); return func.combine((IntfcDef)_h,(DoGen)_gen, (ident)_name, (TypeDefParams)_tparams, (PESubtypeList)_subtypes); } public IntfImpl traverseIntfImpl(final IntfImpl _h, final TypeCheck.Env _targ_){ NETypeUseList _intf = traverseNETypeUseList(_h.getIntf(), _targ_); return func.combine((IntfImpl)_h,(NETypeUseList)_intf); } public IncludeList traverseIncludeList(final IncludeList _h, final TypeCheck.Env _targ_){ if(_h instanceof IncludeCons) return traverseIncludeCons((IncludeCons)_h, _targ_); if(_h instanceof IncludeEmpty) return traverseIncludeEmpty((IncludeEmpty)_h, _targ_); else throw new RuntimeException("Unknown IncludeList Variant"); } public IncludeEmpty traverseIncludeEmpty(final IncludeEmpty _h, final TypeCheck.Env _targ_){ return func.combine((IncludeEmpty)_h); } public IncludeCons traverseIncludeCons(final IncludeCons _h, final TypeCheck.Env _targ_){ Include _first = traverseInclude(_h.getFirst(), _targ_); IncludeList _rest = traverseIncludeList(_h.getRest(), _targ_); return func.combine((IncludeCons)_h,(Include)_first, (IncludeList)_rest); } public Include traverseInclude(final Include _h, final TypeCheck.Env _targ_){ DoGen _gen = traverseDoGen(_h.getGen(), _targ_); String _file = func.combine(_h.getFile()); return func.combine((Include)_h,(DoGen)_gen, (String)_file); } public ImportList traverseImportList(final ImportList _h, final TypeCheck.Env _targ_){ if(_h instanceof ImportCons) return traverseImportCons((ImportCons)_h, _targ_); if(_h instanceof ImportEmpty) return traverseImportEmpty((ImportEmpty)_h, _targ_); else throw new RuntimeException("Unknown ImportList Variant"); } public ImportEmpty traverseImportEmpty(final ImportEmpty _h, final TypeCheck.Env _targ_){ return func.combine((ImportEmpty)_h); } public ImportCons traverseImportCons(final ImportCons _h, final TypeCheck.Env _targ_){ Import _first = traverseImport(_h.getFirst(), _targ_); ImportList _rest = traverseImportList(_h.getRest(), _targ_); return func.combine((ImportCons)_h,(Import)_first, (ImportList)_rest); } public Import traverseImport(final Import _h, final TypeCheck.Env _targ_){ NEPkgList _pkg = traverseNEPkgList(_h.getPkg(), _targ_); return func.combine((Import)_h,(NEPkgList)_pkg); } public Impl traverseImpl(final Impl _h, final TypeCheck.Env _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 FieldOrSyntax traverseFieldOrSyntax(final FieldOrSyntax _h, final TypeCheck.Env _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 FieldList traverseFieldList(final FieldList _h, final TypeCheck.Env _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 FieldEmpty traverseFieldEmpty(final FieldEmpty _h, final TypeCheck.Env _targ_){ return func.combine((FieldEmpty)_h); } public FieldCons traverseFieldCons(final FieldCons _h, final TypeCheck.Env _targ_){ FieldOrSyntax _first = traverseFieldOrSyntax(_h.getFirst(), _targ_); FieldList _rest = traverseFieldList(_h.getRest(), _targ_); return func.combine((FieldCons)_h,(FieldOrSyntax)_first, (FieldList)_rest); } public Field traverseField(final Field _h, final TypeCheck.Env _targ_){ ident _name = func.combine(_h.getName()); TypeUse _type = traverseTypeUse(_h.getType(), _targ_); return func.combine((Field)_h,(ident)_name, (TypeUse)_type); } public Extern traverseExtern(final Extern _h, final TypeCheck.Env _targ_){ return func.combine((Extern)_h); } public EmptyUseParams traverseEmptyUseParams(final EmptyUseParams _h, final TypeCheck.Env _targ_){ return func.combine((EmptyUseParams)_h); } public EmptyDefParams traverseEmptyDefParams(final EmptyDefParams _h, final TypeCheck.Env _targ_){ return func.combine((EmptyDefParams)_h); } public Empty traverseEmpty_CDFile_(final Empty<CDFile> _h, final TypeCheck.Env _targ_){ return func.combine((Empty)_h); } public DoGen traverseDoGen(final DoGen _h, final TypeCheck.Env _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 DefParams traverseDefParams(final DefParams _h, final TypeCheck.Env _targ_){ NENameList _types = traverseNENameList(_h.getTypes(), _targ_); return func.combine((DefParams)_h,(NENameList)_types); } public DGPUses traverseDGPUses(final DGPUses _h, final TypeCheck.Env _targ_){ if(_h instanceof DGPUse) return traverseDGPUse((DGPUse)_h, _targ_); if(_h instanceof NoDGPUse) return traverseNoDGPUse((NoDGPUse)_h, _targ_); else throw new RuntimeException("Unknown DGPUses Variant"); } public DGPUse traverseDGPUse(final DGPUse _h, final TypeCheck.Env _targ_){ NENameList _pkg = traverseNENameList(_h.getPkg(), _targ_); return func.combine((DGPUse)_h,(NENameList)_pkg); } public Cons traverseCons_CDFile_(final Cons<CDFile> _h, final TypeCheck.Env _targ_){ CDFile _first = traverseCDFile(_h.getFirst(), _targ_); List _rest = traverseList_CDFile_(_h.getRest(), _targ_); return func.combine((Cons)_h,(CDFile)_first, (List<CDFile>)_rest); } public ClassDef traverseClassDef(final ClassDef _h, final TypeCheck.Env _targ_){ DoGen _gen = traverseDoGen(_h.getGen(), func.update(_h, new ClassDef.gen(), _targ_)); ident _name = func.combine(_h.getName()); TypeDefParams _tparams = traverseTypeDefParams(_h.getTparams(), func.update(_h, new ClassDef.tparams(), _targ_)); PESubtypeList _subtypes = traversePESubtypeList(_h.getSubtypes(), func.update(_h, new ClassDef.subtypes(), _targ_)); FieldList _fields = traverseFieldList(_h.getFields(), func.update(_h, new ClassDef.fields(), _targ_)); Impl _ext = traverseImpl(_h.getExt(), func.update(_h, new ClassDef.ext(), _targ_)); return func.combine((ClassDef)_h,(DoGen)_gen, (ident)_name, (TypeDefParams)_tparams, (PESubtypeList)_subtypes, (FieldList)_fields, (Impl)_ext); } public ClassBound traverseClassBound(final ClassBound _h, final TypeCheck.Env _targ_){ TypeUse _bound = traverseTypeUse(_h.getBound(), _targ_); return func.combine((ClassBound)_h,(TypeUse)_bound); } public CDFile traverseCDFile(final CDFile _h, final TypeCheck.Env _targ_){ IncludeList _incl = traverseIncludeList(_h.getIncl(), _targ_); DGPUses _dgpuse = traverseDGPUses(_h.getDgpuse(), _targ_); PackageDef _pkg = traversePackageDef(_h.getPkg(), _targ_); LookDef _look = traverseLookDef(_h.getLook(), _targ_); ImportList _imports = traverseImportList(_h.getImports(), _targ_); TypeDefList _types = traverseTypeDefList(_h.getTypes(), _targ_); return func.combine((CDFile)_h,(IncludeList)_incl, (DGPUses)_dgpuse, (PackageDef)_pkg, (LookDef)_look, (ImportList)_imports, (TypeDefList)_types); } public Bound traverseBound(final Bound _h, final TypeCheck.Env _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 AddToken traverseAddToken(final AddToken _h, final TypeCheck.Env _targ_){ String _str = func.combine(_h.getStr()); return func.combine((AddToken)_h,(String)_str); } public AddTab traverseAddTab(final AddTab _h, final TypeCheck.Env _targ_){ return func.combine((AddTab)_h); } public AddSpace traverseAddSpace(final AddSpace _h, final TypeCheck.Env _targ_){ return func.combine((AddSpace)_h); } public AddReturn traverseAddReturn(final AddReturn _h, final TypeCheck.Env _targ_){ return func.combine((AddReturn)_h); } public AddLine traverseAddLine(final AddLine _h, final TypeCheck.Env _targ_){ return func.combine((AddLine)_h); } }