v2/util_string.cpp

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // name: util_string.cpp
  27 // desc: ...
  28 //
  29 // author: Ge Wang (gewang@cs.princeton.edu)
  30 //         Perry R. Cook (prc@cs.princeton.edu)
  31 // date: Summer 2005
  32 //-----------------------------------------------------------------------------
  33 #include "util_string.h"
  34 using namespace std;
  35
  36
  37
  38
  39 //-----------------------------------------------------------------------------
  40 // name: itoa()
  41 // desc: ...
  42 //-----------------------------------------------------------------------------
  43 string itoa( t_CKINT val )
  44 {
  45     char buffer[128];
  46     sprintf( buffer, "%li", val );
  47     return string(buffer);
  48 }
  49
  50
  51
  52 //-----------------------------------------------------------------------------
  53 // name: ftoa()
  54 // desc: ...
  55 //-----------------------------------------------------------------------------
  56 string ftoa( t_CKFLOAT val, t_CKUINT precision )
  57 {
  58     char str[32];
  59     char buffer[128];
  60     if( precision > 32 ) precision = 32;
  61     sprintf( str, "%%.%lif", precision );
  62     sprintf( buffer, str, val );
  63     return string(buffer);
  64 }
  65
  66
  67
  68
  69 //-----------------------------------------------------------------------------
  70 // name: tolower()
  71 // desc: ...
  72 //-----------------------------------------------------------------------------
  73 string tolower( const string & str )
  74 {
  75     string s = str;
  76     t_CKUINT len = s.length();
  77
  78     // loop
  79     for( t_CKUINT i = 0; i < len; i++ )
  80         if( s[i] >= 'A' && s[i] <= 'Z' )
  81             s[i] += 32;
  82
  83     return s;
  84 }
  85
  86
  87
  88
  89 //-----------------------------------------------------------------------------
  90 // name: toupper()
  91 // desc: ...
  92 //-----------------------------------------------------------------------------
  93 string toupper( const string & str )
  94 {
  95     string s = str;
  96     t_CKUINT len = s.length();
  97
  98     // loop
  99     for( t_CKUINT i = 0; i < len; i++ )
 100         if( s[i] >= 'a' && s[i] <= 'z' )
 101             s[i] -= 32;
 102
 103     return s;
 104 }
 105
 106
 107
 108
 109 //-----------------------------------------------------------------------------
 110 // name: trim()
 111 // desc: ...
 112 //-----------------------------------------------------------------------------
 113 string trim( const string & val )
 114 {
 115     // two ends
 116     t_CKINT start = 0;
 117     t_CKINT end = val.length() - 1;
 118
 119     // left trim
 120     for( start = 0; start < end; start++ )
 121     {
 122         // non-white space
 123         if( val[start] != ' ' && val[start] != '\t' )
 124             break;
 125     }
 126
 127     // if start > end, then all white space
 128     if( start > end ) return "";
 129
 130     // right trim
 131     for( ; end >= start; end-- )
 132     {
 133         // non-white space
 134         if( val[end] != ' ' && val[end] != '\t' )
 135             break;
 136     }
 137
 138     // cannot be
 139     assert( end >= start );
 140
 141     // return
 142     return val.substr( start, end - start + 1 );
 143 }
 144
 145
 146
 147 //-----------------------------------------------------------------------------
 148 // name: ltrim()
 149 // desc: ...
 150 //-----------------------------------------------------------------------------
 151 string ltrim( const string & val )
 152 {
 153     // two ends
 154     t_CKINT start = 0;
 155     t_CKINT end = val.length() - 1;
 156
 157     // left trim
 158     for( start = 0; start < end; start++ )
 159     {
 160         // non-white space
 161         if( val[start] != ' ' && val[start] != '\t' )
 162             break;
 163     }
 164
 165     // if start > end, then all white space
 166     if( start > end ) return "";
 167
 168     // return
 169     return val.substr( start, end - start + 1 );
 170 }
 171
 172
 173
 174
 175 //-----------------------------------------------------------------------------
 176 // name: rtrim()
 177 // desc: ...
 178 //-----------------------------------------------------------------------------
 179 string rtrim( const string & val )
 180 {
 181     // two ends
 182     t_CKINT start = 0;
 183     t_CKINT end = val.length() - 1;
 184
 185     // right trim
 186     for( ; end >= start; end-- )
 187     {
 188         // non-white space
 189         if( val[end] != ' ' && val[end] != '\t' )
 190             break;
 191     }
 192
 193     // if end < start, then all white space
 194     if( end < start ) return "";
 195
 196     // return
 197     return val.substr( start, end - start + 1 );
 198 }
 199
 200
 201
 202
 203 //-----------------------------------------------------------------------------
 204 // name: extract_args()
 205 // desc: extract argument from format filename:arg1:arg2:etc
 206 //-----------------------------------------------------------------------------
 207 t_CKBOOL extract_args( const string & token,
 208                        string & filename, vector<string> & args )
 209 {
 210     // clear vector
 211     args.clear();
 212     // clear filename
 213     filename = "";
 214
 215     // last : found pos
 216     t_CKINT prev_pos = 0;
 217     // curr : pos
 218     t_CKINT i = 0;
 219
 220     // copy and trim
 221     string s = trim( token );
 222
 223     // detect
 224     t_CKBOOL scan = FALSE;
 225     t_CKBOOL ret = TRUE;
 226     char * buf = NULL;
 227     char * mask = NULL;
 228     for( i = 0; i < s.length(); i++ )
 229         if( s[i] == '\\' )
 230         {
 231             scan = TRUE;
 232             break;
 233         }
 234
 235     // mad...
 236     if( scan )
 237     {
 238         buf = new char[s.length()+1];
 239         mask = new char[s.length()];
 240         t_CKINT len = 0;
 241
 242         // loop through
 243         for( i = 0; i < s.length(); i++ )
 244         {
 245             // zero
 246             mask[len] = 0;
 247
 248             // escape
 249             if( s[i] == '\\' && (i+1) < s.length() && s[i+1] == ':' )
 250             {
 251                 i++;
 252                 mask[len] = 1;
 253             }
 254
 255             // add
 256             buf[len++] = s[i];
 257         }
 258
 259         // end
 260         buf[len] = '\0';
 261
 262         // copy
 263         s = buf;
 264     }
 265
 266     // loop through
 267     for( i = 0; i < s.length(); i++ )
 268     {
 269         // look for :
 270         if( s[i] == ':' && ( !mask || !mask[i] ) )
 271         {
 272             // sanity
 273             if( i == 0 )
 274             {
 275                 ret = FALSE;
 276                 goto done;
 277             }
 278
 279             // copy
 280             if( filename == "" )
 281                 filename = s.substr( prev_pos, i - prev_pos );
 282             else
 283                 args.push_back( s.substr( prev_pos, i - prev_pos ) );
 284
 285             // update
 286             prev_pos = i + 1;
 287         }
 288     }
 289
 290     // get the remainder, if any
 291     if( prev_pos < s.length() )
 292     {
 293         // copy
 294         if( filename == "" )
 295             filename = s.substr( prev_pos, s.length() - prev_pos );
 296         else
 297             args.push_back( s.substr( prev_pos, s.length() - prev_pos ) );
 298     }
 299
 300 done:
 301     // reclaim
 302     SAFE_DELETE_ARRAY( buf );
 303     SAFE_DELETE_ARRAY( mask );
 304
 305     return ret;
 306 }