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