LCOV - code coverage report
Current view: top level - vcl/source/helper - strhelper.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 128 216 59.3 %
Date: 2014-11-03 Functions: 8 11 72.7 %
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 "vcl/strhelper.hxx"
      21             : #include "sal/alloca.h"
      22             : 
      23             : namespace psp {
      24             : 
      25     2353756 : inline bool isSpace( char cChar )
      26             : {
      27             :     return
      28     2088000 :         cChar == ' '    || cChar == '\t'    ||
      29     2088000 :         cChar == '\r'   || cChar == '\n'    ||
      30     4441756 :         cChar == 0x0c   || cChar == 0x0b;
      31             : }
      32             : 
      33     1226444 : inline bool isSpace( sal_Unicode cChar )
      34             : {
      35             :     return
      36     1120364 :         cChar == ' '    || cChar == '\t'    ||
      37     1120364 :         cChar == '\r'   || cChar == '\n'    ||
      38     2346808 :         cChar == 0x0c   || cChar == 0x0b;
      39             : }
      40             : 
      41       38396 : inline bool isProtect( char cChar )
      42             : {
      43       38396 :     return cChar == '`' || cChar == '\'' || cChar == '"';
      44             : }
      45             : 
      46           0 : inline bool isProtect( sal_Unicode cChar )
      47             : {
      48           0 :     return cChar == '`' || cChar == '\'' || cChar == '"';
      49             : }
      50             : 
      51     1051192 : inline void CopyUntil( char*& pTo, const char*& pFrom, char cUntil, bool bIncludeUntil = false )
      52             : {
      53     1051192 :     do
      54             :     {
      55     1051192 :         if( *pFrom == '\\' )
      56             :         {
      57         232 :             pFrom++;
      58         232 :             if( *pFrom )
      59             :             {
      60         232 :                 *pTo = *pFrom;
      61         232 :                 pTo++;
      62             :             }
      63             :         }
      64     1050960 :         else if( bIncludeUntil || ! isProtect( *pFrom ) )
      65             :         {
      66     1050960 :             *pTo = *pFrom;
      67     1050960 :             pTo++;
      68             :         }
      69     1051192 :         pFrom++;
      70     1051192 :     } while( *pFrom && *pFrom != cUntil );
      71             :     // copy the terminating character unless zero or protector
      72       38396 :     if( ! isProtect( *pFrom ) || bIncludeUntil )
      73             :     {
      74       38396 :         *pTo = *pFrom;
      75       38396 :         if( *pTo )
      76       38396 :             pTo++;
      77             :     }
      78       38396 :     if( *pFrom )
      79       38396 :         pFrom++;
      80       38396 : }
      81             : 
      82           0 : inline void CopyUntil( sal_Unicode*& pTo, const sal_Unicode*& pFrom, sal_Unicode cUntil, bool bIncludeUntil = false )
      83             : {
      84           0 :     do
      85             :     {
      86           0 :         if( *pFrom == '\\' )
      87             :         {
      88           0 :             pFrom++;
      89           0 :             if( *pFrom )
      90             :             {
      91           0 :                 *pTo = *pFrom;
      92           0 :                 pTo++;
      93             :             }
      94             :         }
      95           0 :         else if( bIncludeUntil || ! isProtect( *pFrom ) )
      96             :         {
      97           0 :             *pTo = *pFrom;
      98           0 :             pTo++;
      99             :         }
     100           0 :         pFrom++;
     101           0 :     } while( *pFrom && *pFrom != cUntil );
     102             :     // copy the terminating character unless zero or protector
     103           0 :     if( ! isProtect( *pFrom ) || bIncludeUntil )
     104             :     {
     105           0 :         *pTo = *pFrom;
     106           0 :         if( *pTo )
     107           0 :             pTo++;
     108             :     }
     109           0 :     if( *pFrom )
     110           0 :         pFrom++;
     111           0 : }
     112             : 
     113       47588 : OUString GetCommandLineToken( int nToken, const OUString& rLine )
     114             : {
     115       47588 :     sal_Int32 nLen = rLine.getLength();
     116       47588 :     if( ! nLen )
     117           0 :         return OUString();
     118             : 
     119       47588 :     int nActualToken = 0;
     120       47588 :     sal_Unicode* pBuffer = (sal_Unicode*)alloca( sizeof(sal_Unicode)*( nLen + 1 ) );
     121       47588 :     const sal_Unicode* pRun = rLine.getStr();
     122       47588 :     sal_Unicode* pLeap = NULL;
     123             : 
     124      182612 :     while( *pRun && nActualToken <= nToken )
     125             :     {
     126      214720 :         while( *pRun && isSpace( *pRun ) )
     127       39848 :             pRun++;
     128       87436 :         pLeap = pBuffer;
     129     1175976 :         while( *pRun && ! isSpace( *pRun ) )
     130             :         {
     131     1001104 :             if( *pRun == '\\' )
     132             :             {
     133             :                 // escapement
     134           0 :                 pRun++;
     135           0 :                 *pLeap = *pRun;
     136           0 :                 pLeap++;
     137           0 :                 if( *pRun )
     138           0 :                     pRun++;
     139             :             }
     140     1001104 :             else if( *pRun == '`' )
     141           0 :                 CopyUntil( pLeap, pRun, '`' );
     142     1001104 :             else if( *pRun == '\'' )
     143           0 :                 CopyUntil( pLeap, pRun, '\'' );
     144     1001104 :             else if( *pRun == '"' )
     145           0 :                 CopyUntil( pLeap, pRun, '"' );
     146             :             else
     147             :             {
     148     1001104 :                 *pLeap = *pRun;
     149     1001104 :                 pLeap++;
     150     1001104 :                 pRun++;
     151             :             }
     152             :         }
     153       87436 :         if( nActualToken != nToken )
     154       46808 :             pBuffer[0] = 0;
     155       87436 :         nActualToken++;
     156             :     }
     157             : 
     158       47588 :     *pLeap = 0;
     159             : 
     160       47588 :     return OUString(pBuffer);
     161             : }
     162             : 
     163       45588 : OString GetCommandLineToken(int nToken, const OString& rLine)
     164             : {
     165       45588 :     sal_Int32 nLen = rLine.getLength();
     166       45588 :     if (!nLen)
     167           0 :         return rLine;
     168             : 
     169       45588 :     int nActualToken = 0;
     170       45588 :     char* pBuffer = (char*)alloca( nLen + 1 );
     171       45588 :     const char* pRun = rLine.getStr();
     172       45588 :     char* pLeap = NULL;
     173             : 
     174      138620 :     while( *pRun && nActualToken <= nToken )
     175             :     {
     176       98136 :         while( *pRun && isSpace( *pRun ) )
     177        3248 :             pRun++;
     178       47444 :         pLeap = pBuffer;
     179      681500 :         while( *pRun && ! isSpace( *pRun ) )
     180             :         {
     181      586612 :             if( *pRun == '\\' )
     182             :             {
     183             :                 // escapement
     184           0 :                 pRun++;
     185           0 :                 *pLeap = *pRun;
     186           0 :                 pLeap++;
     187           0 :                 if( *pRun )
     188           0 :                     pRun++;
     189             :             }
     190      586612 :             else if( *pRun == '`' )
     191           0 :                 CopyUntil( pLeap, pRun, '`' );
     192      586612 :             else if( *pRun == '\'' )
     193           0 :                 CopyUntil( pLeap, pRun, '\'' );
     194      586612 :             else if( *pRun == '"' )
     195           0 :                 CopyUntil( pLeap, pRun, '"' );
     196             :             else
     197             :             {
     198      586612 :                 *pLeap = *pRun;
     199      586612 :                 pLeap++;
     200      586612 :                 pRun++;
     201             :             }
     202             :         }
     203       47444 :         if( nActualToken != nToken )
     204        1856 :             pBuffer[0] = 0;
     205       47444 :         nActualToken++;
     206             :     }
     207             : 
     208       45588 :     *pLeap = 0;
     209             : 
     210       45588 :     return OString(pBuffer);
     211             : }
     212             : 
     213           0 : int GetCommandLineTokenCount(const OUString& rLine)
     214             : {
     215           0 :     if (rLine.isEmpty())
     216           0 :         return 0;
     217             : 
     218           0 :     int nTokenCount = 0;
     219           0 :     const sal_Unicode *pRun = rLine.getStr();
     220             : 
     221           0 :     while( *pRun )
     222             :     {
     223           0 :         while( *pRun && isSpace( *pRun ) )
     224           0 :             pRun++;
     225           0 :         if( ! *pRun )
     226           0 :             break;
     227           0 :         while( *pRun && ! isSpace( *pRun ) )
     228             :         {
     229           0 :             if( *pRun == '\\' )
     230             :             {
     231             :                 // escapement
     232           0 :                 pRun++;
     233           0 :                 if( *pRun )
     234           0 :                     pRun++;
     235             :             }
     236           0 :             else if( *pRun == '`' )
     237             :             {
     238           0 :                 do pRun++; while( *pRun && *pRun != '`' );
     239           0 :                 if( *pRun )
     240           0 :                     pRun++;
     241             :             }
     242           0 :             else if( *pRun == '\'' )
     243             :             {
     244           0 :                 do pRun++; while( *pRun && *pRun != '\'' );
     245           0 :                 if( *pRun )
     246           0 :                     pRun++;
     247             :             }
     248           0 :             else if( *pRun == '"' )
     249             :             {
     250           0 :                 do pRun++; while( *pRun && *pRun != '"' );
     251           0 :                 if( *pRun )
     252           0 :                     pRun++;
     253             :             }
     254             :             else
     255           0 :                 pRun++;
     256             :         }
     257           0 :         nTokenCount++;
     258             :     }
     259             : 
     260           0 :     return nTokenCount;
     261             : }
     262             : 
     263        3384 : OUString WhitespaceToSpace( const OUString& rLine, bool bProtect )
     264             : {
     265        3384 :     sal_Int32 nLen = rLine.getLength();
     266        3384 :     if( ! nLen )
     267         216 :         return OUString();
     268             : 
     269        3168 :     sal_Unicode *pBuffer = (sal_Unicode*)alloca( sizeof(sal_Unicode)*(nLen + 1) );
     270        3168 :     const sal_Unicode *pRun = rLine.getStr();
     271        3168 :     sal_Unicode *pLeap = pBuffer;
     272             : 
     273       11232 :     while( *pRun )
     274             :     {
     275        4896 :         if( *pRun && isSpace( *pRun ) )
     276             :         {
     277        4896 :             *pLeap = ' ';
     278        4896 :             pLeap++;
     279        4896 :             pRun++;
     280             :         }
     281        9792 :         while( *pRun && isSpace( *pRun ) )
     282           0 :             pRun++;
     283       36792 :         while( *pRun && ! isSpace( *pRun ) )
     284             :         {
     285       27000 :             if( *pRun == '\\' )
     286             :             {
     287             :                 // escapement
     288           0 :                 pRun++;
     289           0 :                 *pLeap = *pRun;
     290           0 :                 pLeap++;
     291           0 :                 if( *pRun )
     292           0 :                     pRun++;
     293             :             }
     294       27000 :             else if( bProtect && *pRun == '`' )
     295           0 :                 CopyUntil( pLeap, pRun, '`', true );
     296       27000 :             else if( bProtect && *pRun == '\'' )
     297           0 :                 CopyUntil( pLeap, pRun, '\'', true );
     298       27000 :             else if( bProtect && *pRun == '"' )
     299           0 :                 CopyUntil( pLeap, pRun, '"', true );
     300             :             else
     301             :             {
     302       27000 :                 *pLeap = *pRun;
     303       27000 :                 ++pLeap;
     304       27000 :                 ++pRun;
     305             :             }
     306             :         }
     307             :     }
     308             : 
     309        3168 :     *pLeap = 0;
     310             : 
     311             :     // there might be a space at beginning or end
     312        3168 :     pLeap--;
     313        3168 :     if( *pLeap == ' ' )
     314          72 :         *pLeap = 0;
     315             : 
     316        3168 :     return OUString(*pBuffer == ' ' ? pBuffer+1 : pBuffer);
     317             : }
     318             : 
     319       81548 : OString WhitespaceToSpace(const OString& rLine, bool bProtect)
     320             : {
     321       81548 :     sal_Int32 nLen = rLine.getLength();
     322       81548 :     if (!nLen)
     323           0 :         return rLine;
     324             : 
     325       81548 :     char *pBuffer = (char*)alloca( nLen + 1 );
     326       81548 :     const char *pRun = rLine.getStr();
     327       81548 :     char *pLeap = pBuffer;
     328             : 
     329      337096 :     while( *pRun )
     330             :     {
     331      174000 :         if( *pRun && isSpace( *pRun ) )
     332             :         {
     333      133980 :             *pLeap = ' ';
     334      133980 :             pLeap++;
     335      133980 :             pRun++;
     336             :         }
     337      348000 :         while( *pRun && isSpace( *pRun ) )
     338           0 :             pRun++;
     339     1587924 :         while( *pRun && ! isSpace( *pRun ) )
     340             :         {
     341     1239924 :             if( *pRun == '\\' )
     342             :             {
     343             :                 // escapement
     344           0 :                 pRun++;
     345           0 :                 *pLeap = *pRun;
     346           0 :                 pLeap++;
     347           0 :                 if( *pRun )
     348           0 :                     pRun++;
     349             :             }
     350     1239924 :             else if( bProtect && *pRun == '`' )
     351           0 :                 CopyUntil( pLeap, pRun, '`', true );
     352     1239924 :             else if( bProtect && *pRun == '\'' )
     353           0 :                 CopyUntil( pLeap, pRun, '\'', true );
     354     1239924 :             else if( bProtect && *pRun == '"' )
     355       38396 :                 CopyUntil( pLeap, pRun, '"', true );
     356             :             else
     357             :             {
     358     1201528 :                 *pLeap = *pRun;
     359     1201528 :                 ++pLeap;
     360     1201528 :                 ++pRun;
     361             :             }
     362             :         }
     363             :     }
     364             : 
     365       81548 :     *pLeap = 0;
     366             : 
     367             :     // there might be a space at beginning or end
     368       81548 :     pLeap--;
     369       81548 :     if( *pLeap == ' ' )
     370           0 :         *pLeap = 0;
     371             : 
     372       81548 :     return OString(*pBuffer == ' ' ? pBuffer+1 : pBuffer);
     373             : }
     374             : 
     375             : } // namespace
     376             : 
     377             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10