Ruby  2.4.2p198(2017-09-14revision59899)
sprintf.c
Go to the documentation of this file.
1 /**********************************************************************
2 
3  sprintf.c -
4 
5  $Author: nagachika $
6  created at: Fri Oct 15 10:39:26 JST 1993
7 
8  Copyright (C) 1993-2007 Yukihiro Matsumoto
9  Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
10  Copyright (C) 2000 Information-technology Promotion Agency, Japan
11 
12 **********************************************************************/
13 
14 #include "internal.h"
15 #include "ruby/re.h"
16 #include "id.h"
17 #include <math.h>
18 #include <stdarg.h>
19 
20 #ifdef HAVE_IEEEFP_H
21 #include <ieeefp.h>
22 #endif
23 
24 #define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */
25 
26 static void fmt_setup(char*,size_t,int,int,int,int);
27 
28 static char
29 sign_bits(int base, const char *p)
30 {
31  char c = '.';
32 
33  switch (base) {
34  case 16:
35  if (*p == 'X') c = 'F';
36  else c = 'f';
37  break;
38  case 8:
39  c = '7'; break;
40  case 2:
41  c = '1'; break;
42  }
43  return c;
44 }
45 
46 #define FNONE 0
47 #define FSHARP 1
48 #define FMINUS 2
49 #define FPLUS 4
50 #define FZERO 8
51 #define FSPACE 16
52 #define FWIDTH 32
53 #define FPREC 64
54 #define FPREC0 128
55 
56 #define CHECK(l) do {\
57  int cr = ENC_CODERANGE(result);\
58  while (blen + (l) >= bsiz) {\
59  bsiz*=2;\
60  }\
61  rb_str_resize(result, bsiz);\
62  ENC_CODERANGE_SET(result, cr);\
63  buf = RSTRING_PTR(result);\
64 } while (0)
65 
66 #define PUSH(s, l) do { \
67  CHECK(l);\
68  PUSH_(s, l);\
69 } while (0)
70 
71 #define PUSH_(s, l) do { \
72  memcpy(&buf[blen], (s), (l));\
73  blen += (l);\
74 } while (0)
75 
76 #define FILL(c, l) do { \
77  CHECK(l);\
78  FILL_(c, l);\
79 } while (0)
80 
81 #define FILL_(c, l) do { \
82  memset(&buf[blen], (c), (l));\
83  blen += (l);\
84 } while (0)
85 
86 #define GETARG() (nextvalue != Qundef ? nextvalue : \
87  GETNEXTARG())
88 
89 #define GETNEXTARG() ( \
90  check_next_arg(posarg, nextarg), \
91  (posarg = nextarg++, GETNTHARG(posarg)))
92 
93 #define GETPOSARG(n) ( \
94  check_pos_arg(posarg, (n)), \
95  (posarg = -1, GETNTHARG(n)))
96 
97 #define GETNTHARG(nth) \
98  (((nth) >= argc) ? (rb_raise(rb_eArgError, "too few arguments"), 0) : argv[(nth)])
99 
100 #define CHECKNAMEARG(name, len, enc) ( \
101  check_name_arg(posarg, name, len, enc), \
102  posarg = -2)
103 
104 #define GETNUM(n, val) \
105  (!(p = get_num(p, end, enc, &(n))) ? \
106  rb_raise(rb_eArgError, #val " too big") : (void)0)
107 
108 #define GETASTER(val) do { \
109  t = p++; \
110  n = 0; \
111  GETNUM(n, val); \
112  if (*p == '$') { \
113  tmp = GETPOSARG(n); \
114  } \
115  else { \
116  tmp = GETNEXTARG(); \
117  p = t; \
118  } \
119  (val) = NUM2INT(tmp); \
120 } while (0)
121 
122 static const char *
123 get_num(const char *p, const char *end, rb_encoding *enc, int *valp)
124 {
125  int next_n = *valp;
126  for (; p < end && rb_enc_isdigit(*p, enc); p++) {
127  if (MUL_OVERFLOW_INT_P(10, next_n))
128  return NULL;
129  next_n *= 10;
130  if (INT_MAX - (*p - '0') < next_n)
131  return NULL;
132  next_n += *p - '0';
133  }
134  if (p >= end) {
135  rb_raise(rb_eArgError, "malformed format string - %%*[0-9]");
136  }
137  *valp = next_n;
138  return p;
139 }
140 
141 static void
142 check_next_arg(int posarg, int nextarg)
143 {
144  switch (posarg) {
145  case -1:
146  rb_raise(rb_eArgError, "unnumbered(%d) mixed with numbered", nextarg);
147  case -2:
148  rb_raise(rb_eArgError, "unnumbered(%d) mixed with named", nextarg);
149  }
150 }
151 
152 static void
153 check_pos_arg(int posarg, int n)
154 {
155  if (posarg > 0) {
156  rb_raise(rb_eArgError, "numbered(%d) after unnumbered(%d)", n, posarg);
157  }
158  if (posarg == -2) {
159  rb_raise(rb_eArgError, "numbered(%d) after named", n);
160  }
161  if (n < 1) {
162  rb_raise(rb_eArgError, "invalid index - %d$", n);
163  }
164 }
165 
166 static void
167 check_name_arg(int posarg, const char *name, int len, rb_encoding *enc)
168 {
169  if (posarg > 0) {
170  rb_enc_raise(enc, rb_eArgError, "named%.*s after unnumbered(%d)", len, name, posarg);
171  }
172  if (posarg == -1) {
173  rb_enc_raise(enc, rb_eArgError, "named%.*s after numbered", len, name);
174  }
175 }
176 
177 static VALUE
178 get_hash(volatile VALUE *hash, int argc, const VALUE *argv)
179 {
180  VALUE tmp;
181 
182  if (*hash != Qundef) return *hash;
183  if (argc != 2) {
184  rb_raise(rb_eArgError, "one hash required");
185  }
186  tmp = rb_check_hash_type(argv[1]);
187  if (NIL_P(tmp)) {
188  rb_raise(rb_eArgError, "one hash required");
189  }
190  return (*hash = tmp);
191 }
192 
193 /*
194  * call-seq:
195  * format(format_string [, arguments...] ) -> string
196  * sprintf(format_string [, arguments...] ) -> string
197  *
198  * Returns the string resulting from applying <i>format_string</i> to
199  * any additional arguments. Within the format string, any characters
200  * other than format sequences are copied to the result.
201  *
202  * The syntax of a format sequence is follows.
203  *
204  * %[flags][width][.precision]type
205  *
206  * A format
207  * sequence consists of a percent sign, followed by optional flags,
208  * width, and precision indicators, then terminated with a field type
209  * character. The field type controls how the corresponding
210  * <code>sprintf</code> argument is to be interpreted, while the flags
211  * modify that interpretation.
212  *
213  * The field type characters are:
214  *
215  * Field | Integer Format
216  * ------+--------------------------------------------------------------
217  * b | Convert argument as a binary number.
218  * | Negative numbers will be displayed as a two's complement
219  * | prefixed with `..1'.
220  * B | Equivalent to `b', but uses an uppercase 0B for prefix
221  * | in the alternative format by #.
222  * d | Convert argument as a decimal number.
223  * i | Identical to `d'.
224  * o | Convert argument as an octal number.
225  * | Negative numbers will be displayed as a two's complement
226  * | prefixed with `..7'.
227  * u | Identical to `d'.
228  * x | Convert argument as a hexadecimal number.
229  * | Negative numbers will be displayed as a two's complement
230  * | prefixed with `..f' (representing an infinite string of
231  * | leading 'ff's).
232  * X | Equivalent to `x', but uses uppercase letters.
233  *
234  * Field | Float Format
235  * ------+--------------------------------------------------------------
236  * e | Convert floating point argument into exponential notation
237  * | with one digit before the decimal point as [-]d.dddddde[+-]dd.
238  * | The precision specifies the number of digits after the decimal
239  * | point (defaulting to six).
240  * E | Equivalent to `e', but uses an uppercase E to indicate
241  * | the exponent.
242  * f | Convert floating point argument as [-]ddd.dddddd,
243  * | where the precision specifies the number of digits after
244  * | the decimal point.
245  * g | Convert a floating point number using exponential form
246  * | if the exponent is less than -4 or greater than or
247  * | equal to the precision, or in dd.dddd form otherwise.
248  * | The precision specifies the number of significant digits.
249  * G | Equivalent to `g', but use an uppercase `E' in exponent form.
250  * a | Convert floating point argument as [-]0xh.hhhhp[+-]dd,
251  * | which is consisted from optional sign, "0x", fraction part
252  * | as hexadecimal, "p", and exponential part as decimal.
253  * A | Equivalent to `a', but use uppercase `X' and `P'.
254  *
255  * Field | Other Format
256  * ------+--------------------------------------------------------------
257  * c | Argument is the numeric code for a single character or
258  * | a single character string itself.
259  * p | The valuing of argument.inspect.
260  * s | Argument is a string to be substituted. If the format
261  * | sequence contains a precision, at most that many characters
262  * | will be copied.
263  * % | A percent sign itself will be displayed. No argument taken.
264  *
265  * The flags modifies the behavior of the formats.
266  * The flag characters are:
267  *
268  * Flag | Applies to | Meaning
269  * ---------+---------------+-----------------------------------------
270  * space | bBdiouxX | Leave a space at the start of
271  * | aAeEfgG | non-negative numbers.
272  * | (numeric fmt) | For `o', `x', `X', `b' and `B', use
273  * | | a minus sign with absolute value for
274  * | | negative values.
275  * ---------+---------------+-----------------------------------------
276  * (digit)$ | all | Specifies the absolute argument number
277  * | | for this field. Absolute and relative
278  * | | argument numbers cannot be mixed in a
279  * | | sprintf string.
280  * ---------+---------------+-----------------------------------------
281  * # | bBoxX | Use an alternative format.
282  * | aAeEfgG | For the conversions `o', increase the precision
283  * | | until the first digit will be `0' if
284  * | | it is not formatted as complements.
285  * | | For the conversions `x', `X', `b' and `B'
286  * | | on non-zero, prefix the result with ``0x'',
287  * | | ``0X'', ``0b'' and ``0B'', respectively.
288  * | | For `a', `A', `e', `E', `f', `g', and 'G',
289  * | | force a decimal point to be added,
290  * | | even if no digits follow.
291  * | | For `g' and 'G', do not remove trailing zeros.
292  * ---------+---------------+-----------------------------------------
293  * + | bBdiouxX | Add a leading plus sign to non-negative
294  * | aAeEfgG | numbers.
295  * | (numeric fmt) | For `o', `x', `X', `b' and `B', use
296  * | | a minus sign with absolute value for
297  * | | negative values.
298  * ---------+---------------+-----------------------------------------
299  * - | all | Left-justify the result of this conversion.
300  * ---------+---------------+-----------------------------------------
301  * 0 (zero) | bBdiouxX | Pad with zeros, not spaces.
302  * | aAeEfgG | For `o', `x', `X', `b' and `B', radix-1
303  * | (numeric fmt) | is used for negative numbers formatted as
304  * | | complements.
305  * ---------+---------------+-----------------------------------------
306  * * | all | Use the next argument as the field width.
307  * | | If negative, left-justify the result. If the
308  * | | asterisk is followed by a number and a dollar
309  * | | sign, use the indicated argument as the width.
310  *
311  * Examples of flags:
312  *
313  * # `+' and space flag specifies the sign of non-negative numbers.
314  * sprintf("%d", 123) #=> "123"
315  * sprintf("%+d", 123) #=> "+123"
316  * sprintf("% d", 123) #=> " 123"
317  *
318  * # `#' flag for `o' increases number of digits to show `0'.
319  * # `+' and space flag changes format of negative numbers.
320  * sprintf("%o", 123) #=> "173"
321  * sprintf("%#o", 123) #=> "0173"
322  * sprintf("%+o", -123) #=> "-173"
323  * sprintf("%o", -123) #=> "..7605"
324  * sprintf("%#o", -123) #=> "..7605"
325  *
326  * # `#' flag for `x' add a prefix `0x' for non-zero numbers.
327  * # `+' and space flag disables complements for negative numbers.
328  * sprintf("%x", 123) #=> "7b"
329  * sprintf("%#x", 123) #=> "0x7b"
330  * sprintf("%+x", -123) #=> "-7b"
331  * sprintf("%x", -123) #=> "..f85"
332  * sprintf("%#x", -123) #=> "0x..f85"
333  * sprintf("%#x", 0) #=> "0"
334  *
335  * # `#' for `X' uses the prefix `0X'.
336  * sprintf("%X", 123) #=> "7B"
337  * sprintf("%#X", 123) #=> "0X7B"
338  *
339  * # `#' flag for `b' add a prefix `0b' for non-zero numbers.
340  * # `+' and space flag disables complements for negative numbers.
341  * sprintf("%b", 123) #=> "1111011"
342  * sprintf("%#b", 123) #=> "0b1111011"
343  * sprintf("%+b", -123) #=> "-1111011"
344  * sprintf("%b", -123) #=> "..10000101"
345  * sprintf("%#b", -123) #=> "0b..10000101"
346  * sprintf("%#b", 0) #=> "0"
347  *
348  * # `#' for `B' uses the prefix `0B'.
349  * sprintf("%B", 123) #=> "1111011"
350  * sprintf("%#B", 123) #=> "0B1111011"
351  *
352  * # `#' for `e' forces to show the decimal point.
353  * sprintf("%.0e", 1) #=> "1e+00"
354  * sprintf("%#.0e", 1) #=> "1.e+00"
355  *
356  * # `#' for `f' forces to show the decimal point.
357  * sprintf("%.0f", 1234) #=> "1234"
358  * sprintf("%#.0f", 1234) #=> "1234."
359  *
360  * # `#' for `g' forces to show the decimal point.
361  * # It also disables stripping lowest zeros.
362  * sprintf("%g", 123.4) #=> "123.4"
363  * sprintf("%#g", 123.4) #=> "123.400"
364  * sprintf("%g", 123456) #=> "123456"
365  * sprintf("%#g", 123456) #=> "123456."
366  *
367  * The field width is an optional integer, followed optionally by a
368  * period and a precision. The width specifies the minimum number of
369  * characters that will be written to the result for this field.
370  *
371  * Examples of width:
372  *
373  * # padding is done by spaces, width=20
374  * # 0 or radix-1. <------------------>
375  * sprintf("%20d", 123) #=> " 123"
376  * sprintf("%+20d", 123) #=> " +123"
377  * sprintf("%020d", 123) #=> "00000000000000000123"
378  * sprintf("%+020d", 123) #=> "+0000000000000000123"
379  * sprintf("% 020d", 123) #=> " 0000000000000000123"
380  * sprintf("%-20d", 123) #=> "123 "
381  * sprintf("%-+20d", 123) #=> "+123 "
382  * sprintf("%- 20d", 123) #=> " 123 "
383  * sprintf("%020x", -123) #=> "..ffffffffffffffff85"
384  *
385  * For
386  * numeric fields, the precision controls the number of decimal places
387  * displayed. For string fields, the precision determines the maximum
388  * number of characters to be copied from the string. (Thus, the format
389  * sequence <code>%10.10s</code> will always contribute exactly ten
390  * characters to the result.)
391  *
392  * Examples of precisions:
393  *
394  * # precision for `d', 'o', 'x' and 'b' is
395  * # minimum number of digits <------>
396  * sprintf("%20.8d", 123) #=> " 00000123"
397  * sprintf("%20.8o", 123) #=> " 00000173"
398  * sprintf("%20.8x", 123) #=> " 0000007b"
399  * sprintf("%20.8b", 123) #=> " 01111011"
400  * sprintf("%20.8d", -123) #=> " -00000123"
401  * sprintf("%20.8o", -123) #=> " ..777605"
402  * sprintf("%20.8x", -123) #=> " ..ffff85"
403  * sprintf("%20.8b", -11) #=> " ..110101"
404  *
405  * # "0x" and "0b" for `#x' and `#b' is not counted for
406  * # precision but "0" for `#o' is counted. <------>
407  * sprintf("%#20.8d", 123) #=> " 00000123"
408  * sprintf("%#20.8o", 123) #=> " 00000173"
409  * sprintf("%#20.8x", 123) #=> " 0x0000007b"
410  * sprintf("%#20.8b", 123) #=> " 0b01111011"
411  * sprintf("%#20.8d", -123) #=> " -00000123"
412  * sprintf("%#20.8o", -123) #=> " ..777605"
413  * sprintf("%#20.8x", -123) #=> " 0x..ffff85"
414  * sprintf("%#20.8b", -11) #=> " 0b..110101"
415  *
416  * # precision for `e' is number of
417  * # digits after the decimal point <------>
418  * sprintf("%20.8e", 1234.56789) #=> " 1.23456789e+03"
419  *
420  * # precision for `f' is number of
421  * # digits after the decimal point <------>
422  * sprintf("%20.8f", 1234.56789) #=> " 1234.56789000"
423  *
424  * # precision for `g' is number of
425  * # significant digits <------->
426  * sprintf("%20.8g", 1234.56789) #=> " 1234.5679"
427  *
428  * # <------->
429  * sprintf("%20.8g", 123456789) #=> " 1.2345679e+08"
430  *
431  * # precision for `s' is
432  * # maximum number of characters <------>
433  * sprintf("%20.8s", "string test") #=> " string t"
434  *
435  * Examples:
436  *
437  * sprintf("%d %04x", 123, 123) #=> "123 007b"
438  * sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
439  * sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
440  * sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
441  * sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
442  * sprintf("%u", -123) #=> "-123"
443  *
444  * For more complex formatting, Ruby supports a reference by name.
445  * %<name>s style uses format style, but %{name} style doesn't.
446  *
447  * Examples:
448  * sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
449  * #=> 1 : 2.000000
450  * sprintf("%{foo}f", { :foo => 1 })
451  * # => "1f"
452  */
453 
454 VALUE
456 {
457  return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
458 }
459 
460 VALUE
461 rb_str_format(int argc, const VALUE *argv, VALUE fmt)
462 {
463  enum {default_float_precision = 6};
464  rb_encoding *enc;
465  const char *p, *end;
466  char *buf;
467  long blen, bsiz;
468  VALUE result;
469 
470  long scanned = 0;
471  int coderange = ENC_CODERANGE_7BIT;
472  int width, prec, flags = FNONE;
473  int nextarg = 1;
474  int posarg = 0;
475  int tainted = 0;
476  VALUE nextvalue;
477  VALUE tmp;
478  VALUE str;
479  volatile VALUE hash = Qundef;
480 
481 #define CHECK_FOR_WIDTH(f) \
482  if ((f) & FWIDTH) { \
483  rb_raise(rb_eArgError, "width given twice"); \
484  } \
485  if ((f) & FPREC0) { \
486  rb_raise(rb_eArgError, "width after precision"); \
487  }
488 #define CHECK_FOR_FLAGS(f) \
489  if ((f) & FWIDTH) { \
490  rb_raise(rb_eArgError, "flag after width"); \
491  } \
492  if ((f) & FPREC0) { \
493  rb_raise(rb_eArgError, "flag after precision"); \
494  }
495 
496  ++argc;
497  --argv;
498  if (OBJ_TAINTED(fmt)) tainted = 1;
499  StringValue(fmt);
500  enc = rb_enc_get(fmt);
501  fmt = rb_str_new4(fmt);
502  p = RSTRING_PTR(fmt);
503  end = p + RSTRING_LEN(fmt);
504  blen = 0;
505  bsiz = 120;
506  result = rb_str_buf_new(bsiz);
507  rb_enc_copy(result, fmt);
508  buf = RSTRING_PTR(result);
509  memset(buf, 0, bsiz);
510  ENC_CODERANGE_SET(result, coderange);
511 
512  for (; p < end; p++) {
513  const char *t;
514  int n;
515  VALUE sym = Qnil;
516 
517  for (t = p; t < end && *t != '%'; t++) ;
518  PUSH(p, t - p);
519  if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
520  scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &coderange);
521  ENC_CODERANGE_SET(result, coderange);
522  }
523  if (t >= end) {
524  /* end of fmt string */
525  goto sprint_exit;
526  }
527  p = t + 1; /* skip `%' */
528 
529  width = prec = -1;
530  nextvalue = Qundef;
531  retry:
532  switch (*p) {
533  default:
534  if (rb_enc_isprint(*p, enc))
535  rb_raise(rb_eArgError, "malformed format string - %%%c", *p);
536  else
537  rb_raise(rb_eArgError, "malformed format string");
538  break;
539 
540  case ' ':
541  CHECK_FOR_FLAGS(flags);
542  flags |= FSPACE;
543  p++;
544  goto retry;
545 
546  case '#':
547  CHECK_FOR_FLAGS(flags);
548  flags |= FSHARP;
549  p++;
550  goto retry;
551 
552  case '+':
553  CHECK_FOR_FLAGS(flags);
554  flags |= FPLUS;
555  p++;
556  goto retry;
557 
558  case '-':
559  CHECK_FOR_FLAGS(flags);
560  flags |= FMINUS;
561  p++;
562  goto retry;
563 
564  case '0':
565  CHECK_FOR_FLAGS(flags);
566  flags |= FZERO;
567  p++;
568  goto retry;
569 
570  case '1': case '2': case '3': case '4':
571  case '5': case '6': case '7': case '8': case '9':
572  n = 0;
573  GETNUM(n, width);
574  if (*p == '$') {
575  if (nextvalue != Qundef) {
576  rb_raise(rb_eArgError, "value given twice - %d$", n);
577  }
578  nextvalue = GETPOSARG(n);
579  p++;
580  goto retry;
581  }
582  CHECK_FOR_WIDTH(flags);
583  width = n;
584  flags |= FWIDTH;
585  goto retry;
586 
587  case '<':
588  case '{':
589  {
590  const char *start = p;
591  char term = (*p == '<') ? '>' : '}';
592  int len;
593 
594  for (; p < end && *p != term; ) {
595  p += rb_enc_mbclen(p, end, enc);
596  }
597  if (p >= end) {
598  rb_raise(rb_eArgError, "malformed name - unmatched parenthesis");
599  }
600 #if SIZEOF_INT < SIZEOF_SIZE_T
601  if ((size_t)(p - start) >= INT_MAX) {
602  const int message_limit = 20;
603  len = (int)(rb_enc_right_char_head(start, start + message_limit, p, enc) - start);
605  "too long name (%"PRIuSIZE" bytes) - %.*s...%c",
606  (size_t)(p - start - 2), len, start, term);
607  }
608 #endif
609  len = (int)(p - start + 1); /* including parenthesis */
610  if (sym != Qnil) {
611  rb_enc_raise(enc, rb_eArgError, "named%.*s after <%"PRIsVALUE">",
612  len, start, rb_sym2str(sym));
613  }
614  CHECKNAMEARG(start, len, enc);
615  get_hash(&hash, argc, argv);
616  sym = rb_check_symbol_cstr(start + 1,
617  len - 2 /* without parenthesis */,
618  enc);
619  if (!NIL_P(sym)) nextvalue = rb_hash_lookup2(hash, sym, Qundef);
620  if (nextvalue == Qundef) {
621  if (NIL_P(sym)) {
622  sym = rb_sym_intern(start + 1,
623  len - 2 /* without parenthesis */,
624  enc);
625  }
626  nextvalue = rb_hash_default_value(hash, sym);
627  if (NIL_P(nextvalue)) {
628  rb_enc_raise(enc, rb_eKeyError, "key%.*s not found", len, start);
629  }
630  }
631  if (term == '}') goto format_s;
632  p++;
633  goto retry;
634  }
635 
636  case '*':
637  CHECK_FOR_WIDTH(flags);
638  flags |= FWIDTH;
639  GETASTER(width);
640  if (width < 0) {
641  flags |= FMINUS;
642  width = -width;
643  }
644  p++;
645  goto retry;
646 
647  case '.':
648  if (flags & FPREC0) {
649  rb_raise(rb_eArgError, "precision given twice");
650  }
651  flags |= FPREC|FPREC0;
652 
653  prec = 0;
654  p++;
655  if (*p == '*') {
656  GETASTER(prec);
657  if (prec < 0) { /* ignore negative precision */
658  flags &= ~FPREC;
659  }
660  p++;
661  goto retry;
662  }
663 
664  GETNUM(prec, precision);
665  goto retry;
666 
667  case '\n':
668  case '\0':
669  p--;
670  case '%':
671  if (flags != FNONE) {
672  rb_raise(rb_eArgError, "invalid format character - %%");
673  }
674  PUSH("%", 1);
675  break;
676 
677  case 'c':
678  {
679  VALUE val = GETARG();
680  VALUE tmp;
681  unsigned int c;
682  int n;
683 
684  tmp = rb_check_string_type(val);
685  if (!NIL_P(tmp)) {
686  if (rb_enc_strlen(RSTRING_PTR(tmp),RSTRING_END(tmp),enc) != 1) {
687  rb_raise(rb_eArgError, "%%c requires a character");
688  }
689  c = rb_enc_codepoint_len(RSTRING_PTR(tmp), RSTRING_END(tmp), &n, enc);
690  RB_GC_GUARD(tmp);
691  }
692  else {
693  c = NUM2INT(val);
694  n = rb_enc_codelen(c, enc);
695  }
696  if (n <= 0) {
697  rb_raise(rb_eArgError, "invalid character");
698  }
699  if (!(flags & FWIDTH)) {
700  CHECK(n);
701  rb_enc_mbcput(c, &buf[blen], enc);
702  blen += n;
703  }
704  else if ((flags & FMINUS)) {
705  CHECK(n);
706  rb_enc_mbcput(c, &buf[blen], enc);
707  blen += n;
708  if (width > 1) FILL(' ', width-1);
709  }
710  else {
711  if (width > 1) FILL(' ', width-1);
712  CHECK(n);
713  rb_enc_mbcput(c, &buf[blen], enc);
714  blen += n;
715  }
716  }
717  break;
718 
719  case 's':
720  case 'p':
721  format_s:
722  {
723  VALUE arg = GETARG();
724  long len, slen;
725 
726  if (*p == 'p') {
727  str = rb_inspect(arg);
728  }
729  else {
730  str = rb_obj_as_string(arg);
731  }
732  if (OBJ_TAINTED(str)) tainted = 1;
733  len = RSTRING_LEN(str);
734  rb_str_set_len(result, blen);
735  if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
736  int cr = coderange;
737  scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr);
738  ENC_CODERANGE_SET(result,
739  (cr == ENC_CODERANGE_UNKNOWN ?
740  ENC_CODERANGE_BROKEN : (coderange = cr)));
741  }
742  enc = rb_enc_check(result, str);
743  if (flags&(FPREC|FWIDTH)) {
744  slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc);
745  if (slen < 0) {
746  rb_raise(rb_eArgError, "invalid mbstring sequence");
747  }
748  if ((flags&FPREC) && (prec < slen)) {
749  char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
750  prec, enc);
751  slen = prec;
752  len = p - RSTRING_PTR(str);
753  }
754  /* need to adjust multi-byte string pos */
755  if ((flags&FWIDTH) && (width > slen)) {
756  width -= (int)slen;
757  if (!(flags&FMINUS)) {
758  CHECK(width);
759  while (width--) {
760  buf[blen++] = ' ';
761  }
762  }
763  CHECK(len);
764  memcpy(&buf[blen], RSTRING_PTR(str), len);
765  RB_GC_GUARD(str);
766  blen += len;
767  if (flags&FMINUS) {
768  CHECK(width);
769  while (width--) {
770  buf[blen++] = ' ';
771  }
772  }
773  rb_enc_associate(result, enc);
774  break;
775  }
776  }
777  PUSH(RSTRING_PTR(str), len);
778  RB_GC_GUARD(str);
779  rb_enc_associate(result, enc);
780  }
781  break;
782 
783  case 'd':
784  case 'i':
785  case 'o':
786  case 'x':
787  case 'X':
788  case 'b':
789  case 'B':
790  case 'u':
791  {
792  volatile VALUE val = GETARG();
793  int valsign;
794  char nbuf[64], *s;
795  const char *prefix = 0;
796  int sign = 0, dots = 0;
797  char sc = 0;
798  long v = 0;
799  int base, bignum = 0;
800  int len;
801 
802  switch (*p) {
803  case 'd':
804  case 'i':
805  case 'u':
806  sign = 1; break;
807  case 'o':
808  case 'x':
809  case 'X':
810  case 'b':
811  case 'B':
812  if (flags&(FPLUS|FSPACE)) sign = 1;
813  break;
814  }
815  if (flags & FSHARP) {
816  switch (*p) {
817  case 'o':
818  prefix = "0"; break;
819  case 'x':
820  prefix = "0x"; break;
821  case 'X':
822  prefix = "0X"; break;
823  case 'b':
824  prefix = "0b"; break;
825  case 'B':
826  prefix = "0B"; break;
827  }
828  }
829 
830  bin_retry:
831  switch (TYPE(val)) {
832  case T_FLOAT:
833  if (FIXABLE(RFLOAT_VALUE(val))) {
834  val = LONG2FIX((long)RFLOAT_VALUE(val));
835  goto bin_retry;
836  }
837  val = rb_dbl2big(RFLOAT_VALUE(val));
838  if (FIXNUM_P(val)) goto bin_retry;
839  bignum = 1;
840  break;
841  case T_STRING:
842  val = rb_str_to_inum(val, 0, TRUE);
843  goto bin_retry;
844  case T_BIGNUM:
845  bignum = 1;
846  break;
847  case T_FIXNUM:
848  v = FIX2LONG(val);
849  break;
850  default:
851  val = rb_Integer(val);
852  goto bin_retry;
853  }
854 
855  switch (*p) {
856  case 'o':
857  base = 8; break;
858  case 'x':
859  case 'X':
860  base = 16; break;
861  case 'b':
862  case 'B':
863  base = 2; break;
864  case 'u':
865  case 'd':
866  case 'i':
867  default:
868  base = 10; break;
869  }
870 
871  if (base != 10) {
872  int numbits = ffs(base)-1;
873  size_t abs_nlz_bits;
874  size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits);
875  long i;
876  if (INT_MAX-1 < numdigits) /* INT_MAX is used because rb_long2int is used later. */
877  rb_raise(rb_eArgError, "size too big");
878  if (sign) {
879  if (numdigits == 0)
880  numdigits = 1;
881  tmp = rb_str_new(NULL, numdigits);
882  valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
883  1, CHAR_BIT-numbits, INTEGER_PACK_BIG_ENDIAN);
884  for (i = 0; i < RSTRING_LEN(tmp); i++)
885  RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
886  s = RSTRING_PTR(tmp);
887  if (valsign < 0) {
888  sc = '-';
889  width--;
890  }
891  else if (flags & FPLUS) {
892  sc = '+';
893  width--;
894  }
895  else if (flags & FSPACE) {
896  sc = ' ';
897  width--;
898  }
899  }
900  else {
901  /* Following conditional "numdigits++" guarantees the
902  * most significant digit as
903  * - '1'(bin), '7'(oct) or 'f'(hex) for negative numbers
904  * - '0' for zero
905  * - not '0' for positive numbers.
906  *
907  * It also guarantees the most significant two
908  * digits will not be '11'(bin), '77'(oct), 'ff'(hex)
909  * or '00'. */
910  if (numdigits == 0 ||
911  ((abs_nlz_bits != (size_t)(numbits-1) ||
912  !rb_absint_singlebit_p(val)) &&
913  (!bignum ? v < 0 : BIGNUM_NEGATIVE_P(val))))
914  numdigits++;
915  tmp = rb_str_new(NULL, numdigits);
916  valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
918  for (i = 0; i < RSTRING_LEN(tmp); i++)
919  RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
920  s = RSTRING_PTR(tmp);
921  dots = valsign < 0;
922  }
923  len = rb_long2int(RSTRING_END(tmp) - s);
924  }
925  else if (!bignum) {
926  valsign = 1;
927  if (v < 0) {
928  v = -v;
929  sc = '-';
930  width--;
931  valsign = -1;
932  }
933  else if (flags & FPLUS) {
934  sc = '+';
935  width--;
936  }
937  else if (flags & FSPACE) {
938  sc = ' ';
939  width--;
940  }
941  snprintf(nbuf, sizeof(nbuf), "%ld", v);
942  s = nbuf;
943  len = (int)strlen(s);
944  }
945  else {
946  tmp = rb_big2str(val, 10);
947  s = RSTRING_PTR(tmp);
948  valsign = 1;
949  if (s[0] == '-') {
950  s++;
951  sc = '-';
952  width--;
953  valsign = -1;
954  }
955  else if (flags & FPLUS) {
956  sc = '+';
957  width--;
958  }
959  else if (flags & FSPACE) {
960  sc = ' ';
961  width--;
962  }
963  len = rb_long2int(RSTRING_END(tmp) - s);
964  }
965 
966  if (dots) {
967  prec -= 2;
968  width -= 2;
969  }
970 
971  if (*p == 'X') {
972  char *pp = s;
973  int c;
974  while ((c = (int)(unsigned char)*pp) != 0) {
975  *pp = rb_enc_toupper(c, enc);
976  pp++;
977  }
978  }
979  if (prefix && !prefix[1]) { /* octal */
980  if (dots) {
981  prefix = 0;
982  }
983  else if (len == 1 && *s == '0') {
984  len = 0;
985  if (flags & FPREC) prec--;
986  }
987  else if ((flags & FPREC) && (prec > len)) {
988  prefix = 0;
989  }
990  }
991  else if (len == 1 && *s == '0') {
992  prefix = 0;
993  }
994  if (prefix) {
995  width -= (int)strlen(prefix);
996  }
997  if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
998  prec = width;
999  width = 0;
1000  }
1001  else {
1002  if (prec < len) {
1003  if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
1004  prec = len;
1005  }
1006  width -= prec;
1007  }
1008  if (!(flags&FMINUS)) {
1009  CHECK(width);
1010  while (width-- > 0) {
1011  buf[blen++] = ' ';
1012  }
1013  }
1014  if (sc) PUSH(&sc, 1);
1015  if (prefix) {
1016  int plen = (int)strlen(prefix);
1017  PUSH(prefix, plen);
1018  }
1019  CHECK(prec - len);
1020  if (dots) PUSH("..", 2);
1021  if (!sign && valsign < 0) {
1022  char c = sign_bits(base, p);
1023  while (len < prec--) {
1024  buf[blen++] = c;
1025  }
1026  }
1027  else if ((flags & (FMINUS|FPREC)) != FMINUS) {
1028  while (len < prec--) {
1029  buf[blen++] = '0';
1030  }
1031  }
1032  PUSH(s, len);
1033  RB_GC_GUARD(tmp);
1034  CHECK(width);
1035  while (width-- > 0) {
1036  buf[blen++] = ' ';
1037  }
1038  }
1039  break;
1040 
1041  case 'f':
1042  {
1043  VALUE val = GETARG(), num, den;
1044  int sign = (flags&FPLUS) ? 1 : 0, zero = 0;
1045  long len, fill;
1046  if (RB_INTEGER_TYPE_P(val)) {
1047  den = INT2FIX(1);
1048  num = val;
1049  }
1050  else if (RB_TYPE_P(val, T_RATIONAL)) {
1051  den = rb_rational_den(val);
1052  num = rb_rational_num(val);
1053  }
1054  else {
1055  nextvalue = val;
1056  goto float_value;
1057  }
1058  if (!(flags&FPREC)) prec = default_float_precision;
1059  if (FIXNUM_P(num)) {
1060  if ((SIGNED_VALUE)num < 0) {
1061  long n = -FIX2LONG(num);
1062  num = LONG2FIX(n);
1063  sign = -1;
1064  }
1065  }
1066  else if (BIGNUM_NEGATIVE_P(num)) {
1067  sign = -1;
1068  num = rb_big_uminus(num);
1069  }
1070  if (den != INT2FIX(1)) {
1071  num = rb_int_mul(num, rb_int_positive_pow(10, prec));
1072  num = rb_int_plus(num, rb_int_idiv(den, INT2FIX(2)));
1073  num = rb_int_idiv(num, den);
1074  }
1075  else if (prec >= 0) {
1076  zero = prec;
1077  }
1078  val = rb_int2str(num, 10);
1079  len = RSTRING_LEN(val) + zero;
1080  if (prec >= len) len = prec + 1; /* integer part 0 */
1081  if (sign || (flags&FSPACE)) ++len;
1082  if (prec > 0) ++len; /* period */
1083  CHECK(len > width ? len : width);
1084  fill = width > len ? width - len : 0;
1085  if (fill && !(flags&FMINUS) && !(flags&FZERO)) {
1086  FILL_(' ', fill);
1087  }
1088  if (sign || (flags&FSPACE)) {
1089  buf[blen++] = sign > 0 ? '+' : sign < 0 ? '-' : ' ';
1090  }
1091  if (fill && !(flags&FMINUS) && (flags&FZERO)) {
1092  FILL_('0', fill);
1093  }
1094  len = RSTRING_LEN(val) + zero;
1095  t = RSTRING_PTR(val);
1096  if (len > prec) {
1097  PUSH_(t, len - prec);
1098  }
1099  else {
1100  buf[blen++] = '0';
1101  }
1102  if (prec > 0) {
1103  buf[blen++] = '.';
1104  }
1105  if (zero) {
1106  FILL_('0', zero);
1107  }
1108  else if (prec > len) {
1109  FILL_('0', prec - len);
1110  PUSH_(t, len);
1111  }
1112  else if (prec > 0) {
1113  PUSH_(t + len - prec, prec);
1114  }
1115  if (fill && (flags&FMINUS)) {
1116  FILL_(' ', fill);
1117  }
1118  RB_GC_GUARD(val);
1119  break;
1120  }
1121  case 'g':
1122  case 'G':
1123  case 'e':
1124  case 'E':
1125  /* TODO: rational support */
1126  case 'a':
1127  case 'A':
1128  float_value:
1129  {
1130  VALUE val = GETARG();
1131  double fval;
1132  int i, need;
1133  char fbuf[32];
1134 
1135  fval = RFLOAT_VALUE(rb_Float(val));
1136  if (isnan(fval) || isinf(fval)) {
1137  const char *expr;
1138  int elen;
1139  char sign = '\0';
1140 
1141  if (isnan(fval)) {
1142  expr = "NaN";
1143  }
1144  else {
1145  expr = "Inf";
1146  }
1147  need = (int)strlen(expr);
1148  elen = need;
1149  i = 0;
1150  if (!isnan(fval) && fval < 0.0)
1151  sign = '-';
1152  else if (flags & (FPLUS|FSPACE))
1153  sign = (flags & FPLUS) ? '+' : ' ';
1154  if (sign)
1155  ++need;
1156  if ((flags & FWIDTH) && need < width)
1157  need = width;
1158 
1159  FILL(' ', need);
1160  if (flags & FMINUS) {
1161  if (sign)
1162  buf[blen - need--] = sign;
1163  memcpy(&buf[blen - need], expr, elen);
1164  }
1165  else {
1166  if (sign)
1167  buf[blen - elen - 1] = sign;
1168  memcpy(&buf[blen - elen], expr, elen);
1169  }
1170  break;
1171  }
1172 
1173  fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
1174  need = 0;
1175  if (*p != 'e' && *p != 'E') {
1176  i = INT_MIN;
1177  frexp(fval, &i);
1178  if (i > 0)
1179  need = BIT_DIGITS(i);
1180  }
1181  need += (flags&FPREC) ? prec : default_float_precision;
1182  if ((flags&FWIDTH) && need < width)
1183  need = width;
1184  need += 20;
1185 
1186  CHECK(need);
1187  snprintf(&buf[blen], need, fbuf, fval);
1188  blen += strlen(&buf[blen]);
1189  }
1190  break;
1191  }
1192  flags = FNONE;
1193  }
1194 
1195  sprint_exit:
1196  RB_GC_GUARD(fmt);
1197  /* XXX - We cannot validate the number of arguments if (digit)$ style used.
1198  */
1199  if (posarg >= 0 && nextarg < argc) {
1200  const char *mesg = "too many arguments for format string";
1201  if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg);
1202  if (RTEST(ruby_verbose)) rb_warn("%s", mesg);
1203  }
1204  rb_str_resize(result, blen);
1205 
1206  if (tainted) OBJ_TAINT(result);
1207  return result;
1208 }
1209 
1210 static void
1211 fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
1212 {
1213  char *end = buf + size;
1214  *buf++ = '%';
1215  if (flags & FSHARP) *buf++ = '#';
1216  if (flags & FPLUS) *buf++ = '+';
1217  if (flags & FMINUS) *buf++ = '-';
1218  if (flags & FZERO) *buf++ = '0';
1219  if (flags & FSPACE) *buf++ = ' ';
1220 
1221  if (flags & FWIDTH) {
1222  snprintf(buf, end - buf, "%d", width);
1223  buf += strlen(buf);
1224  }
1225 
1226  if (flags & FPREC) {
1227  snprintf(buf, end - buf, ".%d", prec);
1228  buf += strlen(buf);
1229  }
1230 
1231  *buf++ = c;
1232  *buf = '\0';
1233 }
1234 
1235 #undef FILE
1236 #define FILE rb_printf_buffer
1237 #define __sbuf rb_printf_sbuf
1238 #define __sFILE rb_printf_sfile
1239 #undef feof
1240 #undef ferror
1241 #undef clearerr
1242 #undef fileno
1243 #if SIZEOF_LONG < SIZEOF_VOIDP
1244 # if SIZEOF_LONG_LONG == SIZEOF_VOIDP
1245 # define _HAVE_SANE_QUAD_
1246 # define _HAVE_LLP64_
1247 # define quad_t LONG_LONG
1248 # define u_quad_t unsigned LONG_LONG
1249 # endif
1250 #elif SIZEOF_LONG != SIZEOF_LONG_LONG && SIZEOF_LONG_LONG == 8
1251 # define _HAVE_SANE_QUAD_
1252 # define quad_t LONG_LONG
1253 # define u_quad_t unsigned LONG_LONG
1254 #endif
1255 #define FLOATING_POINT 1
1256 #define BSD__dtoa ruby_dtoa
1257 #define BSD__hdtoa ruby_hdtoa
1258 #ifdef RUBY_PRI_VALUE_MARK
1259 # define PRI_EXTRA_MARK RUBY_PRI_VALUE_MARK
1260 #endif
1261 #define lower_hexdigits (ruby_hexdigits+0)
1262 #define upper_hexdigits (ruby_hexdigits+16)
1263 #include "vsnprintf.c"
1264 
1265 int
1266 ruby_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
1267 {
1268  int ret;
1269  rb_printf_buffer f;
1270 
1271  if ((int)n < 1)
1272  return (EOF);
1273  f._flags = __SWR | __SSTR;
1274  f._bf._base = f._p = (unsigned char *)str;
1275  f._bf._size = f._w = n - 1;
1276  f.vwrite = BSD__sfvwrite;
1277  f.vextra = 0;
1278  ret = (int)BSD_vfprintf(&f, fmt, ap);
1279  *f._p = 0;
1280  return ret;
1281 }
1282 
1283 int
1284 ruby_snprintf(char *str, size_t n, char const *fmt, ...)
1285 {
1286  int ret;
1287  va_list ap;
1288 
1289  if ((int)n < 1)
1290  return (EOF);
1291 
1292  va_start(ap, fmt);
1293  ret = ruby_vsnprintf(str, n, fmt, ap);
1294  va_end(ap);
1295  return ret;
1296 }
1297 
1298 typedef struct {
1299  rb_printf_buffer base;
1300  volatile VALUE value;
1302 
1303 static int
1304 ruby__sfvwrite(register rb_printf_buffer *fp, register struct __suio *uio)
1305 {
1306  struct __siov *iov;
1307  VALUE result = (VALUE)fp->_bf._base;
1308  char *buf = (char*)fp->_p;
1309  size_t len, n;
1310  size_t blen = buf - RSTRING_PTR(result), bsiz = fp->_w;
1311 
1312  if (RBASIC(result)->klass) {
1313  rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1314  }
1315  if ((len = uio->uio_resid) == 0)
1316  return 0;
1317  CHECK(len);
1318  buf += blen;
1319  fp->_w = bsiz;
1320  for (iov = uio->uio_iov; len > 0; ++iov) {
1321  MEMCPY(buf, iov->iov_base, char, n = iov->iov_len);
1322  buf += n;
1323  len -= n;
1324  }
1325  fp->_p = (unsigned char *)buf;
1326  rb_str_set_len(result, buf - RSTRING_PTR(result));
1327  return 0;
1328 }
1329 
1330 static const char *
1331 ruby__sfvextra(rb_printf_buffer *fp, size_t valsize, void *valp, long *sz, int sign)
1332 {
1333  VALUE value, result = (VALUE)fp->_bf._base;
1334  rb_encoding *enc;
1335  char *cp;
1336 
1337  if (valsize != sizeof(VALUE)) return 0;
1338  value = *(VALUE *)valp;
1339  if (RBASIC(result)->klass) {
1340  rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1341  }
1342  if (sign == '+') {
1343  if (RB_TYPE_P(value, T_CLASS)) {
1344 # define LITERAL(str) (*sz = rb_strlen_lit(str), str)
1345 
1346  if (value == rb_cNilClass) {
1347  return LITERAL("nil");
1348  }
1349  else if (value == rb_cInteger) {
1350  return LITERAL("Integer");
1351  }
1352  else if (value == rb_cSymbol) {
1353  return LITERAL("Symbol");
1354  }
1355  else if (value == rb_cTrueClass) {
1356  return LITERAL("true");
1357  }
1358  else if (value == rb_cFalseClass) {
1359  return LITERAL("false");
1360  }
1361 # undef LITERAL
1362  }
1363  value = rb_inspect(value);
1364  }
1365  else {
1366  value = rb_obj_as_string(value);
1367  if (sign == ' ') value = QUOTE(value);
1368  }
1369  enc = rb_enc_compatible(result, value);
1370  if (enc) {
1371  rb_enc_associate(result, enc);
1372  }
1373  else {
1374  enc = rb_enc_get(result);
1375  value = rb_str_conv_enc_opts(value, rb_enc_get(value), enc,
1377  Qnil);
1378  *(volatile VALUE *)valp = value;
1379  }
1380  StringValueCStr(value);
1381  RSTRING_GETMEM(value, cp, *sz);
1382  ((rb_printf_buffer_extra *)fp)->value = value;
1383  OBJ_INFECT(result, value);
1384  return cp;
1385 }
1386 
1387 VALUE
1388 rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
1389 {
1390  rb_printf_buffer_extra buffer;
1391 #define f buffer.base
1392  VALUE result;
1393 
1394  f._flags = __SWR | __SSTR;
1395  f._bf._size = 0;
1396  f._w = 120;
1397  result = rb_str_buf_new(f._w);
1398  if (enc) {
1399  if (rb_enc_mbminlen(enc) > 1) {
1400  /* the implementation deeply depends on plain char */
1401  rb_raise(rb_eArgError, "cannot construct wchar_t based encoding string: %s",
1402  rb_enc_name(enc));
1403  }
1404  rb_enc_associate(result, enc);
1405  }
1406  f._bf._base = (unsigned char *)result;
1407  f._p = (unsigned char *)RSTRING_PTR(result);
1408  RBASIC_CLEAR_CLASS(result);
1409  f.vwrite = ruby__sfvwrite;
1410  f.vextra = ruby__sfvextra;
1411  buffer.value = 0;
1412  BSD_vfprintf(&f, fmt, ap);
1414  rb_str_resize(result, (char *)f._p - RSTRING_PTR(result));
1415 #undef f
1416 
1417  return result;
1418 }
1419 
1420 VALUE
1421 rb_enc_sprintf(rb_encoding *enc, const char *format, ...)
1422 {
1423  VALUE result;
1424  va_list ap;
1425 
1426  va_start(ap, format);
1427  result = rb_enc_vsprintf(enc, format, ap);
1428  va_end(ap);
1429 
1430  return result;
1431 }
1432 
1433 VALUE
1434 rb_vsprintf(const char *fmt, va_list ap)
1435 {
1436  return rb_enc_vsprintf(NULL, fmt, ap);
1437 }
1438 
1439 VALUE
1440 rb_sprintf(const char *format, ...)
1441 {
1442  VALUE result;
1443  va_list ap;
1444 
1445  va_start(ap, format);
1446  result = rb_vsprintf(format, ap);
1447  va_end(ap);
1448 
1449  return result;
1450 }
1451 
1452 VALUE
1453 rb_str_vcatf(VALUE str, const char *fmt, va_list ap)
1454 {
1455  rb_printf_buffer_extra buffer;
1456 #define f buffer.base
1457  VALUE klass;
1458 
1459  StringValue(str);
1460  rb_str_modify(str);
1461  f._flags = __SWR | __SSTR;
1462  f._bf._size = 0;
1463  f._w = rb_str_capacity(str);
1464  f._bf._base = (unsigned char *)str;
1465  f._p = (unsigned char *)RSTRING_END(str);
1466  klass = RBASIC(str)->klass;
1467  RBASIC_CLEAR_CLASS(str);
1468  f.vwrite = ruby__sfvwrite;
1469  f.vextra = ruby__sfvextra;
1470  buffer.value = 0;
1471  BSD_vfprintf(&f, fmt, ap);
1472  RBASIC_SET_CLASS_RAW(str, klass);
1473  rb_str_resize(str, (char *)f._p - RSTRING_PTR(str));
1474 #undef f
1475 
1476  return str;
1477 }
1478 
1479 VALUE
1480 rb_str_catf(VALUE str, const char *format, ...)
1481 {
1482  va_list ap;
1483 
1484  va_start(ap, format);
1485  str = rb_str_vcatf(str, format, ap);
1486  va_end(ap);
1487 
1488  return str;
1489 }
RUBY_EXTERN VALUE rb_cString
Definition: ruby.h:1906
static VALUE rb_rational_num(VALUE rat)
Definition: bigdecimal.c:108
int ruby_snprintf(char *str, size_t n, char const *fmt,...)
Definition: sprintf.c:1284
VALUE rb_int_plus(VALUE x, VALUE y)
Definition: numeric.c:3514
#define BIT_DIGITS(N)
Definition: sprintf.c:24
#define RBASIC_CLEAR_CLASS(obj)
Definition: internal.h:1312
int rb_enc_codelen(int c, rb_encoding *enc)
Definition: encoding.c:1077
static double zero(void)
Definition: isinf.c:51
int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
Definition: bignum.c:3531
static VALUE get_hash(volatile VALUE *hash, int argc, const VALUE *argv)
Definition: sprintf.c:178
rb_encoding * rb_enc_check(VALUE str1, VALUE str2)
Definition: encoding.c:879
#define rb_str_new4
Definition: intern.h:859
RUBY_EXTERN VALUE rb_cFalseClass
Definition: ruby.h:1882
void rb_enc_copy(VALUE obj1, VALUE obj2)
Definition: encoding.c:978
long rb_str_coderange_scan_restartable(const char *, const char *, rb_encoding *, int *)
Definition: string.c:530
size_t strlen(const char *)
VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc)
Definition: symbol.c:1030
#define GETNUM(n, val)
Definition: sprintf.c:104
#define T_FIXNUM
Definition: ruby.h:503
#define NUM2INT(x)
Definition: ruby.h:684
static unsigned int hash(str, len) register const char *str
VALUE rb_eKeyError
Definition: error.c:765
#define __SSTR
Definition: vsnprintf.c:194
static int ruby__sfvwrite(register rb_printf_buffer *fp, register struct __suio *uio)
Definition: sprintf.c:1304
#define FPREC
Definition: sprintf.c:53
const char ruby_digitmap[]
Definition: bignum.c:37
#define ENC_CODERANGE_SET(obj, cr)
Definition: encoding.h:106
#define T_RATIONAL
Definition: ruby.h:509
#define FILL(c, l)
Definition: sprintf.c:76
#define rb_long2int(n)
Definition: ruby.h:319
if(len<=MAX_WORD_LENGTH &&len >=MIN_WORD_LENGTH)
Definition: zonetab.h:883
rb_encoding * rb_enc_compatible(VALUE str1, VALUE str2)
Definition: encoding.c:962
void rb_str_set_len(VALUE, long)
Definition: string.c:2545
VALUE rb_int_mul(VALUE x, VALUE y)
Definition: numeric.c:3608
unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len_p, rb_encoding *enc)
Definition: encoding.c:1056
const void * iov_base
Definition: vsnprintf.c:225
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:2207
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Definition: ruby.h:991
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
Definition: encoding.c:854
#define RB_GC_GUARD(v)
Definition: ruby.h:552
#define FNONE
Definition: sprintf.c:46
int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc)
Definition: encoding.c:1008
VALUE rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
Definition: sprintf.c:1388
#define FIXNUM_P(f)
Definition: ruby.h:365
VALUE rb_Float(VALUE)
Definition: object.c:2961
#define GETARG()
Definition: sprintf.c:86
VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts)
Definition: string.c:884
#define INTEGER_PACK_2COMP
Definition: intern.h:143
#define OBJ_TAINTED(x)
Definition: ruby.h:1298
#define ENC_CODERANGE_7BIT
Definition: encoding.h:100
VALUE rb_enc_sprintf(rb_encoding *enc, const char *format,...)
Definition: sprintf.c:1421
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Definition: sprintf.c:461
#define FSPACE
Definition: sprintf.c:51
const char term
Definition: id.c:37
char * rb_enc_nth(const char *, const char *, long, rb_encoding *)
Definition: string.c:2238
int rb_enc_toupper(int c, rb_encoding *enc)
Definition: encoding.c:1094
#define sym(x)
Definition: date_core.c:3721
VALUE rb_hash_default_value(VALUE hash, VALUE key)
Definition: hash.c:817
static char sign_bits(int base, const char *p)
Definition: sprintf.c:29
int rb_absint_singlebit_p(VALUE val)
Definition: bignum.c:3430
#define RBASIC_SET_CLASS_RAW(obj, cls)
Definition: internal.h:1313
#define RB_TYPE_P(obj, type)
Definition: ruby.h:527
static const char * ruby__sfvextra(rb_printf_buffer *fp, size_t valsize, void *valp, long *sz, int sign)
Definition: sprintf.c:1331
VALUE rb_int_idiv(VALUE x, VALUE y)
Definition: numeric.c:3756
#define FMINUS
Definition: sprintf.c:48
VALUE rb_dbl2big(double d)
Definition: bignum.c:5193
static int BSD__sfvwrite(register FILE *fp, register struct __suio *uio)
Definition: vsnprintf.c:241
#define val
VALUE rb_eRuntimeError
Definition: error.c:761
#define LITERAL(str)
#define FSHARP
Definition: sprintf.c:47
VALUE rb_str_to_inum(VALUE str, int base, int badcheck)
Definition: bignum.c:4205
#define RSTRING_END(str)
Definition: ruby.h:986
#define ECONV_INVALID_REPLACE
Definition: encoding.h:388
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1364
#define snprintf
Definition: subst.h:6
#define NIL_P(v)
Definition: ruby.h:451
RUBY_EXTERN VALUE rb_cTrueClass
Definition: ruby.h:1911
VALUE rb_int2str(VALUE num, int base)
Definition: numeric.c:3458
#define CHECK(l)
Definition: sprintf.c:56
#define __SWR
Definition: vsnprintf.c:187
static const char * get_num(const char *p, const char *end, rb_encoding *enc, int *valp)
Definition: sprintf.c:123
#define T_FLOAT
Definition: ruby.h:495
#define TYPE(x)
Definition: ruby.h:521
int argc
Definition: ruby.c:183
#define FZERO
Definition: sprintf.c:50
VALUE rb_Integer(VALUE)
Definition: object.c:2736
VALUE rb_vsprintf(const char *fmt, va_list ap)
Definition: sprintf.c:1434
#define BIGNUM_NEGATIVE_P(b)
Definition: internal.h:503
#define T_BIGNUM
Definition: ruby.h:501
#define ENC_CODERANGE_UNKNOWN
Definition: encoding.h:99
#define rb_enc_isprint(c, enc)
Definition: encoding.h:230
#define MEMCPY(p1, p2, type, n)
Definition: ruby.h:1661
RUBY_EXTERN int isinf(double)
Definition: isinf.c:56
#define ENC_CODERANGE_BROKEN
Definition: encoding.h:102
void rb_enc_raise(rb_encoding *enc, VALUE exc, const char *fmt,...)
Definition: error.c:2194
VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc)
Definition: symbol.c:1003
#define rb_enc_mbminlen(enc)
Definition: encoding.h:174
#define CHECK_FOR_WIDTH(f)
VALUE rb_big2str(VALUE x, int base)
Definition: bignum.c:5041
#define GETASTER(val)
Definition: sprintf.c:108
RUBY_EXTERN VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3949
#define EOF
Definition: vsnprintf.c:201
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2562
static VALUE rb_rational_den(VALUE rat)
Definition: bigdecimal.c:120
#define RSTRING_LEN(str)
Definition: ruby.h:978
#define TRUE
Definition: nkf.h:175
VALUE rb_sprintf(const char *format,...)
Definition: sprintf.c:1440
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Definition: sprintf.c:455
volatile VALUE value
Definition: sprintf.c:1300
#define rb_enc_name(enc)
Definition: encoding.h:171
VALUE rb_check_hash_type(VALUE hash)
Definition: hash.c:736
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4309
#define PRIsVALUE
Definition: ruby.h:135
size_t uio_resid
Definition: vsnprintf.c:231
#define rb_enc_isdigit(c, enc)
Definition: encoding.h:232
#define Qnil
Definition: ruby.h:438
static void fmt_setup(char *, size_t, int, int, int, int)
Definition: sprintf.c:1211
#define PUSH(s, l)
Definition: sprintf.c:66
#define OBJ_TAINT(x)
Definition: ruby.h:1300
unsigned long VALUE
Definition: ruby.h:85
static VALUE result
Definition: nkf.c:40
#define RBASIC(obj)
Definition: ruby.h:1204
RUBY_EXTERN VALUE rb_cInteger
Definition: ruby.h:1891
struct __siov * uio_iov
Definition: vsnprintf.c:229
#define isnan(x)
Definition: win32.h:346
#define FIXABLE(f)
Definition: ruby.h:368
#define FPREC0
Definition: sprintf.c:54
#define CHAR_BIT
Definition: ruby.h:196
#define FPLUS
Definition: sprintf.c:49
#define INTEGER_PACK_BIG_ENDIAN
Definition: intern.h:152
register unsigned int len
Definition: zonetab.h:51
#define StringValueCStr(v)
Definition: ruby.h:571
#define RSTRING_PTR(str)
Definition: ruby.h:982
rb_printf_buffer base
Definition: sprintf.c:1299
#define rb_enc_right_char_head(s, p, e, enc)
Definition: encoding.h:217
#define ECONV_UNDEF_REPLACE
Definition: encoding.h:390
void rb_str_modify(VALUE)
Definition: string.c:1980
static void check_next_arg(int posarg, int nextarg)
Definition: sprintf.c:142
rb_encoding * rb_enc_get(VALUE obj)
Definition: encoding.c:860
VALUE rb_big_uminus(VALUE x)
Definition: bignum.c:5481
RUBY_EXTERN int ffs(int)
Definition: ffs.c:6
#define RFLOAT_VALUE(v)
Definition: ruby.h:940
int size
Definition: encoding.c:57
#define f
VALUE rb_hash_lookup2(VALUE hash, VALUE key, VALUE def)
Definition: hash.c:856
#define INT2FIX(i)
Definition: ruby.h:232
long rb_enc_strlen(const char *, const char *, rb_encoding *)
Definition: string.c:1646
static double float_value(VALUE v)
Definition: random.c:1194
static ssize_t BSD_vfprintf(FILE *fp, const char *fmt0, va_list ap)
Definition: vsnprintf.c:537
VALUE rb_str_vcatf(VALUE str, const char *fmt, va_list ap)
Definition: sprintf.c:1453
VALUE rb_str_catf(VALUE str, const char *format,...)
Definition: sprintf.c:1480
VALUE rb_check_string_type(VALUE)
Definition: string.c:2164
#define LONG2FIX(i)
Definition: ruby.h:234
#define RTEST(v)
Definition: ruby.h:450
#define T_STRING
Definition: ruby.h:496
#define GETPOSARG(n)
Definition: sprintf.c:93
#define PRIuSIZE
Definition: ruby.h:177
#define OBJ_INFECT(x, s)
Definition: ruby.h:1304
size_t rb_str_capacity(VALUE str)
Definition: string.c:674
static void check_name_arg(int posarg, const char *name, int len, rb_encoding *enc)
Definition: sprintf.c:167
size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
Definition: bignum.c:3366
#define CHECKNAMEARG(name, len, enc)
Definition: sprintf.c:100
#define T_CLASS
Definition: ruby.h:492
#define CHECK_FOR_FLAGS(f)
#define PUSH_(s, l)
Definition: sprintf.c:71
#define ruby_debug
Definition: ruby.h:1793
const char * name
Definition: nkf.c:208
VALUE rb_inspect(VALUE)
Definition: object.c:519
#define GETNTHARG(nth)
Definition: sprintf.c:97
#define QUOTE(str)
Definition: internal.h:1472
#define memcpy(d, s, n)
Definition: ffi_common.h:55
int ruby_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
Definition: sprintf.c:1266
RUBY_EXTERN VALUE rb_cSymbol
Definition: ruby.h:1908
#define rb_enc_mbcput(c, buf, enc)
Definition: encoding.h:211
VALUE rb_str_buf_new(long)
Definition: string.c:1247
#define MUL_OVERFLOW_INT_P(a, b)
Definition: internal.h:91
#define RB_INTEGER_TYPE_P(obj)
Definition: ruby_missing.h:20
#define FWIDTH
Definition: sprintf.c:52
#define NULL
Definition: _sdbm.c:102
#define FIX2LONG(x)
Definition: ruby.h:363
#define Qundef
Definition: ruby.h:439
#define FILL_(c, l)
Definition: sprintf.c:81
#define ruby_verbose
Definition: ruby.h:1792
void rb_warn(const char *fmt,...)
Definition: error.c:221
RUBY_EXTERN VALUE rb_cNilClass
Definition: ruby.h:1897
VALUE rb_eArgError
Definition: error.c:763
char ** argv
Definition: ruby.c:184
#define StringValue(v)
Definition: ruby.h:569
size_t iov_len
Definition: vsnprintf.c:226
static void check_pos_arg(int posarg, int n)
Definition: sprintf.c:153
#define rb_sym2str(sym)
Definition: console.c:107
VALUE rb_str_new(const char *, long)
Definition: string.c:736
#define SIGNED_VALUE
Definition: ruby.h:87