configmgr/source/treemgr/configpath.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: configpath.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "configpath.hxx"
  35 #include "configexcept.hxx"
  36 #include <rtl/ustrbuf.hxx>
  37
  38 #ifndef INCLUDED_ALGORITHM
  39 #include <algorithm>
  40 #define INCLUDED_ALGORITHM
  41 #endif
  42
  43 #ifndef CFG_PATH_STRICT
  44 //#define CFG_PATH_STRICT 1
  45 #endif
  46
  47 #define dprint(a,b,c)
  48
  49 namespace configmgr
  50 {
  51     namespace configuration
  52     {
  53
  54     //-------------------------------------------------------------------------
  55
  56 //-----------------------------------------------------------------------------
  57 // Name validation
  58 //-----------------------------------------------------------------------------
  59 namespace
  60 {
  61     //-------------------------------------------------------------------------
  62     inline
  63     bool isValidNameStart(sal_Unicode ch) SAL_THROW(())
  64     {
  65         return (sal_Unicode('A') <= ch && ch <= sal_Unicode('Z')) ||
  66                (sal_Unicode('a') <= ch && ch <= sal_Unicode('z')) ||
  67                 sal_Unicode('_') == ch;
  68     }
  69     inline
  70     bool isValidNameCont(sal_Unicode ch) SAL_THROW(())
  71     {
  72         return  (       (sal_Unicode('0') <= ch && ch <= sal_Unicode('9'))
  73                 ||      (sal_Unicode('.') == ch) // eg for module names
  74                 ||      (sal_Unicode('-') == ch) // eg for locale names
  75                 ||      (sal_Unicode(':') == ch) // support special namespaced names
  76                 );
  77     }
  78
  79     //-------------------------------------------------------------------------
  80 }
  81 //-----------------------------------------------------------------------------
  82
  83 bool isSimpleName(rtl::OUString const& sName) SAL_THROW(())
  84 {
  85     sal_Unicode const* const pStr = sName.getStr();
  86     sal_Unicode const* const pEnd = pStr + sName.getLength();
  87
  88     if ( (pStr == pEnd) || !isValidNameStart(*pStr) )
  89         return false;
  90
  91     for (sal_Unicode const* pValidate = pStr+1; pValidate != pEnd; ++pValidate)
  92     {
  93         if (!isValidNameStart(*pValidate) && !isValidNameCont(*pValidate))
  94             return false;
  95     }
  96
  97     return true;
  98 }
  99 //-----------------------------------------------------------------------------
 100
 101 rtl::OUString validateNodeName(rtl::OUString const& sName)
 102 {
 103     if (!isSimpleName(sName))
 104         throw InvalidName(sName, "is not a valid name for a configuration node");
 105
 106     return sName;
 107 }
 108 //-----------------------------------------------------------------------------
 109
 110 rtl::OUString validateElementName(rtl::OUString const& sName)
 111 {
 112     if (sName.getLength() == 0)
 113         throw InvalidName(sName, "is not a valid name for a configuration item (empty names are not permitted)");
 114
 115     return sName;
 116 }
 117 //-----------------------------------------------------------------------------
 118
 119 namespace // path helpers I
 120 {
 121 //-----------------------------------------------------------------------------
 122     const sal_Unicode c_cDelimiter = '/';
 123
 124     const sal_Unicode c_lBracket = '[', c_rBracket = ']';
 125
 126     const sal_Unicode c_cAnytype = '*';
 127 //-----------------------------------------------------------------------------
 128
 129     // Textually an Absolute path starts with a slash
 130     static
 131     inline
 132     bool detectAbsolutePath(sal_Unicode const* _pPath) SAL_THROW(())
 133     {
 134         OSL_ASSERT( _pPath != NULL );
 135         return  *_pPath == c_cDelimiter;
 136     }
 137 //-----------------------------------------------------------------------------
 138
 139     static
 140     inline
 141     rtl::OUString makeWildcardType() SAL_THROW(())
 142     {
 143         return rtl::OUString(&c_cAnytype,1);
 144     }
 145 //-----------------------------------------------------------------------------
 146
 147     // even handles empty strings (if NUL-terminated)
 148     static
 149     inline
 150     bool isWildcardType(sal_Unicode const* _sType) SAL_THROW(())
 151     {
 152         OSL_ASSERT( _sType != NULL );
 153         return  _sType[0] == c_cAnytype &&
 154                 _sType[1] == 0;
 155     }
 156 //-----------------------------------------------------------------------------
 157
 158     static
 159     inline
 160     bool isEmptyString(sal_Unicode const* _sType) SAL_THROW(())
 161     {
 162         OSL_ASSERT( _sType != NULL );
 163         return  _sType[0] == 0;
 164     }
 165 //-----------------------------------------------------------------------------
 166     static
 167     inline
 168     sal_Unicode lastChar(rtl::OUString const& _sString) SAL_THROW(())
 169     {
 170         sal_Int32 const nLen = _sString.getLength();
 171
 172         OSL_PRECOND( nLen > 0, "Non-empty string expected");
 173
 174         return _sString[nLen-1];
 175     }
 176 //-----------------------------------------------------------------------------
 177
 178     rtl::OUString implMakeCompositeName(rtl::OUString const& _sBaseName, rtl::OUString const& _sPredicate) SAL_THROW((InvalidName));
 179     void implSplitCompositeName(rtl::OUString const& _aCompositeName, rtl::OUString& _rBaseName, rtl::OUString& _rPredicate) SAL_THROW(());
 180 //-----------------------------------------------------------------------------
 181 }
 182 //-----------------------------------------------------------------------------
 183
 184 //-----------------------------------------------------------------------------
 185 namespace Path
 186 {
 187 //-----------------------------------------------------------------------------
 188 // class configuration::Path::Component
 189 //-----------------------------------------------------------------------------
 190
 191 inline // though public, this method is not available outside this translation unit
 192 Component::Component(rtl::OUString const& _sName) SAL_THROW(())
 193 : m_aName(_sName)
 194 {
 195 }
 196 //-----------------------------------------------------------------------------
 197
 198 bool Component::isSimpleName()    const SAL_THROW(())
 199 {
 200     return m_aName.getLength() != 0 && lastChar(m_aName) != c_rBracket;
 201 }
 202 //-----------------------------------------------------------------------------
 203
 204 rtl::OUString Component::getName()    const SAL_THROW(())
 205 {
 206     if (isSimpleName()) return m_aName;
 207
 208     rtl::OUString sName, sType;
 209     implSplitCompositeName(m_aName,sType,sName);
 210
 211     return sName;
 212 }
 213 //-----------------------------------------------------------------------------
 214
 215 rtl::OUString Component::getTypeName()      const SAL_THROW(())
 216 {
 217     if (isSimpleName()) return rtl::OUString();
 218
 219     rtl::OUString sName, sType;
 220     implSplitCompositeName(m_aName,sType,sName);
 221
 222     return sType;
 223 }
 224 //-----------------------------------------------------------------------------
 225
 226 Component makeEmptyComponent() SAL_THROW(())
 227 {
 228     return Component( rtl::OUString() );
 229 }
 230 //-----------------------------------------------------------------------------
 231
 232 Component wrapSimpleName(rtl::OUString const& _sName)
 233 {
 234     OSL_ENSURE( isSimpleName(_sName), "Simple name expected creating path component");
 235     if (!isSimpleName(_sName))
 236         throw InvalidName(_sName, "is not a simple name. Cannot convert to path component");
 237
 238     return Component( _sName );
 239 }
 240 //-----------------------------------------------------------------------------
 241
 242 Component makeCompositeName(rtl::OUString const& _sElementName, rtl::OUString const& _sTypeName)
 243 {
 244     return Component( implMakeCompositeName(_sTypeName,_sElementName) );
 245 }
 246 //-----------------------------------------------------------------------------
 247
 248
 249 bool matches(Component const& lhs,Component const& rhs) SAL_THROW(())
 250 {
 251     // this extra preflight check might be left out (is it good for performance ?)
 252     if (lhs.getInternalName() == rhs.getInternalName())
 253         return true;
 254
 255     if (lhs.getName() != rhs.getName())
 256         return false;
 257
 258     // simple names are considered equivalent to wildcard namess
 259     if (lhs.isSimpleName() || rhs.isSimpleName())
 260         return true;
 261
 262     rtl::OUString aTypeLHS = lhs.getTypeName();
 263     rtl::OUString aTypeRHS = rhs.getTypeName();
 264
 265     // this would need an extra test without our preflight check
 266     OSL_ASSERT(aTypeLHS != aTypeRHS); // would have been dicovered by first check
 267
 268     if ( isWildcardType(aTypeLHS) || isWildcardType(aTypeRHS) )
 269         return true;
 270
 271     return false;
 272 }
 273 //-----------------------------------------------------------------------------
 274
 275 //-----------------------------------------------------------------------------
 276 // weak comparison of components
 277 //-----------------------------------------------------------------------------
 278 bool before(Component const& lhs, Component const& rhs) SAL_THROW(())
 279 { return lhs.getName() < rhs.getName(); }
 280
 281 //-----------------------------------------------------------------------------
 282 bool equiv(Component const& lhs, Component const& rhs) SAL_THROW(())
 283 { return lhs.getName() == rhs.getName(); }
 284
 285 //-----------------------------------------------------------------------------
 286 size_t hashCode(Component const& comp)  SAL_THROW(())
 287 { return comp.getName().hashCode(); }
 288
 289 //-----------------------------------------------------------------------------
 290
 291 //-----------------------------------------------------------------------------
 292 // class configuration::Path::Rep
 293 //-----------------------------------------------------------------------------
 294 void Rep::check_not_empty() const
 295 {
 296     if (m_aComponents.empty())
 297     {
 298         OSL_ENSURE(!m_aComponents.empty(),"Trying to access components of an empty path");
 299         throw Exception("Trying to access components of an empty path");
 300     }
 301 }
 302 //-----------------------------------------------------------------------------
 303
 304 void Rep::prepend(Rep const& _aOther) SAL_THROW(())
 305 {
 306     // to prepend the other path append its components
 307     m_aComponents.insert( m_aComponents.end(),
 308                             _aOther.m_aComponents.begin(),
 309                             _aOther.m_aComponents.end());
 310
 311 }
 312 //-----------------------------------------------------------------------------
 313
 314 rtl::OUString Rep::toString(bool _bAbsolute) const SAL_THROW(())
 315 {
 316     std::vector<Component>::const_reverse_iterator cur = begin();
 317     std::vector<Component>::const_reverse_iterator const stop = end();
 318
 319     rtl::OUStringBuffer sRet;
 320
 321     if (!_bAbsolute && cur != stop)
 322         sRet = cur++->toPathString();
 323
 324     for ( ;cur != stop; ++cur)
 325         sRet.append( c_cDelimiter ).append( cur->toPathString() );
 326
 327     return sRet.makeStringAndClear();
 328 }
 329 //-----------------------------------------------------------------------------
 330
 331 size_t Rep::hashCode() const  SAL_THROW(())
 332 {
 333     const unsigned long mangle_factor = 11; // 1011 (2)
 334     unsigned long nHash = 0;
 335     for (std::vector<Component>::const_reverse_iterator it = begin(), stop = end(); it != stop; ++it)
 336     {
 337         nHash = mangle_factor*nHash + Path::hashCode(*it);
 338     }
 339     return nHash;
 340 }
 341 //-----------------------------------------------------------------------------
 342
 343 bool before(Rep const& lhs, Rep const& rhs) SAL_THROW(())
 344 {
 345     return std::lexicographical_compare(lhs.begin(),lhs.end(),rhs.begin(),rhs.end(), Before());
 346 }
 347 //-----------------------------------------------------------------------------
 348
 349 bool equiv(Rep const& lhs, Rep const& rhs) SAL_THROW(())
 350 {
 351     return (lhs.countComponents() == rhs.countComponents()) &&
 352             std::equal(lhs.begin(),lhs.end(),rhs.begin(),Equiv());
 353 }
 354 //-----------------------------------------------------------------------------
 355
 356 bool matches(Rep const& lhs, Rep const& rhs) SAL_THROW(())
 357 {
 358     return (lhs.countComponents() == rhs.countComponents()) &&
 359             std::equal(lhs.begin(),lhs.end(),rhs.begin(),Matches());
 360 }
 361 //-----------------------------------------------------------------------------
 362
 363 bool isAbsolutePath(rtl::OUString const& _sPath) SAL_THROW(())
 364 {
 365     return detectAbsolutePath(_sPath);
 366 }
 367 //-----------------------------------------------------------------------------
 368
 369 bool hasMatchingPrefix(Rep const& _aPath, Rep const& _aPrefix) SAL_THROW(())
 370 {
 371     return (_aPath.countComponents() >= _aPrefix.countComponents()) &&
 372             std::equal( _aPrefix.begin(), _aPrefix.end(), _aPath.begin(), Matches());
 373 }
 374 //-----------------------------------------------------------------------------
 375
 376 Rep stripMatchingPrefix(Rep const& _aPath,Rep const& _aPrefix) //  SAL_THROW((InvalidName))
 377 {
 378     Rep aResult(_aPath);
 379
 380     for (std::vector<Component>::const_reverse_iterator it = _aPrefix.begin(); it != _aPrefix.end(); ++it)
 381     {
 382         if (aResult.isEmpty() || !matches(*it,aResult.getFirstName()))
 383             throw InvalidName(aResult.getFirstName().toPathString(), "does not match the expected location.");
 384
 385         aResult.dropFirstName();
 386     }
 387
 388     return aResult;
 389 }
 390 //-----------------------------------------------------------------------------
 391 } // namespace Path
 392 //-----------------------------------------------------------------------------
 393
 394 namespace
 395 {
 396 //-----------------------------------------------------------------------------
 397     const sal_Unicode c_quot = '\"';
 398     const sal_Unicode c_apos = '\'';
 399     const sal_Unicode c_amp = '&';
 400
 401     const sal_Unicode c_end_escape = ';';
 402
 403     const sal_Unicode c_normal_quot = c_apos;
 404     //-------------------------------------------
 405     static sal_Char const c_amp_name[]  = "&amp;";
 406     static sal_Char const c_apos_name[] = "&apos;";
 407     static sal_Char const c_quot_name[] = "&quot;";
 408
 409     const sal_Int32 c_nMinEscapeLen = sizeof c_amp_name  - 1;
 410     const sal_Int32 c_nMaxEscapeLen = sizeof c_quot_name - 1;
 411 //-------------------------------------------------------------------------
 412     /// distinguishes which kind of path is held in a path object
 413     enum PathType { eRELATIVE = 1, eABSOLUTE = 2 };
 414
 415 //-----------------------------------------------------------------------------
 416     // missing or mis leading in SAL/rtl: pStr1[nLength] must NOT be evaluated
 417     static
 418     sal_Int32 cfg_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
 419                                                           sal_Int32 nStr1Len,
 420                                                           const sal_Char* pStr2 )
 421     {
 422         while( nStr1Len )
 423         {
 424             sal_Int32 nRet = static_cast<sal_Int32>(*pStr1)-
 425                              static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
 426
 427             if (nRet != 0 || *pStr2 == 0) return nRet;
 428
 429             ++pStr1;
 430             ++pStr2;
 431             --nStr1Len;
 432         }
 433
 434         return -static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
 435     }
 436 //-----------------------------------------------------------------------------
 437
 438
 439     /** find the char being escaped by the escape sequence in the given string range
 440         @return
 441             the char being escaped or zero, if the range is no known escape
 442     */
 443     sal_Unicode implParseEscape(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd) SAL_THROW(())
 444     {
 445         OSL_PRECOND( pBegin <  pEnd, "Nonempty string range expected" );
 446         OSL_PRECOND( pBegin[0] == c_amp,        "String range is not a possible escape: missing start marker" );
 447         OSL_PRECOND( pEnd[-1]  == c_end_escape, "String range is not a possible escape: missing end marker" );
 448
 449         sal_Int32 const nLen = pEnd - pBegin;
 450
 451         sal_Unicode chResult;
 452
 453         if ( c_nMinEscapeLen > nLen || nLen > c_nMaxEscapeLen) // quick check, if there is no possible match
 454             chResult = 0;
 455         // the standard escapes
 456         else if (0 == cfg_ustr_ascii_compare_WithLength(pBegin,nLen,c_amp_name))   chResult = c_amp;
 457         else if (0 == cfg_ustr_ascii_compare_WithLength(pBegin,nLen,c_apos_name))  chResult = c_apos;
 458         else if (0 == cfg_ustr_ascii_compare_WithLength(pBegin,nLen,c_quot_name))  chResult = c_quot;
 459         // extra escapes for XML compatibility
 460         else if (0 == cfg_ustr_ascii_compare_WithLength(pBegin,nLen,"&lt;"))    chResult = sal_Unicode('<');
 461         else if (0 == cfg_ustr_ascii_compare_WithLength(pBegin,nLen,"&gt;"))    chResult = sal_Unicode('>');
 462         else chResult = 0;
 463
 464         return chResult;
 465     }
 466
 467 //-----------------------------------------------------------------------------
 468
 469     /** find the escape sequence to use for the given char
 470         @return
 471             an escape sequence, or NULL, if the char should not be escaped
 472     */
 473     inline
 474     sal_Char const* implGetEscape(sal_Unicode ch ) SAL_THROW(())
 475     {
 476         switch (ch)
 477         {
 478         case c_amp:  return c_amp_name;
 479         case c_apos: return c_apos_name;
 480         case c_quot: return c_quot_name;
 481
 482         default: return NULL;
 483         }
 484     }
 485
 486 //-----------------------------------------------------------------------------
 487
 488     /** find the start of the path component ending before pEnd in the string starting at pBegin
 489         @return
 490             a pointer to the last character before pEnd that is not a name delimiter
 491     */
 492     sal_Unicode const *  implFindNameStart(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd) SAL_THROW(())
 493     {
 494         OSL_PRECOND(pBegin <= pEnd, "Invalid string range");
 495
 496         sal_Int32 const nLen = pEnd-pBegin;
 497         sal_Int32 const nPos = rtl_ustr_lastIndexOfChar_WithLength(pBegin, nLen, c_cDelimiter) + 1;
 498
 499         OSL_ASSERT(0 <= nPos && nPos <= nLen);
 500
 501         return pBegin + nPos;
 502     }
 503 //-----------------------------------------------------------------------------
 504
 505     /** find the start of the bracketed & quoted predicate ending before pEnd in the string starting at pBegin
 506         @return
 507             <ul><li>a pointer to the opening bracket matching the closing bracket at pEnd[-1], if found</li>
 508             <li><var>pEnd</var>, if no bracketed string was found</li>
 509             <li>NULL, if there was a closing bracket, but the beginning could not be discovered</li></ul>
 510     */
 511     sal_Unicode const *  implFindPredicateStart(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd) SAL_THROW(())
 512     {
 513         OSL_PRECOND(pBegin < pEnd, "Nonempty string range required");
 514
 515         if (pEnd == pBegin || pEnd[-1] != c_rBracket) return pEnd;
 516
 517         if (--pEnd == pBegin)
 518         {
 519             OSL_ENSURE(false, "Invalid path component: single ']'");
 520             return NULL; // string was only "]"
 521         }
 522
 523         sal_Unicode chQuote = *--pEnd;
 524
 525         if (chQuote != c_quot && chQuote != c_apos)
 526         {
 527             // should we support empty brackets ?
 528             if (chQuote == c_lBracket)
 529             {
 530                 OSL_ENSURE(false, "Empty predicate brackets found");
 531                 return NULL; // for now we don't
 532
 533             }
 534
 535             // should we support brackets with non-quoted strings ?
 536             chQuote = c_lBracket; // for now we do
 537         }
 538
 539         sal_Int32 nStart = rtl_ustr_lastIndexOfChar_WithLength(pBegin, pEnd-pBegin, chQuote);
 540
 541         if (chQuote != c_lBracket) // needed to support non-quoted strings
 542             --nStart;
 543
 544         if (nStart < 0)
 545         {
 546             OSL_ENSURE(false, "Could not find opening quote or bracket for bracketed predicate");
 547             return NULL;
 548         }
 549
 550         if (pBegin[nStart] != c_lBracket)
 551         {
 552             OSL_ENSURE(false, "Illegal quote character in string");
 553             return NULL; // for now we don't
 554         }
 555
 556         return pBegin + nStart;
 557     }
 558 //-----------------------------------------------------------------------------
 559
 560     /// find the position of the given char in the range given.
 561     inline
 562     sal_Int32 indexOfCharInRange(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd, sal_Unicode ch) SAL_THROW(())
 563     {
 564         return rtl_ustr_indexOfChar_WithLength(pBegin, pEnd-pBegin, ch);
 565     }
 566 //-----------------------------------------------------------------------------
 567
 568     /// find the position of the given char in the range given.
 569     inline
 570     bool containsChar(sal_Unicode const * pString, sal_Unicode ch) SAL_THROW(())
 571     {
 572         return rtl_ustr_indexOfChar(pString, ch) >= 0;
 573     }
 574 //-----------------------------------------------------------------------------
 575
 576     /** validate and normalize a bracketed & quoted predicate from content the string range [pBegin,pEnd)
 577         @param pRequiredEscapes
 578             contains a list of characters that must be preescaped or are otherwise invalid
 579             if NULL is passed, the source range is presumed to contain no escaped data
 580             otherwise the ampersand (&) and all characters in the list are required to be escaped
 581         @return
 582             the normalized, bracketed and quoted predicate
 583         @throw
 584             InvalidName, if the predicate data is not valid
 585     */
 586     rtl::OUString implMakeNormalizedPredicate(sal_Unicode const *  pBeginContent, sal_Unicode const *  pEndContent, sal_Unicode const* pRequiredEscapes) SAL_THROW((InvalidName))
 587     {
 588         OSL_PRECOND(pBeginContent <= pEndContent, "Invalid string range");
 589         if (pBeginContent == pEndContent)
 590             return rtl::OUString();
 591
 592         rtl::OUStringBuffer aNormalized(pEndContent-pBeginContent + 4); // reserve approximate size initially
 593
 594         // prefix: opening bracket and quote
 595         aNormalized.append(c_lBracket).append(c_normal_quot);
 596
 597         // content: copy over each char and handle escaping
 598         for(sal_Unicode const *  pCur = pBeginContent; pCur != pEndContent; ++pCur)
 599         {
 600             sal_Unicode ch = *pCur;
 601
 602             // maybe parse contained escaping
 603             if (pRequiredEscapes)
 604             {
 605                 if (ch == c_amp)
 606                 {
 607                     // find an escape end marker (after pCur). Result is pCur, if the end marker is not there
 608                     sal_Unicode const *  pEndEscape = pCur + 1 + indexOfCharInRange(pCur+1,pEndContent,c_end_escape);
 609                     sal_Unicode ch2   = pCur != pEndEscape ? implParseEscape(pCur,pEndEscape+1) : 0;
 610
 611                     if (ch2 != 0) // found and read a valid escape sequence
 612                     {
 613                         ch = ch2;
 614                         pCur = pEndEscape;
 615                         OSL_ASSERT(*pCur == c_end_escape);
 616                     }
 617                     else
 618                     {
 619                         OSL_ENSURE(false, "Character '&' must be escaped in this context");
 620                         #if 0
 621                             throw InvalidName(rtl::OUString(pBeginContent,pEndContent-pBeginContent),
 622                                           "is not a valid element name string. "
 623                                           "Character '&' must be escaped in this context");
 624                         #endif
 625                     }
 626                 }
 627                 else if ( containsChar(pRequiredEscapes, ch) )
 628                 {
 629                     throw InvalidName(rtl::OUString(pBeginContent,pEndContent-pBeginContent),
 630                                         "is not a valid element name string. "
 631                                         "Some characters must be escaped in this context");
 632                 }
 633             }
 634
 635             // now append (escape if normal)
 636             if (sal_Char const * pEscape = implGetEscape(ch))
 637                 aNormalized.appendAscii( pEscape );
 638
 639             else
 640                 aNormalized.append( ch );
 641         }
 642
 643         // suffix: closing quote and bracket
 644         aNormalized.append(c_normal_quot).append(c_rBracket);
 645
 646         return aNormalized.makeStringAndClear();
 647     }
 648 //-----------------------------------------------------------------------------
 649
 650     /** extract and unescape the normalized predicate content in the string range [pBegin,pEnd)
 651         @return
 652             the denormalized predicate content
 653     */
 654     rtl::OUString implReadPredicate(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd) SAL_THROW(())
 655     {
 656         OSL_PRECOND(pBegin <= pEnd, "Invalid string range");
 657
 658         rtl::OUStringBuffer aContent(pEnd-pBegin); // reserve approximate size initially
 659
 660         sal_Unicode const *  pReadPos = pBegin;
 661
 662         // content: copy data, handling escapes
 663         for(sal_Unicode const *  pCur = pReadPos; pCur != pEnd; ++pCur)
 664         {
 665             if (*pCur != c_amp) continue; // no escape here
 666
 667         // handle an escape
 668             // find an escape end marker (after pCur). Result is pCur, if the end marker is not there
 669             sal_Unicode const *  pEndEscape = pCur + 1 + indexOfCharInRange(pCur+1,pEnd,c_end_escape);
 670
 671             OSL_ENSURE(pEndEscape != pCur, "Found dangling ampersand in normalized data");
 672
 673             sal_Unicode ch = implParseEscape(pCur,pEndEscape+1);
 674
 675             OSL_ENSURE(ch != 0, "Found unreckognized escape in normalized data");
 676
 677             if (ch != 0) // found and read a valid escape sequence
 678             {
 679                 // do copy of preceding data
 680                 aContent.append(pReadPos, pCur-pReadPos).append(ch);
 681                 pCur = pReadPos = pEndEscape;
 682
 683                 ++pReadPos;
 684
 685                 OSL_ASSERT(*pCur == c_end_escape);
 686             }
 687             // otherwise just treat the ampersand as a mormal character
 688         }
 689
 690         // do copy of remaining data
 691         if (pReadPos != pEnd)
 692             aContent.append(pReadPos, pEnd-pReadPos);
 693
 694         return aContent.makeStringAndClear();
 695     }
 696 //-----------------------------------------------------------------------------
 697
 698     /** validate and normalize the bracketed & quoted predicate in the string range [pBegin,pEnd)
 699         @return
 700             the normalized predicate
 701         @throw
 702             InvalidName, if the predicate is not valid
 703     */
 704     rtl::OUString implNormalizePredicate(sal_Unicode const *  pBegin, sal_Unicode const *  pEnd) SAL_THROW((InvalidName))
 705     {
 706         sal_Unicode sStopCharBuf[2];
 707         sal_Unicode const * pStopChars;
 708
 709         OSL_PRECOND(pBegin < pEnd,          "Nonempty string range expected");
 710         OSL_PRECOND(pEnd-pBegin >= 2,       "Bracketed string range expected");
 711         OSL_PRECOND(pBegin[0] == c_lBracket,"Bracketed string range expected");
 712         OSL_PRECOND(pEnd[-1] == c_rBracket, "Bracketed string range expected");
 713
 714         ++pBegin; --pEnd; // skip brackets
 715
 716         sal_Unicode const chUsedQuot = *pBegin;
 717         if (chUsedQuot == c_apos || chUsedQuot == c_quot)
 718         {
 719             OSL_PRECOND(pBegin < pEnd && pEnd-pBegin >= 2,  "Bracketed quoted string range expected");
 720             OSL_PRECOND(pEnd[-1] == chUsedQuot,             "Non-matching quotes in bracketed quoted string");
 721
 722             if (pEnd-pBegin <= 1 || pEnd[-1] != chUsedQuot)
 723                 throw InvalidName( rtl::OUString(pBegin, pEnd-pBegin), "is not a valid element predicate: quotes do not match");
 724
 725             ++pBegin; --pEnd; // skip quotes
 726
 727             sStopCharBuf[0] = chUsedQuot;
 728             sStopCharBuf[1] = 0;
 729
 730             pStopChars = sStopCharBuf;
 731         }
 732
 733         // non-quoted strings are not really valid, but we tolerate them
 734         else
 735         {
 736             OSL_ENSURE(false, "Warning: Invalid path - non-quoted data in bracketed predicate");
 737
 738             static sal_Unicode const sGeneralStoppers[] = { c_quot, c_apos, c_rBracket, c_lBracket, 0 };
 739
 740             pStopChars = sGeneralStoppers;
 741         }
 742
 743         if (pBegin == pEnd)
 744             throw InvalidName(rtl::OUString(pBegin-1,2),"Empty element name in predicate");
 745
 746         return implMakeNormalizedPredicate(pBegin, pEnd, pStopChars);
 747     }
 748 //-----------------------------------------------------------------------------
 749     /// parse a path into a sequence of components
 750     Path::Rep implParsePath(rtl::OUString const& _aPathString, PathType eType) SAL_THROW((InvalidName))
 751     {
 752         Path::Rep aResult;
 753
 754         dprint (stderr, "implParsePath '%s' ",
 755                  rtl::OUStringToOString(_aPathString, RTL_TEXTENCODING_UTF8).getStr());
 756
 757         sal_Unicode const *  pBegin = _aPathString.getStr();
 758         sal_Unicode const *  pEnd   = pBegin + _aPathString.getLength();
 759
 760         if (eType == eABSOLUTE)
 761         {
 762             if ( detectAbsolutePath(_aPathString) )
 763                 ++pBegin; // skip the leading slash
 764
 765 #ifdef CFG_PATH_STRICT
 766             else
 767                 OSL_ENSURE(false, "Warning: trying to parse relative path as absolute");
 768 #endif
 769         }
 770         else
 771             OSL_ENSURE(!detectAbsolutePath(_aPathString), "ERROR: trying to parse absolute path as relative one");
 772
 773         if (detectAbsolutePath(pBegin))
 774             throw InvalidName(_aPathString, "is not a valid path. Illegal empty first component");
 775
 776         else if (pBegin != pEnd && pEnd[-1] == '/')
 777         {
 778 #ifdef CFG_PATH_STRICT
 779             OSL_ENSURE(false, "Illegal configuration path. Terminating '/' found.");
 780 #endif
 781             --pEnd;
 782         }
 783
 784         while (pEnd != pBegin)
 785         {
 786             // check for predicate
 787             sal_Unicode const *  pQuoteStart = implFindPredicateStart(pBegin, pEnd);
 788             if (pQuoteStart == NULL)
 789                 throw InvalidName(_aPathString, "is not a valid path. Invalid name or predicate syntax");
 790
 791             sal_Unicode const *  pNameStart = implFindNameStart(pBegin, pQuoteStart);
 792
 793             rtl::OUString aElementName(pNameStart, pQuoteStart-pNameStart);
 794
 795             if (!isSimpleName(aElementName))
 796             {
 797                 // this is OK only for few cases WITH predicate
 798                 if (pQuoteStart == pEnd)
 799                     throw InvalidName(_aPathString, "is not a valid path. Invalid name");
 800
 801                 if (isEmptyString(aElementName))
 802                     aElementName = makeWildcardType();
 803
 804                 else if ( !isWildcardType(aElementName))
 805                     throw InvalidName(_aPathString, "is not a valid path. Invalid type tag for predicate");
 806             }
 807             if (pQuoteStart != pEnd)
 808             {
 809                 dprint (stderr, "add 'normalize predicate'", "");
 810                 rtl::OUString aPred = implNormalizePredicate(pQuoteStart,pEnd);
 811                 aElementName += aPred;
 812                 dprint (stderr, " [result pred '%s']",
 813                          rtl::OUStringToOString(aPred, RTL_TEXTENCODING_UTF8).getStr());
 814             }
 815
 816             aResult.prepend( Path::Component(aElementName) );
 817
 818             pEnd = pNameStart;
 819             if (pNameStart != pBegin) --pEnd;
 820         }
 821         dprint (stderr, "\n", "");
 822         return aResult;
 823     }
 824 //-----------------------------------------------------------------------------
 825
 826     /// build a composite path component from a base name (type) and a (somewhat optional) predicate
 827     rtl::OUString implMakeCompositeName(rtl::OUString const& _sBaseName, rtl::OUString const& _sPredicate) SAL_THROW((InvalidName))
 828     {
 829         rtl::OUString sComposite(_sBaseName);
 830
 831         if (isEmptyString(_sBaseName))
 832             sComposite = makeWildcardType();
 833
 834         else if (!isWildcardType(_sBaseName) && !isSimpleName(_sBaseName))
 835             throw InvalidName(_sBaseName, "The base-name (type) part of a composite node name must be a simple word");
 836
 837         dprint (stderr, "implMakeNormalizePred '%s' ",
 838                 rtl::OUStringToOString(_sPredicate, RTL_TEXTENCODING_UTF8).getStr());
 839
 840         sal_Unicode const *  pPredStart = _sPredicate.getStr();
 841         sal_Unicode const *  pPredEnd   = pPredStart + _sPredicate.getLength();
 842
 843         if (pPredStart != pPredEnd)
 844             sComposite += implMakeNormalizedPredicate(pPredStart, pPredEnd, NULL);
 845
 846         dprint (stderr, " [result pred '%s']\n",
 847                 rtl::OUStringToOString(sComposite, RTL_TEXTENCODING_UTF8).getStr());
 848
 849         return sComposite;
 850     }
 851 //-----------------------------------------------------------------------------
 852
 853     /// split a composite path component into a base name (type) and a predicate (if present)
 854     void implSplitCompositeName(rtl::OUString const& _aCompositeName, rtl::OUString& _rBaseName, rtl::OUString& _rPredicate) SAL_THROW(())
 855     {
 856         sal_Int32 nPos = _aCompositeName.indexOf(c_lBracket);
 857
 858         if (nPos >= 0)
 859         {
 860             OSL_ENSURE( nPos > 0, "Invalid name: Only predicate, no base type");
 861
 862             _rBaseName = _aCompositeName.copy(0,nPos);
 863
 864             sal_Unicode const *  pBeginPred = _aCompositeName.getStr() + nPos;
 865             sal_Unicode const *  pEndPred   = _aCompositeName.getStr() + _aCompositeName.getLength();
 866
 867             OSL_ASSERT(pBeginPred[0] == c_lBracket);
 868             OSL_ENSURE(pBeginPred[1] == c_normal_quot, "Missing or unexpected quote mark");
 869             OSL_ENSURE(pEndPred[-1] == c_rBracket, "Invalid name: Predicate brackets not closed");
 870             OSL_ENSURE(pEndPred[-2] == c_normal_quot, "Missing or unexpected quote mark");
 871
 872             // skip brackets and quotes - then read data
 873             _rPredicate = implReadPredicate(pBeginPred+2, pEndPred-2);
 874         }
 875         else
 876         {
 877             OSL_ENSURE( _aCompositeName.indexOf(c_rBracket) < 0, "Invalid name: Predicate brackets not opened");
 878             _rBaseName = _aCompositeName;
 879             _rPredicate = rtl::OUString();
 880         }
 881     }
 882 //-----------------------------------------------------------------------------
 883 }
 884 //-----------------------------------------------------------------------------
 885
 886 //-----------------------------------------------------------------------------
 887 // class RelativePath
 888 //-----------------------------------------------------------------------------
 889
 890 // Currently unused method to check/ensure validity
 891 void RelativePath::init() SAL_THROW(())
 892 {
 893 }
 894 //-----------------------------------------------------------------------------
 895
 896 RelativePath RelativePath::parse(rtl::OUString const& aString)
 897 {
 898     return RelativePath( implParsePath(aString, eRELATIVE) );
 899 }
 900 //-----------------------------------------------------------------------------
 901
 902 RelativePath::RelativePath(Path::Component const& aName) SAL_THROW(())
 903 : m_aRep(aName)
 904 {
 905     if (aName.isEmpty()) m_aRep.clearComponents();
 906 }
 907 //-----------------------------------------------------------------------------
 908
 909 RelativePath RelativePath::compose(RelativePath const& aPath) const SAL_THROW(())
 910 {
 911     Path::Rep aResult = aPath.rep();
 912     aResult.prepend( this->m_aRep );
 913     return RelativePath( aResult );
 914 }
 915 //-----------------------------------------------------------------------------
 916 rtl::OUString RelativePath::toString() const SAL_THROW(())
 917 {
 918     return m_aRep.toString(false);
 919 }
 920
 921 //-----------------------------------------------------------------------------
 922 // class AbsolutePath
 923 //-----------------------------------------------------------------------------
 924
 925 // Currently unused method to check/ensure validity
 926 void AbsolutePath::init() SAL_THROW(())
 927 {
 928 }
 929 //-----------------------------------------------------------------------------
 930
 931 AbsolutePath AbsolutePath::parse(rtl::OUString const& aString)
 932 {
 933     return AbsolutePath( implParsePath(aString, eABSOLUTE) );
 934 }
 935 //-----------------------------------------------------------------------------
 936
 937 AbsolutePath AbsolutePath::root() SAL_THROW(())
 938 {
 939     return AbsolutePath( Path::Rep() );
 940 }
 941 //-----------------------------------------------------------------------------
 942
 943 AbsolutePath AbsolutePath::detachedRoot() SAL_THROW(())
 944 {
 945     Path::Rep aRep( Path::makeEmptyComponent() ); // use 1 empty component here, to start detached names
 946     return AbsolutePath( aRep );
 947 }
 948 //-----------------------------------------------------------------------------
 949
 950 static inline Path::Component implMakeSafeModuleName(rtl::OUString const& _sModuleName) SAL_THROW(())
 951 {
 952     OSL_ENSURE( isSimpleName(_sModuleName), "A module name must be a simple name");
 953
 954     // if (isSimpleName(_sModuleName)) sModuleName = escape_name( _sModuleName );
 955
 956     return Path::Component(_sModuleName);
 957 }
 958 //-----------------------------------------------------------------------------
 959
 960 AbsolutePath AbsolutePath::makeModulePath(rtl::OUString const& _sModuleName) SAL_THROW(())
 961 {
 962     return AbsolutePath( Path::Rep( implMakeSafeModuleName(_sModuleName) ) );
 963 }
 964 //-----------------------------------------------------------------------------
 965
 966 AbsolutePath AbsolutePath::compose(RelativePath const& aPath) const SAL_THROW(())
 967 {
 968     Path::Rep aResult = aPath.rep();
 969     aResult.prepend( this->m_aRep );
 970     return AbsolutePath( aResult );
 971 }
 972 //-----------------------------------------------------------------------------
 973
 974 AbsolutePath AbsolutePath::getParentPath() const
 975 {
 976     // or: m_aRep.check_not_empty();
 977     OSL_ENSURE(!isRoot(), "ERROR: Requesting the parent of a root path");
 978     if (isRoot()) return *this;
 979
 980     OSL_ENSURE(!isDetached(), "ERROR: Requesting the parent of a detached path");
 981
 982     return AbsolutePath( Path::Rep(begin(),end()-1) );
 983 }
 984 #if OSL_DEBUG_LEVEL > 0
 985 //-----------------------------------------------------------------------------
 986
 987 bool AbsolutePath::isDetached() const SAL_THROW(())
 988 {
 989     return !m_aRep.isEmpty() && begin()->isEmpty();
 990 }
 991 #endif
 992 //-----------------------------------------------------------------------------
 993
 994 rtl::OUString AbsolutePath::toString() const SAL_THROW(())
 995 {
 996     return m_aRep.toString(true);
 997 }
 998 //-----------------------------------------------------------------------------
 999     }
1000 }
1001