sax/source/fastparser/fastparser.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: fastparser.cxx,v $
  10  * $Revision: 1.4.10.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 //#include <stdlib.h>
  32 //#include <sal/alloca.h>
  33
  34 #include <boost/scoped_ptr.hpp>
  35
  36 #include <osl/diagnose.h>
  37
  38 #include <com/sun/star/lang/DisposedException.hpp>
  39 #include <com/sun/star/xml/sax/XFastContextHandler.hpp>
  40 #include <com/sun/star/xml/sax/SAXParseException.hpp>
  41 #include <com/sun/star/xml/sax/FastToken.hpp>
  42
  43 #include "fastparser.hxx"
  44
  45 #include <string.h>
  46
  47 using ::rtl::OUString;
  48 using ::rtl::OString;
  49 using namespace ::std;
  50 using namespace ::osl;
  51 using namespace ::cppu;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::com::sun::star::lang;
  54 using namespace ::com::sun::star::xml::sax;
  55 //using namespace ::com::sun::star::util;
  56 using namespace ::com::sun::star::io;
  57 namespace sax_fastparser
  58 {
  59
  60 // --------------------------------------------------------------------
  61
  62 struct SaxContextImpl
  63 {
  64     Reference< XFastContextHandler >    mxContext;
  65     sal_uInt32          mnNamespaceCount;
  66     sal_Int32           mnElementToken;
  67     OUString            maNamespace;
  68     OUString            maElementName;
  69
  70     SaxContextImpl() { mnNamespaceCount = 0; mnElementToken = 0; }
  71     SaxContextImpl( const SaxContextImplPtr& p ) { mnNamespaceCount = p->mnNamespaceCount; mnElementToken = p->mnElementToken; maNamespace = p->maNamespace; }
  72 };
  73
  74 // --------------------------------------------------------------------
  75
  76 struct NamespaceDefine
  77 {
  78     OString             maPrefix;
  79     sal_Int32   mnToken;
  80     OUString    maNamespaceURL;
  81
  82     NamespaceDefine( const OString& rPrefix, sal_Int32 nToken, const OUString& rNamespaceURL ) : maPrefix( rPrefix ), mnToken( nToken ), maNamespaceURL( rNamespaceURL ) {}
  83 };
  84
  85 // --------------------------------------------------------------------
  86 // FastLocatorImpl
  87 // --------------------------------------------------------------------
  88
  89 class FastSaxParser;
  90
  91 class FastLocatorImpl : public WeakImplHelper1< XLocator >
  92 {
  93 public:
  94     FastLocatorImpl( FastSaxParser *p ) : mpParser(p) {}
  95
  96     void dispose() { mpParser = 0; }
  97     void checkDispose() throw (RuntimeException) { if( !mpParser ) throw DisposedException(); }
  98
  99     //XLocator
 100     virtual sal_Int32 SAL_CALL getColumnNumber(void) throw (RuntimeException);
 101     virtual sal_Int32 SAL_CALL getLineNumber(void) throw (RuntimeException);
 102     virtual OUString SAL_CALL getPublicId(void) throw (RuntimeException);
 103     virtual OUString SAL_CALL getSystemId(void) throw (RuntimeException);
 104
 105 private:
 106     FastSaxParser *mpParser;
 107 };
 108
 109 // --------------------------------------------------------------------
 110 // FastSaxParser
 111 // --------------------------------------------------------------------
 112
 113 //---------------------------------------------
 114 // the implementation part
 115 //---------------------------------------------
 116
 117 extern "C"
 118 {
 119     static void call_callbackStartElement(void *userData, const XML_Char *name , const XML_Char **atts)
 120     {
 121         FastSaxParser::callbackStartElement(userData,name,atts);
 122     }
 123     static void call_callbackEndElement(void *userData, const XML_Char *name)
 124     {
 125         FastSaxParser::callbackEndElement(userData,name);
 126     }
 127     static void call_callbackCharacters( void *userData , const XML_Char *s , int nLen )
 128     {
 129         FastSaxParser::callbackCharacters(userData,s,nLen);
 130     }
 131     static int call_callbackExternalEntityRef(XML_Parser parser,
 132                                               const XML_Char *openEntityNames,
 133                                               const XML_Char *base,
 134                                               const XML_Char *systemId,
 135                                               const XML_Char *publicId)
 136     {
 137         return FastSaxParser::callbackExternalEntityRef(parser,openEntityNames,base,systemId,publicId);
 138     }
 139 }
 140
 141 // --------------------------------------------------------------------
 142 // FastLocatorImpl implementation
 143 // --------------------------------------------------------------------
 144
 145 sal_Int32 SAL_CALL FastLocatorImpl::getColumnNumber(void) throw (RuntimeException)
 146 {
 147     checkDispose();
 148     return XML_GetCurrentColumnNumber( mpParser->getEntity().mpParser );
 149 }
 150
 151 // --------------------------------------------------------------------
 152
 153 sal_Int32 SAL_CALL FastLocatorImpl::getLineNumber(void) throw (RuntimeException)
 154 {
 155     checkDispose();
 156     return XML_GetCurrentLineNumber( mpParser->getEntity().mpParser );
 157 }
 158
 159 // --------------------------------------------------------------------
 160
 161 OUString SAL_CALL FastLocatorImpl::getPublicId(void) throw (RuntimeException)
 162 {
 163     checkDispose();
 164     return mpParser->getEntity().maStructSource.sPublicId;
 165 }
 166 // --------------------------------------------------------------------
 167
 168 OUString SAL_CALL FastLocatorImpl::getSystemId(void) throw (RuntimeException)
 169 {
 170     checkDispose();
 171     return mpParser->getEntity().maStructSource.sSystemId;
 172 }
 173
 174 // --------------------------------------------------------------------
 175 // FastSaxParser implementation
 176 // --------------------------------------------------------------------
 177
 178 FastSaxParser::FastSaxParser(  )
 179 {
 180     mxDocumentLocator.set( new FastLocatorImpl( this ) );
 181
 182     // performance-Improvment. Reference is needed when calling the startTag callback.
 183     // Handing out the same object with every call is allowed (see sax-specification)
 184     mxAttributes.set( new FastAttributeList( mxTokenHandler ) );
 185
 186     mbExceptionWasThrown = sal_False;
 187 }
 188
 189 // --------------------------------------------------------------------
 190
 191 FastSaxParser::~FastSaxParser()
 192 {
 193     if( mxDocumentLocator.is() )
 194         mxDocumentLocator->dispose();
 195 }
 196
 197 // --------------------------------------------------------------------
 198
 199 void FastSaxParser::pushContext()
 200 {
 201     bool bRootContext = false;
 202     SaxContextImplPtr p;
 203     if( maContextStack.empty() )
 204     {
 205         p.reset( new SaxContextImpl() );
 206         bRootContext = true;
 207     }
 208     else
 209     {
 210         p.reset( new SaxContextImpl( maContextStack.top() ) );
 211     }
 212     maContextStack.push( p );
 213
 214     if( bRootContext )
 215         DefineNamespace( OString("xml"), "http://www.w3.org/XML/1998/namespace");
 216 }
 217
 218 // --------------------------------------------------------------------
 219
 220 void FastSaxParser::popContext()
 221 {
 222     OSL_ENSURE( !maContextStack.empty(), "sax::FastSaxParser::popContext(), pop without push?" );
 223     if( !maContextStack.empty() )
 224         maContextStack.pop();
 225 }
 226
 227 // --------------------------------------------------------------------
 228
 229 void FastSaxParser::DefineNamespace( const OString& rPrefix, const sal_Char* pNamespaceURL )
 230 {
 231     OSL_ENSURE( !maContextStack.empty(), "sax::FastSaxParser::DefineNamespace(), I need a context!" );
 232     if( !maContextStack.empty() )
 233     {
 234         sal_uInt32 nOffset = maContextStack.top()->mnNamespaceCount++;
 235
 236         if( maNamespaceDefines.size() <= nOffset )
 237             maNamespaceDefines.resize( maNamespaceDefines.size() + 64 );
 238
 239         const OUString aNamespaceURL( pNamespaceURL, strlen( pNamespaceURL ), RTL_TEXTENCODING_UTF8 );
 240         maNamespaceDefines[nOffset].reset( new NamespaceDefine( rPrefix, GetNamespaceToken( aNamespaceURL ), aNamespaceURL ) );
 241     }
 242 }
 243
 244 // --------------------------------------------------------------------
 245
 246 sal_Int32 FastSaxParser::GetToken( const OString& rToken )
 247 {
 248     Sequence< sal_Int8 > aSeq( (sal_Int8*)rToken.getStr(), rToken.getLength() );
 249
 250     return mxTokenHandler->getTokenFromUTF8( aSeq );
 251 }
 252
 253 sal_Int32 FastSaxParser::GetToken( const sal_Char* pToken, sal_Int32 nLen /* = 0 */ )
 254 {
 255     if( !nLen )
 256         nLen = strlen( pToken );
 257
 258     Sequence< sal_Int8 > aSeq( (sal_Int8*)pToken, nLen );
 259
 260     return mxTokenHandler->getTokenFromUTF8( aSeq );
 261 }
 262
 263 // --------------------------------------------------------------------
 264
 265 sal_Int32 FastSaxParser::GetTokenWithPrefix( const OString& rPrefix, const OString& rName ) throw (SAXException)
 266 {
 267     sal_Int32 nNamespaceToken = FastToken::DONTKNOW;
 268
 269     sal_uInt32 nNamespace = maContextStack.top()->mnNamespaceCount;
 270     while( nNamespace-- )
 271     {
 272         if( maNamespaceDefines[nNamespace]->maPrefix == rPrefix )
 273         {
 274             nNamespaceToken = maNamespaceDefines[nNamespace]->mnToken;
 275             break;
 276         }
 277
 278         if( !nNamespace )
 279             throw SAXException(); // prefix that has no defined namespace url
 280     }
 281
 282     if( nNamespaceToken != FastToken::DONTKNOW )
 283     {
 284         sal_Int32 nNameToken = GetToken( rName.getStr(), rName.getLength() );
 285         if( nNameToken != FastToken::DONTKNOW )
 286             return nNamespaceToken | nNameToken;
 287     }
 288
 289     return FastToken::DONTKNOW;
 290 }
 291
 292 sal_Int32 FastSaxParser::GetTokenWithPrefix( const sal_Char*pPrefix, int nPrefixLen, const sal_Char* pName, int nNameLen ) throw (SAXException)
 293 {
 294     sal_Int32 nNamespaceToken = FastToken::DONTKNOW;
 295
 296     sal_uInt32 nNamespace = maContextStack.top()->mnNamespaceCount;
 297     while( nNamespace-- )
 298     {
 299         const OString& rPrefix( maNamespaceDefines[nNamespace]->maPrefix );
 300         if( (rPrefix.getLength() == nPrefixLen) &&
 301             (strncmp( rPrefix.getStr(), pPrefix, nPrefixLen ) == 0 ) )
 302         {
 303             nNamespaceToken = maNamespaceDefines[nNamespace]->mnToken;
 304             break;
 305         }
 306
 307         if( !nNamespace )
 308             throw SAXException(); // prefix that has no defined namespace url
 309     }
 310
 311     if( nNamespaceToken != FastToken::DONTKNOW )
 312     {
 313         sal_Int32 nNameToken = GetToken( pName, nNameLen );
 314         if( nNameToken != FastToken::DONTKNOW )
 315             return nNamespaceToken | nNameToken;
 316     }
 317
 318     return FastToken::DONTKNOW;
 319 }
 320
 321 // --------------------------------------------------------------------
 322
 323 sal_Int32 FastSaxParser::GetNamespaceToken( const OUString& rNamespaceURL )
 324 {
 325     NamespaceMap::iterator aIter( maNamespaceMap.find( rNamespaceURL ) );
 326     if( aIter != maNamespaceMap.end() )
 327         return (*aIter).second;
 328     else
 329         return FastToken::DONTKNOW;
 330 }
 331
 332 // --------------------------------------------------------------------
 333
 334 OUString FastSaxParser::GetNamespaceURL( const OString& rPrefix ) throw (SAXException)
 335 {
 336     if( !maContextStack.empty() )
 337     {
 338         sal_uInt32 nNamespace = maContextStack.top()->mnNamespaceCount;
 339         while( nNamespace-- )
 340             if( maNamespaceDefines[nNamespace]->maPrefix == rPrefix )
 341                 return maNamespaceDefines[nNamespace]->maNamespaceURL;
 342     }
 343
 344     throw SAXException(); // prefix that has no defined namespace url
 345 }
 346
 347 OUString FastSaxParser::GetNamespaceURL( const sal_Char*pPrefix, int nPrefixLen ) throw(SAXException)
 348 {
 349     if( pPrefix && !maContextStack.empty() )
 350     {
 351         sal_uInt32 nNamespace = maContextStack.top()->mnNamespaceCount;
 352         while( nNamespace-- )
 353         {
 354             const OString& rPrefix( maNamespaceDefines[nNamespace]->maPrefix );
 355             if( (rPrefix.getLength() == nPrefixLen) &&
 356                 (strncmp( rPrefix.getStr(), pPrefix, nPrefixLen ) == 0 ) )
 357             {
 358                 return maNamespaceDefines[nNamespace]->maNamespaceURL;
 359             }
 360         }
 361     }
 362
 363     throw SAXException(); // prefix that has no defined namespace url
 364 }
 365
 366 // --------------------------------------------------------------------
 367
 368 sal_Int32 FastSaxParser::GetTokenWithNamespaceURL( const OUString& rNamespaceURL, const sal_Char* pName, int nNameLen )
 369 {
 370     sal_Int32 nNamespaceToken = GetNamespaceToken( rNamespaceURL );
 371
 372     if( nNamespaceToken != FastToken::DONTKNOW )
 373     {
 374         sal_Int32 nNameToken = GetToken( pName, nNameLen );
 375         if( nNameToken != FastToken::DONTKNOW )
 376             return nNamespaceToken | nNameToken;
 377     }
 378
 379     return FastToken::DONTKNOW;
 380 }
 381
 382 // --------------------------------------------------------------------
 383
 384 void FastSaxParser::splitName( const XML_Char *pwName, const XML_Char *&rpPrefix, sal_Int32 &rPrefixLen, const XML_Char *&rpName, sal_Int32 &rNameLen )
 385 {
 386     XML_Char *p;
 387     for( p = const_cast< XML_Char* >( pwName ), rNameLen = 0, rPrefixLen = 0; *p; p++ )
 388     {
 389         if( *p == ':' )
 390         {
 391             rPrefixLen = p - pwName;
 392             rNameLen = 0;
 393         }
 394         else
 395         {
 396             rNameLen++;
 397         }
 398     }
 399     if( rPrefixLen )
 400     {
 401         rpPrefix = pwName;
 402         rpName = &pwName[ rPrefixLen + 1 ];
 403     }
 404     else
 405     {
 406         rpPrefix = 0;
 407         rpName = pwName;
 408     }
 409 }
 410
 411 /***************
 412 *
 413 * parseStream does Parser-startup initializations. The FastSaxParser::parse() method does
 414 * the file-specific initialization work. (During a parser run, external files may be opened)
 415 *
 416 ****************/
 417 void FastSaxParser::parseStream( const InputSource& maStructSource)     throw (SAXException, IOException, RuntimeException)
 418 {
 419     // Only one text at one time
 420     MutexGuard guard( maMutex );
 421
 422     struct Entity entity;
 423     entity.maStructSource = maStructSource;
 424
 425     if( ! entity.maStructSource.aInputStream.is() )
 426     {
 427         throw SAXException( OUString::createFromAscii( "No input source" ), Reference< XInterface > () , Any() );
 428     }
 429
 430     entity.maConverter.setInputStream( entity.maStructSource.aInputStream );
 431     if( entity.maStructSource.sEncoding.getLength() )
 432     {
 433         entity.maConverter.setEncoding( OUStringToOString( entity.maStructSource.sEncoding , RTL_TEXTENCODING_ASCII_US ) );
 434     }
 435
 436     // create parser with proper encoding
 437     entity.mpParser = XML_ParserCreate( 0 );
 438     if( ! entity.mpParser )
 439     {
 440         throw SAXException( OUString::createFromAscii( "Couldn't create parser" ), Reference< XInterface > (), Any() );
 441     }
 442
 443     // set all necessary C-Callbacks
 444     XML_SetUserData( entity.mpParser , this );
 445     XML_SetElementHandler(      entity.mpParser ,
 446                             call_callbackStartElement ,
 447                             call_callbackEndElement );
 448     XML_SetCharacterDataHandler( entity.mpParser , call_callbackCharacters );
 449     XML_SetExternalEntityRefHandler(    entity.mpParser,
 450                                         call_callbackExternalEntityRef);
 451
 452     maSavedException.clear();
 453     pushEntity( entity );
 454     try
 455     {
 456         // start the document
 457         if( mxDocumentHandler.is() )
 458         {
 459             Reference< XLocator > xLoc( mxDocumentLocator.get() );
 460             mxDocumentHandler->setDocumentLocator( xLoc );
 461             mxDocumentHandler->startDocument();
 462         }
 463
 464         parse();
 465
 466         // finish document
 467         if( mxDocumentHandler.is() )
 468         {
 469             mxDocumentHandler->endDocument();
 470         }
 471     }
 472     catch( SAXException & )
 473     {
 474         popEntity();
 475         XML_ParserFree( entity.mpParser );
 476           throw;
 477     }
 478     catch( IOException & )
 479     {
 480         popEntity();
 481         XML_ParserFree( entity.mpParser );
 482         throw;
 483     }
 484     catch( RuntimeException & )
 485     {
 486         popEntity();
 487         XML_ParserFree( entity.mpParser );
 488         throw;
 489     }
 490
 491     popEntity();
 492     XML_ParserFree( entity.mpParser );
 493 }
 494
 495 void FastSaxParser::setFastDocumentHandler( const Reference< XFastDocumentHandler >& Handler ) throw (RuntimeException)
 496 {
 497     mxDocumentHandler = Handler;
 498 }
 499
 500 void SAL_CALL FastSaxParser::setTokenHandler( const Reference< XFastTokenHandler >& Handler ) throw (RuntimeException)
 501 {
 502     mxTokenHandler = Handler;
 503     mxAttributes.set( new FastAttributeList( mxTokenHandler ) );
 504 }
 505
 506 void SAL_CALL FastSaxParser::registerNamespace( const OUString& NamespaceURL, sal_Int32 NamespaceToken ) throw (IllegalArgumentException, RuntimeException)
 507 {
 508     if( NamespaceToken >= FastToken::NAMESPACE )
 509     {
 510         if( GetNamespaceToken( NamespaceURL ) == FastToken::DONTKNOW )
 511         {
 512             maNamespaceMap[ NamespaceURL ] = NamespaceToken;
 513             return;
 514         }
 515     }
 516     throw IllegalArgumentException();
 517 }
 518
 519 void FastSaxParser::setErrorHandler(const Reference< XErrorHandler > & Handler) throw (RuntimeException)
 520 {
 521     mxErrorHandler = Handler;
 522 }
 523
 524 void FastSaxParser::setEntityResolver(const Reference < XEntityResolver > & Resolver) throw (RuntimeException)
 525 {
 526     mxEntityResolver = Resolver;
 527 }
 528
 529 void FastSaxParser::setLocale( const Locale & Locale ) throw (RuntimeException)
 530 {
 531     maLocale = Locale;
 532 }
 533
 534 Sequence< OUString > FastSaxParser::getSupportedServiceNames_Static(void)
 535 {
 536     Sequence<OUString> aRet(1);
 537     aRet.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(PARSER_SERVICE_NAME) );
 538     return aRet;
 539 }
 540
 541 // XServiceInfo
 542 OUString FastSaxParser::getImplementationName() throw (RuntimeException)
 543 {
 544     return OUString::createFromAscii( PARSER_IMPLEMENTATION_NAME );
 545 }
 546
 547 // XServiceInfo
 548 sal_Bool FastSaxParser::supportsService(const OUString& ServiceName) throw (RuntimeException)
 549 {
 550     Sequence< OUString > aSNL = getSupportedServiceNames();
 551     const OUString * pArray = aSNL.getConstArray();
 552
 553     for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 554         if( pArray[i] == ServiceName )
 555             return sal_True;
 556
 557     return sal_False;
 558 }
 559
 560 // XServiceInfo
 561 Sequence< OUString > FastSaxParser::getSupportedServiceNames(void) throw (RuntimeException)
 562 {
 563
 564     Sequence<OUString> seq(1);
 565     seq.getArray()[0] = OUString::createFromAscii( PARSER_SERVICE_NAME );
 566     return seq;
 567 }
 568
 569
 570 /*---------------------------------------
 571 *
 572 * Helper functions and classes
 573 *
 574 *-------------------------------------------*/
 575 OUString getErrorMessage( XML_Error xmlE, OUString sSystemId , sal_Int32 nLine )
 576 {
 577     OUString Message;
 578     if( XML_ERROR_NONE == xmlE ) {
 579         Message = OUString::createFromAscii( "No" );
 580     }
 581     else if( XML_ERROR_NO_MEMORY == xmlE ) {
 582         Message = OUString::createFromAscii( "no memory" );
 583     }
 584     else if( XML_ERROR_SYNTAX == xmlE ) {
 585         Message = OUString::createFromAscii( "syntax" );
 586     }
 587     else if( XML_ERROR_NO_ELEMENTS == xmlE ) {
 588         Message = OUString::createFromAscii( "no elements" );
 589     }
 590     else if( XML_ERROR_INVALID_TOKEN == xmlE ) {
 591         Message = OUString::createFromAscii( "invalid token" );
 592     }
 593     else if( XML_ERROR_UNCLOSED_TOKEN == xmlE ) {
 594         Message = OUString::createFromAscii( "unclosed token" );
 595     }
 596     else if( XML_ERROR_PARTIAL_CHAR == xmlE ) {
 597         Message = OUString::createFromAscii( "partial char" );
 598     }
 599     else if( XML_ERROR_TAG_MISMATCH == xmlE ) {
 600         Message = OUString::createFromAscii( "tag mismatch" );
 601     }
 602     else if( XML_ERROR_DUPLICATE_ATTRIBUTE == xmlE ) {
 603         Message = OUString::createFromAscii( "duplicate attribute" );
 604     }
 605     else if( XML_ERROR_JUNK_AFTER_DOC_ELEMENT == xmlE ) {
 606         Message = OUString::createFromAscii( "junk after doc element" );
 607     }
 608     else if( XML_ERROR_PARAM_ENTITY_REF == xmlE ) {
 609         Message = OUString::createFromAscii( "parameter entity reference" );
 610     }
 611     else if( XML_ERROR_UNDEFINED_ENTITY == xmlE ) {
 612         Message = OUString::createFromAscii( "undefined entity" );
 613     }
 614     else if( XML_ERROR_RECURSIVE_ENTITY_REF == xmlE ) {
 615         Message = OUString::createFromAscii( "recursive entity reference" );
 616     }
 617     else if( XML_ERROR_ASYNC_ENTITY == xmlE ) {
 618         Message = OUString::createFromAscii( "async entity" );
 619     }
 620     else if( XML_ERROR_BAD_CHAR_REF == xmlE ) {
 621         Message = OUString::createFromAscii( "bad char reference" );
 622     }
 623     else if( XML_ERROR_BINARY_ENTITY_REF == xmlE ) {
 624         Message = OUString::createFromAscii( "binary entity reference" );
 625     }
 626     else if( XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF == xmlE ) {
 627         Message = OUString::createFromAscii( "attribute external entity reference" );
 628     }
 629     else if( XML_ERROR_MISPLACED_XML_PI == xmlE ) {
 630         Message = OUString::createFromAscii( "misplaced xml processing instruction" );
 631     }
 632     else if( XML_ERROR_UNKNOWN_ENCODING == xmlE ) {
 633         Message = OUString::createFromAscii( "unknown encoding" );
 634     }
 635     else if( XML_ERROR_INCORRECT_ENCODING == xmlE ) {
 636         Message = OUString::createFromAscii( "incorrect encoding" );
 637     }
 638     else if( XML_ERROR_UNCLOSED_CDATA_SECTION == xmlE ) {
 639         Message = OUString::createFromAscii( "unclosed cdata section" );
 640     }
 641     else if( XML_ERROR_EXTERNAL_ENTITY_HANDLING == xmlE ) {
 642         Message = OUString::createFromAscii( "external entity reference" );
 643     }
 644     else if( XML_ERROR_NOT_STANDALONE == xmlE ) {
 645         Message = OUString::createFromAscii( "not standalone" );
 646     }
 647
 648     OUString str = OUString::createFromAscii( "[" );
 649     str += sSystemId;
 650     str += OUString::createFromAscii( " line " );
 651     str += OUString::valueOf( nLine );
 652     str += OUString::createFromAscii( "]: " );
 653     str += Message;
 654     str += OUString::createFromAscii( "error" );
 655
 656     return str;
 657 }
 658
 659
 660 // starts parsing with actual parser !
 661 void FastSaxParser::parse( )
 662 {
 663     const int nBufSize = 16*1024;
 664
 665     int nRead = nBufSize;
 666     Sequence< sal_Int8 > seqOut(nBufSize);
 667
 668     while( nRead )
 669     {
 670         nRead = getEntity().maConverter.readAndConvert( seqOut, nBufSize );
 671
 672         if( ! nRead )
 673         {
 674             XML_Parse( getEntity().mpParser, ( const char * ) seqOut.getArray(), 0 , 1 );
 675             break;
 676         }
 677
 678         sal_Bool bContinue = ( XML_Parse( getEntity().mpParser, (const char *) seqOut.getArray(), nRead, 0 ) != 0 );
 679
 680         if( !bContinue || mbExceptionWasThrown )
 681         {
 682             // Error during parsing !
 683             XML_Error xmlE = XML_GetErrorCode( getEntity().mpParser );
 684             OUString sSystemId = mxDocumentLocator->getSystemId();
 685             sal_Int32 nLine = mxDocumentLocator->getLineNumber();
 686
 687             SAXParseException aExcept(
 688                 getErrorMessage(xmlE , sSystemId, nLine) ,
 689                 Reference< XInterface >(),
 690                 Any( &maSavedException , getCppuType( &maSavedException) ),
 691                 mxDocumentLocator->getPublicId(),
 692                 mxDocumentLocator->getSystemId(),
 693                 mxDocumentLocator->getLineNumber(),
 694                 mxDocumentLocator->getColumnNumber()
 695                 );
 696
 697             if( mxErrorHandler.is() )
 698             {
 699                 // error handler is set, so the handler may throw the maSavedException
 700                 mxErrorHandler->fatalError( Any( aExcept ) );
 701             }
 702
 703             // Error handler has not thrown an maSavedException, but parsing cannot go on,
 704             // so an maSavedException MUST be thrown.
 705             throw aExcept;
 706         }
 707     }
 708 }
 709
 710 //------------------------------------------
 711 //
 712 // The C-Callbacks
 713 //
 714 //-----------------------------------------
 715
 716 namespace {
 717
 718 struct AttributeData
 719 {
 720     OString             maPrefix;
 721     OString             maName;
 722     OString             maValue;
 723 };
 724
 725 } // namespace
 726
 727 void FastSaxParser::callbackStartElement( void *pvThis, const XML_Char *pwName, const XML_Char **awAttributes )
 728 {
 729      FastSaxParser *pThis = (FastSaxParser*)pvThis;
 730
 731     Reference< XFastContextHandler > xParentContext;
 732     if( !pThis->maContextStack.empty() )
 733     {
 734         xParentContext = pThis->maContextStack.top()->mxContext;
 735         if( !xParentContext.is() )
 736         {
 737             // we ignore current elements, so no processing needed
 738             pThis->pushContext();
 739             return;
 740         }
 741     }
 742
 743     pThis->pushContext();
 744
 745     pThis->mxAttributes->clear();
 746
 747     // create attribute map and process namespace instructions
 748     int i = 0;
 749     sal_Int32 nNameLen, nPrefixLen;
 750     const XML_Char *pName;
 751     const XML_Char *pPrefix;
 752
 753     /*  #158414# Each element may define new namespaces, also for attribues.
 754         First, process all namespace attributes and cache other attributes in a
 755         vector. Second, process the attributes after namespaces have been
 756         initialized. */
 757     ::std::vector< AttributeData > aAttribs;
 758
 759     // #158414# first: get namespaces
 760     for( ; awAttributes[i]; i += 2 )
 761     {
 762         OSL_ASSERT( awAttributes[i+1] );
 763
 764         pThis->splitName( awAttributes[i], pPrefix, nPrefixLen, pName, nNameLen );
 765         if( nPrefixLen )
 766         {
 767             if( (nPrefixLen == 5) && (strncmp( pPrefix, "xmlns", 5 ) == 0) )
 768             {
 769                 pThis->DefineNamespace( OString( pName, nNameLen ), awAttributes[i+1] );
 770             }
 771             else
 772             {
 773                 aAttribs.resize( aAttribs.size() + 1 );
 774                 aAttribs.back().maPrefix = OString( pPrefix, nPrefixLen );
 775                 aAttribs.back().maName = OString( pName, nNameLen );
 776                 aAttribs.back().maValue = OString( awAttributes[i+1] );
 777             }
 778         }
 779         else
 780         {
 781             if( (nNameLen == 5) && (strcmp( pName, "xmlns" ) == 0) )
 782             {
 783                 // namespace of the element found
 784                 pThis->maContextStack.top()->maNamespace = OUString( awAttributes[i+1], strlen( awAttributes[i+1] ), RTL_TEXTENCODING_UTF8 );
 785             }
 786             else
 787             {
 788                 aAttribs.resize( aAttribs.size() + 1 );
 789                 aAttribs.back().maName = OString( pName, nNameLen );
 790                 aAttribs.back().maValue = OString( awAttributes[i+1] );
 791             }
 792         }
 793     }
 794
 795     // #158414# second: fill attribute list with other attributes
 796     for( ::std::vector< AttributeData >::const_iterator aIt = aAttribs.begin(), aEnd = aAttribs.end(); aIt != aEnd; ++aIt )
 797     {
 798         if( aIt->maPrefix.getLength() )
 799         {
 800             const sal_Int32 nAttributeToken = pThis->GetTokenWithPrefix( aIt->maPrefix, aIt->maName );
 801             if( nAttributeToken != FastToken::DONTKNOW )
 802                 pThis->mxAttributes->add( nAttributeToken, aIt->maValue );
 803             else
 804                 pThis->mxAttributes->addUnknown( pThis->GetNamespaceURL( aIt->maPrefix ), aIt->maName, aIt->maValue );
 805         }
 806         else
 807         {
 808             const sal_Int32 nAttributeToken = pThis->GetToken( aIt->maName );
 809             if( nAttributeToken != FastToken::DONTKNOW )
 810                 pThis->mxAttributes->add( nAttributeToken, aIt->maValue );
 811             else
 812                 pThis->mxAttributes->addUnknown( aIt->maName, aIt->maValue );
 813         }
 814     }
 815
 816     sal_Int32 nElementToken;
 817     pThis->splitName( pwName, pPrefix, nPrefixLen, pName, nNameLen );
 818     if( nPrefixLen )
 819     {
 820         nElementToken = pThis->GetTokenWithPrefix( pPrefix, nPrefixLen, pName, nNameLen );
 821     }
 822     else if( pThis->maContextStack.top()->maNamespace.getLength() )
 823     {
 824         nElementToken = pThis->GetTokenWithNamespaceURL( pThis->maContextStack.top()->maNamespace, pName, nNameLen );
 825     }
 826     else
 827     {
 828         nElementToken = pThis->GetToken( pName );
 829     }
 830     pThis->maContextStack.top()->mnElementToken = nElementToken;
 831
 832     try
 833     {
 834         Reference< XFastAttributeList > xAttr( pThis->mxAttributes.get() );
 835         Reference< XFastContextHandler > xContext;
 836         if( nElementToken == FastToken::DONTKNOW )
 837         {
 838             if( nPrefixLen )
 839             {
 840                 pThis->maContextStack.top()->maNamespace = pThis->GetNamespaceURL( pPrefix, nPrefixLen );
 841             }
 842
 843             const OUString aNamespace( pThis->maContextStack.top()->maNamespace );
 844             const OUString aElementName( pPrefix, nPrefixLen, RTL_TEXTENCODING_UTF8 );
 845             pThis->maContextStack.top()->maElementName = aElementName;
 846
 847             if( xParentContext.is() )
 848                 xContext = xParentContext->createUnknownChildContext( aNamespace, aElementName, xAttr );
 849             else
 850                 xContext = pThis->mxDocumentHandler->createUnknownChildContext( aNamespace, aElementName, xAttr );
 851
 852             if( xContext.is() )
 853             {
 854                 pThis->maContextStack.top()->mxContext = xContext;
 855                 xContext->startUnknownElement( aNamespace, aElementName, xAttr );
 856             }
 857         }
 858         else
 859         {
 860             if( xParentContext.is() )
 861                 xContext = xParentContext->createFastChildContext( nElementToken, xAttr );
 862             else
 863                 xContext = pThis->mxDocumentHandler->createFastChildContext( nElementToken, xAttr );
 864
 865
 866             if( xContext.is() )
 867             {
 868                 pThis->maContextStack.top()->mxContext = xContext;
 869                 xContext->startFastElement( nElementToken, xAttr );
 870             }
 871         }
 872     }
 873     catch( Exception& e )
 874     {
 875         pThis->maSavedException <<= e;
 876     }
 877 }
 878
 879 void FastSaxParser::callbackEndElement( void *pvThis , const XML_Char *  )
 880 {
 881     FastSaxParser *pThis = (FastSaxParser*)pvThis;
 882
 883     if( !pThis->maContextStack.empty() )
 884     {
 885         SaxContextImplPtr pContext( pThis->maContextStack.top() );
 886         const Reference< XFastContextHandler >& xContext( pContext->mxContext );
 887         if( xContext.is() ) try
 888         {
 889             sal_Int32 nElementToken = pContext->mnElementToken;
 890             if( nElementToken != FastToken::DONTKNOW )
 891             {
 892                 xContext->endFastElement( nElementToken );
 893             }
 894             else
 895             {
 896                 xContext->endUnknownElement( pContext->maNamespace, pContext->maElementName );
 897             }
 898         }
 899         catch( Exception& e )
 900         {
 901             pThis->maSavedException <<= e;
 902         }
 903
 904         pThis->popContext();
 905     }
 906     else
 907     {
 908         OSL_ENSURE( false, "no context on sax::FastSaxParser::callbackEndElement() ??? ");
 909     }
 910 }
 911
 912
 913 void FastSaxParser::callbackCharacters( void *pvThis , const XML_Char *s , int nLen )
 914 {
 915     FastSaxParser *pThis = (FastSaxParser*)pvThis;
 916
 917     const Reference< XFastContextHandler >& xContext( pThis->maContextStack.top()->mxContext );
 918     if( xContext.is() ) try
 919     {
 920         xContext->characters( OUString( s, nLen, RTL_TEXTENCODING_UTF8 ) );
 921     }
 922     catch( Exception& e )
 923     {
 924         pThis->maSavedException <<= e;
 925     }
 926 }
 927
 928 int FastSaxParser::callbackExternalEntityRef( XML_Parser parser,
 929                                                     const XML_Char *context,
 930                                                     const XML_Char * /*base*/,
 931                                                     const XML_Char *systemId,
 932                                                     const XML_Char *publicId)
 933 {
 934     bool bOK = true;
 935     InputSource source;
 936     FastSaxParser *pImpl = ((FastSaxParser*)XML_GetUserData( parser ));
 937
 938     struct Entity entity;
 939
 940     if( pImpl->mxEntityResolver.is() ) {
 941         try
 942         {
 943             entity.maStructSource = pImpl->mxEntityResolver->resolveEntity(
 944                 OUString( publicId, strlen( publicId ), RTL_TEXTENCODING_UTF8 ) ,
 945                 OUString( systemId, strlen( systemId ), RTL_TEXTENCODING_UTF8 ) );
 946         }
 947         catch( SAXParseException & e )
 948         {
 949             pImpl->maSavedException <<= e;
 950             bOK = false;
 951         }
 952         catch( SAXException & e )
 953         {
 954             pImpl->maSavedException <<= SAXParseException(
 955                 e.Message , e.Context , e.WrappedException ,
 956                 pImpl->mxDocumentLocator->getPublicId(),
 957                 pImpl->mxDocumentLocator->getSystemId(),
 958                 pImpl->mxDocumentLocator->getLineNumber(),
 959                 pImpl->mxDocumentLocator->getColumnNumber() );
 960             bOK = false;
 961         }
 962     }
 963
 964     if( entity.maStructSource.aInputStream.is() )
 965     {
 966         entity.mpParser = XML_ExternalEntityParserCreate( parser , context, 0 );
 967         if( ! entity.mpParser )
 968         {
 969             return false;
 970         }
 971
 972         entity.maConverter.setInputStream( entity.maStructSource.aInputStream );
 973         pImpl->pushEntity( entity );
 974         try
 975         {
 976             pImpl->parse();
 977         }
 978         catch( SAXParseException & e )
 979         {
 980             pImpl->maSavedException <<= e;
 981             bOK = false;
 982         }
 983         catch( IOException &e )
 984         {
 985             SAXException aEx;
 986             aEx.WrappedException <<= e;
 987             pImpl->maSavedException <<= aEx;
 988             bOK = false;
 989         }
 990         catch( RuntimeException &e )
 991         {
 992             SAXException aEx;
 993             aEx.WrappedException <<= e;
 994             pImpl->maSavedException <<= aEx;
 995             bOK = false;
 996         }
 997
 998         pImpl->popEntity();
 999
1000         XML_ParserFree( entity.mpParser );
1001     }
1002
1003     return bOK;
1004 }
1005
1006 }