*** empty log message ***

4 files changed, 51 insertions, 28 deletions

diff --git a/sources/scala/tools/dtd2scala/DeclToScala.scala b/sources/scala/tools/dtd2scala/DeclToScala.scala
index e089645395..7b21cb01ca 100644
--- a/sources/scala/tools/dtd2scala/DeclToScala.scala
+++ b/sources/scala/tools/dtd2scala/DeclToScala.scala
@@ -21,7 +21,7 @@ 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 DeclToScala(fOut: PrintWriter, objectName: String, namespace: String, elemMap:Map[String, MyElemDecl]) {
 
   class ObjectTemplate {
     val package_ : String = "";
diff --git a/sources/scala/tools/dtd2scala/Main.scala b/sources/scala/tools/dtd2scala/Main.scala
index b4f292ac46..a750179c3a 100644
--- a/sources/scala/tools/dtd2scala/Main.scala
+++ b/sources/scala/tools/dtd2scala/Main.scala
@@ -57,7 +57,7 @@ object Main {
 
     val p = new PrintWriter(new FileWriter(new File(outdir,
                                                     objName+".scala" )));
-    new DeclToScala( p, objName, ns, myH.elemMap ).run;
+    new DeclToScala(p, objName, ns, myH.elemMap).run;
   }
 
   /*
diff --git a/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml b/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml
index ad092946de..8d62a371d2 100644
--- a/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml
+++ b/sources/scala/tools/dtd2scala/template/ObjectTemplate.scala.xml
@@ -148,5 +148,26 @@
       };
       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 <"+n.label+"> 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>
diff --git a/sources/scala/tools/scalac/transformer/TransMatch.scala b/sources/scala/tools/scalac/transformer/TransMatch.scala
index 62901dbd89..6cfc0d2122 100644
--- a/sources/scala/tools/scalac/transformer/TransMatch.scala
+++ b/sources/scala/tools/scalac/transformer/TransMatch.scala
@@ -34,6 +34,8 @@ import matching.FullRegularTranslator ;
 class TransMatch( global:scalac_Global )
   extends scalac_transformer_OwnerTransformer( global ) {
 
+    import Tree._ ;
+
   var cunit:CompilationUnit = null;
 
   override def apply( cunit:CompilationUnit ):unit = {
@@ -50,20 +52,20 @@ class TransMatch( global:scalac_Global )
     }
 
     def isRegular(pat:Tree):Boolean = pat match {
-      case Tree$Alternative(_)          =>  true
-      case Tree$Bind( n, pat1 )              =>
+      case Alternative(_)          =>  true
+      case Bind( n, pat1 )              =>
         TreeInfo.isNameOfStarPattern( n )
       || TreeInfo.isEmptySequence( pat1 )
       || isRegular( pat1 )
-      case Tree$Ident(n)                =>  false
-      case Tree$Sequence( trees )       =>
+      case Ident(n)                =>  false
+      case Sequence( trees )       =>
         ( trees.length == 0 ) || isRegular( trees );
-      case Tree$Apply( fn, trees )      =>
+      case Apply( fn, trees )      =>
         isRegular( trees ) &&
       !((trees.length == 1) && TreeInfo.isEmptySequence( trees( 0 )))
-      case Tree$Literal(_)              => false;
-      case Tree$Select(_,_)             => false;
-      case Tree$Typed(_,_)              => false;
+      case Literal(_)              => false;
+      case Select(_,_)             => false;
+      case Typed(_,_)              => false;
       case _ => error("in TransMatch.isRegular phase: unknown node"+pat.getClass());
     }
 
@@ -73,17 +75,17 @@ class TransMatch( global:scalac_Global )
         val z:Seq[Tree] = ps; z.elements.foreach( x => getNilVars( x ));
       }
       def getNilVars( p:Tree ):scala.Unit = p match {
-        case Tree$Alternative( _ )  =>  /* no bind allowed! */
-        case Tree$Bind( _, pat )    =>
+        case Alternative( _ )  =>  /* no bind allowed! */
+        case Bind( _, pat )    =>
 	  getNilVars(pat);
 	  if( TreeInfo.isEmptySequence( pat ) )
 	    res = p.symbol() :: res;
-	case Tree$Ident(_)          =>
-	case Tree$Sequence( trees ) => getNilVars1( trees )
-        case Tree$Apply( _,  args ) => getNilVars1( args )
-        case Tree$Literal(_)        =>
-        case Tree$Select(_,_)       =>
-        case Tree$Typed(_,_)        =>
+	case Ident(_)          =>
+	case Sequence( trees ) => getNilVars1( trees )
+        case Apply( _,  args ) => getNilVars1( args )
+        case Literal(_)        =>
+        case Select(_,_)       =>
+        case Typed(_,_)        =>
         case _ => error("in TransMatch.nilVariables: unknown node"+pat.getClass());
       }
       getNilVars( pat );
@@ -91,7 +93,7 @@ class TransMatch( global:scalac_Global )
     }
 
     // 2do: remove binds from pattern
-    def handleNilVariables( cse: Tree$CaseDef ): Unit = {
+    def handleNilVariables( cse: CaseDef ): Unit = {
       val nilvars = nilVariables(cse.pat);
       if( !nilvars.isEmpty ) {
         val newBody = new Array[Tree]( nilvars.length );
@@ -107,7 +109,7 @@ class TransMatch( global:scalac_Global )
 
     //val bsf = new scala.util.automaton.BerrySethi[ matching.PatternTest ]( pe );
 
-  def  transform( root:Tree, cases:Array[Tree$CaseDef], restpe:Type ):Tree = {
+  def  transform( root:Tree, cases:Array[CaseDef], restpe:Type ):Tree = {
 
     if( global.newMatch ) {
       val fm = new FullRegularTranslator( global );
@@ -161,17 +163,17 @@ class TransMatch( global:scalac_Global )
     }
   }
     /** evil hack. OwnerTransformer should have this function */
-    def transform1(ts:Array[Tree$CaseDef]):Array[Tree$CaseDef] =  {
+    def transform1(ts:Array[CaseDef]):Array[CaseDef] =  {
       var i = 0;
       while( i < ts.length ) {
         val t = transform(ts( i ));
         if (t != ts( i )) {
-          val res = new Array[Tree$CaseDef](ts.length);
+          val res = new Array[CaseDef](ts.length);
           System.arraycopy(ts, 0, res, 0, i);
-          res( i ) = t.asInstanceOf[Tree$CaseDef];
+          res( i ) = t.asInstanceOf[CaseDef];
           i = i + 1;
           while(i < ts.length) {
-            res( i ) = transform(ts( i )).asInstanceOf[Tree$CaseDef];
+            res( i ) = transform(ts( i )).asInstanceOf[CaseDef];
             i = i + 1
           };
           return res;
@@ -186,18 +188,18 @@ class TransMatch( global:scalac_Global )
        return null;
      else
        tree match {
-         case Tree$Apply(Tree$Select( receiver, Names._match ), args) =>
+         case Apply(Select( receiver, Names._match ), args) =>
            if ((args != null) && (args.length == 1))
              args( 0 ) match {
-               case Tree$Visitor( cases ) =>
+               case Visitor( cases ) =>
                  return transform(transform(receiver), transform1(cases), tree.getType());
              }
            return tree;
 
-         case Tree$Apply(Tree$TypeApply(Tree$Select( receiver, Names._match ), targs), args) =>
+         case Apply(TypeApply(Select( receiver, Names._match ), targs), args) =>
            if ((args != null) && (args.length == 1))
              args( 0 ) match {
-               case Tree$Visitor( cases ) =>
+               case Visitor( cases ) =>
                  return transform(transform(receiver), transform1(cases), tree.getType());
              }
            return tree;