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