flower/string-convert.cc

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