flower/string.cc

   1 /*
   2
   3  string.cc - implement String
   4
   5  (c) 1997 Han-Wen Nienhuys & Jan Nieuwenhuizen
   6
   7  */
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11
  12 #include <assert.h>
  13 #include <string.h>
  14
  15 #include "string.hh"
  16 #include "libc-extension.hh"
  17 #include "string-convert.hh"
  18
  19 #ifdef STRING_DEBUG
  20 void* mymemmove( void* dest, void const* src, size_t n );
  21 #define memmove mymemmove
  22 #endif
  23
  24 // return array, alloced with new.
  25 Byte*
  26 String::copy_byte_p() const
  27 {
  28     Byte const* src = strh_.byte_c_l();
  29     Byte* dest = new Byte[strh_.length_i() + 1];
  30     memcpy( dest, src, strh_.length_i() + 1 );
  31     return dest;
  32 }
  33 void
  34 String::print_on(ostream& os) const
  35 {
  36     if (strh_.null_terminated_b())
  37         os << ch_c_l();
  38     else
  39         for ( int i = 0; i < length_i(); i++ )
  40             os << (Byte)(*this)[ i ];
  41 }
  42 \f
  43 /*
  44   copying, constructing.
  45  */
  46 String&
  47 String::operator = (String const&source )
  48 {
  49     strh_ = source.strh_;
  50     return *this;
  51 }
  52
  53
  54 String::String(Rational r)
  55 {
  56     *this = String_convert::rational_str(r);
  57 }
  58
  59 String::String (double f, char const* fmt)
  60 {
  61     *this= String_convert::double_str(f,fmt);
  62 }
  63
  64 String::String( char c,  int n )
  65 {
  66     *this = String_convert::char_str (c,n);
  67 }
  68
  69 /**
  70   @see
  71   String_convert::int_str
  72  */
  73 String::String(int i, const char * format )
  74 {
  75     *this = String_convert::int_str(i,format);
  76 }
  77
  78 String::String (bool b)
  79 {
  80     *this = (char const* ) (b ? "true" : "false");
  81 }
  82
  83 String::String( char const* source )
  84 {
  85     assert(source);
  86     strh_ = source;
  87 }
  88
  89 String::String( Byte const* byte_l, int length_i )
  90 {
  91     strh_.set( byte_l, length_i );
  92 }
  93 \f
  94 void
  95 String::append(String s)
  96 {
  97     strh_.append( s.byte_c_l(), s.length_i() );
  98 }
  99 void
 100 String::operator +=(String s)
 101 {
 102     append(s);
 103 }
 104
 105 void
 106 String::prepend(String s)
 107 {
 108     s += *this;
 109     *this = s;
 110 }
 111
 112 int
 113 String::length_i() const
 114 {
 115     return strh_.length_i();
 116 }
 117
 118 Byte const*
 119 String::byte_c_l() const
 120 {
 121     return strh_.byte_c_l();
 122 }
 123
 124 char const*
 125 String::ch_c_l() const
 126 {
 127     return strh_.ch_c_l();
 128 }
 129
 130 Byte*
 131 String::byte_l()
 132 {
 133     return strh_.byte_l();
 134 }
 135
 136 char*
 137 String::ch_l()
 138 {
 139     return strh_.ch_l();
 140 }
 141
 142 /**
 143   Do a signed comparison,  analogous to memcmp;
 144  */
 145 int
 146 String::compare_i(String const& s1, String const& s2 )
 147 {
 148     Byte const* p1 = s1.byte_c_l();
 149     Byte const* p2 = s2.byte_c_l();
 150     if ( p1 == p2 )
 151         return 0;
 152
 153     int i1 = s1.length_i();
 154     int i2 = s2.length_i();
 155
 156     int result=  memcmp( p1, p2, i1 <? i2 );
 157     return result ? result : i1-i2;
 158 }
 159
 160 \f
 161 int
 162 String::index_last_i( char const c ) const
 163 {
 164     if ( !length_i() )
 165         return -1;
 166
 167     char const* me = strh_.ch_c_l();
 168     char const* p = memrchr(me, length_i(), c );
 169     if ( p )
 170         return p - me;
 171     return -1;
 172 }
 173
 174 int
 175 String::index_last_i( char const* string ) const // UGK!
 176 {
 177     assert(false);              // broken
 178     int length = strlen( string ); // ugrh
 179     if ( !length_i() || !length )
 180         return -1;
 181
 182     int next_i = index_i( string );
 183     if ( next_i == -1 )
 184         return -1;
 185
 186     int index_i = 0;
 187     while( next_i >= 0 ) {
 188         index_i += next_i;
 189         next_i = right_str( length_i() - index_i - length ).index_i( string );
 190     }
 191     return index_i;
 192 }
 193
 194 /** find  a character.
 195
 196   @return
 197   the index of the leftmost character #c# (0 <= return < length_i()),
 198   or   -1 if not found.
 199
 200   ? should return length_i()?, as in string.left_str(index_i(delimiter))
 201 */
 202 int
 203 String::index_i(char c ) const
 204 {
 205     char const* me = strh_.ch_c_l();
 206     char const* p = (char const *) memchr( me,c,  length_i());
 207     if ( p )
 208         return p - me;
 209     return -1;
 210 }
 211
 212 /**
 213   find the substring.
 214
 215   @return
 216   index of leftmost occurrence of #searchfor#
 217  */
 218 int
 219 String::index_i( String searchfor ) const
 220 {
 221     char const* me = strh_.ch_c_l();
 222     char const* p = (char const *) memmem(
 223         me, length_i(), searchfor.ch_c_l(), searchfor.length_i());
 224
 225     if ( p )
 226         return p - me;
 227     else
 228         return -1;
 229 }
 230
 231 /** find chars of a set.
 232
 233   @return
 234   the index of the leftmost occurance of an element of #set#
 235   */
 236 int
 237 String::index_any_i( String set ) const
 238 {
 239     int n = length_i();
 240     if ( !n )
 241         return -1;
 242
 243     const void * me_l = (const void*) strh_.ch_c_l();
 244     for (int i=0; i  < set.length_i(); i++) {
 245         char * found=(char*) memchr(me_l, set[i], n  );
 246         if (found) {
 247             return found - me_l;
 248         }
 249     }
 250     return -1;
 251 }
 252 \f
 253 String
 254 String::left_str( int n ) const
 255 {
 256     if (n >= length_i())
 257         return *this;
 258
 259     String retval;
 260     if (n < 1)
 261         return retval;
 262
 263     retval = *this;
 264     retval.strh_.trunc(n);
 265     return retval;
 266 }
 267
 268 String
 269 String::right_str( int n ) const
 270 {
 271     if (n > length_i())
 272         return *this;
 273
 274     if ( n < 1)
 275         return "";
 276
 277     return String( strh_.byte_c_l() + length_i() - n, n );
 278 }
 279
 280
 281 String
 282 String::nomid_str( int index_i, int n ) const
 283 {
 284     if ( index_i < 0 ) {
 285         n += index_i;
 286         index_i = 0;
 287     }
 288     if ( n <= 0)
 289         return *this;
 290
 291     return
 292         left_str( index_i )   +
 293         right_str( length_i() - index_i - n ) ;
 294 }
 295
 296 /*
 297   proposal: change to "cut()"
 298  */
 299 String
 300 String::mid_str( int index_i, int n ) const
 301 {
 302     if (index_i <0) {
 303         n += index_i;
 304         index_i=0;
 305     }
 306
 307     if ( !length_i() || ( index_i < 0 ) || ( index_i >= length_i() ) || ( n < 1 ) )
 308         return String();
 309
 310     if ( ( n > length_i() ) ||  ( index_i + n > length_i() ) )
 311         n = length_i() - index_i;
 312
 313     return String( byte_c_l() + index_i, n );
 314 }
 315 \f
 316 String
 317 String::upper_str() const
 318 {
 319     String str = *this;
 320     str.to_upper();
 321     return str;
 322 }
 323 void
 324 String::to_upper()
 325 {
 326     char *s = (char*)strh_.byte_l();
 327     strnupr( s ,length_i());
 328 }
 329
 330 void
 331 String::to_lower()
 332 {
 333     char* s = strh_.ch_l();
 334     strnlwr(s,length_i());
 335 }
 336
 337
 338 String
 339 String::lower_str() const
 340 {
 341     String str = *this;
 342     str.to_lower();
 343     return str;
 344 }
 345 String
 346 String::reversed_str() const
 347 {
 348     String str = *this;
 349     strrev( str.byte_l(), str.length_i() );
 350     return str;
 351 }
 352
 353 int
 354 String::value_i() const
 355 {
 356     return String_convert::dec2_i( *this );
 357 }
 358
 359 double
 360 String::value_f() const
 361 {
 362     return String_convert::dec2_f( *this );
 363 }
 364
 365