14#include "ruby/internal/config.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"
35#define BIT_DIGITS(N) (((N)*146)/485 + 1)
37static char *fmt_setup(
char*,
size_t,
int,
int,
int,
int);
38static char *ruby_ultoa(
unsigned long val,
char *endp,
int base,
int octzero);
41sign_bits(
int base,
const char *p)
47 if (*p ==
'X') c =
'F';
69 int cr = ENC_CODERANGE(result);\
70 RUBY_ASSERT(bsiz >= blen); \
71 while ((l) > bsiz - blen) {\
73 if (bsiz<0) rb_raise(rb_eArgError, "too big specifier");\
75 rb_str_resize(result, bsiz);\
76 ENC_CODERANGE_SET(result, cr);\
77 buf = RSTRING_PTR(result);\
80#define CHECK_WIDTH(l, w) do { \
81 if ((l) > INT_MAX - (w)) rb_raise(rb_eArgError, "width too big");\
85#define PUSH(s, l) do { \
90#define PUSH_(s, l) do { \
91 memcpy(&buf[blen], (s), (l));\
95#define FILL(c, l) do { \
101#define FILL_(c, l) do { \
102 memset(&buf[blen], (c), (l));\
107format_args_check(
VALUE ary,
int argc,
const VALUE *argv)
109 if (!
RTEST(ary))
return;
115#define GETARG() (!UNDEF_P(nextvalue) ? nextvalue : \
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)))
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)))
128#define GETNTHARG(nth) \
129 (((nth) >= argc) ? (rb_raise(rb_eArgError, "too few arguments"), 0) : argv[(nth)])
131#define CHECKNAMEARG(name, len, enc) ( \
132 check_name_arg(posarg, name, len, enc), \
135#define GETNUM(n, val) \
136 (!(p = get_num(p, end, enc, &(n))) ? \
137 rb_raise(rb_eArgError, #val " too big") : (void)0)
139#define GETASTER(val) do { \
144 tmp = GETPOSARG(n); \
147 tmp = GETNEXTARG(); \
150 (val) = NUM2INT(tmp); \
154get_num(
const char *p,
const char *end, rb_encoding *enc,
int *valp)
157 for (; p < end && rb_enc_isdigit(*p, enc); p++) {
158 if (MUL_OVERFLOW_INT_P(10, next_n))
161 if (INT_MAX - (*p -
'0') < next_n)
166 rb_raise(rb_eArgError,
"malformed format string - %%*[0-9]");
173check_next_arg(
int posarg,
int nextarg)
177 rb_raise(rb_eArgError,
"unnumbered(%d) mixed with numbered", nextarg);
179 rb_raise(rb_eArgError,
"unnumbered(%d) mixed with named", nextarg);
184check_pos_arg(
int posarg,
int n)
187 rb_raise(rb_eArgError,
"numbered(%d) after unnumbered(%d)", n, posarg);
190 rb_raise(rb_eArgError,
"numbered(%d) after named", n);
193 rb_raise(rb_eArgError,
"invalid index - %d$", n);
198check_name_arg(
int posarg,
const char *name,
int len, rb_encoding *enc)
201 rb_enc_raise(enc, rb_eArgError,
"named%.*s after unnumbered(%d)",
len, name, posarg);
204 rb_enc_raise(enc, rb_eArgError,
"named%.*s after numbered",
len, name);
209get_hash(
volatile VALUE *hash,
int argc,
const VALUE *argv)
213 if (!UNDEF_P(*hash))
return *hash;
215 rb_raise(rb_eArgError,
"one hash required");
217 tmp = rb_check_hash_type(argv[1]);
219 rb_raise(rb_eArgError,
"one hash required");
221 return (*hash = tmp);
231reassoc_enc(
VALUE result, rb_encoding *enc)
233 return RSTRING_PTR(rb_enc_associate(result, enc));
237reassoc_enc_index(
VALUE result,
int encidx)
239 return RSTRING_PTR(rb_enc_associate_index(result, encidx));
245 enum {default_float_precision = 6};
254 int width, prec, flags = FNONE;
263#define CHECK_FOR_WIDTH(f) \
264 if ((f) & FWIDTH) { \
265 rb_raise(rb_eArgError, "width given twice"); \
267 if ((f) & FPREC0) { \
268 rb_raise(rb_eArgError, "width after precision"); \
270#define CHECK_FOR_FLAGS(f) \
271 if ((f) & FWIDTH) { \
272 rb_raise(rb_eArgError, "flag after width"); \
274 if ((f) & FPREC0) { \
275 rb_raise(rb_eArgError, "flag after precision"); \
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))); \
288 const int argc0 = argc;
289 const VALUE *argv0 = argv;
294 enc = rb_enc_get(fmt);
297 fmt = rb_str_tmp_frozen_acquire(fmt);
298 p = RSTRING_PTR(fmt);
299 end = p + RSTRING_LEN(fmt);
303 buf = reassoc_enc(result, enc);
304 memset(buf, 0, bsiz);
307 for (; p < end; p++) {
312 for (t = p; t < end && *t !=
'%'; t++) ;
314 rb_raise(rb_eArgError,
"incomplete format specifier; use %%%% (double %%) instead");
317 update_coderange(FALSE);
329 if (rb_enc_isprint(*p, enc))
330 rb_raise(rb_eArgError,
"malformed format string - %%%c", *p);
332 rb_raise(rb_eArgError,
"malformed format string");
336 CHECK_FOR_FLAGS(flags);
342 CHECK_FOR_FLAGS(flags);
348 CHECK_FOR_FLAGS(flags);
354 CHECK_FOR_FLAGS(flags);
360 CHECK_FOR_FLAGS(flags);
365 case '1':
case '2':
case '3':
case '4':
366 case '5':
case '6':
case '7':
case '8':
case '9':
370 if (!UNDEF_P(nextvalue)) {
371 rb_raise(rb_eArgError,
"value given twice - %d$", n);
373 nextvalue = GETPOSARG(n);
377 CHECK_FOR_WIDTH(flags);
385 const char *start = p;
386 char term = (*p ==
'<') ?
'>' :
'}';
389 for (; p < end && *p != term; ) {
390 p += rb_enc_mbclen(p, end, enc);
393 rb_raise(rb_eArgError,
"malformed name - unmatched parenthesis");
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);
400 "too long name (%"PRIuSIZE
" bytes) - %.*s...%c",
401 (
size_t)(p - start - 2),
len, start, term);
404 len = (int)(p - start + 1);
406 rb_enc_raise(enc, rb_eArgError,
"named%.*s after <%"PRIsVALUE
">",
409 CHECKNAMEARG(start,
len, enc);
410 get_hash(&hash, argc, argv);
414 if (!
NIL_P(sym)) nextvalue = rb_hash_lookup2(hash, sym,
Qundef);
415 if (UNDEF_P(nextvalue)) {
417 sym = rb_sym_intern(start + 1,
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);
426 if (term ==
'}')
goto format_s;
432 CHECK_FOR_WIDTH(flags);
437 if (width == INT_MIN) rb_raise(rb_eArgError,
"width too big");
444 if (flags & FPREC0) {
445 rb_raise(rb_eArgError,
"precision given twice");
447 flags |= FPREC|FPREC0;
460 GETNUM(prec, precision);
464 if (flags != FNONE) {
465 rb_raise(rb_eArgError,
"invalid format character - %%");
472 VALUE val = GETARG();
486 n = rb_enc_codelen((c = n), enc);
487 encidx = rb_ascii8bit_appendable_encoding_index(enc, c);
490 rb_raise(rb_eArgError,
"invalid character");
492 if (encidx >= 0 && encidx != rb_enc_to_index(enc)) {
494 buf = reassoc_enc_index(result, encidx);
495 enc = rb_enc_from_index(encidx);
498 if (!(flags & FWIDTH)) {
500 rb_enc_mbcput(c, &buf[blen], enc);
505 CHECK_WIDTH(n, (width > 0 ? width : 0));
506 if (!(flags & FMINUS) && (width > 0)) FILL_(
' ', width);
507 rb_enc_mbcput(c, &buf[blen], enc);
509 if ((flags & FMINUS) && (width > 0)) FILL_(
' ', width);
518 VALUE arg = GETARG();
528 len = RSTRING_LEN(str);
530 update_coderange(TRUE);
531 enc = rb_enc_check(result, str);
532 if (flags&(FPREC|FWIDTH)) {
535 rb_raise(rb_eArgError,
"invalid mbstring sequence");
537 if ((flags&FPREC) && (prec < slen)) {
538 char *p =
rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
541 len = p - RSTRING_PTR(str);
544 if ((flags&FWIDTH) && (width > slen)) {
546 CHECK_WIDTH(
len, width);
547 if (!(flags&FMINUS)) {
551 memcpy(&buf[blen], RSTRING_PTR(str),
len);
557 buf = reassoc_enc(result, enc);
561 PUSH(RSTRING_PTR(str),
len);
563 buf = reassoc_enc(result, enc);
576 volatile VALUE val = GETARG();
578 char nbuf[BIT_DIGITS(SIZEOF_LONG*CHAR_BIT)+2], *s;
579 const char *prefix = 0;
580 int sign = 0, dots = 0;
583 int base, bignum = 0;
596 if (flags&(FPLUS|FSPACE)) sign = 1;
599 if (flags & FSHARP) {
604 prefix =
"0x";
break;
606 prefix =
"0X";
break;
608 prefix =
"0b";
break;
610 prefix =
"0B";
break;
626 val = rb_str_to_inum(val, 0, TRUE);
656 int numbits = ffs(base)-1;
658 size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits);
660 if (INT_MAX-1 < numdigits)
661 rb_raise(rb_eArgError,
"size too big");
666 valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
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);
675 else if (flags & FPLUS) {
679 else if (flags & FSPACE) {
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))))
700 valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
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);
717 else if (flags & FPLUS) {
721 else if (flags & FSPACE) {
725 s = ruby_ultoa((
unsigned long)v, nbuf +
sizeof(nbuf), 10, 0);
726 len = (int)(nbuf +
sizeof(nbuf) - s);
729 tmp = rb_big2str(val, 10);
730 s = RSTRING_PTR(tmp);
738 else if (flags & FPLUS) {
742 else if (flags & FSPACE) {
757 while ((c = (
int)(
unsigned char)*pp) != 0) {
758 *pp = rb_enc_toupper(c, enc);
762 if (prefix && !prefix[1]) {
766 else if (
len == 1 && *s ==
'0') {
768 if (flags & FPREC) prec--;
770 else if ((flags & FPREC) && (prec >
len)) {
774 else if (
len == 1 && *s ==
'0') {
778 width -= (int)strlen(prefix);
780 if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
786 if (!prefix && prec == 0 &&
len == 1 && *s ==
'0')
len = 0;
791 if (!(flags&FMINUS)) {
795 if (sc) PUSH(&sc, 1);
797 int plen = (int)strlen(prefix);
800 if (dots) PUSH(
"..", 2);
803 if (!sign && valsign < 0) {
804 char c = sign_bits(base, p);
805 FILL_(c, prec -
len);
807 else if ((flags & (FMINUS|FPREC)) != FMINUS) {
808 FILL_(
'0', prec -
len);
819 VALUE val = GETARG(), num, den;
820 int sign = (flags&FPLUS) ? 1 : 0, zero = 0;
834 if (!(flags&FPREC)) prec = default_float_precision;
842 else if (BIGNUM_NEGATIVE_P(num)) {
844 num = rb_big_uminus(num);
848 num = rb_int_plus(num, rb_int_idiv(den,
INT2FIX(2)));
849 num = rb_int_idiv(num, den);
851 else if (prec >= 0) {
854 val = rb_int2str(num, 10);
855 len = RSTRING_LEN(val) + zero;
856 if (prec >=
len)
len = prec + 1;
857 if (sign || (flags&FSPACE)) ++
len;
859 fill = width >
len ? width -
len : 0;
861 if (fill && !(flags&(FMINUS|FZERO))) {
864 if (sign || (flags&FSPACE)) {
865 buf[blen++] = sign > 0 ?
'+' : sign < 0 ?
'-' :
' ';
867 if (fill && (flags&(FMINUS|FZERO)) == FZERO) {
870 len = RSTRING_LEN(val) + zero;
871 t = RSTRING_PTR(val);
873 PUSH_(t,
len - prec);
884 else if (prec >
len) {
885 FILL_(
'0', prec -
len);
889 PUSH_(t +
len - prec, prec);
891 if (fill && (flags&FMINUS)) {
906 VALUE val = GETARG();
910 if (!isfinite(fval)) {
922 need = (int)strlen(expr);
924 if (!isnan(fval) && fval < 0.0)
926 else if (flags & (FPLUS|FSPACE))
927 sign = (flags & FPLUS) ?
'+' :
' ';
930 if ((flags & FWIDTH) && need < width)
934 if (flags & FMINUS) {
936 buf[blen - need--] = sign;
937 memcpy(&buf[blen - need], expr, elen);
941 buf[blen - elen - 1] = sign;
942 memcpy(&buf[blen - elen], expr, elen);
948 char fbuf[2*BIT_DIGITS(SIZEOF_INT*CHAR_BIT)+10];
949 char *fmt = fmt_setup(fbuf,
sizeof(fbuf), *p, flags, width, prec);
951 rb_str_catf(result, fmt, fval);
962 update_coderange(FALSE);
964 rb_str_tmp_frozen_release(orig, fmt);
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";
973 rb_str_resize(result, blen);
981 return rb_str_format_ary(argc, argv, fmt,
Qfalse);
985fmt_setup(
char *buf,
size_t size,
int c,
int flags,
int width,
int prec)
992 buf = ruby_ultoa(prec, buf, 10, 0);
996 if (flags & FWIDTH) {
997 buf = ruby_ultoa(width, buf, 10, 0);
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 =
'#';
1010#define FILE rb_printf_buffer
1011#define __sbuf rb_printf_sbuf
1012#define __sFILE rb_printf_sfile
1017#if SIZEOF_LONG < SIZEOF_LONG_LONG
1018# if SIZEOF_LONG_LONG == SIZEOF_VOIDP
1021# define _HAVE_LLP64_
1023# define _HAVE_SANE_QUAD_
1024# define quad_t LONG_LONG
1025# define u_quad_t unsigned LONG_LONG
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
1033#define lower_hexdigits (ruby_hexdigits+0)
1034#define upper_hexdigits (ruby_hexdigits+16)
1035#include "vsnprintf.c"
1038ruby_ultoa(
unsigned long val,
char *endp,
int base,
int flags)
1040 const char *xdigs = lower_hexdigits;
1041 int octzero = flags & FSHARP;
1042 return BSD__ultoa(val, endp, base, octzero, xdigs);
1045static int ruby_do_vsnprintf(
char *str,
size_t n,
const char *fmt, va_list ap);
1050 if (str && (ssize_t)n < 1)
1052 return ruby_do_vsnprintf(str, n, fmt, ap);
1056ruby_do_vsnprintf(
char *str,
size_t n,
const char *fmt, va_list ap)
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;
1066 ret = BSD_vfprintf(&f, fmt, ap);
1068#if SIZEOF_SIZE_T > SIZEOF_INT
1069 if (n > INT_MAX)
return INT_MAX;
1080 if (str && (ssize_t)n < 1)
1084 ret = ruby_do_vsnprintf(str, n, fmt, ap);
1090 rb_printf_buffer base;
1091 volatile VALUE value;
1095ruby__sfvwrite(
register rb_printf_buffer *fp,
register struct __suio *uio)
1099 char *buf = (
char*)fp->_p;
1101 long blen = buf - RSTRING_PTR(result), bsiz = fp->_w;
1103 if (
RBASIC(result)->klass) {
1106 if (uio->uio_resid == 0)
1108#if SIZE_MAX > LONG_MAX
1109 if (uio->uio_resid >= LONG_MAX)
1112 len = (long)uio->uio_resid;
1116 for (iov = uio->uio_iov;
len > 0; ++iov) {
1117 MEMCPY(buf, iov->iov_base,
char, n = iov->iov_len);
1121 fp->_p = (
unsigned char *)buf;
1127ruby__sfvextra(rb_printf_buffer *fp,
size_t valsize,
void *valp,
long *sz,
int sign)
1133 if (valsize !=
sizeof(
VALUE))
return 0;
1134 value = *(
VALUE *)valp;
1135 if (
RBASIC(result)->klass) {
1139# define LITERAL(str) (*sz = rb_strlen_lit(str), str)
1142# define LITERAL_CASE(x) case Q##x: return LITERAL(#x)
1145 LITERAL_CASE(
false);
1153 if (sign ==
' ' && !rb_str_symname_p(value)) {
1154 value = rb_str_escape(value);
1159 if (sign ==
' ') value = QUOTE(value);
1161 enc = rb_enc_compatible(result, value);
1163 rb_enc_associate(result, enc);
1166 enc = rb_enc_get(result);
1170 *(
volatile VALUE *)valp = value;
1179ruby_vsprintf0(
VALUE result,
char *p,
const char *fmt, va_list ap)
1182#define f buffer.base
1189 f._flags = __SWR | __SSTR;
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;
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;
1205 rb_str_coderange_scan_restartable(p + scanned, p + blen, rb_enc_get(result), &coderange);
1208 rb_str_resize(result, blen);
1215 const int initial_len = 120;
1220 if (rb_enc_mbminlen(enc) > 1) {
1222 rb_raise(rb_eArgError,
"cannot construct wchar_t based encoding string: %s",
1225 rb_enc_associate(result, enc);
1227 ruby_vsprintf0(result, RSTRING_PTR(result), fmt, ap);
1237 va_start(ap, format);
1251rb_sprintf(
const char *format, ...)
1256 va_start(ap, format);
1264rb_str_vcatf(
VALUE str,
const char *fmt, va_list ap)
1268 ruby_vsprintf0(str, RSTRING_END(str), fmt, ap);
1274rb_str_catf(
VALUE str,
const char *format, ...)
1278 va_start(ap, format);
1279 str = rb_str_vcatf(str, format, ap);
ruby_coderange_type
What rb_enc_str_coderange() returns.
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.
VALUE rb_enc_sprintf(rb_encoding *enc, const char *fmt,...)
Identical to rb_sprintf(), except it additionally takes an encoding.
#define TYPE(_)
Old name of rb_type.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define ENC_CODERANGE_VALID
Old name of RUBY_ENC_CODERANGE_VALID.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define ECONV_UNDEF_REPLACE
Old name of RUBY_ECONV_UNDEF_REPLACE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define ENC_CODERANGE(obj)
Old name of RB_ENC_CODERANGE.
#define ENC_CODERANGE_UNKNOWN
Old name of RUBY_ENC_CODERANGE_UNKNOWN.
#define FIXABLE
Old name of RB_FIXABLE.
#define LONG2FIX
Old name of RB_INT2FIX.
#define ECONV_INVALID_REPLACE
Old name of RUBY_ECONV_INVALID_REPLACE.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define T_HASH
Old name of RUBY_T_HASH.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define NUM2INT
Old name of RB_NUM2INT.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#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.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
void rb_enc_raise(rb_encoding *enc, VALUE exc, const char *fmt,...)
Identical to rb_raise(), except it additionally takes an encoding.
VALUE rb_Float(VALUE val)
This is the logic behind Kernel#Float.
VALUE rb_Integer(VALUE val)
This is the logic behind Kernel#Integer.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
char * rb_enc_nth(const char *head, const char *tail, long nth, rb_encoding *enc)
Queries the n-th character.
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.
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.
VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc)
Identical to rb_check_id_cstr(), except for the return type.
#define INTEGER_PACK_BIG_ENDIAN
Big endian combination.
#define INTEGER_PACK_2COMP
Uses 2's complement representation.
VALUE rb_int_positive_pow(long x, unsigned long y)
Raises the passed x to the power of y.
VALUE rb_rational_num(VALUE rat)
Queries the numerator of the passed Rational.
VALUE rb_rational_den(VALUE rat)
Queries the denominator of the passed Rational.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the string.
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
int len
Length of the buffer.
VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
Formats a string.
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Identical to rb_str_format(), except how the arguments are arranged.
VALUE rb_vsprintf(const char *fmt, va_list ap)
Identical to rb_sprintf(), except it takes a va_list.
#define rb_long2int
Just another name of rb_long2int_inline.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RBASIC(obj)
Convenient casting macro.
#define StringValue(v)
Ensures that the parameter object is a String.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap)
Identical to ruby_snprintf(), except it takes a va_list.
int ruby_snprintf(char *str, size_t n, char const *fmt,...)
Our own locale-insensitive version of snprintf(3).
#define RTEST
This is an old name of RB_TEST.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t VALUE
Type that represents a Ruby object.