Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
sprintf.c
1/**********************************************************************
2
3 sprintf.c -
4
5 $Author$
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 "ruby/internal/config.h"
15
16#include <math.h>
17#include <stdarg.h>
18
19#ifdef HAVE_IEEEFP_H
20# include <ieeefp.h>
21#endif
22
23#include "id.h"
24#include "internal.h"
25#include "internal/error.h"
26#include "internal/hash.h"
27#include "internal/numeric.h"
28#include "internal/object.h"
29#include "internal/sanitizers.h"
30#include "internal/symbol.h"
31#include "ruby/encoding.h"
32#include "ruby/re.h"
33#include "ruby/util.h"
34
35#define BIT_DIGITS(N) (((N)*146)/485 + 1) /* log2(10) =~ 146/485 */
36
37static char *fmt_setup(char*,size_t,int,int,int,int);
38static char *ruby_ultoa(unsigned long val, char *endp, int base, int octzero);
39
40static char
41sign_bits(int base, const char *p)
42{
43 char c = '.';
44
45 switch (base) {
46 case 16:
47 if (*p == 'X') c = 'F';
48 else c = 'f';
49 break;
50 case 8:
51 c = '7'; break;
52 case 2:
53 c = '1'; break;
54 }
55 return c;
56}
57
58#define FNONE 0
59#define FSHARP 1
60#define FMINUS 2
61#define FPLUS 4
62#define FZERO 8
63#define FSPACE 16
64#define FWIDTH 32
65#define FPREC 64
66#define FPREC0 128
67
68#define CHECK(l) do {\
69 int cr = ENC_CODERANGE(result);\
70 RUBY_ASSERT(bsiz >= blen); \
71 while ((l) > bsiz - blen) {\
72 bsiz*=2;\
73 if (bsiz<0) rb_raise(rb_eArgError, "too big specifier");\
74 }\
75 rb_str_resize(result, bsiz);\
76 ENC_CODERANGE_SET(result, cr);\
77 buf = RSTRING_PTR(result);\
78} while (0)
79
80#define CHECK_WIDTH(l, w) do { \
81 if ((l) > INT_MAX - (w)) rb_raise(rb_eArgError, "width too big");\
82 CHECK((l)+(w));\
83} while (0)
84
85#define PUSH(s, l) do { \
86 CHECK(l);\
87 PUSH_(s, l);\
88} while (0)
89
90#define PUSH_(s, l) do { \
91 memcpy(&buf[blen], (s), (l));\
92 blen += (l);\
93} while (0)
94
95#define FILL(c, l) do { \
96 if ((l) <= 0) break;\
97 CHECK(l);\
98 FILL_(c, l);\
99} while (0)
100
101#define FILL_(c, l) do { \
102 memset(&buf[blen], (c), (l));\
103 blen += (l);\
104} while (0)
105
106static void
107format_args_check(VALUE ary, int argc, const VALUE *argv)
108{
109 if (!RTEST(ary)) return;
110 if (RARRAY_LEN(ary) != argc || RARRAY_CONST_PTR(ary) != argv) {
111 rb_raise(rb_eRuntimeError, "array modified during formatting");
112 }
113}
114
115#define GETARG() (!UNDEF_P(nextvalue) ? nextvalue : \
116 GETNEXTARG())
117
118#define GETNEXTARG() ( \
119 check_next_arg(posarg, nextarg), \
120 (RTEST(ary) ? (format_args_check(ary, argc0, argv0), 0) : 0), \
121 (posarg = nextarg++, GETNTHARG(posarg)))
122
123#define GETPOSARG(n) ( \
124 check_pos_arg(posarg, (n)), \
125 (RTEST(ary) ? (format_args_check(ary, argc0, argv0), 0) : 0), \
126 (posarg = -1, GETNTHARG(n)))
127
128#define GETNTHARG(nth) \
129 (((nth) >= argc) ? (rb_raise(rb_eArgError, "too few arguments"), 0) : argv[(nth)])
130
131#define CHECKNAMEARG(name, len, enc) ( \
132 check_name_arg(posarg, name, len, enc), \
133 posarg = -2)
134
135#define GETNUM(n, val) \
136 (!(p = get_num(p, end, enc, &(n))) ? \
137 rb_raise(rb_eArgError, #val " too big") : (void)0)
138
139#define GETASTER(val) do { \
140 t = p++; \
141 n = 0; \
142 GETNUM(n, val); \
143 if (*p == '$') { \
144 tmp = GETPOSARG(n); \
145 } \
146 else { \
147 tmp = GETNEXTARG(); \
148 p = t; \
149 } \
150 (val) = NUM2INT(tmp); \
151} while (0)
152
153static const char *
154get_num(const char *p, const char *end, rb_encoding *enc, int *valp)
155{
156 int next_n = *valp;
157 for (; p < end && rb_enc_isdigit(*p, enc); p++) {
158 if (MUL_OVERFLOW_INT_P(10, next_n))
159 return NULL;
160 next_n *= 10;
161 if (INT_MAX - (*p - '0') < next_n)
162 return NULL;
163 next_n += *p - '0';
164 }
165 if (p >= end) {
166 rb_raise(rb_eArgError, "malformed format string - %%*[0-9]");
167 }
168 *valp = next_n;
169 return p;
170}
171
172static void
173check_next_arg(int posarg, int nextarg)
174{
175 switch (posarg) {
176 case -1:
177 rb_raise(rb_eArgError, "unnumbered(%d) mixed with numbered", nextarg);
178 case -2:
179 rb_raise(rb_eArgError, "unnumbered(%d) mixed with named", nextarg);
180 }
181}
182
183static void
184check_pos_arg(int posarg, int n)
185{
186 if (posarg > 0) {
187 rb_raise(rb_eArgError, "numbered(%d) after unnumbered(%d)", n, posarg);
188 }
189 if (posarg == -2) {
190 rb_raise(rb_eArgError, "numbered(%d) after named", n);
191 }
192 if (n < 1) {
193 rb_raise(rb_eArgError, "invalid index - %d$", n);
194 }
195}
196
197static void
198check_name_arg(int posarg, const char *name, int len, rb_encoding *enc)
199{
200 if (posarg > 0) {
201 rb_enc_raise(enc, rb_eArgError, "named%.*s after unnumbered(%d)", len, name, posarg);
202 }
203 if (posarg == -1) {
204 rb_enc_raise(enc, rb_eArgError, "named%.*s after numbered", len, name);
205 }
206}
207
208static VALUE
209get_hash(volatile VALUE *hash, int argc, const VALUE *argv)
210{
211 VALUE tmp;
212
213 if (!UNDEF_P(*hash)) return *hash;
214 if (argc != 2) {
215 rb_raise(rb_eArgError, "one hash required");
216 }
217 tmp = rb_check_hash_type(argv[1]);
218 if (NIL_P(tmp)) {
219 rb_raise(rb_eArgError, "one hash required");
220 }
221 return (*hash = tmp);
222}
223
224VALUE
225rb_f_sprintf(int argc, const VALUE *argv)
226{
227 return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
228}
229
230static char *
231reassoc_enc(VALUE result, rb_encoding *enc)
232{
233 return RSTRING_PTR(rb_enc_associate(result, enc));
234}
235
236static char *
237reassoc_enc_index(VALUE result, int encidx)
238{
239 return RSTRING_PTR(rb_enc_associate_index(result, encidx));
240}
241
242VALUE
243rb_str_format_ary(int argc, const VALUE *argv, VALUE fmt, VALUE ary)
244{
245 enum {default_float_precision = 6};
246 rb_encoding *enc;
247 const char *p, *end;
248 char *buf;
249 long blen, bsiz;
250 VALUE result;
251
252 long scanned = 0;
254 int width, prec, flags = FNONE;
255 int nextarg = 1;
256 int posarg = 0;
257 VALUE nextvalue;
258 VALUE tmp;
259 VALUE orig;
260 VALUE str;
261 volatile VALUE hash = Qundef;
262
263#define CHECK_FOR_WIDTH(f) \
264 if ((f) & FWIDTH) { \
265 rb_raise(rb_eArgError, "width given twice"); \
266 } \
267 if ((f) & FPREC0) { \
268 rb_raise(rb_eArgError, "width after precision"); \
269 }
270#define CHECK_FOR_FLAGS(f) \
271 if ((f) & FWIDTH) { \
272 rb_raise(rb_eArgError, "flag after width"); \
273 } \
274 if ((f) & FPREC0) { \
275 rb_raise(rb_eArgError, "flag after precision"); \
276 }
277
278#define update_coderange(partial) do { \
279 if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) { \
280 int cr = coderange; \
281 scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr); \
282 ENC_CODERANGE_SET(result, \
283 (partial && cr == ENC_CODERANGE_UNKNOWN ? \
284 ENC_CODERANGE_BROKEN : (coderange = cr))); \
285 } \
286 } while (0)
287
288 const int argc0 = argc;
289 const VALUE *argv0 = argv;
290
291 ++argc;
292 --argv;
293 StringValue(fmt);
294 enc = rb_enc_get(fmt);
296 orig = fmt;
297 fmt = rb_str_tmp_frozen_acquire(fmt);
298 p = RSTRING_PTR(fmt);
299 end = p + RSTRING_LEN(fmt);
300 blen = 0;
301 bsiz = 120;
302 result = rb_str_buf_new(bsiz);
303 buf = reassoc_enc(result, enc);
304 memset(buf, 0, bsiz);
305 ENC_CODERANGE_SET(result, coderange);
306
307 for (; p < end; p++) {
308 const char *t;
309 int n;
310 VALUE sym = Qnil;
311
312 for (t = p; t < end && *t != '%'; t++) ;
313 if (t + 1 == end) {
314 rb_raise(rb_eArgError, "incomplete format specifier; use %%%% (double %%) instead");
315 }
316 PUSH(p, t - p);
317 update_coderange(FALSE);
318 if (t >= end) {
319 /* end of fmt string */
320 goto sprint_exit;
321 }
322 p = t + 1; /* skip `%' */
323
324 width = prec = -1;
325 nextvalue = Qundef;
326 retry:
327 switch (*p) {
328 default:
329 if (rb_enc_isprint(*p, enc))
330 rb_raise(rb_eArgError, "malformed format string - %%%c", *p);
331 else
332 rb_raise(rb_eArgError, "malformed format string");
333 break;
334
335 case ' ':
336 CHECK_FOR_FLAGS(flags);
337 flags |= FSPACE;
338 p++;
339 goto retry;
340
341 case '#':
342 CHECK_FOR_FLAGS(flags);
343 flags |= FSHARP;
344 p++;
345 goto retry;
346
347 case '+':
348 CHECK_FOR_FLAGS(flags);
349 flags |= FPLUS;
350 p++;
351 goto retry;
352
353 case '-':
354 CHECK_FOR_FLAGS(flags);
355 flags |= FMINUS;
356 p++;
357 goto retry;
358
359 case '0':
360 CHECK_FOR_FLAGS(flags);
361 flags |= FZERO;
362 p++;
363 goto retry;
364
365 case '1': case '2': case '3': case '4':
366 case '5': case '6': case '7': case '8': case '9':
367 n = 0;
368 GETNUM(n, width);
369 if (*p == '$') {
370 if (!UNDEF_P(nextvalue)) {
371 rb_raise(rb_eArgError, "value given twice - %d$", n);
372 }
373 nextvalue = GETPOSARG(n);
374 p++;
375 goto retry;
376 }
377 CHECK_FOR_WIDTH(flags);
378 width = n;
379 flags |= FWIDTH;
380 goto retry;
381
382 case '<':
383 case '{':
384 {
385 const char *start = p;
386 char term = (*p == '<') ? '>' : '}';
387 int len;
388
389 for (; p < end && *p != term; ) {
390 p += rb_enc_mbclen(p, end, enc);
391 }
392 if (p >= end) {
393 rb_raise(rb_eArgError, "malformed name - unmatched parenthesis");
394 }
395#if SIZEOF_INT < SIZEOF_SIZE_T
396 if ((size_t)(p - start) >= INT_MAX) {
397 const int message_limit = 20;
398 len = (int)(rb_enc_right_char_head(start, start + message_limit, p, enc) - start);
399 rb_enc_raise(enc, rb_eArgError,
400 "too long name (%"PRIuSIZE" bytes) - %.*s...%c",
401 (size_t)(p - start - 2), len, start, term);
402 }
403#endif
404 len = (int)(p - start + 1); /* including parenthesis */
405 if (sym != Qnil) {
406 rb_enc_raise(enc, rb_eArgError, "named%.*s after <%"PRIsVALUE">",
407 len, start, rb_sym2str(sym));
408 }
409 CHECKNAMEARG(start, len, enc);
410 get_hash(&hash, argc, argv);
411 sym = rb_check_symbol_cstr(start + 1,
412 len - 2 /* without parenthesis */,
413 enc);
414 if (!NIL_P(sym)) nextvalue = rb_hash_lookup2(hash, sym, Qundef);
415 if (UNDEF_P(nextvalue)) {
416 if (NIL_P(sym)) {
417 sym = rb_sym_intern(start + 1,
418 len - 2 /* without parenthesis */,
419 enc);
420 }
421 nextvalue = rb_hash_default_value(hash, sym);
422 if (NIL_P(nextvalue)) {
423 rb_key_err_raise(rb_enc_sprintf(enc, "key%.*s not found", len, start), hash, sym);
424 }
425 }
426 if (term == '}') goto format_s;
427 p++;
428 goto retry;
429 }
430
431 case '*':
432 CHECK_FOR_WIDTH(flags);
433 flags |= FWIDTH;
434 GETASTER(width);
435 if (width < 0) {
436 flags |= FMINUS;
437 if (width == INT_MIN) rb_raise(rb_eArgError, "width too big");
438 width = -width;
439 }
440 p++;
441 goto retry;
442
443 case '.':
444 if (flags & FPREC0) {
445 rb_raise(rb_eArgError, "precision given twice");
446 }
447 flags |= FPREC|FPREC0;
448
449 prec = 0;
450 p++;
451 if (*p == '*') {
452 GETASTER(prec);
453 if (prec < 0) { /* ignore negative precision */
454 flags &= ~FPREC;
455 }
456 p++;
457 goto retry;
458 }
459
460 GETNUM(prec, precision);
461 goto retry;
462
463 case '%':
464 if (flags != FNONE) {
465 rb_raise(rb_eArgError, "invalid format character - %%");
466 }
467 PUSH("%", 1);
468 break;
469
470 case 'c':
471 {
472 VALUE val = GETARG();
473 VALUE tmp;
474 unsigned int c;
475 int n, encidx;
476
477 tmp = rb_check_string_type(val);
478 if (!NIL_P(tmp)) {
479 flags |= FPREC;
480 prec = 1;
481 str = tmp;
482 goto format_s1;
483 }
484 n = NUM2INT(val);
485 if (n >= 0) {
486 n = rb_enc_codelen((c = n), enc);
487 encidx = rb_ascii8bit_appendable_encoding_index(enc, c);
488 }
489 if (n <= 0) {
490 rb_raise(rb_eArgError, "invalid character");
491 }
492 if (encidx >= 0 && encidx != rb_enc_to_index(enc)) {
493 /* special case */
494 buf = reassoc_enc_index(result, encidx);
495 enc = rb_enc_from_index(encidx);
496 coderange = ENC_CODERANGE_VALID;
497 }
498 if (!(flags & FWIDTH)) {
499 CHECK(n);
500 rb_enc_mbcput(c, &buf[blen], enc);
501 blen += n;
502 }
503 else {
504 --width;
505 CHECK_WIDTH(n, (width > 0 ? width : 0));
506 if (!(flags & FMINUS) && (width > 0)) FILL_(' ', width);
507 rb_enc_mbcput(c, &buf[blen], enc);
508 blen += n;
509 if ((flags & FMINUS) && (width > 0)) FILL_(' ', width);
510 }
511 }
512 break;
513
514 case 's':
515 case 'p':
516 format_s:
517 {
518 VALUE arg = GETARG();
519 long len, slen;
520
521 if (*p == 'p') {
522 str = rb_inspect(arg);
523 }
524 else {
525 str = rb_obj_as_string(arg);
526 }
527 format_s1:
528 len = RSTRING_LEN(str);
529 rb_str_set_len(result, blen);
530 update_coderange(TRUE);
531 enc = rb_enc_check(result, str);
532 if (flags&(FPREC|FWIDTH)) {
533 slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc);
534 if (slen < 0) {
535 rb_raise(rb_eArgError, "invalid mbstring sequence");
536 }
537 if ((flags&FPREC) && (prec < slen)) {
538 char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
539 prec, enc);
540 slen = prec;
541 len = p - RSTRING_PTR(str);
542 }
543 /* need to adjust multi-byte string pos */
544 if ((flags&FWIDTH) && (width > slen)) {
545 width -= (int)slen;
546 CHECK_WIDTH(len, width);
547 if (!(flags&FMINUS)) {
548 FILL_(' ', width);
549 width = 0;
550 }
551 memcpy(&buf[blen], RSTRING_PTR(str), len);
552 RB_GC_GUARD(str);
553 blen += len;
554 if (flags&FMINUS) {
555 FILL_(' ', width);
556 }
557 buf = reassoc_enc(result, enc);
558 break;
559 }
560 }
561 PUSH(RSTRING_PTR(str), len);
562 RB_GC_GUARD(str);
563 buf = reassoc_enc(result, enc);
564 }
565 break;
566
567 case 'd':
568 case 'i':
569 case 'o':
570 case 'x':
571 case 'X':
572 case 'b':
573 case 'B':
574 case 'u':
575 {
576 volatile VALUE val = GETARG();
577 int valsign;
578 char nbuf[BIT_DIGITS(SIZEOF_LONG*CHAR_BIT)+2], *s;
579 const char *prefix = 0;
580 int sign = 0, dots = 0;
581 char sc = 0;
582 long v = 0;
583 int base, bignum = 0;
584 int len;
585
586 switch (*p) {
587 case 'd':
588 case 'i':
589 case 'u':
590 sign = 1; break;
591 case 'o':
592 case 'x':
593 case 'X':
594 case 'b':
595 case 'B':
596 if (flags&(FPLUS|FSPACE)) sign = 1;
597 break;
598 }
599 if (flags & FSHARP) {
600 switch (*p) {
601 case 'o':
602 prefix = "0"; break;
603 case 'x':
604 prefix = "0x"; break;
605 case 'X':
606 prefix = "0X"; break;
607 case 'b':
608 prefix = "0b"; break;
609 case 'B':
610 prefix = "0B"; break;
611 }
612 }
613
614 bin_retry:
615 switch (TYPE(val)) {
616 case T_FLOAT:
617 if (FIXABLE(RFLOAT_VALUE(val))) {
618 val = LONG2FIX((long)RFLOAT_VALUE(val));
619 goto bin_retry;
620 }
621 val = rb_dbl2big(RFLOAT_VALUE(val));
622 if (FIXNUM_P(val)) goto bin_retry;
623 bignum = 1;
624 break;
625 case T_STRING:
626 val = rb_str_to_inum(val, 0, TRUE);
627 goto bin_retry;
628 case T_BIGNUM:
629 bignum = 1;
630 break;
631 case T_FIXNUM:
632 v = FIX2LONG(val);
633 break;
634 default:
635 val = rb_Integer(val);
636 goto bin_retry;
637 }
638
639 switch (*p) {
640 case 'o':
641 base = 8; break;
642 case 'x':
643 case 'X':
644 base = 16; break;
645 case 'b':
646 case 'B':
647 base = 2; break;
648 case 'u':
649 case 'd':
650 case 'i':
651 default:
652 base = 10; break;
653 }
654
655 if (base != 10) {
656 int numbits = ffs(base)-1;
657 size_t abs_nlz_bits;
658 size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits);
659 long i;
660 if (INT_MAX-1 < numdigits) /* INT_MAX is used because rb_long2int is used later. */
661 rb_raise(rb_eArgError, "size too big");
662 if (sign) {
663 if (numdigits == 0)
664 numdigits = 1;
665 tmp = rb_str_new(NULL, numdigits);
666 valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
667 1, CHAR_BIT-numbits, INTEGER_PACK_BIG_ENDIAN);
668 for (i = 0; i < RSTRING_LEN(tmp); i++)
669 RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
670 s = RSTRING_PTR(tmp);
671 if (valsign < 0) {
672 sc = '-';
673 width--;
674 }
675 else if (flags & FPLUS) {
676 sc = '+';
677 width--;
678 }
679 else if (flags & FSPACE) {
680 sc = ' ';
681 width--;
682 }
683 }
684 else {
685 /* Following conditional "numdigits++" guarantees the
686 * most significant digit as
687 * - '1'(bin), '7'(oct) or 'f'(hex) for negative numbers
688 * - '0' for zero
689 * - not '0' for positive numbers.
690 *
691 * It also guarantees the most significant two
692 * digits will not be '11'(bin), '77'(oct), 'ff'(hex)
693 * or '00'. */
694 if (numdigits == 0 ||
695 ((abs_nlz_bits != (size_t)(numbits-1) ||
696 !rb_absint_singlebit_p(val)) &&
697 (!bignum ? v < 0 : BIGNUM_NEGATIVE_P(val))))
698 numdigits++;
699 tmp = rb_str_new(NULL, numdigits);
700 valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
701 1, CHAR_BIT-numbits, INTEGER_PACK_2COMP | INTEGER_PACK_BIG_ENDIAN);
702 for (i = 0; i < RSTRING_LEN(tmp); i++)
703 RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
704 s = RSTRING_PTR(tmp);
705 dots = valsign < 0;
706 }
707 len = rb_long2int(RSTRING_END(tmp) - s);
708 }
709 else if (!bignum) {
710 valsign = 1;
711 if (v < 0) {
712 v = -v;
713 sc = '-';
714 width--;
715 valsign = -1;
716 }
717 else if (flags & FPLUS) {
718 sc = '+';
719 width--;
720 }
721 else if (flags & FSPACE) {
722 sc = ' ';
723 width--;
724 }
725 s = ruby_ultoa((unsigned long)v, nbuf + sizeof(nbuf), 10, 0);
726 len = (int)(nbuf + sizeof(nbuf) - s);
727 }
728 else {
729 tmp = rb_big2str(val, 10);
730 s = RSTRING_PTR(tmp);
731 valsign = 1;
732 if (s[0] == '-') {
733 s++;
734 sc = '-';
735 width--;
736 valsign = -1;
737 }
738 else if (flags & FPLUS) {
739 sc = '+';
740 width--;
741 }
742 else if (flags & FSPACE) {
743 sc = ' ';
744 width--;
745 }
746 len = rb_long2int(RSTRING_END(tmp) - s);
747 }
748
749 if (dots) {
750 prec -= 2;
751 width -= 2;
752 }
753
754 if (*p == 'X') {
755 char *pp = s;
756 int c;
757 while ((c = (int)(unsigned char)*pp) != 0) {
758 *pp = rb_enc_toupper(c, enc);
759 pp++;
760 }
761 }
762 if (prefix && !prefix[1]) { /* octal */
763 if (dots) {
764 prefix = 0;
765 }
766 else if (len == 1 && *s == '0') {
767 len = 0;
768 if (flags & FPREC) prec--;
769 }
770 else if ((flags & FPREC) && (prec > len)) {
771 prefix = 0;
772 }
773 }
774 else if (len == 1 && *s == '0') {
775 prefix = 0;
776 }
777 if (prefix) {
778 width -= (int)strlen(prefix);
779 }
780 if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
781 prec = width;
782 width = 0;
783 }
784 else {
785 if (prec < len) {
786 if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
787 prec = len;
788 }
789 width -= prec;
790 }
791 if (!(flags&FMINUS)) {
792 FILL(' ', width);
793 width = 0;
794 }
795 if (sc) PUSH(&sc, 1);
796 if (prefix) {
797 int plen = (int)strlen(prefix);
798 PUSH(prefix, plen);
799 }
800 if (dots) PUSH("..", 2);
801 if (prec > len) {
802 CHECK(prec - len);
803 if (!sign && valsign < 0) {
804 char c = sign_bits(base, p);
805 FILL_(c, prec - len);
806 }
807 else if ((flags & (FMINUS|FPREC)) != FMINUS) {
808 FILL_('0', prec - len);
809 }
810 }
811 PUSH(s, len);
812 RB_GC_GUARD(tmp);
813 FILL(' ', width);
814 }
815 break;
816
817 case 'f':
818 {
819 VALUE val = GETARG(), num, den;
820 int sign = (flags&FPLUS) ? 1 : 0, zero = 0;
821 long len, fill;
822 if (RB_INTEGER_TYPE_P(val)) {
823 den = INT2FIX(1);
824 num = val;
825 }
826 else if (RB_TYPE_P(val, T_RATIONAL)) {
827 den = rb_rational_den(val);
828 num = rb_rational_num(val);
829 }
830 else {
831 nextvalue = val;
832 goto float_value;
833 }
834 if (!(flags&FPREC)) prec = default_float_precision;
835 if (FIXNUM_P(num)) {
836 if ((SIGNED_VALUE)num < 0) {
837 long n = -FIX2LONG(num);
838 num = LONG2NUM(n);
839 sign = -1;
840 }
841 }
842 else if (BIGNUM_NEGATIVE_P(num)) {
843 sign = -1;
844 num = rb_big_uminus(num);
845 }
846 if (den != INT2FIX(1)) {
847 num = rb_int_mul(num, rb_int_positive_pow(10, prec));
848 num = rb_int_plus(num, rb_int_idiv(den, INT2FIX(2)));
849 num = rb_int_idiv(num, den);
850 }
851 else if (prec >= 0) {
852 zero = prec;
853 }
854 val = rb_int2str(num, 10);
855 len = RSTRING_LEN(val) + zero;
856 if (prec >= len) len = prec + 1; /* integer part 0 */
857 if (sign || (flags&FSPACE)) ++len;
858 if (prec > 0) ++len; /* period */
859 fill = width > len ? width - len : 0;
860 CHECK(fill + len); /* max(width, len) */
861 if (fill && !(flags&(FMINUS|FZERO))) {
862 FILL_(' ', fill);
863 }
864 if (sign || (flags&FSPACE)) {
865 buf[blen++] = sign > 0 ? '+' : sign < 0 ? '-' : ' ';
866 }
867 if (fill && (flags&(FMINUS|FZERO)) == FZERO) {
868 FILL_('0', fill);
869 }
870 len = RSTRING_LEN(val) + zero;
871 t = RSTRING_PTR(val);
872 if (len > prec) {
873 PUSH_(t, len - prec);
874 }
875 else {
876 buf[blen++] = '0';
877 }
878 if (prec > 0) {
879 buf[blen++] = '.';
880 }
881 if (zero) {
882 FILL_('0', zero);
883 }
884 else if (prec > len) {
885 FILL_('0', prec - len);
886 PUSH_(t, len);
887 }
888 else if (prec > 0) {
889 PUSH_(t + len - prec, prec);
890 }
891 if (fill && (flags&FMINUS)) {
892 FILL_(' ', fill);
893 }
894 RB_GC_GUARD(val);
895 break;
896 }
897 case 'g':
898 case 'G':
899 case 'e':
900 case 'E':
901 /* TODO: rational support */
902 case 'a':
903 case 'A':
904 float_value:
905 {
906 VALUE val = GETARG();
907 double fval;
908
909 fval = RFLOAT_VALUE(rb_Float(val));
910 if (!isfinite(fval)) {
911 const char *expr;
912 int need;
913 int elen;
914 char sign = '\0';
915
916 if (isnan(fval)) {
917 expr = "NaN";
918 }
919 else {
920 expr = "Inf";
921 }
922 need = (int)strlen(expr);
923 elen = need;
924 if (!isnan(fval) && fval < 0.0)
925 sign = '-';
926 else if (flags & (FPLUS|FSPACE))
927 sign = (flags & FPLUS) ? '+' : ' ';
928 if (sign)
929 ++need;
930 if ((flags & FWIDTH) && need < width)
931 need = width;
932
933 FILL(' ', need);
934 if (flags & FMINUS) {
935 if (sign)
936 buf[blen - need--] = sign;
937 memcpy(&buf[blen - need], expr, elen);
938 }
939 else {
940 if (sign)
941 buf[blen - elen - 1] = sign;
942 memcpy(&buf[blen - elen], expr, elen);
943 }
944 break;
945 }
946 else {
947 int cr = ENC_CODERANGE(result);
948 char fbuf[2*BIT_DIGITS(SIZEOF_INT*CHAR_BIT)+10];
949 char *fmt = fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
950 rb_str_set_len(result, blen);
951 rb_str_catf(result, fmt, fval);
952 ENC_CODERANGE_SET(result, cr);
953 bsiz = rb_str_capacity(result);
954 RSTRING_GETMEM(result, buf, blen);
955 }
956 }
957 break;
958 }
959 flags = FNONE;
960 }
961
962 update_coderange(FALSE);
963 sprint_exit:
964 rb_str_tmp_frozen_release(orig, fmt);
965 /* XXX - We cannot validate the number of arguments if (digit)$ style used.
966 */
967 format_args_check(ary, argc0, argv0);
968 if (posarg >= 0 && nextarg < argc && !(argc == 2 && RB_TYPE_P(argv[1], T_HASH))) {
969 const char *mesg = "too many arguments for format string";
970 if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg);
971 if (RTEST(ruby_verbose)) rb_warn("%s", mesg);
972 }
973 rb_str_resize(result, blen);
974
975 return result;
976}
977
978VALUE
979rb_str_format(int argc, const VALUE *argv, VALUE fmt)
980{
981 return rb_str_format_ary(argc, argv, fmt, Qfalse);
982}
983
984static char *
985fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
986{
987 buf += size;
988 *--buf = '\0';
989 *--buf = c;
990
991 if (flags & FPREC) {
992 buf = ruby_ultoa(prec, buf, 10, 0);
993 *--buf = '.';
994 }
995
996 if (flags & FWIDTH) {
997 buf = ruby_ultoa(width, buf, 10, 0);
998 }
999
1000 if (flags & FSPACE) *--buf = ' ';
1001 if (flags & FZERO) *--buf = '0';
1002 if (flags & FMINUS) *--buf = '-';
1003 if (flags & FPLUS) *--buf = '+';
1004 if (flags & FSHARP) *--buf = '#';
1005 *--buf = '%';
1006 return buf;
1007}
1008
1009#undef FILE
1010#define FILE rb_printf_buffer
1011#define __sbuf rb_printf_sbuf
1012#define __sFILE rb_printf_sfile
1013#undef feof
1014#undef ferror
1015#undef clearerr
1016#undef fileno
1017#if SIZEOF_LONG < SIZEOF_LONG_LONG
1018# if SIZEOF_LONG_LONG == SIZEOF_VOIDP
1019/* actually this doesn't mean a pointer is strictly 64bit, but just
1020 * quad_t size */
1021# define _HAVE_LLP64_
1022# endif
1023# define _HAVE_SANE_QUAD_
1024# define quad_t LONG_LONG
1025# define u_quad_t unsigned LONG_LONG
1026#endif
1027#define FLOATING_POINT 1
1028#define BSD__dtoa ruby_dtoa
1029#define BSD__hdtoa ruby_hdtoa
1030#ifdef RUBY_PRI_VALUE_MARK
1031# define PRI_EXTRA_MARK RUBY_PRI_VALUE_MARK
1032#endif
1033#define lower_hexdigits (ruby_hexdigits+0)
1034#define upper_hexdigits (ruby_hexdigits+16)
1035#include "vsnprintf.c"
1036
1037static char *
1038ruby_ultoa(unsigned long val, char *endp, int base, int flags)
1039{
1040 const char *xdigs = lower_hexdigits;
1041 int octzero = flags & FSHARP;
1042 return BSD__ultoa(val, endp, base, octzero, xdigs);
1043}
1044
1045static int ruby_do_vsnprintf(char *str, size_t n, const char *fmt, va_list ap);
1046
1047int
1048ruby_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
1049{
1050 if (str && (ssize_t)n < 1)
1051 return (EOF);
1052 return ruby_do_vsnprintf(str, n, fmt, ap);
1053}
1054
1055static int
1056ruby_do_vsnprintf(char *str, size_t n, const char *fmt, va_list ap)
1057{
1058 ssize_t ret;
1059 rb_printf_buffer f;
1060
1061 f._flags = __SWR | __SSTR;
1062 f._bf._base = f._p = (unsigned char *)str;
1063 f._bf._size = f._w = str ? (n - 1) : 0;
1064 f.vwrite = BSD__sfvwrite;
1065 f.vextra = 0;
1066 ret = BSD_vfprintf(&f, fmt, ap);
1067 if (str) *f._p = 0;
1068#if SIZEOF_SIZE_T > SIZEOF_INT
1069 if (n > INT_MAX) return INT_MAX;
1070#endif
1071 return (int)ret;
1072}
1073
1074int
1075ruby_snprintf(char *str, size_t n, char const *fmt, ...)
1076{
1077 int ret;
1078 va_list ap;
1079
1080 if (str && (ssize_t)n < 1)
1081 return (EOF);
1082
1083 va_start(ap, fmt);
1084 ret = ruby_do_vsnprintf(str, n, fmt, ap);
1085 va_end(ap);
1086 return ret;
1087}
1088
1089typedef struct {
1090 rb_printf_buffer base;
1091 volatile VALUE value;
1093
1094static int
1095ruby__sfvwrite(register rb_printf_buffer *fp, register struct __suio *uio)
1096{
1097 struct __siov *iov;
1098 VALUE result = (VALUE)fp->_bf._base;
1099 char *buf = (char*)fp->_p;
1100 long len, n;
1101 long blen = buf - RSTRING_PTR(result), bsiz = fp->_w;
1102
1103 if (RBASIC(result)->klass) {
1104 rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1105 }
1106 if (uio->uio_resid == 0)
1107 return 0;
1108#if SIZE_MAX > LONG_MAX
1109 if (uio->uio_resid >= LONG_MAX)
1110 rb_raise(rb_eRuntimeError, "too big string");
1111#endif
1112 len = (long)uio->uio_resid;
1113 CHECK(len);
1114 buf += blen;
1115 fp->_w = bsiz;
1116 for (iov = uio->uio_iov; len > 0; ++iov) {
1117 MEMCPY(buf, iov->iov_base, char, n = iov->iov_len);
1118 buf += n;
1119 len -= n;
1120 }
1121 fp->_p = (unsigned char *)buf;
1122 rb_str_set_len(result, buf - RSTRING_PTR(result));
1123 return 0;
1124}
1125
1126static const char *
1127ruby__sfvextra(rb_printf_buffer *fp, size_t valsize, void *valp, long *sz, int sign)
1128{
1129 VALUE value, result = (VALUE)fp->_bf._base;
1130 rb_encoding *enc;
1131 char *cp;
1132
1133 if (valsize != sizeof(VALUE)) return 0;
1134 value = *(VALUE *)valp;
1135 if (RBASIC(result)->klass) {
1136 rb_raise(rb_eRuntimeError, "rb_vsprintf reentered");
1137 }
1138 if (sign == '+') {
1139# define LITERAL(str) (*sz = rb_strlen_lit(str), str)
1140 /* optimize special const cases */
1141 switch (value) {
1142# define LITERAL_CASE(x) case Q##x: return LITERAL(#x)
1143 LITERAL_CASE(nil);
1144 LITERAL_CASE(true);
1145 LITERAL_CASE(false);
1146# undef LITERAL_CASE
1147 }
1148# undef LITERAL
1149 value = rb_inspect(value);
1150 }
1151 else if (SYMBOL_P(value)) {
1152 value = rb_sym2str(value);
1153 if (sign == ' ' && !rb_str_symname_p(value)) {
1154 value = rb_str_escape(value);
1155 }
1156 }
1157 else {
1158 value = rb_obj_as_string(value);
1159 if (sign == ' ') value = QUOTE(value);
1160 }
1161 enc = rb_enc_compatible(result, value);
1162 if (enc) {
1163 rb_enc_associate(result, enc);
1164 }
1165 else {
1166 enc = rb_enc_get(result);
1167 value = rb_str_conv_enc_opts(value, rb_enc_get(value), enc,
1169 Qnil);
1170 *(volatile VALUE *)valp = value;
1171 }
1172 StringValueCStr(value);
1173 RSTRING_GETMEM(value, cp, *sz);
1174 ((rb_printf_buffer_extra *)fp)->value = value;
1175 return cp;
1176}
1177
1178static void
1179ruby_vsprintf0(VALUE result, char *p, const char *fmt, va_list ap)
1180{
1182#define f buffer.base
1183 VALUE klass = RBASIC(result)->klass;
1184 int coderange = ENC_CODERANGE(result);
1185 long scanned = 0;
1186
1187 if (coderange != ENC_CODERANGE_UNKNOWN) scanned = p - RSTRING_PTR(result);
1188
1189 f._flags = __SWR | __SSTR;
1190 f._bf._size = 0;
1191 f._w = rb_str_capacity(result);
1192 f._bf._base = (unsigned char *)result;
1193 f._p = (unsigned char *)p;
1194 RBASIC_CLEAR_CLASS(result);
1195 f.vwrite = ruby__sfvwrite;
1196 f.vextra = ruby__sfvextra;
1197 buffer.value = 0;
1198 BSD_vfprintf(&f, fmt, ap);
1199 RBASIC_SET_CLASS_RAW(result, klass);
1200 p = RSTRING_PTR(result);
1201 long blen = (char *)f._p - p;
1202
1203 coderange = ENC_CODERANGE(result);
1204 if (coderange != ENC_CODERANGE_UNKNOWN && scanned < blen) {
1205 rb_str_coderange_scan_restartable(p + scanned, p + blen, rb_enc_get(result), &coderange);
1206 ENC_CODERANGE_SET(result, coderange);
1207 }
1208 rb_str_resize(result, blen);
1209#undef f
1210}
1211
1212VALUE
1213rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
1214{
1215 const int initial_len = 120;
1216 VALUE result;
1217
1218 result = rb_str_buf_new(initial_len);
1219 if (enc) {
1220 if (rb_enc_mbminlen(enc) > 1) {
1221 /* the implementation deeply depends on plain char */
1222 rb_raise(rb_eArgError, "cannot construct wchar_t based encoding string: %s",
1223 rb_enc_name(enc));
1224 }
1225 rb_enc_associate(result, enc);
1226 }
1227 ruby_vsprintf0(result, RSTRING_PTR(result), fmt, ap);
1228 return result;
1229}
1230
1231VALUE
1232rb_enc_sprintf(rb_encoding *enc, const char *format, ...)
1233{
1234 VALUE result;
1235 va_list ap;
1236
1237 va_start(ap, format);
1238 result = rb_enc_vsprintf(enc, format, ap);
1239 va_end(ap);
1240
1241 return result;
1242}
1243
1244VALUE
1245rb_vsprintf(const char *fmt, va_list ap)
1246{
1247 return rb_enc_vsprintf(NULL, fmt, ap);
1248}
1249
1250VALUE
1251rb_sprintf(const char *format, ...)
1252{
1253 VALUE result;
1254 va_list ap;
1255
1256 va_start(ap, format);
1257 result = rb_vsprintf(format, ap);
1258 va_end(ap);
1259
1260 return result;
1261}
1262
1263VALUE
1264rb_str_vcatf(VALUE str, const char *fmt, va_list ap)
1265{
1266 StringValue(str);
1267 rb_str_modify(str);
1268 ruby_vsprintf0(str, RSTRING_END(str), fmt, ap);
1269
1270 return str;
1271}
1272
1273VALUE
1274rb_str_catf(VALUE str, const char *format, ...)
1275{
1276 va_list ap;
1277
1278 va_start(ap, format);
1279 str = rb_str_vcatf(str, format, ap);
1280 va_end(ap);
1281
1282 return str;
1283}
ruby_coderange_type
What rb_enc_str_coderange() returns.
Definition coderange.h:33
VALUE rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap)
Identical to rb_enc_sprintf(), except it takes a va_list instead of variadic arguments.
Definition sprintf.c:1213
VALUE rb_enc_sprintf(rb_encoding *enc, const char *fmt,...)
Identical to rb_sprintf(), except it additionally takes an encoding.
Definition sprintf.c:1232
#define TYPE(_)
Old name of rb_type.
Definition value_type.h:108
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
Definition value_type.h:87
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
Definition coderange.h:180
#define ENC_CODERANGE_VALID
Old name of RUBY_ENC_CODERANGE_VALID.
Definition coderange.h:181
#define RFLOAT_VALUE
Old name of rb_float_value.
Definition double.h:28
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define T_FLOAT
Old name of RUBY_T_FLOAT.
Definition value_type.h:64
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
Definition value_type.h:57
#define ECONV_UNDEF_REPLACE
Old name of RUBY_ECONV_UNDEF_REPLACE.
Definition transcode.h:526
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
Definition value_type.h:63
#define ENC_CODERANGE(obj)
Old name of RB_ENC_CODERANGE.
Definition coderange.h:184
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
Definition coderange.h:179
#define FIXABLE
Old name of RB_FIXABLE.
Definition fixnum.h:25
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
#define ECONV_INVALID_REPLACE
Old name of RUBY_ECONV_INVALID_REPLACE.
Definition transcode.h:524
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
Definition value_type.h:76
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define LONG2NUM
Old name of RB_LONG2NUM.
Definition long.h:50
#define NUM2INT
Old name of RB_NUM2INT.
Definition int.h:44
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
Definition long.h:46
#define NIL_P
Old name of RB_NIL_P.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define ENC_CODERANGE_SET(obj, cr)
Old name of RB_ENC_CODERANGE_SET.
Definition coderange.h:186
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
Definition error.h:486
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
Definition error.h:475
VALUE rb_eRuntimeError
RuntimeError exception.
Definition error.c:1429
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
void rb_enc_raise(rb_encoding *enc, VALUE exc, const char *fmt,...)
Identical to rb_raise(), except it additionally takes an encoding.
Definition error.c:3779
VALUE rb_Float(VALUE val)
This is the logic behind Kernel#Float.
Definition object.c:3738
VALUE rb_Integer(VALUE val)
This is the logic behind Kernel#Integer.
Definition object.c:3381
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
Definition object.c:686
Encoding relates APIs.
char * rb_enc_nth(const char *head, const char *tail, long nth, rb_encoding *enc)
Queries the n-th character.
Definition string.c:3059
VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts)
Identical to rb_str_conv_enc(), except it additionally takes IO encoder options.
Definition string.c:1243
long rb_enc_strlen(const char *head, const char *tail, rb_encoding *enc)
Counts the number of characters of the passed string, according to the passed encoding.
Definition string.c:2363
VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc)
Identical to rb_check_id_cstr(), except for the return type.
Definition symbol.c:1235
#define INTEGER_PACK_BIG_ENDIAN
Big endian combination.
Definition bignum.h:572
#define INTEGER_PACK_2COMP
Uses 2's complement representation.
Definition bignum.h:549
VALUE rb_int_positive_pow(long x, unsigned long y)
Raises the passed x to the power of y.
Definition numeric.c:4701
VALUE rb_rational_num(VALUE rat)
Queries the numerator of the passed Rational.
Definition rational.c:2037
VALUE rb_rational_den(VALUE rat)
Queries the denominator of the passed Rational.
Definition rational.c:2043
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
Definition string.h:1499
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
Definition string.c:1018
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the string.
Definition string.c:3418
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
Definition string.c:2821
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
Definition string.c:2981
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
Definition string.c:1735
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
Definition string.c:1868
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:994
int len
Length of the buffer.
Definition io.h:8
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
Definition sprintf.c:979
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Identical to rb_str_format(), except how the arguments are arranged.
Definition sprintf.c:225
VALUE rb_vsprintf(const char *fmt, va_list ap)
Identical to rb_sprintf(), except it takes a va_list.
Definition sprintf.c:1245
#define rb_long2int
Just another name of rb_long2int_inline.
Definition long.h:62
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
Definition memory.h:372
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define StringValue(v)
Ensures that the parameter object is a String.
Definition rstring.h:66
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
Definition rstring.h:450
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
Definition rstring.h:89
int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap)
Identical to ruby_snprintf(), except it takes a va_list.
Definition sprintf.c:1048
int ruby_snprintf(char *str, size_t n, char const *fmt,...)
Our own locale-insensitive version of snprintf(3).
Definition sprintf.c:1075
#define RTEST
This is an old name of RB_TEST.
Defines old _.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
Definition value.h:63
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40