flower/string-convert.cc

   1 /*
   2   PROJECT: FlowerSoft C++ library
   3   FILE   : string-convert.cc
   4
   5 --*/
   6
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <assert.h>
  10 #include <limits.h>
  11 #include "libc-extension.hh"
  12 #include "string.hh"
  13 #include "string-convert.hh"
  14 #include "rational.hh"
  15 #include "array.hh"
  16
  17 /**
  18    A safe length for stringconversion buffers.
  19
  20    worst case would be %f printing HUGE (or 1/HUGE), which is approx
  21    2e318, this number would have approx 318 zero's in its string.
  22
  23    Should enlarge buff dynamically.
  24
  25    @see
  26    man 3 snprintf
  27    */
  28 static const int STRING_BUFFER_LEN=1024;
  29
  30 String
  31 String_convert::bool_str (bool b)
  32 {
  33   return String (b ? "true" : "false");
  34 }
  35
  36 String
  37 String_convert::bin2hex_str (String bin_str)
  38 {
  39   String str;
  40   Byte const* byte_C = bin_str.byte_C ();
  41   for (int i = 0; i < bin_str.length_i (); i++)
  42     {
  43       str += to_str ((char)nibble2hex_byte (*byte_C >> 4));
  44       str += to_str ((char)nibble2hex_byte (*byte_C++));
  45     }
  46   return str;
  47 }
  48
  49 int
  50 String_convert::bin2_i (String bin_str)
  51 {
  52   return bin2_u (bin_str);
  53 }
  54
  55 unsigned
  56 String_convert::bin2_u (String bin_str)
  57 {
  58   assert (bin_str.length_i () <= (int)sizeof (unsigned));
  59
  60   unsigned result_u = 0;
  61   for (int i = 0; i < bin_str.length_i (); i++)
  62     {
  63       result_u <<= 8;
  64       result_u += (Byte)bin_str[ i ];
  65     }
  66   return result_u;
  67 }
  68
  69 // breendet imp from String
  70 int
  71 String_convert::dec2_i (String dec_str)
  72 {
  73   if (!dec_str.length_i ())
  74     return 0;
  75
  76   long l = 0;
  77   int conv = sscanf (dec_str.ch_C (), "%ld", &l);
  78   assert (conv);
  79
  80   return (int)l;
  81 }
  82
  83 String
  84 String_convert::i64_str (I64 i64, char const* fmt)
  85 {
  86   char buffer[STRING_BUFFER_LEN];
  87   snprintf (buffer, STRING_BUFFER_LEN,
  88  (fmt ? fmt : "%Ld"), i64);     // assume radix 10
  89   return String (buffer);
  90
  91 }
  92 // breendet imp from String
  93 double
  94 String_convert::dec2_f (String dec_str)
  95 {
  96   if (!dec_str.length_i ())
  97     return 0;
  98   double d = 0;
  99   int conv = sscanf (dec_str.ch_C (), "%lf", &d);
 100   assert (conv);
 101   return d;
 102 }
 103
 104 int
 105 String_convert::hex2bin_i (String hex_str, String& bin_str_r)
 106 {
 107   if (hex_str.length_i () % 2)
 108     hex_str = "0" + hex_str;
 109
 110   bin_str_r = "";
 111   Byte const* byte_C= hex_str.byte_C ();
 112   int i = 0;
 113   while (i < hex_str.length_i ())
 114     {
 115       int high_i = hex2nibble_i (*byte_C++);
 116       int low_i = hex2nibble_i (*byte_C++);
 117       if (high_i < 0 || low_i < 0)
 118         return 1; // illegal char
 119       bin_str_r += to_str ((char) (high_i << 4 | low_i), 1 );
 120       i += 2;
 121     }
 122   return 0;
 123 }
 124
 125 String
 126 String_convert::hex2bin_str (String hex_str)
 127 {
 128   String str;
 129   //  silly, asserts should alway be "on"!
 130   //    assert (!hex2bin_i (hex_str, str) );
 131   int error_i = hex2bin_i (hex_str, str);
 132   assert (!error_i);
 133   return str;
 134 }
 135
 136 int
 137 String_convert::hex2nibble_i (Byte byte)
 138 {
 139   if (byte >= '0' && byte <= '9')
 140     return byte - '0';
 141   if (byte >= 'A' && byte <= 'F')
 142     return byte - 'A' + 10;
 143   if (byte >= 'a' && byte <= 'f')
 144     return byte - 'a' + 10;
 145   return -1;
 146 }
 147
 148 // stupido.  Should use int_str ()
 149 String
 150 String_convert::i2dec_str (int i, int length_i, char ch)
 151 {
 152   char fill_ch = ch;
 153   if (fill_ch)
 154     fill_ch = '0';
 155
 156   // ugh
 157   String dec_str = to_str (i);
 158
 159   // ugh
 160   return to_str (fill_ch, length_i - dec_str.length_i ()) + dec_str;
 161 }
 162
 163
 164 // stupido.  Should use int_str ()
 165 String
 166 String_convert::u2hex_str (unsigned u, int length_i, char fill_ch)
 167 {
 168   String str;
 169   if (!u)
 170     str = "0";
 171
 172 #if 1 // both go...
 173   while (u)
 174     {
 175       str = to_str ((char) ((u % 16)["0123456789abcdef"] ) ) + str;
 176       u /= 16;
 177     }
 178 #else
 179   str += int_str (u, "%x");     // hmm. %lx vs. %x -> portability?
 180 #endif
 181
 182   str = to_str (fill_ch, length_i - str.length_i ()) + str;
 183   while ((str.length_i () > length_i) && (str[ 0 ] == 'f' ) )
 184     str = str.cut_str (2, INT_MAX);
 185
 186   return str;
 187 }
 188
 189 String
 190 String_convert::i2hex_str (int i, int length_i, char fill_ch)
 191 {
 192   return u2hex_str ((unsigned)i, length_i, fill_ch);
 193 }
 194
 195 Byte
 196 String_convert::nibble2hex_byte (Byte byte)
 197 {
 198   if ((byte & 0x0f) <= 9 )
 199     return (byte & 0x0f) + '0';
 200   else
 201     return (byte & 0x0f) - 10 + 'a';
 202 }
 203 /**
 204   Convert an integer to a string
 205
 206   @param
 207   #fmt# is a printf style format, default assumes "%d" as format.
 208   */
 209 String
 210 String_convert::int_str (int i, char const* fmt)
 211 {
 212   char buffer[STRING_BUFFER_LEN];
 213   snprintf (buffer, STRING_BUFFER_LEN,
 214  (fmt ? fmt : "%d"), i);     // assume radix 10
 215   return String (buffer);
 216 }
 217
 218 String
 219 String_convert::form_str (char const* format, ...)
 220 {
 221   va_list args;
 222   va_start (args, format);
 223   char buffer[STRING_BUFFER_LEN];
 224   vsnprintf (buffer, STRING_BUFFER_LEN, format, args);
 225   va_end (args);
 226   return String (buffer);
 227 }
 228
 229 String
 230 String_convert::vform_str (char const* format, va_list args)
 231 {
 232   char buffer[STRING_BUFFER_LEN];
 233   vsnprintf (buffer, STRING_BUFFER_LEN, format, args);
 234   return String (buffer);
 235 }
 236
 237 /**
 238   Convert a double to a string.
 239
 240   @param #fmt# is a printf style format, default assumes "%lf" as format
 241  */
 242 String
 243 String_convert::double_str (double f, char const* fmt)
 244 {
 245   char buf[STRING_BUFFER_LEN];
 246
 247   snprintf (buf, STRING_BUFFER_LEN, fmt ? fmt : "%f", f);
 248   return String (buf);
 249 }
 250
 251 /**
 252 Make a string from a single character.
 253
 254   @param
 255   #n# is a repetition count, default value is 1
 256  */
 257 String
 258 String_convert::char_str (char c, int n)
 259 {
 260   n = n >= 0 ? n : 0;
 261   char* ch_p = new char[ n ];
 262   memset (ch_p, c, n);
 263   String s ((Byte*)ch_p, n);
 264   delete[] ch_p;
 265   return s;
 266 }
 267
 268 String
 269 String_convert::rational_str (Rational r)
 270 {
 271         return r.str ();
 272 }
 273
 274 String
 275 String_convert::pointer_str (void const *l)
 276 {
 277   char buffer[STRING_BUFFER_LEN];
 278   snprintf (buffer, STRING_BUFFER_LEN, "%p", l);     // assume radix 10
 279   return String (buffer);
 280 }
 281
 282 /**
 283   Convert a double to a string.
 284
 285   @param
 286   #n# is the number of nonzero digits
 287  */
 288 String
 289 String_convert::precision_str (double x, int n)
 290 {
 291   String format = "%." + to_str (0 >? n - 1) + "e";
 292   String str = double_str (abs (x), format.ch_C ());
 293
 294   int exp = str.right_str (3).value_i ();
 295   str = str.left_str (str.length_i () - 4);
 296
 297   while (str[str.length_i () - 1] == '0')
 298     str = str.left_str (str.length_i () - 1);
 299   if (str[str.length_i () - 1] == '.')
 300     str = str.left_str (str.length_i () - 1);
 301
 302   if (exp == 0)
 303     return (sign (x) > 0 ? str : "-" + str);
 304
 305   str = str.left_str (1) + str.cut_str (2, INT_MAX);
 306   int dot = 1 + exp;
 307   if (dot <= 0)
 308     str = "0." + to_str ('0', -dot) + str;
 309   else if (dot >= str.length_i ())
 310     str += to_str ('0', dot - str.length_i ());
 311   else if (( dot > 0) && (dot < str.length_i ()))
 312     str = str.left_str (dot) + "." + str.cut_str (dot, INT_MAX);
 313   else
 314     assert (0);
 315
 316   return (sign (x) > 0 ? str : "-" + str);
 317 }
 318
 319 Array<String>
 320 String_convert::split_arr (String str, char c)
 321 {
 322   Array<String> a;
 323   int i = str.index_i (c);
 324   while (i >=0)
 325     {
 326       String s = str.left_str (i);
 327       a.push (s);
 328       while (str[++i] == c)
 329         ;
 330       str = str.cut_str (i, INT_MAX);
 331       i = str.index_i (c);
 332     }
 333   if (str.length_i ())
 334     a.push (str);
 335   return a;
 336 }
 337
 338
 339 String
 340 String_convert::long_str (long l)
 341 {
 342   char s[STRING_BUFFER_LEN];
 343   sprintf (s,"%ld", l);
 344   return s;
 345 }
 346
 347 String
 348 String_convert::pad_to (String s, int n)
 349 {
 350   return s + to_str (' ' , (n - s.length_i ()) >? 0);
 351 }