src/library/scala/xml/include/sax/Main.scala


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

package scala.xml.include.sax

import org.xml.sax.SAXException
import org.xml.sax.SAXParseException
import org.xml.sax.EntityResolver
import org.xml.sax.helpers.XMLReaderFactory
import org.xml.sax.XMLReader

object Main {

    /**
      * The driver method for xinc
      * Output is written to System.out via Conolse
      * </p>
      *
      * @param args  contains the URLs and/or filenames
      *              of the documents to be procesed.
      */
    def main(args: Array[String]): Unit = {
      var parser: XMLReader = null;
      var err = false;
      try {
        parser = XMLReaderFactory.createXMLReader();
      }
      catch {
        case e:SAXException =>
          try {
            parser = XMLReaderFactory.createXMLReader(
              "org.apache.xerces.parsers.SAXParser");
          } catch {
            case e2:SAXException =>
              System.err.println("Could not find an XML parser");
            err = true;
          }
      }

      if(err) return;
      // Need better namespace handling
      try {
        parser.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
      }
      catch {
        case e:SAXException =>
          System.err.println(e);
          err = true
      }
      if(err) return;

      if (args.length == 0) return;
      var resolver: EntityResolver = null;
      var arg: int = 0;
      if (args(0).equals("-r")) {
        try {
          resolver = Class.forName(args(1)).newInstance().asInstanceOf[EntityResolver];
          parser.setEntityResolver(resolver);
        }
        catch {
          case ex:Exception =>
            System.err.println("Could not load requested EntityResolver");
          err = true;
        }
        arg = 2;
      }
      if(err) return;

      while (arg < args.length) {
        try {
          val includer = new XIncludeFilter();
          includer.setParent(parser);
          val s = new XIncluder(System.out, "UTF-8");
          includer.setContentHandler(s);
          if (resolver != null) includer.setEntityResolver(resolver);
          try {
            includer.setProperty(
              "http://xml.org/sax/properties/lexical-handler",
              s);
            s.setFilter(includer);
          }
          catch {
            case e:SAXException => // Will not support comments
          }
          includer.parse(args(arg));
        }
        catch {
          case e:SAXParseException =>
            System.err.println(e);
            System.err.println("Problem in " + e.getSystemId()
                               + " at line " + e.getLineNumber());
          case e: Exception => // be specific about exceptions????
            System.err.println(e);
            e.printStackTrace();
        }
        arg = arg + 1;
      }
    }
}