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