?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nss: upgrade to release 3.73
[LibreOffice.git] / xmloff / source / core / namespacemap.cxx
blob1fd9f9d70cbba2a74137ac018bf52f9955eae920
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/namespacemap.hxx>
28
29 #include <xmloff/xmlnamespace.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 : 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::GetKeyByAttrValueQName(
264 const OUString& rAttrValue,
265 OUString *pLocalName) const
266 {
267 return GetKeyByQName(rAttrValue, nullptr, pLocalName, nullptr, QNameMode::AttrValue);
268 }
269
270 /**
271 @param rQName either attribute name or qualified/namespaced attribute value
272 @param bCacheAttrName true: rQName is element or attribute name, cache it
273 false: rQName is attribute value, may contain extra ':', don't cache it
274 */
275 sal_uInt16 SvXMLNamespaceMap::GetKeyByQName(const OUString& rQName,
276 OUString *pPrefix,
277 OUString *pLocalName,
278 OUString *pNamespace,
279 QNameMode const eMode) const
280 {
281 sal_uInt16 nKey;
282
283 NameSpaceHash::const_iterator it;
284 if (eMode == QNameMode::AttrNameCached)
285 it = aNameCache.find ( rQName );
286 else
287 it = aNameCache.end();
288 if ( it != aNameCache.end() )
289 {
290 const NameSpaceEntry &rEntry = *((*it).second);
291 if ( pPrefix )
292 *pPrefix = rEntry.sPrefix;
293 if ( pLocalName )
294 *pLocalName = rEntry.sName;
295 nKey = rEntry.nKey;
296 if ( pNamespace )
297 {
298 NameSpaceMap::const_iterator aMapIter = aNameMap.find (nKey);
299 *pNamespace = aMapIter != aNameMap.end() ? (*aMapIter).second->sName : OUString();
300 }
301 }
302 else
303 {
304 OUString sEntryPrefix, sEntryName;
305
306 sal_Int32 nColonPos = rQName.indexOf( ':' );
307 if( -1 == nColonPos )
308 {
309 // case: no ':' found -> default namespace
310 sEntryName = rQName;
311 }
312 else
313 {
314 // normal case: ':' found -> get prefix/suffix
315 sEntryPrefix = rQName.copy( 0L, nColonPos );
316 sEntryName = rQName.copy( nColonPos + 1 );
317 }
318
319 if (eMode == QNameMode::AttrNameCached && sEntryName.indexOf(':') != -1)
320 {
321 SAL_INFO("xmloff", "invalid attribute name with multiple ':'");
322 assert(false);
323 return XML_NAMESPACE_UNKNOWN;
324 }
325
326 if( pPrefix )
327 *pPrefix = sEntryPrefix;
328 if( pLocalName )
329 *pLocalName = sEntryName;
330
331 NameSpaceHash::const_iterator aIter = aNameHash.find( sEntryPrefix );
332 if ( aIter != aNameHash.end() )
333 {
334 // found: retrieve namespace key
335 nKey = (*aIter).second->nKey;
336 if ( pNamespace )
337 *pNamespace = (*aIter).second->sName;
338 }
339 else if ( sEntryPrefix == sXMLNS )
340 // not found, but xmlns prefix: return xmlns 'namespace'
341 nKey = XML_NAMESPACE_XMLNS;
342 else if( nColonPos == -1 )
343 // not found, and no namespace: 'namespace' none
344 nKey = XML_NAMESPACE_NONE;
345 else
346 nKey = XML_NAMESPACE_UNKNOWN;
347
348 if (eMode == QNameMode::AttrNameCached)
349 {
350 rtl::Reference<NameSpaceEntry> xEntry(new NameSpaceEntry);
351 xEntry->sPrefix = std::move(sEntryPrefix);
352 xEntry->sName = std::move(sEntryName);
353 xEntry->nKey = std::move(nKey);
354 aNameCache.emplace(rQName, std::move(xEntry));
355 }
356 }
357
358 return nKey;
359 }
360
361 sal_uInt16 SvXMLNamespaceMap::GetFirstKey() const
362 {
363 return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
364 }
365
366 sal_uInt16 SvXMLNamespaceMap::GetNextKey( sal_uInt16 nLastKey ) const
367 {
368 NameSpaceMap::const_iterator aIter = aNameMap.find ( nLastKey );
369 return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
370 }
371
372
373 // All methods after this are deprecated...
374
375 sal_uInt16 SvXMLNamespaceMap::GetIndexByKey( sal_uInt16 nKey )
376 {
377 return nKey;
378 }
379 sal_uInt16 SvXMLNamespaceMap::GetFirstIndex() const
380 {
381 return aNameMap.empty() ? USHRT_MAX : (*aNameMap.begin()).second->nKey;
382 }
383
384 sal_uInt16 SvXMLNamespaceMap::GetNextIndex( sal_uInt16 nOldIdx ) const
385 {
386 NameSpaceMap::const_iterator aIter = aNameMap.find ( nOldIdx );
387 return (++aIter == aNameMap.end()) ? USHRT_MAX : (*aIter).second->nKey;
388 }
389
390 void SvXMLNamespaceMap::AddAtIndex( const OUString& rPrefix,
391 const OUString& rName, sal_uInt16 nKey )
392 {
393 if( XML_NAMESPACE_UNKNOWN == nKey )
394 nKey = GetKeyByName( rName );
395
396 assert(XML_NAMESPACE_NONE != nKey);
397 if( XML_NAMESPACE_NONE != nKey && ! ( aNameHash.count ( rPrefix ) ) )
398 {
399 Add_( rPrefix, rName, nKey );
400 }
401 }
402
403 OUString SvXMLNamespaceMap::GetAttrNameByIndex( sal_uInt16 nIdx ) const
404 {
405 return GetAttrNameByKey( nIdx );
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) const
428 {
429 return GetKeyByQName(rAttrName, nullptr, pLocalName, nullptr, QNameMode::AttrNameCached);
430 }
431
432 sal_uInt16 SvXMLNamespaceMap::GetKeyByAttrName( const OUString& rAttrName,
433 OUString *pPrefix,
434 OUString *pLocalName,
435 OUString *pNamespace ) const
436 {
437 return GetKeyByQName(rAttrName, pPrefix, pLocalName, pNamespace, QNameMode::AttrNameCached);
438 }
439
440 bool SvXMLNamespaceMap::NormalizeURI( OUString& rName )
441 {
442 // try OASIS + W3 URI normalization
443 bool bSuccess = NormalizeOasisURN( rName );
444 if( ! bSuccess )
445 bSuccess = NormalizeW3URI( rName );
446 return bSuccess;
447 }
448
449 bool SvXMLNamespaceMap::NormalizeW3URI( OUString& rName )
450 {
451 // check if URI matches:
452 // http://www.w3.org/[0-9]*/[:letter:]*
453 // (year)/(WG name)
454 // For the following WG/standards names:
455 // - xforms
456
457 bool bSuccess = false;
458 const OUString& sURIPrefix = GetXMLToken( XML_URI_W3_PREFIX );
459 if( rName.startsWith( sURIPrefix ) )
460 {
461 const OUString& sURISuffix = GetXMLToken( XML_URI_XFORMS_SUFFIX );
462 sal_Int32 nCompareFrom = rName.getLength() - sURISuffix.getLength();
463 if( rName.subView( nCompareFrom ) == sURISuffix )
464 {
465 // found W3 prefix, and xforms suffix
466 rName = GetXMLToken( XML_N_XFORMS_1_0 );
467 bSuccess = true;
468 }
469 }
470 return bSuccess;
471 }
472
473 bool SvXMLNamespaceMap::NormalizeOasisURN( OUString& rName )
474 {
475 // #i38644#
476 // we exported the wrong namespace for smil, so we correct this here on load
477 // for older documents
478 if( IsXMLToken( rName, ::xmloff::token::XML_N_SVG ) )
479 {
480 rName = GetXMLToken( ::xmloff::token::XML_N_SVG_COMPAT );
481 return true;
482 }
483 else if( IsXMLToken( rName, ::xmloff::token::XML_N_FO ) )
484 {
485 rName = GetXMLToken( ::xmloff::token::XML_N_FO_COMPAT );
486 return true;
487 }
488 else if( IsXMLToken( rName, ::xmloff::token::XML_N_SMIL ) ||
489 IsXMLToken( rName, ::xmloff::token::XML_N_SMIL_OLD ) )
490 {
491 rName = GetXMLToken( ::xmloff::token::XML_N_SMIL_COMPAT );
492 return true;
493 }
494
495
496 // Check if URN matches
497 // :urn:oasis:names:tc:[^:]*:xmlns:[^:]*:1.[^:]*
498 // |---| |---| |-----|
499 // TC-Id Sub-Id Version
500
501 sal_Int32 nNameLen = rName.getLength();
502 // :urn:oasis:names:tc.*
503 const OUString& rOasisURN = GetXMLToken( XML_URN_OASIS_NAMES_TC );
504 if( !rName.startsWith( rOasisURN ) )
505 return false;
506
507 // :urn:oasis:names:tc:.*
508 sal_Int32 nPos = rOasisURN.getLength();
509 if( nPos >= nNameLen || rName[nPos] != ':' )
510 return false;
511
512 // :urn:oasis:names:tc:[^:]:.*
513 sal_Int32 nTCIdStart = nPos+1;
514 sal_Int32 nTCIdEnd = rName.indexOf( ':', nTCIdStart );
515 if( -1 == nTCIdEnd )
516 return false;
517
518 // :urn:oasis:names:tc:[^:]:xmlns.*
519 nPos = nTCIdEnd + 1;
520 OUString sTmp( rName.copy( nPos ) );
521 const OUString& rXMLNS = GetXMLToken( XML_XMLNS );
522 if( !sTmp.startsWith( rXMLNS ) )
523 return false;
524
525 // :urn:oasis:names:tc:[^:]:xmlns:.*
526 nPos += rXMLNS.getLength();
527 if( nPos >= nNameLen || rName[nPos] != ':' )
528 return false;
529
530 // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:.*
531 nPos = rName.indexOf( ':', nPos+1 );
532 if( -1 == nPos )
533 return false;
534
535 // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:[^:][^:][^:][^:]*
536 sal_Int32 nVersionStart = nPos+1;
537 if( nVersionStart+2 >= nNameLen ||
538 -1 != rName.indexOf( ':', nVersionStart ) )
539 return false;
540
541 // :urn:oasis:names:tc:[^:]:xmlns:[^:]*:1\.[^:][^:]*
542 if( rName[nVersionStart] != '1' || rName[nVersionStart+1] != '.' )
543 return false;
544
545 // replace [tcid] with current TCID and version with current version.
546
547 rName = rName.subView( 0, nTCIdStart ) +
548 GetXMLToken( XML_OPENDOCUMENT ) +
549 rName.subView( nTCIdEnd, nVersionStart-nTCIdEnd ) +
550 GetXMLToken( XML_1_0 );
551
552 return true;
553 }
554
555 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE