]> git.donarmstrong.com Git - lilypond.git/blob - flower/string-convert.cc
(class Sources): idem.
[lilypond.git] / flower / string-convert.cc
1 /*
2   PROJECT: FlowerSoft C++ library
3   FILE   : string-convert.cc
4
5   --*/
6
7 #include "string-convert.hh"
8
9 #include <cstring>
10 #include <cstdio>
11 using namespace std;
12
13 #include "libc-extension.hh"
14 #include "rational.hh"
15 #include "std-vector.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_string (bool b)
32 {
33   return string (b ? "true" : "false");
34 }
35
36 string
37 String_convert::bin2hex (string bin_string)
38 {
39   string str;
40   Byte const *byte = (Byte const*)bin_string.data ();
41   for (ssize i = 0; i < bin_string.length (); i++)
42     {
43       str += to_string ((char)nibble2hex_byte (*byte >> 4));
44       str += to_string ((char)nibble2hex_byte (*byte++));
45     }
46   return str;
47 }
48
49 int
50 String_convert::bin2int (string bin_string)
51 {
52   return bin2unsigned (bin_string);
53 }
54
55 unsigned
56 String_convert::bin2unsigned (string bin_string)
57 {
58   assert (bin_string.length () <= (int)sizeof (unsigned));
59
60   unsigned result_u = 0;
61   for (ssize i = 0; i < bin_string.length (); i++)
62     {
63       result_u <<= 8;
64       result_u += (Byte)bin_string[ i ];
65     }
66   return result_u;
67 }
68
69 // breendet imp from string
70 int
71 String_convert::dec2int (string dec_string)
72 {
73   if (!dec_string.length ())
74     return 0;
75
76   long l = 0;
77   int conv = sscanf (dec_string.c_str (), "%ld", &l);
78   assert (conv);
79
80   return (int)l;
81 }
82
83 string
84 String_convert::i64_string (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 // breendet imp from string
92 double
93 String_convert::dec2double (string dec_string)
94 {
95   if (!dec_string.length ())
96     return 0;
97   double d = 0;
98   int conv = sscanf (dec_string.c_str (), "%lf", &d);
99   assert (conv);
100   return d;
101 }
102
103 int
104 String_convert::hex2bin (string hex_string, string &bin_string_r)
105 {
106   if (hex_string.length () % 2)
107     hex_string = "0" + hex_string;
108
109   bin_string_r = "";
110   Byte const *byte = (Byte const*) hex_string.data ();
111   ssize i = 0;
112   while (i < hex_string.length ())
113     {
114       int high_i = hex2nibble (*byte++);
115       int low_i = hex2nibble (*byte++);
116       if (high_i < 0 || low_i < 0)
117         return 1; // illegal char
118       bin_string_r += to_string ((char) (high_i << 4 | low_i), 1);
119       i += 2;
120     }
121   return 0;
122 }
123
124 string
125 String_convert::hex2bin (string hex_string)
126 {
127   string str;
128   //  silly, asserts should alway be "on"!
129   //    assert (!hex2bin (hex_string, str) );
130   int error_i = hex2bin (hex_string, str);
131   assert (!error_i);
132   return str;
133 }
134
135 int
136 String_convert::hex2nibble (Byte byte)
137 {
138   if (byte >= '0' && byte <= '9')
139     return byte - '0';
140   if (byte >= 'A' && byte <= 'F')
141     return byte - 'A' + 10;
142   if (byte >= 'a' && byte <= 'f')
143     return byte - 'a' + 10;
144   return -1;
145 }
146
147 // stupido.  Should use int_string ()
148 string
149 String_convert::int2dec (int i, int length_i, char ch)
150 {
151   char fill_char = ch;
152   if (fill_char)
153     fill_char = '0';
154
155   // ugh
156   string dec_string = to_string (i);
157
158   // ugh
159   return to_string (fill_char, length_i - dec_string.length ()) + dec_string;
160 }
161
162 // stupido.  Should use int_string ()
163 string
164 String_convert::unsigned2hex (unsigned u, ssize length, char fill_char)
165 {
166   string str;
167   if (!u)
168     str = "0";
169
170 #if 1 // both go...
171   while (u)
172     {
173       str = to_string ((char) ((u % 16)["0123456789abcdef"])) + str;
174       u /= 16;
175     }
176 #else
177   str += int_string (u, "%x");  // hmm. %lx vs. %x -> portability?
178 #endif
179
180   str = to_string (fill_char, length - str.length ()) + str;
181   while ((str.length () > length) && (str[ 0 ] == 'f'))
182     str = str.substr (2);
183
184   return str;
185 }
186
187 string
188 String_convert::int2hex (int i, int length_i, char fill_char)
189 {
190   return unsigned2hex ((unsigned)i, length_i, fill_char);
191 }
192
193 Byte
194 String_convert::nibble2hex_byte (Byte byte)
195 {
196   if ((byte & 0x0f) <= 9)
197     return (byte & 0x0f) + '0';
198   else
199     return (byte & 0x0f) - 10 + 'a';
200 }
201 /**
202    Convert an integer to a string
203
204    @param
205    #fmt# is a printf style format, default assumes "%d" as format.
206 */
207 string
208 String_convert::int_string (int i, char const *fmt)
209 {
210   char buffer[STRING_BUFFER_LEN];
211   snprintf (buffer, STRING_BUFFER_LEN,
212             (fmt ? fmt : "%d"), i); // assume radix 10
213   return string (buffer);
214 }
215
216 string
217 String_convert::form_string (char const *format, ...)
218 {
219   va_list args;
220   va_start (args, format);
221   char buffer[STRING_BUFFER_LEN];
222   vsnprintf (buffer, STRING_BUFFER_LEN, format, args);
223   va_end (args);
224   return string (buffer);
225 }
226
227 string
228 String_convert::vform_string (char const *format, va_list args)
229 {
230   char buffer[STRING_BUFFER_LEN];
231   vsnprintf (buffer, STRING_BUFFER_LEN, format, args);
232   return string (buffer);
233 }
234
235 /**
236    Convert a double to a string.
237
238    @param #fmt# is a printf style format, default assumes "%lf" as format
239 */
240 string
241 String_convert::double_string (double f, char const *fmt)
242 {
243   char buf[STRING_BUFFER_LEN];
244
245   snprintf (buf, STRING_BUFFER_LEN, fmt ? fmt : "%f", f);
246   return string (buf);
247 }
248
249 /**
250    Make a string from a single character.
251
252    @param
253    #n# is a repetition count, default value is 1
254 */
255 string
256 String_convert::char_string (char c, int n)
257 {
258   n = n >= 0 ? n : 0;
259   char *ch = new char[ n ];
260   memset (ch, c, n);
261   string s (ch, n);
262   
263   delete[] ch;
264   return s;
265 }
266
267 string
268 String_convert::rational_string (Rational r)
269 {
270   return r.to_string ();
271 }
272
273 string
274 String_convert::pointer_string (void const *l)
275 {
276   char buffer[STRING_BUFFER_LEN];
277   snprintf (buffer, STRING_BUFFER_LEN, "%p", l); // assume radix 10
278   return string (buffer);
279 }
280
281 /**
282    Convert a double to a string.
283
284    @param
285    #n# is the number of nonzero digits
286 */
287 string
288 String_convert::precision_string (double x, int n)
289 {
290   string format = "%." + to_string (max (0, n - 1)) + "e";
291   string str = double_string (abs (x), format.c_str ());
292
293   int exp = dec2int (str.substr (str.length () - 3));
294   str = str.substr (0, str.length () - 4);
295
296   while (str[str.length () - 1] == '0')
297     str = str.substr (0, str.length () - 1);
298   if (str[str.length () - 1] == '.')
299     str = str.substr (0, str.length () - 1);
300
301   if (exp == 0)
302     return (sign (x) > 0 ? str : "-" + str);
303
304   str = str.substr (0, 1) + str.substr (2);
305   ssize dot = 1 + exp;
306   if (dot <= 0)
307     str = "0." + to_string ('0', -dot) + str;
308   else if (dot >= str.length ())
309     str += to_string ('0', dot - str.length ());
310   else if ((dot > 0) && (dot < str.length ()))
311     str = str.substr (0, dot) + "." + str.substr (dot);
312   else
313     assert (0);
314
315   return (sign (x) > 0 ? str : "-" + str);
316 }
317
318
319 string
320 String_convert::long_string (long l)
321 {
322   char s[STRING_BUFFER_LEN];
323   sprintf (s, "%ld", l);
324   return s;
325 }
326
327 string
328 String_convert::unsigned_string (unsigned u)
329 {
330   char s[STRING_BUFFER_LEN];
331   sprintf (s, "%u", u);
332   return s;
333 }
334
335 string
336 String_convert::pad_to (string s, int n)
337 {
338   return s + string (max (int(n - s.length ()), 0), ' ');
339 }
340
341 string
342 String_convert::to_upper (string s)
343 {
344   return strnupr ((char *)s.c_str (), s.length ());
345 }
346
347 string
348 String_convert::to_lower (string s)
349 {
350   return strnlwr ((char *)s.c_str (), s.length ());
351 }
352
353 string
354 String_convert::reverse (string s)
355 {
356   return (char*) memrev ((unsigned char *)s.data (), s.length ());
357 }