flower/string-convert.cc

   1 /*
   2   PROJECT: FlowerSoft C++ library
   3   FILE   : string-convert.cc
   4
   5 --*/
   6
   7
   8 #include <assert.h>
   9 #include "string.hh"
  10 #include "string-convert.hh"
  11
  12 /**
  13    a safe length for stringconversion buffers
  14
  15    worst case would be %f printing HUGE (or 1/HUGE), which is approx
  16    2e318, this number would have approx 318 zero's in its string.
  17
  18    Should enlarge buff dynamically.
  19    @see
  20    man 3 snprintf
  21    */
  22 static const int STRING_BUFFER_LEN=1024;
  23
  24 String
  25 String_convert::bin2hex_str( String bin_str )
  26 {
  27     String str;
  28     Byte const* byte_c_l = bin_str.byte_c_l();
  29     for ( int i = 0; i < bin_str.length_i(); i++ ) {
  30         str += (char)nibble2hex_byte( *byte_c_l >> 4 );
  31         str += (char)nibble2hex_byte( *byte_c_l++ );
  32     }
  33     return str;
  34 }
  35
  36 int
  37 String_convert::bin2_i( String bin_str )
  38 {
  39     assert( bin_str.length_i() <= 4 );
  40
  41     int result_i = 0;
  42     for ( int i = 0; i < bin_str.length_i(); i++ ) {
  43         result_i <<= 8;
  44         result_i += (Byte)bin_str[ i ];
  45     }
  46     return result_i;
  47 }
  48
  49 // breendet imp from String
  50 int
  51 String_convert::dec2_i( String dec_str )
  52 {
  53     if ( !dec_str.length_i() )
  54         return 0;
  55
  56     long l = 0;
  57     int conv = sscanf( dec_str.ch_c_l(), "%ld", &l );
  58     assert( conv );
  59
  60     return (int)l;
  61 }
  62
  63 String
  64 String_convert::longlong_str(long long ll, char const* fmt)
  65 {
  66     char buffer[STRING_BUFFER_LEN];
  67     snprintf(buffer, STRING_BUFFER_LEN,
  68              (fmt ? fmt : "%Ld"), ll );     // assume radix 10
  69     return String(buffer);
  70
  71 }
  72 // breendet imp from String
  73 double
  74 String_convert::dec2_f( String dec_str )
  75 {
  76     if ( !dec_str.length_i() )
  77         return 0;
  78     double d = 0;
  79     int conv = sscanf( dec_str.ch_c_l(), "%lf", &d );
  80     assert( conv );
  81     return d;
  82 }
  83
  84 int
  85 String_convert::hex2bin_i( String hex_str, String& bin_str_r )
  86 {
  87     if ( hex_str.length_i() % 2 )
  88         hex_str = "0" + hex_str;
  89
  90     bin_str_r = "";
  91     Byte const* byte_c_l= hex_str.byte_c_l();
  92     int i = 0;
  93     while ( i < hex_str.length_i() ) {
  94         int high_i = hex2nibble_i( *byte_c_l++ );
  95         int low_i = hex2nibble_i( *byte_c_l++ );
  96         if ( high_i < 0 || low_i < 0 )
  97             return 1; // illegal char
  98         bin_str_r += String( (char)( high_i << 4 | low_i ), 1 );
  99         i += 2;
 100     }
 101     return 0;
 102 }
 103
 104 String
 105 String_convert::hex2bin_str( String hex_str )
 106 {
 107     String str;
 108 //  silly, asserts should alway be "on"!
 109 //    assert( !hex2bin_i( hex_str, str ) );
 110     int error_i = hex2bin_i( hex_str, str );
 111     assert( !error_i );
 112     return str;
 113 }
 114
 115 int
 116 String_convert::hex2nibble_i( Byte byte )
 117 {
 118     if ( byte >= '0' && byte <= '9' )
 119         return byte - '0';
 120     if ( byte >= 'A' && byte <= 'F' )
 121         return byte - 'A' + 10;
 122     if ( byte >= 'a' && byte <= 'f')
 123         return byte - 'a' + 10;
 124     return -1;
 125 }
 126
 127 // stupido.  Should use int_str()
 128 String
 129 String_convert::i2dec_str( int i, int length_i, char ch )
 130 {
 131     char fill_ch = ch;
 132     if ( fill_ch)
 133         fill_ch = '0';
 134
 135     // ugh
 136     String dec_str( i );
 137
 138     // ugh
 139     return String( fill_ch, length_i - dec_str.length_i() ) + dec_str;
 140 }
 141
 142
 143 // stupido.  Should use int_str()
 144 String
 145 String_convert::i2hex_str( int i, int length_i, char ch )
 146 {
 147     String str;
 148     if ( !i )
 149         str = "0";
 150     while ( i ) {
 151         str = ( i % 16 )["0123456789abcdef"] + str;
 152         i /= 16;
 153     }
 154     if ( str.length_i() < length_i )
 155         str = String( ch, length_i - str.length_i() ) + str;
 156     return str;
 157 }
 158
 159 Byte
 160 String_convert::nibble2hex_byte( Byte byte )
 161 {
 162     if ( ( byte & 0x0f ) <= 9 )
 163         return ( byte & 0x0f ) + '0';
 164     else
 165         return ( byte & 0x0f ) - 10 + 'a';
 166 }
 167 /**
 168   Convert an integer to a string
 169
 170   @param
 171   #fmt# is a printf style format, default assumes "%d" as format.
 172   */
 173 String
 174 String_convert::int_str(int i, char const* fmt)
 175 {
 176     char buffer[STRING_BUFFER_LEN];
 177     snprintf(buffer, STRING_BUFFER_LEN,
 178              (fmt ? fmt : "%d"), i );     // assume radix 10
 179     return String(buffer);
 180 }
 181
 182 /**
 183   Convert a double to a string.
 184
 185   @param #fmt# is a printf style format, default assumes "%lf" as format
 186  */
 187 String
 188 String_convert::double_str(double f, char const* fmt)
 189 {
 190     char buf[STRING_BUFFER_LEN];
 191
 192     snprintf(buf, STRING_BUFFER_LEN, fmt ? fmt : "%f", f);
 193     return buf;
 194 }
 195
 196 /**
 197   Make a string from a single character.
 198
 199   @param
 200     #n# is a repetition count, default value is 1
 201  */
 202 String
 203 String_convert::char_str(char c, int n)
 204 {
 205     n = n >= 0 ? n : 0;
 206     char* ch_p = new char[ n ];
 207     memset( ch_p, c, n );
 208     String s((Byte*)ch_p, n);
 209     delete ch_p;
 210     return s;
 211 }
 212
 213 String
 214 String_convert::rational_str(Rational r)
 215 {
 216     char * n = Itoa(r.numerator()); // LEAK????
 217
 218     String s = n;
 219     if (r.denominator() != 1) {
 220         char * d = Itoa(r.denominator());
 221         s +=  String( '/' ) + String(d);
 222         //delete d;
 223     }
 224 /*    delete n;
 225     */
 226     return s;
 227 }
 228
 229 String
 230 String_convert::pointer_str(const void *l)
 231 {
 232     long long int ill = (long long int )l;
 233     return String_convert::longlong_str(ill,  "0x%0Lx");
 234 }