← Back to branch summary

~ubuntu-branches/ubuntu/precise/lilypond/precise

« back to all changes in this revision

Viewing changes to flower/string-convert.cc

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Bushnell, BSG
  • Date: 2006-12-19 10:18:12 UTC
  • mfrom: (3.1.4 feisty)
  • Revision ID: james.westby@ubuntu.com-20061219101812-7awtjkp0i393wxty
Tags: 2.8.7-3
http://bugs.debian.org/400550
scripts/midi2ly.py: When setting DATADIR, find Lilypond python files
in the @TOPLEVEL_VERSION@ directory, not 'current'.  Patch thanks to
Chris Lamb (chris@chris-lamb.co.uk).  (Closes: #400550)

Show diffs side-by-side

added added

removed removed

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