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