removed dtd2scala

7 files changed, 28 insertions, 716 deletions

diff --git a/Makefile b/Makefile
index d056f7e2af..c3c25cbb34 100644
--- a/Makefile
+++ b/Makefile
@@ -112,7 +112,7 @@ nsc			: main.nsc
 scalai			: main.scalai
 scaladoc		: main.scaladoc
 scalap			: main.scalap
-dtd2scala		: main.dtd2scala
+#dtd2scala		: main.dtd2scala
 scala4ant		: main.scala4ant
 scalatest		: main.scalatest
 tools			: main.tools
@@ -130,7 +130,7 @@ $(prefix).nsc		: $(latest)nsc
 $(prefix).scalai	: $(latest)scalai
 $(prefix).scaladoc	: $(latest)scaladoc
 $(prefix).scalap	: $(latest)scalap
-$(prefix).dtd2scala	: $(latest)dtd2scala
+#$(prefix).dtd2scala	: $(latest)dtd2scala
 $(prefix).scala4ant	: $(latest)scala4ant
 $(prefix).scalatest	: $(latest)scalatest
 $(prefix).tools		: $(latest)tools
@@ -156,7 +156,7 @@ test.%			: ; @$(make) prefix="test" $@;
 .PHONY			: scalai
 .PHONY			: scaladoc
 .PHONY			: scalap
-.PHONY			: dtd2scala
+#.PHONY			: dtd2scala
 .PHONY			: scala4ant
 .PHONY			: scalatest
 .PHONY			: tools
@@ -174,7 +174,7 @@ test.%			: ; @$(make) prefix="test" $@;
 .PHONY			: $(prefix).scalai
 .PHONY			: $(prefix).scaladoc
 .PHONY			: $(prefix).scalap
-.PHONY			: $(prefix).dtd2scala
+#.PHONY			: $(prefix).dtd2scala
 .PHONY			: $(prefix).scala4ant
 .PHONY			: $(prefix).scalatest
 .PHONY			: $(prefix).tools
@@ -286,7 +286,7 @@ SCRIPTS_ALIASES_NAMES	+= scalarun
 SCRIPTS_ALIASES_NAMES	+= scalarun-debug
 SCRIPTS_ALIASES_NAMES	+= scalaint
 SCRIPTS_ALIASES_NAMES	+= scalaint-debug
-SCRIPTS_ALIASES_NAMES	+= dtd2scala
+#SCRIPTS_ALIASES_NAMES	+= dtd2scala
 SCRIPTS_ALIASES_NAMES	+= scalap
 SCRIPTS_ALIASES_NAMES	+= scalatest
 SCRIPTS_ALIASES_FILES	+= $(SCRIPTS_ALIASES_NAMES:%=$(SCRIPTS_BINARYDIR)/%)
@@ -596,28 +596,28 @@ $(latest)scalap-sc	: $(SCALAP_SC_FILES)
 ##############################################################################
 # Targets - scala tools - dtd2scala
 
-PROJECT_SOURCES		+= $(DTD2SCALA_SOURCES)
-DTD2SCALA_ROOT		 = $(PROJECT_SOURCEDIR)/scala/tools/dtd2scala
-DTD2SCALA_LIST		+= $(call READLIST,$(PROJECT_LISTDIR)/dtd2scala.lst)
-DTD2SCALA_SOURCES	+= $(DTD2SCALA_LIST:%=$(DTD2SCALA_ROOT)/%)
-DTD2SCALA_SC_FILES	+= $(filter %.scala,$(DTD2SCALA_SOURCES))
-DTD2SCALA_RSRC_LIST	+= $(filter %.xml,$(DTD2SCALA_LIST))
-DTD2SCALA_RSRC_FILES	+= $(filter %.xml,$(DTD2SCALA_SOURCES))
-DTD2SCALA_RSRC_OUTPUTDIR = $(DTD2SCALA_ROOT:$(PROJECT_SOURCEDIR)/%=$(JC_OUTPUTDIR)/%)
-
-$(latest)dtd2scala	: $(latest)dtd2scala-sc
-$(latest)dtd2scala	: $(latest)dtd2scala-rsrc
-$(latest)dtd2scala	:
-	$(TOUCH) $@
-
-$(latest)dtd2scala-sc	: $(DTD2SCALA_SC_FILES)
-	@$(make) sc target=DTD2SCALA DTD2SCALA_SC_FILES='$?'
-	$(TOUCH) $@
-
-$(latest)dtd2scala-rsrc	: $(DTD2SCALA_RSRC_FILES)
-	$(strip $(MIRROR) -m 644 -C $(DTD2SCALA_ROOT) $(DTD2SCALA_RSRC_LIST) \
-	    $(DTD2SCALA_RSRC_OUTPUTDIR))
-	$(TOUCH) $@
+#PROJECT_SOURCES		+= $(DTD2SCALA_SOURCES)
+#DTD2SCALA_ROOT		 = $(PROJECT_SOURCEDIR)/scala/tools/dtd2scala
+#DTD2SCALA_LIST		+= $(call READLIST,$(PROJECT_LISTDIR)/dtd2scala.lst)
+#DTD2SCALA_SOURCES	+= $(DTD2SCALA_LIST:%=$(DTD2SCALA_ROOT)/%)
+#DTD2SCALA_SC_FILES	+= $(filter %.scala,$(DTD2SCALA_SOURCES))
+#DTD2SCALA_RSRC_LIST	+= $(filter %.xml,$(DTD2SCALA_LIST))
+#DTD2SCALA_RSRC_FILES	+= $(filter %.xml,$(DTD2SCALA_SOURCES))
+#DTD2SCALA_RSRC_OUTPUTDIR = $(DTD2SCALA_ROOT:$(PROJECT_SOURCEDIR)/%=$(JC_OUTPUTDIR)/%)
+
+#$(latest)dtd2scala	: $(latest)dtd2scala-sc
+#$(latest)dtd2scala	: $(latest)dtd2scala-rsrc
+#$(latest)dtd2scala	:
+#	$(TOUCH) $@
+
+#$(latest)dtd2scala-sc	: $(DTD2SCALA_SC_FILES)
+#	@$(make) sc target=DTD2SCALA DTD2SCALA_SC_FILES='$?'
+#	$(TOUCH) $@
+
+#$(latest)dtd2scala-rsrc	: $(DTD2SCALA_RSRC_FILES)
+#	$(strip $(MIRROR) -m 644 -C $(DTD2SCALA_ROOT) $(DTD2SCALA_RSRC_LIST) \
+#	    $(DTD2SCALA_RSRC_OUTPUTDIR))
+#	$(TOUCH) $@
 
 ##############################################################################
 # Targets - scala tools - scala4ant
@@ -670,7 +670,7 @@ $(latest)tools		: $(latest)scalac
 $(latest)tools		: $(latest)scalai
 $(latest)tools		: $(latest)scaladoc
 $(latest)tools		: $(latest)scalap
-$(latest)tools		: $(latest)dtd2scala
+#$(latest)tools		: $(latest)dtd2scala
 $(latest)tools		: $(latest)scala4ant
 $(latest)tools		: $(latest)scalatest
 $(latest)tools		:
diff --git a/config/list/dtd2scala.lst b/config/list/dtd2scala.lst
deleted file mode 100644
index 1495b33ec5..0000000000
--- a/config/list/dtd2scala.lst
+++ /dev/null
@@ -1,12 +0,0 @@
-############################################################-*-Makefile-*-####
-# scala dtd2scala source files (paths are relative to ./sources/scala/tools/dtd2scala)
-##############################################################################
-# $Id$
-
-DeclToScala.scala
-Main.scala
-MainHandler.scala
-MyElemDecl.scala
-
-template/ObjectTemplate.scala.xml
-##############################################################################
diff --git a/sources/scala/tools/dtd2scala/DeclToScala.scala b/sources/scala/tools/dtd2scala/DeclToScala.scala
deleted file mode 100644
index 282909064b..0000000000
--- a/sources/scala/tools/dtd2scala/DeclToScala.scala
+++ /dev/null
@@ -1,312 +0,0 @@
-// $Id$
-
-import scalac.util.Name ;
-import scala.tools.scalac.ast.parser.Tokens ; /* for keywords */
-
-package scala.tools.dtd2scala {
-
-import java.io.PrintWriter ;
-import org.xml.sax.InputSource ;
-
-import scala.collection.Map ;
-import scala.collection.mutable.HashMap ;
-
-import scala.xml._ ;
-import scala.xml.dtd.{AttrDecl, ContentModel, ElemDecl};
-
-import ContentModel._ ;
-import scala.xml.dtd.{REQUIRED,IMPLIED,DEFAULT};
-import scala.xml.nobinding.XML ;
-
-/** transforms a set of DTD declaraion to a scala source file.
- *  2do: parameterize with destination package.
- */
-class DeclToScala(fOut: PrintWriter, objectName: String, namespace: String, elemMap:Map[String, MyElemDecl]) {
-
-  class ObjectTemplate {
-    val package_ : String = "";
-    val compress : boolean = true;
-    final val tmplFile = "scala/tools/dtd2scala/template/ObjectTemplate.scala.xml";
-    final val tmpl:Node = XML.load( new InputSource(ClassLoader.getSystemResourceAsStream(tmplFile)) );
-
-    val lookup : HashMap[String,String] = new HashMap[String,String]();
-    var curAttribs: Map[String,AttrDecl] = null ;  /* of current elem */
-    var curModel: RegExp = null;
-
-    /** 1.populate with special "<R" and default
-    **/
-    def initAttributes( curAttribs:Map[String,AttrDecl] ):String = {
-        val sb = new StringBuffer();
-        for( val key <- curAttribs.keys ) {
-          curAttribs( key ).default match {
-            case REQUIRED =>
-              sb.append("map = map.update(\"");
-              sb.append( key );
-              sb.append("\", ");
-              sb.append("\"<R\"); req=req+1; // REQUIRED");
-            case IMPLIED  =>
-              /* no default value */
-            case DEFAULT( _, attValue ) =>
-              sb.append("map = map.update(\"");
-              sb.append( key );
-              sb.append("\", \"");
-              sb.append(attValue); /* quotes??? */
-              sb.append("\");");
-          }
-          sb.append('\n');
-        }
-        sb.toString();
-    }
-    /** 1.populate with actual values: throw error if FIXED is wrong
-    **  2.throw error if a REQUIRED one is missing*/
-    def validateAttributes(curAttribs: Map[String,AttrDecl]):String = {
-      def appendKey( key:String, sb:StringBuffer ) = {
-        val it = Iterator.fromString( key );
-        sb.append('\'');
-        sb.append( it.next );
-        sb.append('\'');
-        it.foreach {
-          c =>
-          sb.append(',');
-          sb.append('\'');
-          sb.append( c );
-          sb.append('\'')
-        }
-      }
-      val sb = new StringBuffer();
-      for( val key <- curAttribs.keys ) {
-        sb.append(" case Seq((),");
-        curAttribs( key ) match {
-          case AttrDecl( key, tpe, df ) =>
-          appendKey( key, sb );
-          sb.append(") =>");
-          df match {
-            case DEFAULT( true, attValue ) =>
-              sb.append("if( b._2 != \"");
-              sb.append( attValue );
-              sb.append("\" ) error_FixedAttribute(b._1,\"");
-              sb.append( attValue );
-              sb.append("\") else {};");
-            case REQUIRED =>
-              sb.append(" req = req - 1; map = map.update( b._1, b._2 );");
-            case _ =>
-              sb.append(" map = map.update( b._1, b._2 );");
-          }
-        }
-        sb.append('\n');
-      }
-      sb.toString();
-    }
-
-    def shallowValidate( r:RegExp ):String = {
-
-    def shallowContentModel1(rs:List[RegExp],sep:Char):String = {
-      val it = rs.elements;
-      val sb = new StringBuffer();
-      sb.append('(');
-      sb.append(  shallowContentModel( it.next ) );
-      for( val z <- it ) {
-        sb.append( sep );
-        sb.append( shallowContentModel( z ) );
-      }
-      sb.append( ')' );
-      sb.toString()
-    }
-
-    def shallowContentModel(r:RegExp):String = {
-      /*Console.println("sCM:"+ r.getClass() + " r:"+r );*/
-      r match {
-        case Eps   => ""
-        case Letter(ElemName(name)) => refTag( name ).toString();
-        case Star(r) => "("+shallowContentModel( r ) +") *"
-        case Alt( rs @ _* )  => shallowContentModel1( rs, '|' )
-        case Sequ( rs @ _* ) =>  shallowContentModel1( rs, ',' )
-        case _ => error("unexpected regexp:"+r);
-      }
-    }
-
-      /*Console.println("shallowValid:"+ r.getClass() + " r:"+r );*/
-      r match {
-      case ANY_ => "true";
-      case Eps  => "ch.length == 0"
-      case PCDATA_ | Sequ( PCDATA_ ) =>
-        val sb = new StringBuffer("tagIterator( ch ).forall( x => x < 0 )");
-        sb.toString();
-      case Star(Alt(PCDATA_, alts @ _*)) => {
-        val sb = new StringBuffer("tagIterator( ch ).forall( x:Int => x match {");
-        for( val alt <- alts.elements ) {
-          sb.append("                          case ");
-          alt match { case Letter(ElemName( name )) => sb.append( refTag( name ).toString() )}
-          sb.append(" => true \n");
-        }
-        sb.append("case _ => false })");
-        sb.toString();
-      }
-      case _ =>  val sb = new StringBuffer("tagIterator( ch ).toList.match {");
-        sb.append("         case Seq(");
-        sb.append( shallowContentModel( r ) );
-        sb.append( ") => true \n");
-        sb.append( "case _ => Console.println( tagIterator( ch ).toList);false }\n");
-        sb.toString();
-      }
-    }
-
-    var tagCounter = 0;
-    val refTag = new HashMap[String,Int]();
-    def newTag(elemName:String) = {
-      val i = tagCounter;
-      tagCounter = tagCounter + 1;
-      refTag.update( elemName, i );
-      i
-    }
-
-    def write:Unit = {
-      def writeNode( x:Node ):Unit = {
-        //Console.println("visiting "+x);
-        x match {
-          case Text(text) =>
-            fOut.print( text );
-          case n:Elem =>
-            n.label match {
-              case "attributeDecls" =>
-                var sb = new StringBuffer("Nil");
-                for( val aDecl <- curAttribs.values ) {
-                  sb.insert(0, "::");
-                  sb.insert(0, aDecl.toString());
-                }
-                fOut.print(sb.toString());
-
-              case "elemDecl" =>
-                fOut.print(ContentModel.toString( curModel ));
-
-              case "template" => {
-                lookup.update("objectName", objectName);
-                lookup.update("namespace",  namespace);
-                lookup.update("compressDefault", compress.toString());
-                n.child.elements.foreach { n => writeNode(n) }
-              }
-              case "initAttributes" =>
-                fOut.print(  initAttributes( curAttribs ) );
-              case "validateAttributes" =>
-                fOut.print(  validateAttributes( curAttribs ) );
-              case "shallowContentRegExp" =>
-                fOut.print(  shallowValidate( curModel ) );
-              case "makeTag" =>
-                fOut.print( newTag( lookup("elementName") ).toString() );
-              case "refTag" =>
-                fOut.print( refTag( lookup("elementName") ).toString() );
-              case "elementBinding" => {
-                for( val decl <- elemMap.values ) {
-                  lookup += "elementName" -> decl.name;
-                  lookup += "elementContainsText" -> decl.containsText.toString();
-                  lookup += "elementContentModel" -> decl.contentModel;
-                  //Console.println("elemName="+decl.name);
-                  curModel = decl.parsedContentModel ;
-                  //Console.println("curModel="+curModel);
-                  curAttribs = decl.attribs;
-                  n.child.elements.foreach{ n => writeNode( n ) }
-                }
-                curModel = null;
-                curAttribs = null;
-                lookup -= "elementName";
-                lookup -= "elementContainsText";
-              }
-              /*
-              case "attributeAssign" => {
-                for( val aDecl <- curAttribs.keys.elements ) {
-                  lookup += "attributeName" -> aDecl;
-                  n.child.elements.foreach{ n => writeNode( n ) }
-                }
-                lookup -= "attributeName";
-              }
-              */
-              case "attributeBinding" => {
-                for( val aDecl <- curAttribs.keys ) {
-                  lookup += "attributeName" -> aDecl;
-                  lookup += "attributeDecl" -> curAttribs(aDecl).toString();
-                  n.child.elements.foreach{ n => writeNode( n ) }
-                }
-                lookup -= "attributeName";
-              }
-              case "ccstring" => {
-                fOut.print( cookedCap( lookup( n.attribute("ref") ) ));
-              }
-              case "cstring" => {
-                fOut.print( cooked( lookup( n.attribute("ref") ) ));
-              }
-              case "string" => {
-                fOut.print( lookup( n.attribute("ref") ) );
-              }
-              case "qstring" =>  {
-                fOut.print("\"");
-                fOut.print( lookup( n.attribute("ref") ) );
-                fOut.print("\"");
-              }
-              case _ => error("what shall I do with a \""+n.label+"\" node ?")
-            }
-        }
-      }
-      writeNode( tmpl )
-    }
-  }
-
-  /** runs translation. */
-  def run:Unit = {
-    new ObjectTemplate().write;
-    fOut.flush();
-    fOut.close();
-  }
-
-  private def warning_attrib(name:String,tpe:String) = {
-    System.err.print( "[ignoring attribute \"" );
-    System.err.print( name );
-    System.err.print( "\" of type \"" );
-    System.err.print( tpe );
-    System.err.print( "\"]" );
-  }
-
-
-//
-// cooking raw names
-//
-
-/* replace dash, colons with underscore, keywords with appended $ */
-private def cooked( ckd:StringBuffer, raw:String, off:int ):String = {
-  for( val i <- List.range( off, raw.length()) ) {
-    val _ = raw.charAt( i ).match {
-      case '-' =>
-        ckd.append( '_' )
-      case ':' =>
-        ckd.append( '_' )
-      case x =>
-        ckd.append( x )
-    };
-  };
-
-  if( Tokens.isKeyword(raw)) {
-    val _ = ckd.append('$');
-  };
-  ckd.toString()
-
-}
-
-// type       -> type$
-// http-equiv -> http_equiv
-
-private def cooked( raw:String ):String  = cooked(new StringBuffer(), raw, 0);
-
-
-// type       -> Type$
-// http-equiv -> Http_equiv
-
-private def cookedCap( raw:String ):String = {
-  val ckd:StringBuffer = new StringBuffer();
-  ckd.append( Character.toUpperCase( raw.charAt( 0 ) ));
-  cooked( ckd, raw, 1);
-}
-
-  Tokens; // initialize tokens
-
-}
-
-}
diff --git a/sources/scala/tools/dtd2scala/Main.scala b/sources/scala/tools/dtd2scala/Main.scala
deleted file mode 100644
index beaad8bc43..0000000000
--- a/sources/scala/tools/dtd2scala/Main.scala
+++ /dev/null
@@ -1,113 +0,0 @@
-// $Id$
-
-package scala.tools.dtd2scala ;
-import org.xml.sax.{InputSource,SAXException,SAXParseException,XMLReader}
-//import org.xml.sax.helpers.XMLReaderFactory;
-
-import java.io.{File,FileWriter,PrintWriter,StringReader};
-
-import javax.xml.parsers.SAXParserFactory;
-import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.parsers.SAXParser;
-
-object Main {
-
-  // included in JDK1.4, but cannot resolve relative sysIDs
-  //final val DEFAULT_PARSER_NAME = "org.apache.crimson.parser.XMLReaderImpl" ;
-  //final val DEFAULT_PARSER_NAME = "org.apache.xerces.parsers.SAXParser" ;
-
-  /** Default namespaces support (true). */
-  final val DEFAULT_NAMESPACES = false;
-
-  final val DECL_HANDLER = "http://xml.org/sax/properties/declaration-handler";
-
-  final val NAMESPACES_FEATURE_ID = "http://xml.org/sax/features/namespaces";
-
-
-  def  printUsage:Unit = {
-    Console.println("usage: dtd2scala [ -d <dir> ] <sysID> <object name> [<namespace>]");
-    Console.println("       binds a DTD to class definitions");
-    Console.println("       will create a file [<dir>/]<object name>.scala");
-    Console.println("<dir> is the output directory [path of <sysID> is default]");
-    Console.println("<sysID> is a system ID of an XML DTD");
-    Console.println("<object name> is the name of the resulting Scala source file ");
-  }
-
-  /** translates dtd to scala class definitions. see also printUsage */
-  def main(argv:Array[String]):Unit = {
-    //import scala.Seq ; // to shadow case class Seq RegExp
-
-    List.fromArray(argv, 0, argv.length) match {
-      case Seq( "-d", outdir, sysID, objName ) =>
-        continue( new File( outdir ), sysID, objName, "" );
-      case Seq( "-d", outdir, sysID, objName, namespace ) =>
-        continue( new File( outdir ), sysID, objName, namespace );
-      //case Seq( "-sql", sysID ) => dosql( sysID );
-      case Seq( sysID, objName ) =>
-        continue( new File( sysID ).getParentFile(), sysID, objName, "" );
-      case Seq( sysID, objName, namespace ) =>
-        continue( new File( sysID ).getParentFile(), sysID, objName, namespace );
-      case _ =>
-        { printUsage; System.exit(-1); }
-    }
-  }
-
-  private def continue( outdir:File, sysID:String, objName:String, ns:String ) = {
-    val myH:MainHandler  = new MainHandler();
-    parse( sysID, myH );
-    // myH.print(); // DEBUG
-
-    val p = new PrintWriter(new FileWriter(new File(outdir,
-                                                    objName+".scala" )));
-    new DeclToScala(p, objName, ns, myH.elemMap).run;
-  }
-
-  /*
-  private def dosql( sysID:String ) = {
-    val myH:MainHandler  = new MainHandler();
-    parse( sysID, myH );
-    //val q = new PrintWriter(new FileWriter(new File(outdir,
-    //                                                objName+".sql" )));
-    val q = new PrintWriter(System.out);
-    new DeclToSQL( q, null:String, myH.elemMap ).run;
-  }
-*/
-
-  private def inputsrc( sysID:String ):InputSource = {
-    // create isrc for a fake doc referencing the DTD
-    val  isrc:InputSource = new InputSource(
-      new StringReader("<!DOCTYPE doc SYSTEM \""+ sysID +"\"><doc></doc>")
-    );
-    val curDir:String = System.getProperty("user.dir");
-    isrc.setSystemId( "file:///"+curDir+"/fubar.xml" );
-    isrc;
-  }
-
-  private def parse( sysID:String, myH:MainHandler ) = {
-    val parser:SAXParser  = SAXParserFactory.newInstance().newSAXParser();
-
-    /*
-    try {parser.setFeature( NAMESPACES_FEATURE_ID,
-                            DEFAULT_NAMESPACES );}
-    catch {
-      case e:SAXException =>
-    }
-*/
-    try   { parser.setProperty( DECL_HANDLER, myH ); }
-    catch { case e:SAXException => e.printStackTrace(System.err); }
-    try { parser.parse( inputsrc( sysID ), myH ); }
-    catch {
-      case e:SAXParseException =>
-        System.err.println("SaxParseEx");e.printStackTrace( System.err );
-      case e:Exception => {
-        System.err.println("error: Parse error occurred - "+e.getMessage());
-        if( e.isInstanceOf[SAXException] )
-          e.asInstanceOf[SAXException].getException()
-        .printStackTrace( System.err )
-        else e.printStackTrace()
-      }
-    }
-
-  }
-
-} //object main
diff --git a/sources/scala/tools/dtd2scala/MainHandler.scala b/sources/scala/tools/dtd2scala/MainHandler.scala
deleted file mode 100644
index 588ce99fa8..0000000000
--- a/sources/scala/tools/dtd2scala/MainHandler.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-package scala.tools.dtd2scala ;
-
-import org.xml.sax.helpers.DefaultHandler;
-import org.xml.sax.ext.DeclHandler;
-
-import scala.xml.dtd._ ;
-import scala.collection.mutable.HashMap ;
-// 2 do :  - handle modes of attributes ( #REQUIRED,  defaults for #IMPLIED )
-
-/** SAX handler, reacts to events during declaration parsing */
-class MainHandler extends DefaultHandler with DeclHandler {
-
-  var elemMap:HashMap[String,MyElemDecl] = new HashMap[String,MyElemDecl];
-
-  //                                        zzz    DTDHandler methods    zzz
-
-  /** encountered element declaration */
-  def elementDecl( name:String, contentModel:String ) = {
-    elemMap.get( name ).match {
-      case Some(decl) => // was added because of ATTLIST decl before
-        elemMap.update( name, new MyElemDecl( decl.name,
-                                             contentModel,
-                                             decl.myAttribs ) )
-      case None =>
-        elemMap.update( name, new MyElemDecl( name,
-                                             contentModel,
-                                             new HashMap[String,AttrDecl]() ));
-    }
-  } // elementDecl(String,String)
-
-  /** encountered attribute declaration. */
-  def attributeDecl(elementName:String,
-                    attributeName:String,
-                    tpe:String,
-                    valueDefault:String,
-                    value:String ) = {
-
-     val attribs = elemMap.get( elementName ).match {
-	 case None => { val amap = new HashMap[String,AttrDecl];
-		        elemMap.update( elementName,
-				       new MyElemDecl( elementName,
-                                                  null:String,
-                                                  amap ));
-                        amap
-                     }
-       	 case Some(decl) => decl.myAttribs;
-     }
-     val defDecl = if( valueDefault == null ) {
-       DEFAULT( false, value );
-     } else valueDefault match {
-       case "#IMPLIED" => IMPLIED;
-       case "#REQUIRED" => REQUIRED;
-       case "#FIXED" => DEFAULT( true, value );
-     }
-     attribs.update( attributeName, AttrDecl(attributeName, tpe, defDecl ));
-  } // attributeDecl(String,String,String,String,String)
-
-
-  /** Internal entity declaration. */
-  def internalEntityDecl( name:String, text:String ) = {/*ignored*/}
-
-  /** External entity declaration. */
-  def externalEntityDecl(name:String,pubId:String,sysId:String)= {/*ignored*/}
-
-} // class MyDTDHandler
-
diff --git a/sources/scala/tools/dtd2scala/MyElemDecl.scala b/sources/scala/tools/dtd2scala/MyElemDecl.scala
deleted file mode 100644
index fc22af6b5a..0000000000
--- a/sources/scala/tools/dtd2scala/MyElemDecl.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-package scala.tools.dtd2scala ;
-
-import scala.xml.dtd._ ;
-import scala.collection.mutable.HashMap ;
-
-class MyElemDecl( name:String ,
-                 contentModel:String ,
-                 theAttribs:HashMap[String,AttrDecl] ) extends ElemDecl( name, contentModel, theAttribs ) {
-                   def myAttribs = theAttribs;
-};
diff --git a/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml b/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml
deleted file mode 100644
index 57a7d5ce3e..0000000000
--- a/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml
+++ /dev/null
@@ -1,175 +0,0 @@
-<!-- $Id$ -->
-<!DOCTYPE template [ 
-  <!ENTITY elementName   '<string ref="elementName"/>'> 
-  <!ENTITY qElementName  '<qstring ref="elementName"/>'> 
-  <!ENTITY ccElementName '<ccstring ref="elementName"/>'> 
-  <!ENTITY elementContentModel   '<string ref="elementContentModel"/>'> 
-  <!ENTITY attributeName   '<string ref="attributeName"/>'> 
-  <!ENTITY qAttributeName  '<qstring ref="attributeName"/>'> 
-  <!ENTITY cAttributeName '<cstring ref="attributeName"/>'> 
-  <!ENTITY space '<![CDATA[ ]]>'> 
-  <!ENTITY br ''> 
-]>
-<!-- generalize to abstract syntax instead of concrete ? -->
-<!-- the formatting should be done by a code beautifier -->
-<template>
-  /* this file is generated from a DTD using ObjectTemplate.scala.xml */
-  <!-- package/ -->
-  
-  /** the following elements are bound
-  <elementBinding>
-    * &elementName; : &elementContentModel; {<attributeBinding>&attributeName;</attributeBinding>&space;}
-  </elementBinding>
-  **/
-  
-  object <string ref="objectName"/> {
-
-    import scala.collection.Map;
-    import scala.collection.immutable;
-    import scala.collection.mutable;
-
-    type cT = scala.Seq[scala.xml.Node];
-
-    def error_InvalidChildren( elName:String, ch:cT, cM:String ) =
-      error("trying to construct invalid "+elName+",\n children labels were: "
-            +ch.elements.map( x => x.label ).toList.mkString("",",","")
-            +"\n content model was "+cM);
-
-    abstract class <string ref="objectName"/>Node$ extends scala.xml.Node {
-      /** the namespace of this node */
-      final val namespace: String = <qstring ref="namespace"/>;
-    }
-
-    def tagIterator(ch:Seq[scala.xml.Node]):Iterator[Int] = new Iterator[Int] {
-      val it = ch.elements.buffered;
-      def hasNext = { 
-        while (it.hasNext &amp;&amp; it.head.typeTag$ &lt; 0) it.next; 
-        it.hasNext
-      }
-      def next = {
-        if( hasNext ) {
-          val n = it.next;
-          val i = n.typeTag$;
-          if( i > 0 ) i else $tagMap.get( n.label ) match {
-              case Some( j ) => j
-              case _         => 0
-            }
-          
-        } else {
-          error("internal error");
-        }
-      }
-    }
-    private val $tagMap = new mutable.HashMap[String,Int];
-    <elementBinding>
-     $tagMap.update( &qElementName;, <makeTag/> );
-    </elementBinding>
-    <elementBinding>
-
-     def constr_&ccElementName;( attrs:scala.xml.AttributeSeq, ch:cT ) = &ccElementName;(attrs,ch:_*);
-
-     private val &ccElementName;AttribValidator = {
-       import scala.xml.dtd._;
-       new AttributeValidator(  
-         <qstring ref="namespace"/>, <attributeDecls/>);
-         }
-
-     private val &ccElementName;Validator = {
-       import scala.xml.dtd._;
-       import ContentModel._;
-       new ElementValidator(<qstring ref="namespace"/>, <elemDecl/>);
-     }
-
-     case class &ccElementName;( attrs:scala.xml.AttributeSeq, ch:scala.xml.Node* ) extends <string ref="objectName"/>Node$ {
-
-     &ccElementName;Validator.validate( ch );
-
-    final override def typeTag$ = <refTag/>;
-
-     final def label = &qElementName;;
-     final def child      =  ch;
-     final def attributes = theAttrs; 
-
-     val theAttrs = &ccElementName;AttribValidator.validate( attrs );
-
-     
-     /* attributes
-     <!-- attributeBinding>
-       
-       <string ref="attributeDecl"/>
-        final def &cAttributeName; : String = attribute(&qAttributeName;);
-      </attributeBinding -->
-      */
-
-     /** returns a new &ccElementName; with updated attributes 
-     final def %(attrs: Seq[Pair[String, String]]) = {
-       var newmap = scala.xml.Node.NoAttributes;
-       for( val p &lt;- attribute.elements ) { 
-          newmap = newmap.update( p._1, p._2 )
-       }
-       for( val p &lt;- attrs ) { 
-          newmap = newmap.update( p._1, p._2 )
-       }
-       &ccElementName;( newmap, child:_* ) ;
-     }
-  */
-     /** returns a new &ccElementName; with updated attribute 
-     final def %(attr: Pair[String, String])  = {
-       var newmap = scala.xml.Node.NoAttributes;
-       for( val p &lt;- attribute.elements ) { 
-          newmap = newmap.update( p._1, p._2 );
-       };
-       newmap = newmap.update( attr._1, attr._2 );
-       &ccElementName;( newmap, child:_* ) ;
-     }
-*/
-    }
-    </elementBinding>
-    
-
-    def load( filename:String ):scala.xml.Node = load( filename, <string ref="compressDefault"/> );
-
-    def load( filename:String, _compress:boolean ):scala.xml.Node = {
-      val fAdapter = new scala.xml.BindingFactoryAdapter  {
-      val namespace=<qstring ref="namespace"/>;
-      
-        val f = { 
-          val res = new mutable.HashMap[String, (scala.xml.AttributeSeq,cT) => scala.xml.Node]() ;
-          <elementBinding>
-          res.update( &qElementName;, constr_&ccElementName;);</elementBinding>
-          res;
-        }
-
-        val g = { 
-          val res = new mutable.HashMap[String, boolean]() ;
-          <elementBinding>
-          res.update( &qElementName;, <string ref="elementContainsText"/>);</elementBinding>
-          res;
-        }
-        val compress = _compress ; 
-      };
-      fAdapter.loadXML( new org.xml.sax.InputSource(filename) );
-    };    
-
-    def main(args: Array[String]) = {
-      val s: Seq[String] = args;
-      s match {
-        case Seq(sysID) =>
-          try {
-            val source = scala.io.Source.fromFile(sysID);
-            val cparse = scala.xml.parsing.ConstructingParser.fromSource(source);
-            cparse.element;
-            val n = load(sysID);
-            Console.println(sysID+" is a valid &lt;"+n.label+"&gt; element");
-          } catch {
-            case e:Exception => 
-              Console.println(sysID+" is not valid:"+e.getMessage());
-              //e.printStackTrace
-          }
-
-        case _          =>
-          Console.println("to validate, give exactly one argument");
-      }
-    }
-}
-</template>