/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2000, 2010 Oracle and/or its affiliates. * * OpenOffice.org - a multi-platform office productivity suite * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_unotools.hxx" #include "unotools/configpathes.hxx" #include #include #include //---------------------------------------------------------------------------- namespace utl { //---------------------------------------------------------------------------- using ::rtl::OUString; using ::rtl::OUStringBuffer; //---------------------------------------------------------------------------- static void lcl_resolveCharEntities(OUString & aLocalString) { sal_Int32 nEscapePos=aLocalString.indexOf('&'); if (nEscapePos < 0) return; OUStringBuffer aResult; sal_Int32 nStart = 0; do { sal_Unicode ch = 0; if (aLocalString.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("&"),nEscapePos)) ch = '&'; else if (aLocalString.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("'"),nEscapePos)) ch = '\''; else if (aLocalString.matchAsciiL(RTL_CONSTASCII_STRINGPARAM("""),nEscapePos)) ch = '"'; OSL_ENSURE(ch,"Configuration path contains '&' that is not part of a valid character escape"); if (ch) { aResult.append(aLocalString.copy(nStart,nEscapePos-nStart)).append(ch); sal_Int32 nEscapeEnd=aLocalString.indexOf(';',nEscapePos); nStart = nEscapeEnd+1; nEscapePos=aLocalString.indexOf('&',nStart); } else { nEscapePos=aLocalString.indexOf('&',nEscapePos+1); } } while ( nEscapePos > 0); aResult.append(aLocalString.copy(nStart)); aLocalString = aResult.makeStringAndClear(); } //---------------------------------------------------------------------------- sal_Bool splitLastFromConfigurationPath(OUString const& _sInPath, OUString& _rsOutPath, OUString& _rsLocalName) { sal_Int32 nStart,nEnd; sal_Int32 nPos = _sInPath.getLength()-1; // strip trailing slash if (nPos > 0 && _sInPath[ nPos ] == sal_Unicode('/')) { OSL_ENSURE(false, "Invalid config path: trailing '/' is not allowed"); --nPos; } // check for predicate ['xxx'] or ["yyy"] if (nPos > 0 && _sInPath[ nPos ] == sal_Unicode(']')) { sal_Unicode chQuote = _sInPath[--nPos]; if (chQuote == '\'' || chQuote == '\"') { nEnd = nPos; nPos = _sInPath.lastIndexOf(chQuote,nEnd); nStart = nPos + 1; --nPos; // nPos = rInPath.lastIndexOf('[',nPos); } else // allow [xxx] { nEnd = nPos + 1; nPos = _sInPath.lastIndexOf('[',nEnd); nStart = nPos + 1; } OSL_ENSURE(nPos >= 0 && _sInPath[nPos] == '[', "Invalid config path: unmatched quotes or brackets"); if (nPos >= 0 && _sInPath[nPos] == '[') { nPos = _sInPath.lastIndexOf('/',nPos); } else // defined behavior for invalid pathes { nStart = 0, nEnd = _sInPath.getLength(); nPos = -1; } } else { nEnd = nPos+1; nPos = _sInPath.lastIndexOf('/',nEnd); nStart = nPos + 1; } OSL_ASSERT( -1 <= nPos && nPos < nStart && nStart < nEnd && nEnd <= _sInPath.getLength() ); OSL_ASSERT(nPos == -1 || _sInPath[nPos] == '/'); OSL_ENSURE(nPos != 0 , "Invalid config child path: immediate child of root"); _rsLocalName = _sInPath.copy(nStart, nEnd-nStart); _rsOutPath = (nPos > 0) ? _sInPath.copy(0,nPos) : OUString(); lcl_resolveCharEntities(_rsLocalName); return nPos >= 0; } //---------------------------------------------------------------------------- OUString extractFirstFromConfigurationPath(OUString const& _sInPath, OUString* _sOutPath) { sal_Int32 nSep = _sInPath.indexOf('/'); sal_Int32 nBracket = _sInPath.indexOf('['); sal_Int32 nStart = nBracket + 1; sal_Int32 nEnd = nSep; if (0 <= nBracket) // found a bracket-quoted relative path { if (nSep < 0 || nBracket < nSep) // and the separator comes after it { sal_Unicode chQuote = _sInPath[nStart]; if (chQuote == '\'' || chQuote == '\"') { ++nStart; nEnd = _sInPath.indexOf(chQuote, nStart+1); nBracket = nEnd+1; } else { nEnd = _sInPath.indexOf(']',nStart); nBracket = nEnd; } OSL_ENSURE(nEnd > nStart && _sInPath[nBracket] == ']', "Invalid config path: improper mismatch of quote or bracket"); OSL_ENSURE((nBracket+1 == _sInPath.getLength() && nSep == -1) || (_sInPath[nBracket+1] == '/' && nSep == nBracket+1), "Invalid config path: brackets not followed by slash"); } else // ... but our initial element name is in simple form nStart = 0; } OUString sResult = (nEnd >= 0) ? _sInPath.copy(nStart, nEnd-nStart) : _sInPath; lcl_resolveCharEntities(sResult); if (_sOutPath != 0) { *_sOutPath = (nSep >= 0) ? _sInPath.copy(nSep + 1) : OUString(); } return sResult; } //---------------------------------------------------------------------------- // find the position after the prefix in the nested path static inline sal_Int32 lcl_findPrefixEnd(OUString const& _sNestedPath, OUString const& _sPrefixPath) { // TODO: currently handles only exact prefix matches sal_Int32 nPrefixLength = _sPrefixPath.getLength(); OSL_ENSURE(nPrefixLength == 0 || _sPrefixPath[nPrefixLength-1] != '/', "Cannot handle slash-terminated prefix pathes"); sal_Bool bIsPrefix; if (_sNestedPath.getLength() > nPrefixLength) { bIsPrefix = _sNestedPath[nPrefixLength] == '/' && _sNestedPath.compareTo(_sPrefixPath,nPrefixLength) == 0; ++nPrefixLength; } else if (_sNestedPath.getLength() == nPrefixLength) { bIsPrefix = _sNestedPath.equals(_sPrefixPath); } else { bIsPrefix = false; } return bIsPrefix ? nPrefixLength : 0; } //---------------------------------------------------------------------------- sal_Bool isPrefixOfConfigurationPath(OUString const& _sNestedPath, OUString const& _sPrefixPath) { return _sPrefixPath.getLength() == 0 || lcl_findPrefixEnd(_sNestedPath,_sPrefixPath) != 0; } //---------------------------------------------------------------------------- OUString dropPrefixFromConfigurationPath(OUString const& _sNestedPath, OUString const& _sPrefixPath) { if ( sal_Int32 nPrefixEnd = lcl_findPrefixEnd(_sNestedPath,_sPrefixPath) ) { return _sNestedPath.copy(nPrefixEnd); } else { OSL_ENSURE(_sPrefixPath.getLength() == 0, "Path does not start with expected prefix"); return _sNestedPath; } } //---------------------------------------------------------------------------- static OUString lcl_wrapName(const OUString& _sContent, const OUString& _sType) { const sal_Unicode * const pBeginContent = _sContent.getStr(); const sal_Unicode * const pEndContent = pBeginContent + _sContent.getLength(); OSL_PRECOND(_sType.getLength(), "Unexpected config type name: empty"); OSL_PRECOND(pBeginContent <= pEndContent, "Invalid config name: empty"); if (pBeginContent == pEndContent) return _sType; rtl::OUStringBuffer aNormalized(_sType.getLength() + _sContent.getLength() + 4); // reserve approximate size initially // prefix: type, opening bracket and quote aNormalized.append( _sType ).appendAscii( RTL_CONSTASCII_STRINGPARAM("['") ); // content: copy over each char and handle escaping for(const sal_Unicode* pCur = pBeginContent; pCur != pEndContent; ++pCur) { // append (escape if needed) switch(*pCur) { case sal_Unicode('&') : aNormalized.appendAscii( RTL_CONSTASCII_STRINGPARAM("&") ); break; case sal_Unicode('\''): aNormalized.appendAscii( RTL_CONSTASCII_STRINGPARAM("'") ); break; case sal_Unicode('\"'): aNormalized.appendAscii( RTL_CONSTASCII_STRINGPARAM(""") ); break; default: aNormalized.append( *pCur ); } } // suffix: closing quote and bracket aNormalized.appendAscii( RTL_CONSTASCII_STRINGPARAM("']") ); return aNormalized.makeStringAndClear(); } //---------------------------------------------------------------------------- OUString wrapConfigurationElementName(OUString const& _sElementName) { return lcl_wrapName(_sElementName, OUString(RTL_CONSTASCII_USTRINGPARAM("*")) ); } //---------------------------------------------------------------------------- OUString wrapConfigurationElementName(OUString const& _sElementName, OUString const& _sTypeName) { // todo: check that _sTypeName is valid return lcl_wrapName(_sElementName, _sTypeName); } //---------------------------------------------------------------------------- } // namespace utl /* vim:set shiftwidth=4 softtabstop=4 expandtab: */