vcl/source/helper/strhelper.cxx

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