sax/source/tools/fastserializer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 #include "fastserializer.hxx"
  29 #include <rtl/ustrbuf.hxx>
  30
  31 #include <com/sun/star/xml/Attribute.hpp>
  32 #include <com/sun/star/xml/FastAttribute.hpp>
  33 #include <com/sun/star/xml/sax/XFastAttributeList.hpp>
  34
  35 #include <string.h>
  36
  37 using ::rtl::OString;
  38 using ::rtl::OUString;
  39 using ::rtl::OUStringBuffer;
  40 using ::rtl::OUStringToOString;
  41 using ::com::sun::star::uno::Reference;
  42 using ::com::sun::star::uno::RuntimeException;
  43 using ::com::sun::star::uno::Sequence;
  44 using ::com::sun::star::xml::FastAttribute;
  45 using ::com::sun::star::xml::Attribute;
  46 using ::com::sun::star::xml::sax::SAXException;
  47 using ::com::sun::star::xml::sax::XFastAttributeList;
  48 using ::com::sun::star::xml::sax::XFastTokenHandler;
  49 using ::com::sun::star::xml::sax::XFastSerializer;
  50 using ::com::sun::star::io::XOutputStream;
  51 using ::com::sun::star::io::NotConnectedException;
  52 using ::com::sun::star::io::IOException;
  53 using ::com::sun::star::io::BufferSizeExceededException;
  54
  55 static Sequence< sal_Int8 > aClosingBracket((sal_Int8 *)">", 1);
  56 static Sequence< sal_Int8 > aSlashAndClosingBracket((sal_Int8 *)"/>", 2);
  57 static Sequence< sal_Int8 > aColon((sal_Int8 *)":", 1);
  58 static Sequence< sal_Int8 > aOpeningBracket((sal_Int8 *)"<", 1);
  59 static Sequence< sal_Int8 > aOpeningBracketAndSlash((sal_Int8 *)"</", 2);
  60 static Sequence< sal_Int8 > aQuote((sal_Int8 *)"\"", 1);
  61 static Sequence< sal_Int8 > aEqualSignAndQuote((sal_Int8 *)"=\"", 2);
  62 static Sequence< sal_Int8 > aSpace((sal_Int8 *)" ", 1);
  63 static Sequence< sal_Int8 > aXmlHeader((sal_Int8*) "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n", 56);
  64
  65 #define HAS_NAMESPACE(x) ((x & 0xffff0000) != 0)
  66 #define NAMESPACE(x) (x >> 16)
  67 #define TOKEN(x) (x & 0xffff)
  68
  69 namespace sax_fastparser {
  70     FastSaxSerializer::FastSaxSerializer( ) : mxOutputStream(), mxFastTokenHandler(), maMarkStack() {}
  71     FastSaxSerializer::~FastSaxSerializer() {}
  72
  73     void SAL_CALL FastSaxSerializer::startDocument(  ) throw (SAXException, RuntimeException)
  74     {
  75         if (!mxOutputStream.is())
  76             return;
  77         writeBytes(aXmlHeader);
  78     }
  79
  80     OUString FastSaxSerializer::escapeXml( const OUString& s )
  81     {
  82         ::rtl::OUStringBuffer sBuf( s.getLength() );
  83         const sal_Unicode* pStr = s;
  84         sal_Int32 nLen = s.getLength();
  85         for( sal_Int32 i = 0; i < nLen; ++i)
  86         {
  87             sal_Unicode c = pStr[ i ];
  88             switch( c )
  89             {
  90                 case '<':   sBuf.appendAscii( "&lt;" );     break;
  91                 case '>':   sBuf.appendAscii( "&gt;" );     break;
  92                 case '&':   sBuf.appendAscii( "&amp;" );    break;
  93                 case '\'':  sBuf.appendAscii( "&apos;" );   break;
  94                 case '"':   sBuf.appendAscii( "&quot;" );   break;
  95                 default:    sBuf.append( c );               break;
  96             }
  97         }
  98         return sBuf.makeStringAndClear();
  99     }
 100
 101     void FastSaxSerializer::write( const OUString& s )
 102     {
 103         OString sOutput( OUStringToOString( s, RTL_TEXTENCODING_UTF8 ) );
 104         writeBytes( Sequence< sal_Int8 >(
 105                     reinterpret_cast< const sal_Int8*>( sOutput.getStr() ),
 106                     sOutput.getLength() ) );
 107     }
 108
 109     void SAL_CALL FastSaxSerializer::endDocument(  ) throw (SAXException, RuntimeException)
 110     {
 111         if (!mxOutputStream.is())
 112             return;
 113     }
 114
 115     void SAL_CALL FastSaxSerializer::writeId( ::sal_Int32 nElement )
 116     {
 117         if( HAS_NAMESPACE( nElement ) ) {
 118             writeBytes(mxFastTokenHandler->getUTF8Identifier(NAMESPACE(nElement)));
 119             writeBytes(aColon);
 120             writeBytes(mxFastTokenHandler->getUTF8Identifier(TOKEN(nElement)));
 121         } else
 122             writeBytes(mxFastTokenHandler->getUTF8Identifier(nElement));
 123     }
 124
 125     void SAL_CALL FastSaxSerializer::startFastElement( ::sal_Int32 Element, const Reference< XFastAttributeList >& Attribs )
 126         throw (SAXException, RuntimeException)
 127     {
 128         if (!mxOutputStream.is())
 129             return;
 130
 131         writeBytes(aOpeningBracket);
 132
 133         writeId(Element);
 134         writeFastAttributeList(Attribs);
 135
 136         writeBytes(aClosingBracket);
 137     }
 138
 139     void SAL_CALL FastSaxSerializer::startUnknownElement( const OUString& Namespace, const OUString& Name, const Reference< XFastAttributeList >& Attribs )
 140         throw (SAXException, RuntimeException)
 141     {
 142         if (!mxOutputStream.is())
 143             return;
 144
 145         writeBytes(aOpeningBracket);
 146
 147         if (Namespace.getLength())
 148         {
 149             write(Namespace);
 150             writeBytes(aColon);
 151         }
 152
 153         write(Name);
 154
 155         writeFastAttributeList(Attribs);
 156
 157         writeBytes(aClosingBracket);
 158     }
 159
 160     void SAL_CALL FastSaxSerializer::endFastElement( ::sal_Int32 Element )
 161         throw (SAXException, RuntimeException)
 162     {
 163         if (!mxOutputStream.is())
 164             return;
 165
 166         writeBytes(aOpeningBracketAndSlash);
 167
 168         writeId(Element);
 169
 170         writeBytes(aClosingBracket);
 171     }
 172
 173     void SAL_CALL FastSaxSerializer::endUnknownElement( const OUString& Namespace, const OUString& Name )
 174         throw (SAXException, RuntimeException)
 175     {
 176         if (!mxOutputStream.is())
 177             return;
 178
 179         writeBytes(aOpeningBracketAndSlash);
 180
 181         if (Namespace.getLength())
 182         {
 183             write(Namespace);
 184             writeBytes(aColon);
 185         }
 186
 187         write(Name);
 188
 189         writeBytes(aClosingBracket);
 190     }
 191
 192     void SAL_CALL FastSaxSerializer::singleFastElement( ::sal_Int32 Element, const Reference< XFastAttributeList >& Attribs )
 193         throw (SAXException, RuntimeException)
 194     {
 195         if (!mxOutputStream.is())
 196             return;
 197
 198         writeBytes(aOpeningBracket);
 199
 200         writeId(Element);
 201         writeFastAttributeList(Attribs);
 202
 203         writeBytes(aSlashAndClosingBracket);
 204     }
 205
 206     void SAL_CALL FastSaxSerializer::singleUnknownElement( const OUString& Namespace, const OUString& Name, const Reference< XFastAttributeList >& Attribs )
 207         throw (SAXException, RuntimeException)
 208     {
 209         if (!mxOutputStream.is())
 210             return;
 211
 212         writeBytes(aOpeningBracket);
 213
 214         if (Namespace.getLength())
 215         {
 216             write(Namespace);
 217             writeBytes(aColon);
 218         }
 219
 220         write(Name);
 221
 222         writeFastAttributeList(Attribs);
 223
 224         writeBytes(aSlashAndClosingBracket);
 225     }
 226
 227     void SAL_CALL FastSaxSerializer::characters( const OUString& aChars )
 228         throw (SAXException, RuntimeException)
 229     {
 230         if (!mxOutputStream.is())
 231             return;
 232
 233         write( aChars );
 234     }
 235
 236     void SAL_CALL FastSaxSerializer::setOutputStream( const ::com::sun::star::uno::Reference< ::com::sun::star::io::XOutputStream >& xOutputStream )
 237         throw (::com::sun::star::uno::RuntimeException)
 238     {
 239         mxOutputStream = xOutputStream;
 240     }
 241
 242     void SAL_CALL FastSaxSerializer::setFastTokenHandler( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastTokenHandler >& xFastTokenHandler )
 243         throw (::com::sun::star::uno::RuntimeException)
 244     {
 245         mxFastTokenHandler = xFastTokenHandler;
 246     }
 247     void FastSaxSerializer::writeFastAttributeList( const Reference< XFastAttributeList >& Attribs )
 248     {
 249         Sequence< Attribute > aAttrSeq = Attribs->getUnknownAttributes();
 250         const Attribute *pAttr = aAttrSeq.getConstArray();
 251         sal_Int32 nAttrLength = aAttrSeq.getLength();
 252         for (sal_Int32 i = 0; i < nAttrLength; i++)
 253         {
 254             writeBytes(aSpace);
 255
 256             write(pAttr[i].Name);
 257             writeBytes(aEqualSignAndQuote);
 258             write(escapeXml(pAttr[i].Value));
 259             writeBytes(aQuote);
 260         }
 261
 262         Sequence< FastAttribute > aFastAttrSeq = Attribs->getFastAttributes();
 263         const FastAttribute *pFastAttr = aFastAttrSeq.getConstArray();
 264         sal_Int32 nFastAttrLength = aFastAttrSeq.getLength();
 265         for (sal_Int32 j = 0; j < nFastAttrLength; j++)
 266         {
 267             writeBytes(aSpace);
 268
 269             sal_Int32 nToken = pFastAttr[j].Token;
 270             writeId(nToken);
 271
 272             writeBytes(aEqualSignAndQuote);
 273
 274             write(escapeXml(Attribs->getValue(pFastAttr[j].Token)));
 275
 276             writeBytes(aQuote);
 277         }
 278     }
 279
 280     // XServiceInfo
 281     OUString FastSaxSerializer::getImplementationName() throw (RuntimeException)
 282     {
 283         return OUString::createFromAscii( SERIALIZER_IMPLEMENTATION_NAME );
 284     }
 285
 286     // XServiceInfo
 287     sal_Bool FastSaxSerializer::supportsService(const OUString& ServiceName) throw (RuntimeException)
 288     {
 289         Sequence< OUString > aSNL = getSupportedServiceNames();
 290         const OUString * pArray = aSNL.getConstArray();
 291
 292         for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
 293         if( pArray[i] == ServiceName )
 294             return sal_True;
 295
 296         return sal_False;
 297     }
 298
 299     // XServiceInfo
 300     Sequence< OUString > FastSaxSerializer::getSupportedServiceNames(void) throw (RuntimeException)
 301     {
 302         Sequence<OUString> seq(1);
 303         seq.getArray()[0] = OUString::createFromAscii( SERIALIZER_SERVICE_NAME );
 304         return seq;
 305     }
 306
 307     OUString FastSaxSerializer::getImplementationName_Static()
 308     {
 309         return OUString::createFromAscii( SERIALIZER_IMPLEMENTATION_NAME );
 310     }
 311
 312     Sequence< OUString > FastSaxSerializer::getSupportedServiceNames_Static(void)
 313     {
 314         Sequence<OUString> aRet(1);
 315         aRet.getArray()[0] = OUString( RTL_CONSTASCII_USTRINGPARAM(SERIALIZER_SERVICE_NAME) );
 316         return aRet;
 317     }
 318
 319     void FastSaxSerializer::mark()
 320     {
 321         maMarkStack.push( ForMerge() );
 322     }
 323
 324     void FastSaxSerializer::mergeTopMarks( sax_fastparser::MergeMarksEnum eMergeType )
 325     {
 326         if ( maMarkStack.empty() )
 327             return;
 328
 329         if ( maMarkStack.size() == 1 )
 330         {
 331             mxOutputStream->writeBytes( maMarkStack.top().getData() );
 332             maMarkStack.pop();
 333             return;
 334         }
 335
 336         const Int8Sequence aMerge( maMarkStack.top().getData() );
 337         maMarkStack.pop();
 338
 339         switch ( eMergeType )
 340         {
 341             case MERGE_MARKS_APPEND:   maMarkStack.top().append( aMerge );   break;
 342             case MERGE_MARKS_PREPEND:  maMarkStack.top().prepend( aMerge );  break;
 343             case MERGE_MARKS_POSTPONE: maMarkStack.top().postpone( aMerge ); break;
 344         }
 345     }
 346
 347     void FastSaxSerializer::writeBytes( const Sequence< ::sal_Int8 >& aData ) throw ( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException )
 348     {
 349         if ( maMarkStack.empty() )
 350             mxOutputStream->writeBytes( aData );
 351         else
 352             maMarkStack.top().append( aData );
 353     }
 354
 355     FastSaxSerializer::Int8Sequence& FastSaxSerializer::ForMerge::getData()
 356     {
 357         merge( maData, maPostponed, true );
 358         maPostponed.realloc( 0 );
 359
 360         return maData;
 361     }
 362
 363     void FastSaxSerializer::ForMerge::prepend( const Int8Sequence &rWhat )
 364     {
 365         merge( maData, rWhat, false );
 366     }
 367
 368     void FastSaxSerializer::ForMerge::append( const Int8Sequence &rWhat )
 369     {
 370         merge( maData, rWhat, true );
 371     }
 372
 373     void FastSaxSerializer::ForMerge::postpone( const Int8Sequence &rWhat )
 374     {
 375         merge( maPostponed, rWhat, true );
 376     }
 377
 378     void FastSaxSerializer::ForMerge::merge( Int8Sequence &rTop, const Int8Sequence &rMerge, bool bAppend )
 379     {
 380         sal_Int32 nMergeLen = rMerge.getLength();
 381         if ( nMergeLen > 0 )
 382         {
 383             sal_Int32 nTopLen = rTop.getLength();
 384
 385             rTop.realloc( nTopLen + nMergeLen );
 386             if ( bAppend )
 387             {
 388                 // append the rMerge to the rTop
 389                 memcpy( rTop.getArray() + nTopLen, rMerge.getConstArray(), nMergeLen );
 390             }
 391             else
 392             {
 393                 // prepend the rMerge to the rTop
 394                 memmove( rTop.getArray() + nMergeLen, rTop.getConstArray(), nTopLen );
 395                 memcpy( rTop.getArray(), rMerge.getConstArray(), nMergeLen );
 396             }
 397         }
 398     }
 399
 400 } // namespace sax_fastparser
 401