xmloff/source/core/nmspmap.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <rtl/ustring.hxx>
  23 #include <rtl/ustrbuf.hxx>
  24
  25 #include <xmloff/xmltoken.hxx>
  26 #include <xmloff/nmspmap.hxx>
  27
  28 #include <xmloff/xmlnmspe.hxx>
  29
  30
  31 using namespace ::xmloff::token;
  32
  33 /* The basic idea of this class is that we have two two ways to search our
  34  * data...by prefix and by key. We use an unordered_map for fast prefix
  35  * searching and an STL map for fast key searching.
  36  *
  37  * The references to an 'Index' refer to an earlier implementation of the
  38  * name space map and remain to support code which uses these interfaces.
  39  *
  40  * In this implementation, key and index should always be the same number.
  41  *
  42  * All references to Indices are now deprecated and the corresponding
  43  * 'Key' methods should be used instead
  44  *
  45  * Martin 13/06/01
  46  */
  47
  48 SvXMLNamespaceMap::SvXMLNamespaceMap()
  49 : sXMLNS( GetXMLToken ( XML_XMLNS ) )
  50 {
  51 }
  52
  53 SvXMLNamespaceMap::SvXMLNamespaceMap( const SvXMLNamespaceMap& rMap )
  54 : sXMLNS( GetXMLToken ( XML_XMLNS ) )
  55 {
  56     aNameHash = rMap.aNameHash;
  57     aNameMap  = rMap.aNameMap;
  58 }
  59
  60 SvXMLNamespaceMap& SvXMLNamespaceMap::operator=( const SvXMLNamespaceMap& rMap )
  61 {
  62     aNameHash = rMap.aNameHash;
  63     aNameMap = rMap.aNameMap;
  64     return *this;
  65 }
  66
  67 SvXMLNamespaceMap::~SvXMLNamespaceMap()
  68 {
  69 }
  70
  71 bool SvXMLNamespaceMap::operator ==( const SvXMLNamespaceMap& rCmp ) const
  72 {
  73     return aNameHash == rCmp.aNameHash;
  74 }
  75
  76 sal_uInt16 SvXMLNamespaceMap::Add_( const OUString& rPrefix, const OUString &rName, sal_uInt16 nKey )
  77 {
  78     if( XML_NAMESPACE_UNKNOWN == nKey )
  79     {
  80         // create a new unique key with UNKNOWN flag set
  81         nKey = XML_NAMESPACE_UNKNOWN_FLAG;
  82         do
  83         {
  84             NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
  85             if( aIter == aNameMap.end() )
  86                 break;
  87             nKey++;
  88         }
  89         while ( true );
  90     }
  91     ::rtl::Reference<NameSpaceEntry> pEntry(new NameSpaceEntry);
  92     pEntry->sName   = rName;
  93     pEntry->nKey    = nKey;
  94     pEntry->sPrefix = rPrefix;
  95     aNameHash[ rPrefix ] = pEntry;
  96     aNameMap [ nKey ]    = pEntry;
  97     return nKey;
  98 }
  99
 100 sal_uInt16 SvXMLNamespaceMap::Add( const OUString& rPrefix, const OUString& rName,
 101                                sal_uInt16 nKey )
 102 {
 103     if( XML_NAMESPACE_UNKNOWN == nKey )
 104         nKey = GetKeyByName( rName );
 105
 106 #ifdef NDEBUG
 107     if( XML_NAMESPACE_NONE == nKey )
 108         return USHRT_MAX;
 109 #else
 110     assert(XML_NAMESPACE_NONE != nKey);
 111 #endif
 112
 113     if ( aNameHash.find ( rPrefix ) == aNameHash.end() )
 114         nKey = Add_( rPrefix, rName, nKey );
 115
 116     return nKey;
 117 }
 118
 119 sal_uInt16 SvXMLNamespaceMap::AddIfKnown( const OUString& rPrefix, const OUString& rName )
 120 {
 121     sal_uInt16 nKey = GetKeyByName( rName );
 122
 123 #ifdef NDEBUG
 124     if( XML_NAMESPACE_NONE == nKey )
 125         return XML_NAMESPACE_UNKNOWN;
 126 #else
 127     assert(nKey != XML_NAMESPACE_NONE);
 128 #endif
 129
 130     if( XML_NAMESPACE_UNKNOWN != nKey )
 131     {
 132         NameSpaceHash::const_iterator aIter = aNameHash.find( rPrefix );
 133         if( aIter == aNameHash.end() || (*aIter).second->sName != rName )
 134             nKey = Add_( rPrefix, rName, nKey );
 135     }
 136
 137     return nKey;
 138 }
 139
 140
 141 sal_uInt16 SvXMLNamespaceMap::GetKeyByPrefix( const OUString& rPrefix ) const
 142 {
 143     NameSpaceHash::const_iterator aIter = aNameHash.find(rPrefix);
 144     return (aIter != aNameHash.end()) ? (*aIter).second->nKey : USHRT_MAX;
 145 }
 146
 147 sal_uInt16 SvXMLNamespaceMap::GetKeyByName( const OUString& rName ) const
 148 {
 149     sal_uInt16 nKey = XML_NAMESPACE_UNKNOWN;
 150     NameSpaceHash::const_iterator aIter = aNameHash.begin(), aEnd = aNameHash.end();
 151     while (aIter != aEnd )
 152     {
 153         if ((*aIter).second->sName == rName)
 154         {
 155             nKey = (*aIter).second->nKey;
 156             break;
 157         }
 158         ++aIter;
 159     }
 160     return nKey;
 161 }
 162
 163 const OUString& SvXMLNamespaceMap::GetPrefixByKey( sal_uInt16 nKey ) const
 164 {
 165     NameSpaceMap::const_iterator aIter = aNameMap.find (nKey);
 166     return (aIter != aNameMap.end()) ? (*aIter).second->sPrefix : sEmpty;
 167 }
 168
 169 const OUString& SvXMLNamespaceMap::GetNameByKey( sal_uInt16 nKey ) const
 170 {
 171     NameSpaceMap::const_iterator aIter = aNameMap.find (nKey);
 172     return (aIter != aNameMap.end()) ? (*aIter).second->sName : sEmpty;
 173 }
 174
 175 OUString SvXMLNamespaceMap::GetAttrNameByKey( sal_uInt16 nKey ) const
 176 {
 177     OUStringBuffer sAttrName;
 178     NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
 179     if (aIter != aNameMap.end())
 180     {
 181         sAttrName.append( sXMLNS  );
 182         const OUString & prefix( (*aIter).second->sPrefix );
 183         if (!prefix.isEmpty()) // not default namespace
 184         {
 185             sAttrName.append( ':' );
 186             sAttrName.append( prefix );
 187         }
 188     }
 189     return sAttrName.makeStringAndClear();
 190 }
 191
 192 OUString SvXMLNamespaceMap::GetQNameByKey( sal_uInt16 nKey,
 193                             const OUString& rLocalName,
 194                             bool bCache) const
 195 {
 196     // We always want to return at least the rLocalName...
 197
 198     switch ( nKey )
 199     {
 200         case XML_NAMESPACE_UNKNOWN:
 201             // ...if it's a completely unknown namespace, assert and return the local name
 202             SAL_WARN("xmloff.core", "unknown namespace, probable missing xmlns: declaration");
 203             SAL_FALLTHROUGH;
 204         case XML_NAMESPACE_NONE:
 205             // ...if there isn't one, return the local name
 206             return rLocalName;
 207         case XML_NAMESPACE_XMLNS:
 208         {
 209             // ...if it's in the xmlns namespace, make the prefix
 210             // don't bother caching this, it rarely happens
 211             OUStringBuffer sQName;
 212             sQName.append ( sXMLNS );
 213             if (!rLocalName.isEmpty()) // not default namespace
 214             {
 215                 sQName.append ( ':' );
 216                 sQName.append ( rLocalName );
 217             }
 218             return sQName.makeStringAndClear();
 219         }
 220         case XML_NAMESPACE_XML:
 221         {
 222             // this namespace is reserved, and needs not to be declared
 223             OUStringBuffer sQName;
 224             sQName.append ( GetXMLToken(XML_XML) );
 225             sQName.append ( ':' );
 226             sQName.append ( rLocalName );
 227             return sQName.makeStringAndClear();
 228         }
 229         default:
 230         {
 231             QNameCache::const_iterator aQCacheIter;
 232             if (bCache)
 233                 aQCacheIter = aQNameCache.find ( QNamePair ( nKey, rLocalName ) );
 234             else
 235                 aQCacheIter = aQNameCache.end();
 236             if ( aQCacheIter != aQNameCache.end() )
 237                 return (*aQCacheIter).second;
 238             else
 239             {
 240                 NameSpaceMap::const_iterator aIter = aNameMap.find ( nKey );
 241                 if ( aIter != aNameMap.end() )
 242                 {
 243                     OUStringBuffer sQName;
 244                     // ...if it's in our map, make the prefix
 245                     const OUString & prefix( (*aIter).second->sPrefix );
 246                     if (!prefix.isEmpty()) // not default namespace
 247                     {
 248                         sQName.append( prefix );
 249                         sQName.append( ':' );
 250                     }
 251                     sQName.append ( rLocalName );
 252                     if (bCache)
 253                     {
 254                         OUString sString(sQName.makeStringAndClear());
 255                         aQNameCache.insert(
 256                             QNameCache::value_type(
 257                                 QNamePair(nKey, rLocalName), sString));
 258                         return sString;
 259                     }
 260                     else
 261                         return sQName.makeStringAndClear();
 262                 }
 263                 else
 264                 {
 265                     // ... if it isn't, this is a Bad Thing, assert and return the local name
 266                     assert(false);
 267                     return rLocalName;
 268                 }
 269             }
 270         }
 271     }
 272 }
 273
 274 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName_(
 275                             const OUString& rAttrName,
 276                             OUString *pLocalName) const
 277 {
 278     return GetKeyByAttrName_( rAttrName, nullptr, pLocalName, nullptr, false/*bCache*/ );
 279 }
 280
 281 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName_( const OUString& rAttrName,
 282                                             OUString *pPrefix,
 283                                             OUString *pLocalName,
 284                                             OUString *pNamespace,
 285                                             bool bCache) const
 286 {
 287     sal_uInt16 nKey = XML_NAMESPACE_UNKNOWN;
 288
 289     NameSpaceHash::const_iterator it;
 290     if (bCache)
 291         it = aNameCache.find ( rAttrName );
 292     else
 293         it = aNameCache.end();
 294     if ( it != aNameCache.end() )
 295     {
 296         const NameSpaceEntry &rEntry = *((*it).second);
 297         if ( pPrefix )
 298             *pPrefix = rEntry.sPrefix;
 299         if ( pLocalName )
 300             *pLocalName = rEntry.sName;
 301         nKey = rEntry.nKey;
 302         if ( pNamespace )
 303         {
 304             NameSpaceMap::const_iterator aMapIter = aNameMap.find (nKey);
 305             *pNamespace = aMapIter != aNameMap.end() ? (*aMapIter).second->sName : OUString();
 306         }
 307     }
 308     else
 309     {
 310     rtl::Reference<NameSpaceEntry> xEntry(new NameSpaceEntry());
 311
 312         sal_Int32 nColonPos = rAttrName.indexOf( ':' );
 313         if( -1L == nColonPos )
 314         {
 315             // case: no ':' found -> default namespace
 316             (xEntry->sPrefix).clear();
 317             xEntry->sName = rAttrName;
 318         }
 319         else
 320         {
 321             // normal case: ':' found -> get prefix/suffix
 322             xEntry->sPrefix = rAttrName.copy( 0L, nColonPos );
 323             xEntry->sName = rAttrName.copy( nColonPos + 1L );
 324         }
 325
 326         if( pPrefix )
 327             *pPrefix = xEntry->sPrefix;
 328         if( pLocalName )
 329             *pLocalName = xEntry->sName;
 330
 331         NameSpaceHash::const_iterator aIter = aNameHash.find( xEntry->sPrefix );
 332         if ( aIter != aNameHash.end() )
 333         {
 334             // found: retrieve namespace key
 335             nKey = xEntry->nKey = (*aIter).second->nKey;
 336             if ( pNamespace )
 337                 *pNamespace = (*aIter).second->sName;
 338         }
 339         else if ( xEntry->sPrefix == sXMLNS )
 340             // not found, but xmlns prefix: return xmlns 'namespace'
 341             nKey = xEntry->nKey = XML_NAMESPACE_XMLNS;
 342         else if( nColonPos == -1L )
 343             // not found, and no namespace: 'namespace' none
 344             nKey = xEntry->nKey = XML_NAMESPACE_NONE;
 345
 346         if (bCache)
 347         {
 348             aNameCache.insert(NameSpaceHash::value_type(rAttrName, xEntry));
 349         }
 350     }
 351
 352     return nKey;
 353 }
 354
 355 sal_uInt16 SvXMLNamespaceMap::GetFirstKey() const
 356 {
 357     return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
 358 }
 359
 360 sal_uInt16 SvXMLNamespaceMap::GetNextKey( sal_uInt16 nLastKey ) const
 361 {
 362     NameSpaceMap::const_iterator aIter = aNameMap.find ( nLastKey );
 363     return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
 364 }
 365
 366
 367 // All methods after this are deprecated...
 368
 369 sal_uInt16 SvXMLNamespaceMap::GetIndexByKey( sal_uInt16 nKey )
 370 {
 371     return nKey;
 372 }
 373 sal_uInt16 SvXMLNamespaceMap::GetFirstIndex() const
 374 {
 375     return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
 376 }
 377
 378 sal_uInt16 SvXMLNamespaceMap::GetNextIndex( sal_uInt16 nOldIdx ) const
 379 {
 380     NameSpaceMap::const_iterator aIter = aNameMap.find ( nOldIdx );
 381     return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
 382 }
 383
 384 void SvXMLNamespaceMap::AddAtIndex( sal_uInt16 /*nIdx*/, const OUString& rPrefix,
 385                                     const OUString& rName, sal_uInt16 nKey )
 386 {
 387     if( XML_NAMESPACE_UNKNOWN == nKey )
 388         nKey = GetKeyByName( rName );
 389
 390     assert(XML_NAMESPACE_NONE != nKey);
 391     if( XML_NAMESPACE_NONE != nKey && ! ( aNameHash.count ( rPrefix ) ) )
 392     {
 393         Add_( rPrefix, rName, nKey );
 394     }
 395 }
 396
 397 OUString SvXMLNamespaceMap::GetAttrNameByIndex( sal_uInt16 nIdx ) const
 398 {
 399     return GetAttrNameByKey( nIdx );
 400 }
 401
 402 OUString SvXMLNamespaceMap::GetQNameByIndex( sal_uInt16 nIdx,
 403                                            const OUString& rLocalName ) const
 404 {
 405     return GetQNameByKey( nIdx, rLocalName );
 406 }
 407
 408 const OUString& SvXMLNamespaceMap::GetPrefixByIndex( sal_uInt16 nIdx ) const
 409 {
 410     NameSpaceMap::const_iterator aIter = aNameMap.find (nIdx);
 411     return (aIter != aNameMap.end()) ? (*aIter).second->sPrefix : sEmpty;
 412 }
 413
 414 const OUString& SvXMLNamespaceMap::GetNameByIndex( sal_uInt16 nIdx ) const
 415 {
 416     NameSpaceMap::const_iterator aIter = aNameMap.find (nIdx);
 417     return (aIter != aNameMap.end()) ? (*aIter).second->sName : sEmpty;
 418 }
 419
 420 sal_uInt16 SvXMLNamespaceMap::GetIndexByPrefix( const OUString& rPrefix ) const
 421 {
 422     NameSpaceHash::const_iterator aIter = aNameHash.find(rPrefix);
 423     return (aIter != aNameHash.end()) ? (*aIter).second->nKey : USHRT_MAX;
 424 }
 425 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName(
 426                             const OUString& rAttrName,
 427                             OUString *pLocalName,
 428                             sal_uInt16 /*nIdxGuess*/) const
 429 {
 430     return GetKeyByAttrName_( rAttrName, nullptr, pLocalName );
 431 }
 432
 433 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName( const OUString& rAttrName,
 434                                             OUString *pPrefix,
 435                                             OUString *pLocalName,
 436                                             OUString *pNamespace,
 437                                             sal_uInt16 /*nIdxGuess*/ ) const
 438 {
 439     return GetKeyByAttrName_ ( rAttrName, pPrefix, pLocalName, pNamespace );
 440 }
 441
 442 bool SvXMLNamespaceMap::NormalizeURI( OUString& rName )
 443 {
 444     // try OASIS + W3 URI normalization
 445     bool bSuccess = NormalizeOasisURN( rName );
 446     if( ! bSuccess )
 447         bSuccess = NormalizeW3URI( rName );
 448     return bSuccess;
 449 }
 450
 451 bool SvXMLNamespaceMap::NormalizeW3URI( OUString& rName )
 452 {
 453     // check if URI matches:
 454     // http://www.w3.org/[0-9]*/[:letter:]*
 455     //                   (year)/(WG name)
 456     // For the following WG/standards names:
 457     // - xforms
 458
 459     bool bSuccess = false;
 460     const OUString& sURIPrefix = GetXMLToken( XML_URI_W3_PREFIX );
 461     if( rName.startsWith( sURIPrefix ) )
 462     {
 463         const OUString& sURISuffix = GetXMLToken( XML_URI_XFORMS_SUFFIX );
 464         sal_Int32 nCompareFrom = rName.getLength() - sURISuffix.getLength();
 465         if( rName.copy( nCompareFrom ).equals( sURISuffix ) )
 466         {
 467             // found W3 prefix, and xforms suffix
 468             rName = GetXMLToken( XML_N_XFORMS_1_0 );
 469             bSuccess = true;
 470         }
 471     }
 472     return bSuccess;
 473 }
 474
 475 bool SvXMLNamespaceMap::NormalizeOasisURN( OUString& rName )
 476 {
 477     // #i38644#
 478     // we exported the wrong namespace for smil, so we correct this here on load
 479     // for older documents
 480     if( IsXMLToken( rName, ::xmloff::token::XML_N_SVG ) )
 481     {
 482         rName = GetXMLToken( ::xmloff::token::XML_N_SVG_COMPAT );
 483         return true;
 484     }
 485     else if( IsXMLToken( rName, ::xmloff::token::XML_N_FO ) )
 486     {
 487         rName = GetXMLToken( ::xmloff::token::XML_N_FO_COMPAT );
 488         return true;
 489     }
 490     else if( IsXMLToken( rName, ::xmloff::token::XML_N_SMIL ) ||
 491                IsXMLToken( rName, ::xmloff::token::XML_N_SMIL_OLD )  )
 492     {
 493         rName = GetXMLToken( ::xmloff::token::XML_N_SMIL_COMPAT );
 494         return true;
 495     }
 496
 497
 498     // Check if URN matches
 499     // :urn:oasis:names:tc:[^:]*:xmlns:[^:]*:1.[^:]*
 500     //                     |---|       |---| |-----|
 501     //                     TC-Id      Sub-Id Version
 502
 503     sal_Int32 nNameLen = rName.getLength();
 504     // :urn:oasis:names:tc.*
 505     const OUString& rOasisURN = GetXMLToken( XML_URN_OASIS_NAMES_TC );
 506     if( !rName.startsWith( rOasisURN ) )
 507         return false;
 508
 509     // :urn:oasis:names:tc:.*
 510     sal_Int32 nPos = rOasisURN.getLength();
 511     if( nPos >= nNameLen || rName[nPos] != ':' )
 512         return false;
 513
 514     // :urn:oasis:names:tc:[^:]:.*
 515     sal_Int32 nTCIdStart = nPos+1;
 516     sal_Int32 nTCIdEnd = rName.indexOf( ':', nTCIdStart );
 517     if( -1 == nTCIdEnd )
 518         return false;
 519
 520     // :urn:oasis:names:tc:[^:]:xmlns.*
 521     nPos = nTCIdEnd + 1;
 522     OUString sTmp( rName.copy( nPos ) );
 523     const OUString& rXMLNS = GetXMLToken( XML_XMLNS );
 524     if( !sTmp.startsWith( rXMLNS ) )
 525         return false;
 526
 527     // :urn:oasis:names:tc:[^:]:xmlns:.*
 528     nPos += rXMLNS.getLength();
 529     if( nPos >= nNameLen || rName[nPos] != ':' )
 530         return false;
 531
 532     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:.*
 533     nPos = rName.indexOf( ':', nPos+1 );
 534     if( -1 == nPos )
 535         return false;
 536
 537     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:[^:][^:][^:][^:]*
 538     sal_Int32 nVersionStart = nPos+1;
 539     if( nVersionStart+2 >= nNameLen ||
 540         -1 != rName.indexOf( ':', nVersionStart ) )
 541         return false;
 542
 543     // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:1\.[^:][^:]*
 544     if( rName[nVersionStart] != '1' || rName[nVersionStart+1] != '.' )
 545         return false;
 546
 547     // replace [tcid] with current TCID and version with current version.
 548
 549     rName = rName.copy( 0, nTCIdStart ) +
 550             GetXMLToken( XML_OPENDOCUMENT ) +
 551             rName.copy( nTCIdEnd, nVersionStart-nTCIdEnd ) +
 552             GetXMLToken( XML_1_0 );
 553
 554     return true;
 555 }
 556
 557 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */