LCOV - code coverage report
Current view: top level - ucb/source/regexp - regexp.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 89 225 39.6 %
Date: 2014-11-03 Functions: 8 9 88.9 %
Legend: Lines: hit not hit

          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 <regexp.hxx>
      21             : 
      22             : #include <cstddef>
      23             : 
      24             : #include "osl/diagnose.h"
      25             : #include <com/sun/star/lang/IllegalArgumentException.hpp>
      26             : #include <rtl/ustrbuf.hxx>
      27             : #include <rtl/ustring.hxx>
      28             : #include <comphelper/string.hxx>
      29             : 
      30             : namespace unnamed_ucb_regexp {} using namespace unnamed_ucb_regexp;
      31             :     // unnamed namespaces don't work well yet...
      32             : 
      33             : using namespace com::sun::star;
      34             : using namespace ucb_impl;
      35             : 
      36             : 
      37             : 
      38             : //  Regexp
      39             : 
      40             : 
      41             : 
      42       12118 : inline Regexp::Regexp(Kind eTheKind, OUString const & rThePrefix,
      43             :                       bool bTheEmptyDomain, OUString const & rTheInfix,
      44             :                       bool bTheTranslation,
      45             :                       OUString const & rTheReversePrefix):
      46             :     m_eKind(eTheKind),
      47             :     m_aPrefix(rThePrefix),
      48             :     m_aInfix(rTheInfix),
      49             :     m_aReversePrefix(rTheReversePrefix),
      50             :     m_bEmptyDomain(bTheEmptyDomain),
      51       12118 :     m_bTranslation(bTheTranslation)
      52             : {
      53             :     OSL_ASSERT(m_eKind == KIND_DOMAIN
      54             :                || (!m_bEmptyDomain && m_aInfix.isEmpty()));
      55             :     OSL_ASSERT(m_bTranslation || m_aReversePrefix.isEmpty());
      56       12118 : }
      57             : 
      58             : 
      59             : namespace unnamed_ucb_regexp {
      60             : 
      61     1115138 : bool matchStringIgnoreCase(sal_Unicode const ** pBegin,
      62             :                            sal_Unicode const * pEnd,
      63             :                            OUString const & rString)
      64             : {
      65     1115138 :     sal_Unicode const * p = *pBegin;
      66             : 
      67     1115138 :     sal_Unicode const * q = rString.getStr();
      68     1115138 :     sal_Unicode const * qEnd = q + rString.getLength();
      69             : 
      70     1115138 :     if (pEnd - p < qEnd - q)
      71      257044 :         return false;
      72             : 
      73     5975213 :     while (q != qEnd)
      74             :     {
      75     4582160 :         sal_Unicode c1 = *p++;
      76     4582160 :         sal_Unicode c2 = *q++;
      77     4582160 :         if (c1 >= 'a' && c1 <= 'z')
      78     3689337 :             c1 -= 'a' - 'A';
      79     4582160 :         if (c2 >= 'a' && c2 <= 'z')
      80     3689853 :             c2 -= 'a' - 'A';
      81     4582160 :         if (c1 != c2)
      82      323135 :             return false;
      83             :     }
      84             : 
      85      534959 :     *pBegin = p;
      86      534959 :     return true;
      87             : }
      88             : 
      89             : }
      90             : 
      91     1115138 : bool Regexp::matches(OUString const & rString,
      92             :                      OUString * pTranslation, bool * pTranslated) const
      93             : {
      94     1115138 :     sal_Unicode const * pBegin = rString.getStr();
      95     1115138 :     sal_Unicode const * pEnd = pBegin + rString.getLength();
      96             : 
      97     1115138 :     bool bMatches = false;
      98             : 
      99     1115138 :     sal_Unicode const * p = pBegin;
     100     1115138 :     if (matchStringIgnoreCase(&p, pEnd, m_aPrefix))
     101             :     {
     102      534959 :         sal_Unicode const * pBlock1Begin = p;
     103      534959 :         sal_Unicode const * pBlock1End = pEnd;
     104             : 
     105      534959 :         sal_Unicode const * pBlock2Begin = 0;
     106      534959 :         sal_Unicode const * pBlock2End = 0;
     107             : 
     108      534959 :         switch (m_eKind)
     109             :         {
     110             :             case KIND_PREFIX:
     111      534959 :                 bMatches = true;
     112      534959 :                 break;
     113             : 
     114             :             case KIND_AUTHORITY:
     115           0 :                 bMatches = p == pEnd || *p == '/' || *p == '?' || *p == '#';
     116           0 :                 break;
     117             : 
     118             :             case KIND_DOMAIN:
     119           0 :                 if (!m_bEmptyDomain)
     120             :                 {
     121           0 :                     if (p == pEnd || *p == '/' || *p == '?' || *p == '#')
     122             :                         break;
     123           0 :                     ++p;
     124             :                 }
     125             :                 for (;;)
     126             :                 {
     127           0 :                     sal_Unicode const * q = p;
     128           0 :                     if (matchStringIgnoreCase(&q, pEnd, m_aInfix)
     129           0 :                         && (q == pEnd || *q == '/' || *q == '?' || *q == '#'))
     130             :                     {
     131           0 :                         bMatches = true;
     132           0 :                         pBlock1End = p;
     133           0 :                         pBlock2Begin = q;
     134           0 :                         pBlock2End = pEnd;
     135           0 :                         break;
     136             :                     }
     137             : 
     138           0 :                     if (p == pEnd)
     139           0 :                         break;
     140             : 
     141           0 :                     sal_Unicode c = *p++;
     142           0 :                     if (c == '/' || c == '?' || c == '#')
     143             :                         break;
     144           0 :                 }
     145           0 :                 break;
     146             :         }
     147             : 
     148      534959 :         if (bMatches)
     149             :         {
     150      534959 :             if (m_bTranslation)
     151             :             {
     152           0 :                 if (pTranslation)
     153             :                 {
     154           0 :                     OUStringBuffer aBuffer(m_aReversePrefix);
     155           0 :                     aBuffer.append(pBlock1Begin, pBlock1End - pBlock1Begin);
     156           0 :                     aBuffer.append(m_aInfix);
     157           0 :                     aBuffer.append(pBlock2Begin, pBlock2End - pBlock2Begin);
     158           0 :                     *pTranslation = aBuffer.makeStringAndClear();
     159             :                 }
     160           0 :                 if (pTranslated)
     161           0 :                     *pTranslated = true;
     162             :             }
     163             :             else
     164             :             {
     165      534959 :                 if (pTranslation)
     166           0 :                     *pTranslation = rString;
     167      534959 :                 if (pTranslated)
     168           0 :                     *pTranslated = false;
     169             :             }
     170             :         }
     171             :     }
     172             : 
     173     1115138 :     return bMatches;
     174             : }
     175             : 
     176             : 
     177             : namespace unnamed_ucb_regexp {
     178             : 
     179       17706 : bool isScheme(OUString const & rString, bool bColon)
     180             : {
     181             :     using comphelper::string::isalphaAscii;
     182             :     using comphelper::string::isdigitAscii;
     183             :     // Return true if rString matches <scheme> (plus a trailing ":" if bColon
     184             :     // is true) from RFC 2396:
     185       17706 :     sal_Unicode const * p = rString.getStr();
     186       17706 :     sal_Unicode const * pEnd = p + rString.getLength();
     187       17706 :     if (p != pEnd && isalphaAscii(*p))
     188       17338 :         for (++p;;)
     189             :         {
     190      148126 :             if (p == pEnd)
     191       11756 :                 return !bColon;
     192      136370 :             sal_Unicode c = *p++;
     193      295100 :             if (!(isalphaAscii(c) || isdigitAscii(c)
     194      158730 :                   || c == '+' || c == '-' || c == '.'))
     195        5582 :                 return bColon && c == ':' && p == pEnd;
     196      130788 :         }
     197         368 :     return false;
     198             : }
     199             : 
     200           0 : void appendStringLiteral(OUStringBuffer * pBuffer,
     201             :                          OUString const & rString)
     202             : {
     203             :     OSL_ASSERT(pBuffer);
     204             : 
     205           0 :     pBuffer->append('"');
     206           0 :     sal_Unicode const * p = rString.getStr();
     207           0 :     sal_Unicode const * pEnd = p + rString.getLength();
     208           0 :     while (p != pEnd)
     209             :     {
     210           0 :         sal_Unicode c = *p++;
     211           0 :         if (c == '"' || c == '\\')
     212           0 :             pBuffer->append('\\');
     213           0 :         pBuffer->append(c);
     214             :     }
     215           0 :     pBuffer->append('"');
     216           0 : }
     217             : 
     218             : }
     219             : 
     220        5588 : OUString Regexp::getRegexp(bool bReverse) const
     221             : {
     222        5588 :     if (m_bTranslation)
     223             :     {
     224           0 :         OUStringBuffer aBuffer;
     225           0 :         if (bReverse)
     226             :         {
     227           0 :             if (!m_aReversePrefix.isEmpty())
     228           0 :                 appendStringLiteral(&aBuffer, m_aReversePrefix);
     229             :         }
     230             :         else
     231             :         {
     232           0 :             if (!m_aPrefix.isEmpty())
     233           0 :                 appendStringLiteral(&aBuffer, m_aPrefix);
     234             :         }
     235           0 :         switch (m_eKind)
     236             :         {
     237             :             case KIND_PREFIX:
     238           0 :                 aBuffer.append("(.*)");
     239           0 :                 break;
     240             : 
     241             :             case KIND_AUTHORITY:
     242           0 :                 aBuffer.append("(([/?#].*)?)");
     243           0 :                 break;
     244             : 
     245             :             case KIND_DOMAIN:
     246           0 :                 aBuffer.append("([^/?#]");
     247           0 :                 aBuffer.append(sal_Unicode(m_bEmptyDomain ? '*' : '+'));
     248           0 :                 if (!m_aInfix.isEmpty())
     249           0 :                     appendStringLiteral(&aBuffer, m_aInfix);
     250           0 :                 aBuffer.append("([/?#].*)?)");
     251           0 :                 break;
     252             :         }
     253           0 :         aBuffer.append("->");
     254           0 :         if (bReverse)
     255             :         {
     256           0 :             if (!m_aPrefix.isEmpty())
     257           0 :                 appendStringLiteral(&aBuffer, m_aPrefix);
     258             :         }
     259             :         else
     260             :         {
     261           0 :             if (!m_aReversePrefix.isEmpty())
     262           0 :                 appendStringLiteral(&aBuffer, m_aReversePrefix);
     263             :         }
     264           0 :         aBuffer.append("\\1");
     265           0 :         return aBuffer.makeStringAndClear();
     266             :     }
     267        5588 :     else if (m_eKind == KIND_PREFIX && isScheme(m_aPrefix, true))
     268        5582 :         return m_aPrefix.copy(0, m_aPrefix.getLength() - 1);
     269             :     else
     270             :     {
     271           6 :         OUStringBuffer aBuffer;
     272           6 :         if (!m_aPrefix.isEmpty())
     273           0 :             appendStringLiteral(&aBuffer, m_aPrefix);
     274           6 :         switch (m_eKind)
     275             :         {
     276             :             case KIND_PREFIX:
     277           6 :                 aBuffer.append(".*");
     278           6 :                 break;
     279             : 
     280             :             case KIND_AUTHORITY:
     281           0 :                 aBuffer.append("([/?#].*)?");
     282           0 :                 break;
     283             : 
     284             :             case KIND_DOMAIN:
     285           0 :                 aBuffer.append("[^/?#]");
     286           0 :                 aBuffer.append( m_bEmptyDomain ? '*' : '+' );
     287           0 :                 if (!m_aInfix.isEmpty())
     288           0 :                     appendStringLiteral(&aBuffer, m_aInfix);
     289           0 :                 aBuffer.append("([/?#].*)?");
     290           0 :                 break;
     291             :         }
     292           6 :         return aBuffer.makeStringAndClear();
     293             :     }
     294             : }
     295             : 
     296             : 
     297             : namespace unnamed_ucb_regexp {
     298             : 
     299         362 : bool matchString(sal_Unicode const ** pBegin, sal_Unicode const * pEnd,
     300             :                  sal_Char const * pString, size_t nStringLength)
     301             : {
     302         362 :     sal_Unicode const * p = *pBegin;
     303             : 
     304         362 :     unsigned char const * q = reinterpret_cast< unsigned char const * >(pString);
     305         362 :     unsigned char const * qEnd = q + nStringLength;
     306             : 
     307         362 :     if (pEnd - p < qEnd - q)
     308           0 :         return false;
     309             : 
     310        1448 :     while (q != qEnd)
     311             :     {
     312         724 :         sal_Unicode c1 = *p++;
     313         724 :         sal_Unicode c2 = *q++;
     314         724 :         if (c1 != c2)
     315           0 :             return false;
     316             :     }
     317             : 
     318         362 :     *pBegin = p;
     319         362 :     return true;
     320             : }
     321             : 
     322         362 : bool scanStringLiteral(sal_Unicode const ** pBegin, sal_Unicode const * pEnd,
     323             :                        OUString * pString)
     324             : {
     325         362 :     sal_Unicode const * p = *pBegin;
     326             : 
     327         362 :     if (p == pEnd || *p++ != '"')
     328         362 :         return false;
     329             : 
     330           0 :     OUStringBuffer aBuffer;
     331             :     for (;;)
     332             :     {
     333           0 :         if (p == pEnd)
     334           0 :             return false;
     335           0 :         sal_Unicode c = *p++;
     336           0 :         if (c == '"')
     337           0 :             break;
     338           0 :         if (c == '\\')
     339             :         {
     340           0 :             if (p == pEnd)
     341           0 :                 return false;
     342           0 :             c = *p++;
     343           0 :             if (c != '"' && c != '\\')
     344           0 :                 return false;
     345             :         }
     346           0 :         aBuffer.append(c);
     347           0 :     }
     348             : 
     349           0 :     *pBegin = p;
     350           0 :     *pString = aBuffer.makeStringAndClear();
     351           0 :     return true;
     352             : }
     353             : 
     354             : }
     355             : 
     356       12118 : Regexp Regexp::parse(OUString const & rRegexp)
     357             : {
     358             :     // Detect an input of '<scheme>' as an abbreviation of '"<scheme>:".*'
     359             :     // where <scheme> is as defined in RFC 2396:
     360       12118 :     if (isScheme(rRegexp, false))
     361             :         return Regexp(Regexp::KIND_PREFIX,
     362       23512 :                       rRegexp + ":",
     363             :                       false,
     364             :                       OUString(),
     365             :                       false,
     366       35268 :                       OUString());
     367             : 
     368         362 :     sal_Unicode const * p = rRegexp.getStr();
     369         362 :     sal_Unicode const * pEnd = p + rRegexp.getLength();
     370             : 
     371         362 :     OUString aPrefix;
     372         362 :     scanStringLiteral(&p, pEnd, &aPrefix);
     373             : 
     374         362 :     if (p == pEnd)
     375           0 :         throw lang::IllegalArgumentException();
     376             : 
     377             :     // This and the matchString() calls below are some of the few places where
     378             :     // RTL_CONSTASCII_STRINGPARAM() should NOT be removed.
     379             :     // (c.f. https://gerrit.libreoffice.org/3117)
     380         362 :     if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM(".*")))
     381             :     {
     382         362 :         if (p != pEnd)
     383           0 :             throw lang::IllegalArgumentException();
     384             : 
     385             :         return Regexp(Regexp::KIND_PREFIX, aPrefix, false, OUString(),
     386         362 :                       false, OUString());
     387             :     }
     388           0 :     else if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("(.*)->")))
     389             :     {
     390           0 :         OUString aReversePrefix;
     391           0 :         scanStringLiteral(&p, pEnd, &aReversePrefix);
     392             : 
     393           0 :         if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))
     394           0 :             || p != pEnd)
     395           0 :             throw lang::IllegalArgumentException();
     396             : 
     397             :         return Regexp(Regexp::KIND_PREFIX, aPrefix, false, OUString(),
     398           0 :                       true, aReversePrefix);
     399             :     }
     400           0 :     else if (matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("([/?#].*)?")))
     401             :     {
     402           0 :         if (p != pEnd)
     403           0 :             throw lang::IllegalArgumentException();
     404             : 
     405             :         return Regexp(Regexp::KIND_AUTHORITY, aPrefix, false, OUString(),
     406           0 :                       false, OUString());
     407             :     }
     408           0 :     else if (matchString(&p, pEnd,
     409           0 :                          RTL_CONSTASCII_STRINGPARAM("(([/?#].*)?)->")))
     410             :     {
     411           0 :         OUString aReversePrefix;
     412           0 :         if (!(scanStringLiteral(&p, pEnd, &aReversePrefix)
     413           0 :               && matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))
     414           0 :               && p == pEnd))
     415           0 :             throw lang::IllegalArgumentException();
     416             : 
     417             :         return Regexp(Regexp::KIND_AUTHORITY, aPrefix, false, OUString(),
     418           0 :                       true, aReversePrefix);
     419             :     }
     420             :     else
     421             :     {
     422           0 :         bool bOpen = false;
     423           0 :         if (p != pEnd && *p == '(')
     424             :         {
     425           0 :             ++p;
     426           0 :             bOpen = true;
     427             :         }
     428             : 
     429           0 :         if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("[^/?#]")))
     430           0 :             throw lang::IllegalArgumentException();
     431             : 
     432           0 :         if (p == pEnd || (*p != '*' && *p != '+'))
     433           0 :             throw lang::IllegalArgumentException();
     434           0 :         bool bEmptyDomain = *p++ == '*';
     435             : 
     436           0 :         OUString aInfix;
     437           0 :         scanStringLiteral(&p, pEnd, &aInfix);
     438             : 
     439           0 :         if (!matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("([/?#].*)?")))
     440           0 :             throw lang::IllegalArgumentException();
     441             : 
     442           0 :         OUString aReversePrefix;
     443           0 :         if (bOpen
     444           0 :             && !(matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM(")->"))
     445           0 :                  && scanStringLiteral(&p, pEnd, &aReversePrefix)
     446           0 :                  && matchString(&p, pEnd, RTL_CONSTASCII_STRINGPARAM("\\1"))))
     447           0 :             throw lang::IllegalArgumentException();
     448             : 
     449           0 :         if (p != pEnd)
     450           0 :             throw lang::IllegalArgumentException();
     451             : 
     452             :         return Regexp(Regexp::KIND_DOMAIN, aPrefix, bEmptyDomain, aInfix,
     453           0 :                       bOpen, aReversePrefix);
     454         362 :     }
     455             : }
     456             : 
     457             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10