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