Source for gnu.xml.libxmlj.sax.GnomeXMLReader

   1: /* GnomeXMLReader.java -
   2:    Copyright (C) 2004 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., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 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.libxmlj.sax;
  39: 
  40: import java.io.File;
  41: import java.io.FileNotFoundException;
  42: import java.io.InputStream;
  43: import java.io.IOException;
  44: import java.net.MalformedURLException;
  45: import java.net.URL;
  46: import java.util.Arrays;
  47: import java.util.ArrayList;
  48: import java.util.Iterator;
  49: import java.util.List;
  50: 
  51: import org.xml.sax.Attributes;
  52: import org.xml.sax.ContentHandler;
  53: import org.xml.sax.DTDHandler;
  54: import org.xml.sax.EntityResolver;
  55: import org.xml.sax.ErrorHandler;
  56: import org.xml.sax.InputSource;
  57: import org.xml.sax.Locator;
  58: import org.xml.sax.SAXException;
  59: import org.xml.sax.SAXNotRecognizedException;
  60: import org.xml.sax.SAXNotSupportedException;
  61: import org.xml.sax.SAXParseException;
  62: import org.xml.sax.XMLReader;
  63: import org.xml.sax.ext.DeclHandler;
  64: import org.xml.sax.ext.LexicalHandler;
  65: 
  66: import gnu.xml.libxmlj.util.NamedInputStream;
  67: import gnu.xml.libxmlj.util.StandaloneLocator;
  68: import gnu.xml.libxmlj.util.XMLJ;
  69: 
  70: /**
  71:  * A SAX2 parser that uses libxml2.
  72:  *
  73:  * @author <a href='mailto:dog@gnu.org'>Chris Burdess</a>
  74:  */
  75: public class GnomeXMLReader
  76: implements XMLReader
  77: {
  78: 
  79:   static
  80:   {
  81:     XMLJ.init ();
  82:   }
  83: 
  84:   private static final String FEATURES_PREFIX =
  85:     "http://xml.org/sax/features/";
  86: 
  87:   private static final List RECOGNIZED_FEATURES =
  88:     Arrays.asList (new String[]
  89:                    {
  90:                    "external-general-entities",
  91:                    "external-parameter-entities",
  92:                    "is-standalone",
  93:                    "lexical-handler/parameter-entities",
  94:                    "namespaces",
  95:                    "namespace-prefixes",
  96:                    "resolve-dtd-uris",
  97:                    "string-interning",
  98:                    "use-attributes2",
  99:                    "use-locator2",
 100:                    "use-entity-resolver2",
 101:                    "validation"
 102:                    });
 103: 
 104:   private static final String PROPERTIES_PREFIX =
 105:     "http://xml.org/sax/properties/";
 106: 
 107:   private static final List RECOGNIZED_PROPERTIES =
 108:     Arrays.asList (new String[]
 109:                    {
 110:                    "declaration-handler",
 111:                    "dom-node",
 112:                    "lexical-handler",
 113:                    "xml-string"
 114:                    });
 115: 
 116:   // Features
 117: 
 118:   private transient boolean standalone;
 119:   private boolean namespaces;
 120:   private boolean namespacePrefixes;
 121:   private boolean validation;
 122: 
 123:   // Callback handlers
 124: 
 125:   private ContentHandler contentHandler;
 126: 
 127:   private DTDHandler dtdHandler;
 128: 
 129:   private EntityResolver entityResolver;
 130: 
 131:   private ErrorHandler errorHandler;
 132: 
 133:   private DeclHandler declarationHandler;
 134: 
 135:   private LexicalHandler lexicalHandler;
 136: 
 137:   private GnomeLocator locator;
 138: 
 139:   // Namespace helper for handling callbacks
 140:   private transient Namespaces ns;
 141: 
 142:   // If true, do not invoke callback methods except endDocument
 143:   private transient boolean seenFatalError;
 144: 
 145:   private transient boolean seenStartDocument;
 146: 
 147:   private transient String base;
 148: 
 149:   public GnomeXMLReader ()
 150:   {
 151:     this (true, true);
 152:   }
 153: 
 154:   public GnomeXMLReader (boolean namespaces, boolean validation)
 155:   {
 156:     this.namespaces = namespaces;
 157:     this.validation = validation;
 158:     ns = new Namespaces ();
 159:   }
 160: 
 161:   public ContentHandler getContentHandler ()
 162:   {
 163:     return contentHandler;
 164:   }
 165: 
 166:   public void setContentHandler (ContentHandler handler)
 167:   {
 168:     contentHandler = handler;
 169:   }
 170: 
 171:   public DTDHandler getDTDHandler ()
 172:   {
 173:     return dtdHandler;
 174:   }
 175: 
 176:   public void setDTDHandler (DTDHandler handler)
 177:   {
 178:     dtdHandler = handler;
 179:   }
 180: 
 181:   public EntityResolver getEntityResolver ()
 182:   {
 183:     return entityResolver;
 184:   }
 185: 
 186:   public void setEntityResolver (EntityResolver resolver)
 187:   {
 188:     entityResolver = resolver;
 189:   }
 190: 
 191:   public ErrorHandler getErrorHandler ()
 192:   {
 193:     return errorHandler;
 194:   }
 195: 
 196:   public void setErrorHandler (ErrorHandler handler)
 197:   {
 198:     errorHandler = handler;
 199:   }
 200: 
 201:   // Features
 202: 
 203:   public boolean getFeature (String name)
 204:     throws SAXNotRecognizedException, SAXNotSupportedException
 205:   {
 206:     checkFeatureName (name);
 207:     String key = name.substring (FEATURES_PREFIX.length ());
 208:     if ("external-general-entities".equals (key))
 209:       {
 210:         return validation; // TODO check this
 211:       }
 212:     else if ("external-parameter-entities".equals (key))
 213:       {
 214:         return validation; // TODO check this
 215:       }
 216:     else if ("is-standalone".equals (key))
 217:       {
 218:         return standalone;
 219:       }
 220:     else if ("namespaces".equals (key))
 221:       {
 222:         return namespaces;
 223:       }
 224:     else if ("namespace-prefixes".equals (key))
 225:       {
 226:         return namespacePrefixes;
 227:       }
 228:     else if ("resolve-dtd-uris".equals (key))
 229:       {
 230:         return true;
 231:       }
 232:     else if ("validation".equals (key))
 233:       {
 234:         return validation;
 235:       }
 236:     else
 237:       {
 238:         return false;
 239:       }
 240:   }
 241: 
 242:   public void setFeature (String name, boolean value)
 243:     throws SAXNotRecognizedException, SAXNotSupportedException
 244:   {
 245:     checkFeatureName (name);
 246:     String key = name.substring (FEATURES_PREFIX.length ());
 247:     if ("namespaces".equals (key))
 248:       {
 249:         namespaces = value;
 250:       }
 251:     else if ("namespace-prefixes".equals (key))
 252:       {
 253:         namespacePrefixes = value;
 254:       }
 255:     else if ("validation".equals (key))
 256:       {
 257:         validation = value;
 258:       }
 259:   }
 260: 
 261:   /**
 262:    * Check that the specified feature name is recognized.
 263:    */
 264:   static void checkFeatureName (String name)
 265:     throws SAXNotRecognizedException
 266:   {
 267:     if (name == null || !name.startsWith (FEATURES_PREFIX))
 268:       {
 269:         throw new SAXNotRecognizedException (name);
 270:       }
 271:     String key = name.substring (FEATURES_PREFIX.length ());
 272:     if (!RECOGNIZED_FEATURES.contains (key))
 273:       {
 274:         throw new SAXNotRecognizedException (name);
 275:       }
 276:   }
 277: 
 278:   // Properties
 279: 
 280:   public Object getProperty (String name)
 281:     throws SAXNotRecognizedException, SAXNotSupportedException
 282:   {
 283:     checkPropertyName (name);
 284:     String key = name.substring (PROPERTIES_PREFIX.length ());
 285:     if ("declaration-handler".equals (key))
 286:       {
 287:         return getDeclarationHandler ();
 288:       }
 289:     else if ("lexical-handler".equals (key))
 290:       {
 291:         return getLexicalHandler ();
 292:       }
 293:     else
 294:       {
 295:         throw new SAXNotSupportedException (name);
 296:       }
 297:   }
 298: 
 299:   public void setProperty (String name, Object value)
 300:     throws SAXNotRecognizedException, SAXNotSupportedException
 301:   {
 302:     checkPropertyName (name);
 303:     String key = name.substring (PROPERTIES_PREFIX.length ());
 304:     if ("declaration-handler".equals (key))
 305:       {
 306:         setDeclarationHandler ((DeclHandler) value);
 307:       }
 308:     else if ("lexical-handler".equals (key))
 309:       {
 310:         setLexicalHandler ((LexicalHandler) value);
 311:       }
 312:   }
 313: 
 314:   public DeclHandler getDeclarationHandler ()
 315:   {
 316:     return declarationHandler;
 317:   }
 318: 
 319:   public void setDeclarationHandler (DeclHandler declarationHandler)
 320:   {
 321:     this.declarationHandler = declarationHandler;
 322:   }
 323: 
 324:   public LexicalHandler getLexicalHandler ()
 325:   {
 326:     return lexicalHandler;
 327:   }
 328: 
 329:   public void setLexicalHandler (LexicalHandler lexicalHandler)
 330:   {
 331:     this.lexicalHandler = lexicalHandler;
 332:   }
 333: 
 334:   /**
 335:    * Check that the specified property name is recognized.
 336:    */
 337:   static void checkPropertyName (String name)
 338:     throws SAXNotRecognizedException
 339:   {
 340:     if (!name.startsWith (PROPERTIES_PREFIX))
 341:       {
 342:         throw new SAXNotRecognizedException (name);
 343:       }
 344:     String key = name.substring (PROPERTIES_PREFIX.length ());
 345:     if (!RECOGNIZED_PROPERTIES.contains (key))
 346:       {
 347:         throw new SAXNotRecognizedException (name);
 348:       }
 349:   }
 350: 
 351:   // Parse
 352: 
 353:   public void parse (String systemId)
 354:     throws IOException, SAXException
 355:   {
 356:     URL url = null;
 357:     try
 358:       {
 359:         url = new URL (systemId);
 360:       }
 361:     catch (MalformedURLException e)
 362:       {
 363:         File file = new File(systemId);
 364:         if (!file.exists ())
 365:           {
 366:             throw new FileNotFoundException (systemId);
 367:           }
 368:         String path  = file.getAbsolutePath();
 369:         if (File.separatorChar != '/')
 370:           {
 371:             path = path.replace (File.separatorChar, '/');
 372:           }
 373:         if (!path.startsWith ("/"))
 374:           {
 375:             path = "/" + path;
 376:           }
 377:         if (!path.endsWith ("/") && file.isDirectory ())
 378:           {
 379:             path = path + "/";
 380:           }
 381:         url = new URL ("file:" + path);
 382:       }
 383:     InputSource source = new InputSource(url.toString ());
 384:     source.setByteStream (url.openStream ());
 385:     parse (source);
 386:   }
 387: 
 388:   public synchronized void parse (InputSource input)
 389:     throws IOException, SAXException
 390:   {
 391:     NamedInputStream in = XMLJ.getInputStream (input);
 392:     byte[] detectBuffer = in.getDetectBuffer ();
 393:     String publicId = input.getPublicId ();
 394:     String systemId = input.getSystemId ();
 395:     base = XMLJ.getBaseURI (systemId);
 396:     // Reset state
 397:     standalone = false;
 398:     seenFatalError = false;
 399:     seenStartDocument = false;
 400:     if (systemId != null)
 401:       {
 402:         int lsi = systemId.lastIndexOf ('/');
 403:         if (lsi != -1)
 404:           {
 405:             base = systemId.substring (0, lsi + 1);
 406:           }
 407:       }
 408:     // Handle zero-length document
 409:     if (detectBuffer == null)
 410:       {
 411:         startDocument (true);
 412:         fatalError ("No document element", 0, 0, publicId, systemId);
 413:         endDocument ();
 414:         return;
 415:       }
 416:     // Parse
 417:     parseStream(in,
 418:                 detectBuffer,
 419:                 publicId,
 420:                 systemId,
 421:                 base,
 422:                 validation,
 423:                 contentHandler != null,
 424:                 dtdHandler != null,
 425:                 entityResolver != null,
 426:                 errorHandler != null,
 427:                 declarationHandler != null,
 428:                 lexicalHandler != null);
 429:     in.close ();
 430:   }
 431: 
 432:   native void parseStream (InputStream in,
 433:                            byte[] detectBuffer,
 434:                            String publicId,
 435:                            String systemId,
 436:                            String base,
 437:                            boolean validate,
 438:                            boolean contentHandler,
 439:                            boolean dtdHandler,
 440:                            boolean entityResolver,
 441:                            boolean errorHandler,
 442:                            boolean declarationHandler,
 443:                            boolean lexicalHandler)
 444:     throws IOException, SAXException;
 445: 
 446:   String getURI (String prefix)
 447:   {
 448:     if (!namespaces)
 449:       {
 450:         return null;
 451:       }
 452:     return ns.getURI (prefix);
 453:   }
 454: 
 455:   // Callbacks from libxmlj
 456: 
 457:   private void startDTD (String name, String publicId, String systemId)
 458:     throws SAXException
 459:   {
 460:     if (seenFatalError || lexicalHandler == null)
 461:       {
 462:         return;
 463:       }
 464:     try
 465:       {
 466:         systemId = XMLJ.getAbsoluteURI (base, systemId);
 467:         lexicalHandler.startDTD (name, publicId, systemId);
 468:       }
 469:     catch (Exception e)
 470:       {
 471:         if (e instanceof SAXException)
 472:           {
 473:             throw (SAXException) e;
 474:           }
 475:         else
 476:           {
 477:             throw new SAXException (e);
 478:           }
 479:       }
 480:   }
 481: 
 482:   private void externalEntityDecl (String name, String publicId,
 483:                                    String systemId)
 484:     throws SAXException
 485:   {
 486:     if (seenFatalError || declarationHandler == null)
 487:       {
 488:         return;
 489:       }
 490:     try
 491:       {
 492:         systemId = XMLJ.getAbsoluteURI (base, systemId);
 493:         declarationHandler.externalEntityDecl (name, publicId, systemId);
 494:       }
 495:     catch (Exception e)
 496:       {
 497:         if (e instanceof SAXException)
 498:           {
 499:             throw (SAXException) e;
 500:           }
 501:         else
 502:           {
 503:             throw new SAXException (e);
 504:           }
 505:       }
 506:   }
 507: 
 508:   private void internalEntityDecl (String name, String value)
 509:     throws SAXException
 510:   {
 511:     if (seenFatalError || declarationHandler == null)
 512:       {
 513:         return;
 514:       }
 515:     try
 516:       {
 517:         declarationHandler.internalEntityDecl (name, value);
 518:       }
 519:     catch (Exception e)
 520:       {
 521:         if (e instanceof SAXException)
 522:           {
 523:             throw (SAXException) e;
 524:           }
 525:         else
 526:           {
 527:             throw new SAXException (e);
 528:           }
 529:       }
 530:   }
 531: 
 532:   private InputStream resolveEntity (String publicId, String systemId)
 533:     throws SAXException, IOException
 534:   {
 535:     if (entityResolver == null)
 536:       {
 537:         return null;
 538:       }
 539:     try
 540:       {
 541:         systemId = XMLJ.getAbsoluteURI (base, systemId);
 542:         InputSource source = entityResolver.resolveEntity (publicId, systemId);
 543:         return (source == null) ? null : XMLJ.getInputStream (source);
 544:       }
 545:     catch (Exception e)
 546:       {
 547:         if (e instanceof SAXException)
 548:           {
 549:             throw (SAXException) e;
 550:           }
 551:         else
 552:           {
 553:             throw new SAXException (e);
 554:           }
 555:       }
 556:   }
 557: 
 558:   private void notationDecl (String name, String publicId, String systemId)
 559:     throws SAXException
 560:   {
 561:     if (seenFatalError || dtdHandler == null)
 562:       {
 563:         return;
 564:       }
 565:     try
 566:       {
 567:         systemId = XMLJ.getAbsoluteURI (base, systemId);
 568:         dtdHandler.notationDecl (name, publicId, systemId);
 569:       }
 570:     catch (Exception e)
 571:       {
 572:         if (e instanceof SAXException)
 573:           {
 574:             throw (SAXException) e;
 575:           }
 576:         else
 577:           {
 578:             throw new SAXException (e);
 579:           }
 580:       }
 581:   }
 582: 
 583:   private void attributeDecl (String eName, String aName, String type,
 584:                               String mode, String value)
 585:     throws SAXException
 586:   {
 587:     if (seenFatalError || declarationHandler == null)
 588:       {
 589:         return;
 590:       }
 591:     try
 592:       {
 593:         declarationHandler.attributeDecl (eName, aName, type, mode, value);
 594:       }
 595:     catch (Exception e)
 596:       {
 597:         if (e instanceof SAXException)
 598:           {
 599:             throw (SAXException) e;
 600:           }
 601:         else
 602:           {
 603:             throw new SAXException (e);
 604:           }
 605:       }
 606:   }
 607: 
 608:   private void elementDecl (String name, String model)
 609:     throws SAXException
 610:   {
 611:     if (seenFatalError || declarationHandler == null)
 612:       {
 613:         return;
 614:       }
 615:     try
 616:       {
 617:         declarationHandler.elementDecl (name, model);
 618:       }
 619:     catch (Exception e)
 620:       {
 621:         if (e instanceof SAXException)
 622:           {
 623:             throw (SAXException) e;
 624:           }
 625:         else
 626:           {
 627:             throw new SAXException (e);
 628:           }
 629:       }
 630:   }
 631: 
 632:   private void unparsedEntityDecl (String name, String publicId,
 633:                                    String systemId, String notationName)
 634:     throws SAXException
 635:   {
 636:     if (seenFatalError || dtdHandler == null)
 637:       {
 638:         return;
 639:       }
 640:     try
 641:       {
 642:         systemId = XMLJ.getAbsoluteURI (base, systemId);
 643:         dtdHandler.unparsedEntityDecl (name, publicId, systemId,
 644:                                        notationName);
 645:       }
 646:     catch (Exception e)
 647:       {
 648:         if (e instanceof SAXException)
 649:           {
 650:             throw (SAXException) e;
 651:           }
 652:         else
 653:           {
 654:             throw new SAXException (e);
 655:           }
 656:       }
 657:   }
 658: 
 659:   private void setDocumentLocator (Object ctx, Object loc)
 660:   {
 661:     locator = new GnomeLocator (ctx, loc);
 662:     if (seenFatalError || contentHandler == null)
 663:       {
 664:         return;
 665:       }
 666:     try
 667:       {
 668:         contentHandler.setDocumentLocator (locator);
 669:       }
 670:     catch (Exception e)
 671:       {
 672:       }
 673:   }
 674: 
 675:   private void startDocument (boolean standalone)
 676:     throws SAXException
 677:   {
 678:     this.standalone = standalone;
 679:     seenStartDocument = true;
 680:     if (contentHandler == null)
 681:       {
 682:         return;
 683:       }
 684:     try
 685:       {
 686:         contentHandler.startDocument ();
 687:       }
 688:     catch (Exception e)
 689:       {
 690:         if (e instanceof SAXException)
 691:           {
 692:             throw (SAXException) e;
 693:           }
 694:         else
 695:           {
 696:             throw new SAXException (e);
 697:           }
 698:       }
 699:   }
 700: 
 701:   private void endDocument ()
 702:     throws SAXException
 703:   {
 704:     if (contentHandler == null)
 705:       {
 706:         return;
 707:       }
 708:     try
 709:       {
 710:         contentHandler.endDocument();
 711:       }
 712:     catch (Exception e)
 713:       {
 714:         if (e instanceof SAXException)
 715:           {
 716:             throw (SAXException) e;
 717:           }
 718:         else
 719:           {
 720:             throw new SAXException (e);
 721:           }
 722:       }
 723:   }
 724: 
 725:   private void startElement(String name, String[] attrs)
 726:     throws SAXException
 727:   {
 728:     if (seenFatalError || contentHandler == null)
 729:       {
 730:         return;
 731:       }
 732:     try
 733:       {
 734:         XMLName xName = new XMLName (this, name);
 735:         if (namespaces)
 736:           {
 737:             // Handle defined namespaces
 738:             ns.push ();
 739:             int len = (attrs == null) ? 0 : attrs.length;
 740:             if (len > 0)
 741:               {
 742:                 ArrayList filtered = new ArrayList (len);
 743:                 for (int i = 0; i < len; i += 2)
 744:                   {
 745:                     String attName = attrs[i];
 746:                     String attValue = attrs[i + 1];
 747:                     if (attName.equals ("xmlns"))
 748:                       {
 749:                         startPrefixMapping ("", attValue);
 750:                       }
 751:                     else if (attName.startsWith ("xmlns:"))
 752:                       {
 753:                         startPrefixMapping (attName.substring (6), attValue);
 754:                       }
 755:                     else
 756:                       {
 757:                         filtered.add (attName);
 758:                         filtered.add (attValue);
 759:                       }
 760:                   }
 761:                 // Remove xmlns attributes
 762:                 attrs = new String[filtered.size ()];
 763:                 filtered.toArray (attrs);
 764:               }
 765:           }
 766:         // Construct attributes
 767:         Attributes atts = new StringArrayAttributes (this, attrs);
 768:         contentHandler.startElement (xName.uri, xName.localName, xName.qName,
 769:                                      atts);
 770:       }
 771:     catch (Exception e)
 772:       {
 773:         if (e instanceof SAXException)
 774:           {
 775:             throw (SAXException) e;
 776:           }
 777:         else
 778:           {
 779:             throw new SAXException (e);
 780:           }
 781:       }
 782:   }
 783: 
 784:   private void endElement (String name)
 785:     throws SAXException
 786:   {
 787:     if (seenFatalError || contentHandler == null)
 788:       {
 789:         return;
 790:       }
 791:     try
 792:       {
 793:         XMLName xName = new XMLName (this, name);
 794:         String uri = (xName.uri == null) ? "" : xName.uri;
 795:         contentHandler.endElement (uri, xName.localName, xName.qName);
 796:         // Handle undefining namespaces
 797:         if (namespaces)
 798:           {
 799:             for (Iterator i = ns.currentPrefixes (); i.hasNext (); )
 800:               {
 801:                 endPrefixMapping ((String) i.next ());
 802:               }
 803:             ns.pop (); // releases current depth
 804:           }
 805:       }
 806:     catch (Exception e)
 807:       {
 808:         if (e instanceof SAXException)
 809:           {
 810:             throw (SAXException) e;
 811:           }
 812:         else
 813:           {
 814:             throw new SAXException (e);
 815:           }
 816:       }
 817:   }
 818: 
 819:   private void startPrefixMapping (String prefix, String uri)
 820:     throws SAXException
 821:   {
 822:     if (seenFatalError || contentHandler == null)
 823:       {
 824:         return;
 825:       }
 826:     ns.define (prefix, uri);
 827:     contentHandler.startPrefixMapping (prefix, uri);
 828:   }
 829: 
 830:   private void endPrefixMapping (String prefix)
 831:     throws SAXException
 832:   {
 833:     if (seenFatalError || contentHandler == null)
 834:       {
 835:         return;
 836:       }
 837:     contentHandler.endPrefixMapping (prefix);
 838:   }
 839: 
 840:   private void characters (String text)
 841:     throws SAXException
 842:   {
 843:     if (seenFatalError || contentHandler == null || text == null)
 844:       {
 845:         return;
 846:       }
 847:     try
 848:       {
 849:         char[] ch = text.toCharArray ();
 850:         contentHandler.characters (ch, 0, ch.length);
 851:       }
 852:     catch (Exception e)
 853:       {
 854:         if (e instanceof SAXException)
 855:           {
 856:             throw (SAXException) e;
 857:           }
 858:         else
 859:           {
 860:             throw new SAXException (e);
 861:           }
 862:       }
 863:   }
 864: 
 865:   private void ignorableWhitespace (String text)
 866:     throws SAXException
 867:   {
 868:     if (seenFatalError || contentHandler == null || text == null)
 869:       {
 870:         return;
 871:       }
 872:     try
 873:       {
 874:         char[] ch = text.toCharArray ();
 875:         contentHandler.ignorableWhitespace (ch, 0, ch.length);
 876:       }
 877:     catch (Exception e)
 878:       {
 879:         if (e instanceof SAXException)
 880:           {
 881:             throw (SAXException) e;
 882:           }
 883:         else
 884:           {
 885:             throw new SAXException (e);
 886:           }
 887:       }
 888:   }
 889: 
 890:   private void processingInstruction (String target, String data)
 891:     throws SAXException
 892:   {
 893:     if (seenFatalError || contentHandler == null)
 894:       {
 895:         return;
 896:       }
 897:     try
 898:       {
 899:         if (data == null)
 900:           {
 901:             data = "";
 902:           }
 903:         contentHandler.processingInstruction (target, data);
 904:       }
 905:     catch (Exception e)
 906:       {
 907:         if (e instanceof SAXException)
 908:           {
 909:             throw (SAXException) e;
 910:           }
 911:         else
 912:           {
 913:             throw new SAXException (e);
 914:           }
 915:       }
 916:   }
 917: 
 918:   private void comment (String text)
 919:     throws SAXException
 920:   {
 921:     if (seenFatalError || lexicalHandler == null || text == null)
 922:       {
 923:         return;
 924:       }
 925:     try
 926:       {
 927:         char[] ch = text.toCharArray ();
 928:         lexicalHandler.comment (ch, 0, ch.length);
 929:       }
 930:     catch (Exception e)
 931:       {
 932:         if (e instanceof SAXException)
 933:           {
 934:             throw (SAXException) e;
 935:           }
 936:         else
 937:           {
 938:             throw new SAXException (e);
 939:           }
 940:       }
 941:   }
 942: 
 943:   private void cdataBlock (String text)
 944:     throws SAXException
 945:   {
 946:     if (seenFatalError || text == null)
 947:       {
 948:         return;
 949:       }
 950:     try
 951:       {
 952:         if (lexicalHandler == null)
 953:           {
 954:             characters(text);
 955:           }
 956:         else
 957:           {
 958:             lexicalHandler.startCDATA();
 959:             characters(text);
 960:             lexicalHandler.endCDATA();
 961:           }
 962:       }
 963:     catch (Exception e)
 964:       {
 965:         if (e instanceof SAXException)
 966:           {
 967:             throw (SAXException) e;
 968:           }
 969:         else
 970:           {
 971:             throw new SAXException (e);
 972:           }
 973:       }
 974:   }
 975: 
 976:   private void warning (String message,
 977:                         int lineNumber, int columnNumber,
 978:                         String publicId, String systemId)
 979:     throws SAXException
 980:   {
 981:     if (seenFatalError || errorHandler == null)
 982:       {
 983:         return;
 984:       }
 985:     try
 986:       {
 987:         Locator l = new StandaloneLocator (lineNumber, columnNumber,
 988:                                            publicId, systemId);
 989:         errorHandler.warning (new SAXParseException (message, l));
 990:       }
 991:     catch (Exception e)
 992:       {
 993:         if (e instanceof SAXException)
 994:           {
 995:             throw (SAXException) e;
 996:           }
 997:         else
 998:           {
 999:             throw new SAXException (e);
1000:           }
1001:       }
1002:   }
1003: 
1004:   private void error (String message,
1005:                       int lineNumber, int columnNumber,
1006:                       String publicId, String systemId)
1007:     throws SAXException
1008:   {
1009:     if (seenFatalError || errorHandler == null)
1010:       {
1011:         return;
1012:       }
1013:     try
1014:       {
1015:         Locator l = new StandaloneLocator (lineNumber, columnNumber,
1016:                                            publicId, systemId);
1017:         errorHandler.error (new SAXParseException (message, l));
1018:       }
1019:     catch (Exception e)
1020:       {
1021:         if (e instanceof SAXException)
1022:           {
1023:             throw (SAXException) e;
1024:           }
1025:         else
1026:           {
1027:             throw new SAXException (e);
1028:           }
1029:       }
1030:   }
1031: 
1032:   private void fatalError (String message,
1033:                            int lineNumber, int columnNumber,
1034:                            String publicId, String systemId)
1035:     throws SAXException
1036:   {
1037:     if (seenFatalError || errorHandler == null)
1038:       {
1039:         return;
1040:       }
1041:     try
1042:       {
1043:         if (!seenStartDocument)
1044:           {
1045:             startDocument (false);
1046:           }
1047:         seenFatalError = true;
1048:         Locator l = new StandaloneLocator (lineNumber, columnNumber,
1049:                                            publicId, systemId);
1050:         errorHandler.fatalError (new SAXParseException (message, l));
1051:       }
1052:     catch (Exception e)
1053:       {
1054:         if (e instanceof SAXException)
1055:           {
1056:             throw (SAXException) e;
1057:           }
1058:         else
1059:           {
1060:             throw new SAXException (e);
1061:           }
1062:       }
1063:   }
1064: 
1065: }