libjava/gnu/xml/dom/ls/DomLSParser.java

   1 /* DomLSParser.java --
   2    Copyright (C) 1999,2000,2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package gnu.xml.dom.ls;
  39
  40 import java.io.File;
  41 import java.io.InputStream;
  42 import java.io.IOException;
  43 import java.net.MalformedURLException;
  44 import java.net.URL;
  45 import java.util.Arrays;
  46 import java.util.List;
  47 import javax.xml.parsers.ParserConfigurationException;
  48 import javax.xml.parsers.SAXParser;
  49 import javax.xml.parsers.SAXParserFactory;
  50 import org.w3c.dom.Document;
  51 import org.w3c.dom.DOMConfiguration;
  52 import org.w3c.dom.DOMException;
  53 import org.w3c.dom.DOMStringList;
  54 import org.w3c.dom.Node;
  55 import org.w3c.dom.ls.DOMImplementationLS;
  56 import org.w3c.dom.ls.LSException;
  57 import org.w3c.dom.ls.LSInput;
  58 import org.w3c.dom.ls.LSParser;
  59 import org.w3c.dom.ls.LSParserFilter;
  60 import org.xml.sax.EntityResolver;
  61 import org.xml.sax.ErrorHandler;
  62 import org.xml.sax.InputSource;
  63 import org.xml.sax.SAXException;
  64 import org.xml.sax.SAXNotRecognizedException;
  65 import org.xml.sax.SAXParseException;
  66 import org.xml.sax.XMLReader;
  67 import gnu.xml.dom.DomDocument;
  68 import gnu.xml.dom.DomDOMException;
  69
  70 /**
  71  * Parser implementation for GNU DOM.
  72  *
  73  * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
  74  */
  75 public class DomLSParser
  76   implements LSParser, DOMConfiguration, DOMStringList, ErrorHandler
  77 {
  78
  79   private static final List SUPPORTED_PARAMETERS
  80     = Arrays.asList(new String[] { "cdata-sections",
  81                     "comments",
  82                     "element-content-whitespace",
  83                     "namespaces",
  84                     "expand-entity-references",
  85                     "coalescing",
  86                     "validating",
  87                     "xinclude-aware",
  88                     "entity-resolver",
  89                     "error-handler" });
  90
  91   private LSParserFilter filter;
  92   private final boolean async;
  93   private String schemaType;
  94   private SAXEventSink eventSink;
  95   private SAXParserFactory factory;
  96   private XMLReader reader;
  97
  98   private boolean namespaceAware = true;
  99   private boolean ignoreWhitespace;
 100   private boolean expandEntityReferences;
 101   private boolean ignoreComments;
 102   private boolean coalescing;
 103   private boolean validating;
 104   private boolean xIncludeAware;
 105   private EntityResolver entityResolver;
 106   private ErrorHandler errorHandler;
 107
 108   public DomLSParser(short mode, String schemaType)
 109     throws DOMException
 110   {
 111     switch (mode)
 112       {
 113       case DOMImplementationLS.MODE_ASYNCHRONOUS:
 114         async = true;
 115         break;
 116       case DOMImplementationLS.MODE_SYNCHRONOUS:
 117         async = false;
 118         break;
 119       default:
 120         throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR);
 121       }
 122     // TODO schemaType
 123     this.schemaType = schemaType;
 124     factory = SAXParserFactory.newInstance();
 125   }
 126
 127   // -- LSParser --
 128
 129   public DOMConfiguration getDomConfig()
 130   {
 131     return this;
 132   }
 133
 134   public LSParserFilter getFilter()
 135   {
 136     return filter;
 137   }
 138
 139   public void setFilter(LSParserFilter filter)
 140   {
 141     this.filter = filter;
 142   }
 143
 144   public boolean getAsync()
 145   {
 146     return async;
 147   }
 148
 149   public boolean getBusy()
 150   {
 151     return eventSink != null;
 152   }
 153
 154   public Document parse(LSInput input)
 155     throws DOMException, LSException
 156   {
 157     if (async)
 158       {
 159         return doParse(input);
 160       }
 161     else
 162       {
 163         synchronized (this)
 164           {
 165             return doParse(input);
 166           }
 167       }
 168   }
 169
 170   public Document parseURI(String uri)
 171     throws DOMException, LSException
 172   {
 173     LSInput input = new DomLSInput();
 174     input.setSystemId(uri);
 175     return parse(input);
 176   }
 177
 178   public Node parseWithContext(LSInput input, Node context, short action)
 179     throws DOMException, LSException
 180   {
 181     Document doc = (context.getNodeType() == Node.DOCUMENT_NODE) ?
 182       (Document) context : context.getOwnerDocument();
 183     input.setBaseURI(doc.getDocumentURI());
 184     // TODO use namespaces defined on context node
 185     Document ret = parse(input);
 186     Node root = ret.getDocumentElement();
 187     root = doc.adoptNode(root);
 188     switch (action)
 189       {
 190       case ACTION_APPEND_AS_CHILDREN:
 191         context.appendChild(root);
 192         break;
 193       case ACTION_REPLACE_CHILDREN:
 194         Node c1 = context.getFirstChild();
 195         while (c1 != null)
 196           {
 197             Node next = c1.getNextSibling();
 198             context.removeChild(c1);
 199             c1 = next;
 200           }
 201         context.appendChild(root);
 202         break;
 203       case ACTION_INSERT_BEFORE:
 204         Node p1 = context.getParentNode();
 205         p1.insertBefore(root, context);
 206         break;
 207       case ACTION_INSERT_AFTER:
 208         Node p2 = context.getParentNode();
 209         Node r1 = context.getNextSibling();
 210         if (r1 == null)
 211           {
 212             p2.appendChild(root);
 213           }
 214         else
 215           {
 216             p2.insertBefore(root, r1);
 217           }
 218         break;
 219       case ACTION_REPLACE:
 220         Node p3 = context.getParentNode();
 221         Node r2 = context.getNextSibling();
 222         p3.removeChild(context);
 223         if (r2 == null)
 224           {
 225             p3.appendChild(root);
 226           }
 227         else
 228           {
 229             p3.insertBefore(root, r2);
 230           }
 231         break;
 232       }
 233     return root;
 234   }
 235
 236   public void abort()
 237   {
 238     if (eventSink != null)
 239       {
 240         eventSink.interrupt();
 241       }
 242   }
 243
 244   private Document doParse(LSInput input)
 245     throws DOMException, LSException
 246   {
 247     // create event sink
 248     if (eventSink != null)
 249       {
 250         throw new LSException(LSException.PARSE_ERR, "parse in progress");
 251       }
 252     InputSource source = getInputSource(input);
 253     eventSink = (filter == null) ? new SAXEventSink() :
 254       new FilteredSAXEventSink(filter);
 255     // configure sink
 256     eventSink.namespaceAware = namespaceAware;
 257     eventSink.ignoreWhitespace = ignoreWhitespace;
 258     eventSink.expandEntityReferences = expandEntityReferences;
 259     eventSink.ignoreComments = ignoreComments;
 260     eventSink.coalescing = coalescing;
 261     // get and configure reader
 262     XMLReader reader = getXMLReader();
 263     try
 264       {
 265         reader.setContentHandler(eventSink);
 266         reader.setDTDHandler(eventSink);
 267         reader.setProperty("http://xml.org/sax/properties/lexical-handler",
 268                            eventSink);
 269         reader.setProperty("http://xml.org/sax/properties/declaration-handler",
 270                            eventSink);
 271         reader.setFeature("http://xml.org/sax/features/namespaces",
 272                           namespaceAware);
 273         reader.setFeature("http://xml.org/sax/features/namespace-prefixes",
 274                           true);
 275         reader.setFeature("http://xml.org/sax/features/validation",
 276                           validating);
 277         try
 278           {
 279             reader.setFeature("http://xml.org/sax/features/use-attributes2",
 280                               true);
 281           }
 282         catch (SAXNotRecognizedException e)
 283           {
 284             // ignore
 285           }
 286         try
 287           {
 288             reader.setFeature("http://xml.org/sax/features/external-general-entities",
 289                               true);
 290           }
 291         catch (SAXNotRecognizedException e)
 292           {
 293             // ignore
 294           }
 295         reader.setEntityResolver(entityResolver);
 296         reader.setErrorHandler(errorHandler);
 297         // parse
 298         reader.parse(source);
 299       }
 300     catch (DOMException e)
 301       {
 302         reader = null;
 303         eventSink = null;
 304         throw e;
 305       }
 306     catch (SAXException e)
 307       {
 308         reader = null;
 309         eventSink = null;
 310         throw new DomLSException(LSException.PARSE_ERR, e);
 311       }
 312     catch (IOException e)
 313       {
 314         reader = null;
 315         eventSink = null;
 316         throw new DomLSException(LSException.PARSE_ERR, e);
 317       }
 318     // return document
 319     Document ret = eventSink.doc;
 320     String systemId = input.getSystemId();
 321     if (systemId != null && ret instanceof DomDocument)
 322       {
 323         ((DomDocument) ret).setDocumentURI(systemId);
 324       }
 325     eventSink = null;
 326     return ret;
 327   }
 328
 329   private XMLReader getXMLReader()
 330     throws LSException
 331   {
 332     if (reader == null)
 333       {
 334         factory.setNamespaceAware(namespaceAware);
 335         factory.setValidating(validating);
 336         factory.setXIncludeAware(xIncludeAware);
 337         try
 338           {
 339             SAXParser parser = factory.newSAXParser();
 340             reader = parser.getXMLReader();
 341           }
 342         catch (ParserConfigurationException e)
 343           {
 344             throw new DomLSException(LSException.PARSE_ERR, e);
 345           }
 346         catch (SAXException e)
 347           {
 348             throw new DomLSException(LSException.PARSE_ERR, e);
 349           }
 350       }
 351     return reader;
 352   }
 353
 354   private InputSource getInputSource(LSInput input)
 355     throws LSException
 356   {
 357     InputSource source = null;
 358     String systemId = input.getSystemId();
 359     InputStream in = input.getByteStream();
 360     if (in != null)
 361       {
 362         source = new InputSource(in);
 363         source.setSystemId(systemId);
 364       }
 365     if (source == null && entityResolver != null)
 366       {
 367         String publicId = input.getPublicId();
 368         try
 369           {
 370             source = entityResolver.resolveEntity(publicId, systemId);
 371           }
 372         catch (SAXException e)
 373           {
 374             throw new DomLSException(LSException.PARSE_ERR, e);
 375           }
 376         catch (IOException e)
 377           {
 378             throw new DomLSException(LSException.PARSE_ERR, e);
 379           }
 380       }
 381     if (source == null)
 382       {
 383         URL url = null;
 384         String base = input.getBaseURI();
 385         try
 386           {
 387             try
 388               {
 389                 URL baseURL = (base == null) ? null : new URL(base);
 390                 url = (baseURL == null) ? new URL(systemId) :
 391                   new URL(baseURL, systemId);
 392               }
 393             catch (MalformedURLException e)
 394               {
 395                 File baseFile = (base == null) ? null : new File(base);
 396                 url = (baseFile == null) ? new File(systemId).toURL() :
 397                   new File(baseFile, systemId).toURL();
 398               }
 399             in = url.openStream();
 400             systemId = url.toString();
 401             source = new InputSource(in);
 402             source.setSystemId(systemId);
 403           }
 404         catch (IOException e)
 405           {
 406             throw new DomLSException(LSException.PARSE_ERR, e);
 407           }
 408       }
 409     return source;
 410   }
 411
 412   // -- DOMConfiguration --
 413
 414   public void setParameter(String name, Object value)
 415     throws DOMException
 416   {
 417     name = name.toLowerCase();
 418     if ("cdata-sections".equals(name))
 419       {
 420         coalescing = !((Boolean) value).booleanValue();
 421       }
 422     else if ("comments".equals(name))
 423       {
 424         ignoreComments = !((Boolean) value).booleanValue();
 425       }
 426     else if ("element-content-whitespace".equals(name))
 427       {
 428         ignoreWhitespace = !((Boolean) value).booleanValue();
 429       }
 430     else if ("namespaces".equals(name))
 431       {
 432         namespaceAware = ((Boolean) value).booleanValue();
 433       }
 434     else if ("expand-entity-references".equals(name))
 435       {
 436         expandEntityReferences = ((Boolean) value).booleanValue();
 437       }
 438     else if ("coalescing".equals(name))
 439       {
 440         coalescing = ((Boolean) value).booleanValue();
 441       }
 442     else if ("validating".equals(name))
 443       {
 444         validating = ((Boolean) value).booleanValue();
 445       }
 446     else if ("xinclude-aware".equals(name))
 447       {
 448         xIncludeAware = ((Boolean) value).booleanValue();
 449       }
 450     else if ("entity-resolver".equals(name))
 451       {
 452         entityResolver = (EntityResolver) value;
 453       }
 454     else if ("error-handler".equals(name))
 455       {
 456         errorHandler = (ErrorHandler) value;
 457       }
 458     else
 459       {
 460         throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR);
 461       }
 462     // invalidate reader, a new one will be created
 463     reader = null;
 464   }
 465
 466   public Object getParameter(String name)
 467     throws DOMException
 468   {
 469     name = name.toLowerCase();
 470     if ("cdata-sections".equals(name))
 471       {
 472         return coalescing ? Boolean.FALSE : Boolean.TRUE;
 473       }
 474     else if ("comments".equals(name))
 475       {
 476         return ignoreComments ? Boolean.FALSE : Boolean.TRUE;
 477       }
 478     else if ("element-content-whitespace".equals(name))
 479       {
 480         return ignoreWhitespace ? Boolean.FALSE : Boolean.TRUE;
 481       }
 482     else if ("namespaces".equals(name))
 483       {
 484         return namespaceAware ? Boolean.TRUE : Boolean.FALSE;
 485       }
 486     else if ("expand-entity-references".equals(name))
 487       {
 488         return expandEntityReferences ? Boolean.TRUE : Boolean.FALSE;
 489       }
 490     else if ("coalescing".equals(name))
 491       {
 492         return coalescing ? Boolean.TRUE : Boolean.FALSE;
 493       }
 494     else if ("validating".equals(name))
 495       {
 496         return validating ? Boolean.TRUE : Boolean.FALSE;
 497       }
 498     else if ("xinclude-aware".equals(name))
 499       {
 500         return xIncludeAware ? Boolean.TRUE : Boolean.FALSE;
 501       }
 502     else if ("entity-resolver".equals(name))
 503       {
 504         return entityResolver;
 505       }
 506     else if ("error-handler".equals(name))
 507       {
 508         return errorHandler;
 509       }
 510     else
 511       {
 512         throw new DomDOMException(DOMException.NOT_SUPPORTED_ERR);
 513       }
 514   }
 515
 516   public boolean canSetParameter(String name, Object value)
 517   {
 518     return contains(name);
 519   }
 520
 521   public DOMStringList getParameterNames()
 522   {
 523     return this;
 524   }
 525
 526   // -- DOMStringList --
 527
 528   public String item(int i)
 529   {
 530     return (String) SUPPORTED_PARAMETERS.get(i);
 531   }
 532
 533   public int getLength()
 534   {
 535     return SUPPORTED_PARAMETERS.size();
 536   }
 537
 538   public boolean contains(String str)
 539   {
 540     return SUPPORTED_PARAMETERS.contains(str);
 541   }
 542
 543   // -- ErrorHandler --
 544
 545   public void warning(SAXParseException e)
 546     throws SAXException
 547   {
 548     if (errorHandler != null)
 549       {
 550         errorHandler.warning(e);
 551       }
 552   }
 553
 554   public void error(SAXParseException e)
 555     throws SAXException
 556   {
 557     if (errorHandler != null)
 558       {
 559         errorHandler.error(e);
 560       }
 561   }
 562
 563   public void fatalError(SAXParseException e)
 564     throws SAXException
 565   {
 566     if (errorHandler != null)
 567       {
 568         errorHandler.fatalError(e);
 569       }
 570     abort();
 571   }
 572
 573 }
 574