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