14 #include <sys/types.h>
18 #define GCC_VERSION_SINCE(major, minor, patchlevel) \
19 (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
20 ((__GNUC__ > (major)) || \
21 (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
22 (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
23 #if SIZEOF_SHORT != 2 || SIZEOF_LONG != 4
34 static int endian_value;
37 if (init)
return endian_value;
40 return endian_value = p[0]?0:1;
42 # define BIGENDIAN_P() (is_bigendian())
43 #elif defined(WORDS_BIGENDIAN)
44 # define BIGENDIAN_P() 1
46 # define BIGENDIAN_P() 0
50 # define NATINT_LEN(type,len) (natint?(int)sizeof(type):(int)(len))
52 # define NATINT_LEN(type,len) ((int)sizeof(type))
56 # define INT64toNUM(x) LONG2NUM(x)
57 # define UINT64toNUM(x) ULONG2NUM(x)
58 #elif defined(HAVE_LONG_LONG) && SIZEOF_LONG_LONG == 8
59 # define INT64toNUM(x) LL2NUM(x)
60 # define UINT64toNUM(x) ULL2NUM(x)
63 #define define_swapx(x, xtype) \
65 TOKEN_PASTE(swap,x)(xtype z) \
69 unsigned char *s, *t; \
72 zp = xmalloc(sizeof(xtype)); \
74 s = (unsigned char*)zp; \
75 t = xmalloc(sizeof(xtype)); \
76 for (i=0; i<sizeof(xtype); i++) { \
77 t[sizeof(xtype)-i-1] = s[i]; \
85 #if GCC_VERSION_SINCE(4,3,0)
86 # define swap32(x) __builtin_bswap32(x)
87 # define swap64(x) __builtin_bswap64(x)
91 # define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
95 # define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
97 |(((x)&0x0000FF00)<<8) \
98 |(((x)&0x00FF0000)>>8) ))
103 # define byte_in_64bit(n) ((uint64_t)0xff << (n))
104 # define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
106 |(((x)&byte_in_64bit(8))<<40) \
107 |(((x)&byte_in_64bit(48))>>40) \
108 |(((x)&byte_in_64bit(16))<<24) \
109 |(((x)&byte_in_64bit(40))>>24) \
110 |(((x)&byte_in_64bit(24))<<8) \
111 |(((x)&byte_in_64bit(32))>>8)))
115 #if SIZEOF_SHORT == 2
116 # define swaps(x) swap16(x)
117 #elif SIZEOF_SHORT == 4
118 # define swaps(x) swap32(x)
124 # define swapi(x) swap16(x)
125 #elif SIZEOF_INT == 4
126 # define swapi(x) swap32(x)
132 # define swapl(x) swap32(x)
133 #elif SIZEOF_LONG == 8
134 # define swapl(x) swap64(x)
139 #ifdef HAVE_LONG_LONG
140 # if SIZEOF_LONG_LONG == 8
141 # define swapll(x) swap64(x)
147 #if SIZEOF_FLOAT == 4 && defined(HAVE_INT32_T)
148 # define swapf(x) swap32(x)
149 # define FLOAT_SWAPPER uint32_t
154 #if SIZEOF_DOUBLE == 8 && defined(HAVE_INT64_T)
155 # define swapd(x) swap64(x)
156 # define DOUBLE_SWAPPER uint64_t
157 #elif SIZEOF_DOUBLE == 8 && defined(HAVE_INT32_T)
159 swapd(
const double d)
165 utmp[0] = 0; utmp[1] = 0;
166 memcpy(utmp,&dtmp,
sizeof(
double));
168 utmp[0] =
swap32(utmp[1]);
170 memcpy(&dtmp,utmp,
sizeof(
double));
179 #define rb_ntohf(x) (BIGENDIAN_P()?(x):swapf(x))
180 #define rb_ntohd(x) (BIGENDIAN_P()?(x):swapd(x))
181 #define rb_htonf(x) (BIGENDIAN_P()?(x):swapf(x))
182 #define rb_htond(x) (BIGENDIAN_P()?(x):swapd(x))
183 #define rb_htovf(x) (BIGENDIAN_P()?swapf(x):(x))
184 #define rb_htovd(x) (BIGENDIAN_P()?swapd(x):(x))
185 #define rb_vtohf(x) (BIGENDIAN_P()?swapf(x):(x))
186 #define rb_vtohd(x) (BIGENDIAN_P()?swapd(x):(x))
189 # define FLOAT_CONVWITH(y) FLOAT_SWAPPER y;
190 # define HTONF(x,y) (memcpy(&(y),&(x),sizeof(float)), \
191 (y) = rb_htonf((FLOAT_SWAPPER)(y)), \
192 memcpy(&(x),&(y),sizeof(float)), \
194 # define HTOVF(x,y) (memcpy(&(y),&(x),sizeof(float)), \
195 (y) = rb_htovf((FLOAT_SWAPPER)(y)), \
196 memcpy(&(x),&(y),sizeof(float)), \
198 # define NTOHF(x,y) (memcpy(&(y),&(x),sizeof(float)), \
199 (y) = rb_ntohf((FLOAT_SWAPPER)(y)), \
200 memcpy(&(x),&(y),sizeof(float)), \
202 # define VTOHF(x,y) (memcpy(&(y),&(x),sizeof(float)), \
203 (y) = rb_vtohf((FLOAT_SWAPPER)(y)), \
204 memcpy(&(x),&(y),sizeof(float)), \
207 # define FLOAT_CONVWITH(y)
208 # define HTONF(x,y) rb_htonf(x)
209 # define HTOVF(x,y) rb_htovf(x)
210 # define NTOHF(x,y) rb_ntohf(x)
211 # define VTOHF(x,y) rb_vtohf(x)
214 #ifdef DOUBLE_SWAPPER
215 # define DOUBLE_CONVWITH(y) DOUBLE_SWAPPER y;
216 # define HTOND(x,y) (memcpy(&(y),&(x),sizeof(double)), \
217 (y) = rb_htond((DOUBLE_SWAPPER)(y)), \
218 memcpy(&(x),&(y),sizeof(double)), \
220 # define HTOVD(x,y) (memcpy(&(y),&(x),sizeof(double)), \
221 (y) = rb_htovd((DOUBLE_SWAPPER)(y)), \
222 memcpy(&(x),&(y),sizeof(double)), \
224 # define NTOHD(x,y) (memcpy(&(y),&(x),sizeof(double)), \
225 (y) = rb_ntohd((DOUBLE_SWAPPER)(y)), \
226 memcpy(&(x),&(y),sizeof(double)), \
228 # define VTOHD(x,y) (memcpy(&(y),&(x),sizeof(double)), \
229 (y) = rb_vtohd((DOUBLE_SWAPPER)(y)), \
230 memcpy(&(x),&(y),sizeof(double)), \
233 # define DOUBLE_CONVWITH(y)
234 # define HTOND(x,y) rb_htond(x)
235 # define HTOVD(x,y) rb_htovd(x)
236 # define NTOHD(x,y) rb_ntohd(x)
237 # define VTOHD(x,y) rb_vtohd(x)
254 #define MAX_INTEGER_PACK_SIZE 8
257 static const char toofew[] =
"too few arguments";
262 static unsigned long utf8_to_uv(
const char*,
long*);
371 static const char nul10[] =
"\0\0\0\0\0\0\0\0\0\0";
372 static const char spc10[] =
" ";
373 const char *
p, *pend;
376 long items,
len,
idx, plen;
382 int integer_size, bigendian_p;
392 #define TOO_FEW (rb_raise(rb_eArgError, toofew), 0)
393 #define THISFROM (items > 0 ? RARRAY_PTR(ary)[idx] : TOO_FEW)
394 #define NEXTFROM (items-- > 0 ? RARRAY_PTR(ary)[idx++] : TOO_FEW)
397 int explicit_endian = 0;
408 while ((p < pend) && (*p !=
'\n')) {
415 static const char natstr[] =
"sSiIlL";
416 static const char endstr[] =
"sSiIlLqQ";
422 if (
strchr(natstr, type)) {
435 if (!
strchr(endstr, type)) {
438 if (explicit_endian) {
441 explicit_endian = *p++;
447 len =
strchr(
"@Xxu", type) ? 0
454 len =
STRTOUL(p, (
char**)&p, 10);
466 if (enc_info == 1) enc_info = 2;
468 case 'm':
case 'M':
case 'u':
477 case 'A':
case 'a':
case 'Z':
501 if (p[-1] ==
'*' && type ==
'Z')
515 #define castchar(from) (char)((from) & 0xff)
523 j = (len - plen + 1)/2;
526 for (i=0; i++ <
len; ptr++) {
539 byte >>= 7 - (len & 7);
554 j = (len - plen + 1)/2;
557 for (i=0; i++ <
len; ptr++) {
569 byte <<= 7 - (len & 7);
584 j = (len + 1) / 2 - (plen + 1) / 2;
587 for (i=0; i++ <
len; ptr++) {
589 byte |= (((*ptr & 15) + 9) & 15) << 4;
591 byte |= (*ptr & 15) << 4;
615 j = (len + 1) / 2 - (plen + 1) / 2;
618 for (i=0; i++ <
len; ptr++) {
620 byte |= ((*ptr & 15) + 9) & 15;
664 integer_size = (
int)
sizeof(
int);
669 integer_size = (
int)
sizeof(
int);
714 if (explicit_endian) {
715 bigendian_p = explicit_endian ==
'>';
718 switch (integer_size) {
719 #if defined(HAVE_INT16_T) && !defined(FORCE_BIG_PACK)
724 char a[
sizeof(int16_t)];
735 #if defined(HAVE_INT32_T) && !defined(FORCE_BIG_PACK)
740 char a[
sizeof(int32_t)];
751 #if defined(HAVE_INT64_T) && SIZEOF_LONG == SIZEOF_INT64_T && !defined(FORCE_BIG_PACK)
756 char a[
sizeof(int64_t)];
769 rb_bug(
"unexpected intger size for pack: %d", integer_size);
775 int num_longs = (integer_size+SIZEOF_LONG-1)/SIZEOF_LONG;
781 for (i = 0; i < num_longs/2; i++) {
782 unsigned long t =
v.i[
i];
783 v.i[
i] =
v.i[num_longs-1-
i];
784 v.i[num_longs-1-
i] =
t;
788 for (i = 0; i < num_longs; i++)
789 v.i[i] = swapl(
v.i[i]);
793 v.a +
sizeof(
long)*num_longs - integer_size :
890 if (len > 0)
goto grow;
892 if (len > 0)
goto shrink;
923 if (len == 0 && type ==
'm') {
924 encodes(res, ptr, plen, type, 0);
930 else if (len > 63 && type ==
'u')
941 encodes(res, ptr, todo, type, 1);
988 char c, *bufs, *bufe;
1019 while (bufs < bufe) {
1034 rb_warning(
"unknown pack directive '%c' in '%s'",
1059 "`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
1061 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1066 enum {buff_size = 4096, encoded_unit = 4};
1067 char buff[buff_size + 1];
1069 const char *trans = type ==
'u' ? uu_table :
b64_table;
1073 buff[i++] = (char)len +
' ';
1080 while (len >= 3 && buff_size-i >= encoded_unit) {
1081 buff[i++] = trans[077 & (*s >> 2)];
1082 buff[i++] = trans[077 & (((*s << 4) & 060) | ((s[1] >> 4) & 017))];
1083 buff[i++] = trans[077 & (((s[1] << 2) & 074) | ((s[2] >> 6) & 03))];
1084 buff[i++] = trans[077 & s[2]];
1088 if (buff_size-i < encoded_unit) {
1095 buff[i++] = trans[077 & (*s >> 2)];
1096 buff[i++] = trans[077 & (((*s << 4) & 060) | ((s[1] >> 4) & 017))];
1097 buff[i++] = trans[077 & (((s[1] << 2) & 074) | ((
'\0' >> 6) & 03))];
1098 buff[i++] = padding;
1100 else if (len == 1) {
1101 buff[i++] = trans[077 & (*s >> 2)];
1102 buff[i++] = trans[077 & (((*s << 4) & 060) | (('\0' >> 4) & 017))];
1103 buff[i++] = padding;
1104 buff[i++] = padding;
1106 if (tail_lf) buff[i++] =
'\n';
1108 if ((
size_t)i >
sizeof(buff))
rb_bug(
"encodes() buffer overrun");
1117 long i = 0,
n = 0, prev =
EOF;
1123 (*s < 32 && *s !=
'\n' && *s !=
'\t') ||
1126 buff[i++] = hex_table[*s >> 4];
1127 buff[i++] = hex_table[*s & 0x0f];
1131 else if (*s ==
'\n') {
1132 if (prev ==
' ' || prev ==
'\t') {
1170 case '0':
case '1':
case '2':
case '3':
case '4':
1171 case '5':
case '6':
case '7':
case '8':
case '9':
1173 case 'a':
case 'b':
case 'c':
1174 case 'd':
case 'e':
case 'f':
1175 return c -
'a' + 10;
1176 case 'A':
case 'B':
case 'C':
1177 case 'D':
case 'E':
case 'F':
1178 return c -
'A' + 10;
1184 #define PACK_LENGTH_ADJUST_SIZE(sz) do { \
1186 if (len > (long)((send-s)/(sz))) { \
1188 tmp_len = len-(send-s)/(sz); \
1190 len = (send-s)/(sz); \
1194 #define PACK_ITEM_ADJUST() do { \
1195 if (tmp_len > 0 && !block_p) \
1196 rb_ary_store(ary, RARRAY_LEN(ary)+tmp_len-1, Qnil); \
1319 static const char hexdigits[] =
"0123456789abcdef";
1330 int signed_p, integer_size, bigendian_p;
1331 #define UNPACK_PUSH(item) do {\
1332 VALUE item_val = (item);\
1334 rb_yield(item_val);\
1337 rb_ary_push(ary, item_val);\
1350 int explicit_endian = 0;
1358 while ((p < pend) && (*p !=
'\n')) {
1366 static const char natstr[] =
"sSiIlL";
1367 static const char endstr[] =
"sSiIlLqQ";
1374 if (
strchr(natstr, type)) {
1387 if (!
strchr(endstr, type)) {
1390 if (explicit_endian) {
1393 explicit_endian = *p++;
1400 else if (*p ==
'*') {
1407 len =
STRTOUL(p, (
char**)&p, 10);
1413 len = (type !=
'@');
1422 if (len > send - s) len = send -
s;
1425 char *
t = s + len - 1;
1428 if (*t !=
' ' && *t !=
'\0')
break;
1440 if (len > send-s) len = send-
s;
1441 while (t < s+len && *t) t++;
1444 s = star ? t : s+
len;
1449 if (len > send - s) len = send -
s;
1461 if (p[-1] ==
'*' || len > (send - s) * 8)
1462 len = (send -
s) * 8;
1466 for (i=0; i<
len; i++) {
1467 if (i & 7) bits >>= 1;
1469 *t++ = (bits & 1) ?
'1' :
'0';
1481 if (p[-1] ==
'*' || len > (send - s) * 8)
1482 len = (send - s) * 8;
1486 for (i=0; i<
len; i++) {
1487 if (i & 7) bits <<= 1;
1489 *t++ = (bits & 128) ?
'1' :
'0';
1501 if (p[-1] ==
'*' || len > (send - s) * 2)
1502 len = (send - s) * 2;
1506 for (i=0; i<
len; i++) {
1511 *t++ = hexdigits[bits & 15];
1523 if (p[-1] ==
'*' || len > (send - s) * 2)
1524 len = (send -
s) * 2;
1528 for (i=0; i<
len; i++) {
1533 *t++ = hexdigits[(bits >> 4) & 15];
1542 if (c > (
char)127) c-=256;
1551 unsigned char c = *s++;
1561 goto unpack_integer;
1567 goto unpack_integer;
1571 integer_size = (
int)
sizeof(
int);
1573 goto unpack_integer;
1577 integer_size = (
int)
sizeof(
int);
1579 goto unpack_integer;
1585 goto unpack_integer;
1591 goto unpack_integer;
1597 goto unpack_integer;
1603 goto unpack_integer;
1609 goto unpack_integer;
1615 goto unpack_integer;
1621 goto unpack_integer;
1627 goto unpack_integer;
1630 if (explicit_endian) {
1631 bigendian_p = explicit_endian ==
'>';
1634 switch (integer_size) {
1635 #if defined(HAVE_INT16_T) && !defined(FORCE_BIG_PACK)
1636 case SIZEOF_INT16_T:
1642 char a[
sizeof(int16_t)];
1644 memcpy(
v.a, s,
sizeof(int16_t));
1646 s +=
sizeof(int16_t);
1656 char a[
sizeof(uint16_t)];
1658 memcpy(
v.a, s,
sizeof(uint16_t));
1660 s +=
sizeof(uint16_t);
1668 #if defined(HAVE_INT32_T) && !defined(FORCE_BIG_PACK)
1669 case SIZEOF_INT32_T:
1675 char a[
sizeof(int32_t)];
1677 memcpy(
v.a, s,
sizeof(int32_t));
1679 s +=
sizeof(int32_t);
1701 #if defined(HAVE_INT64_T) && !defined(FORCE_BIG_PACK)
1702 case SIZEOF_INT64_T:
1708 char a[
sizeof(int64_t)];
1710 memcpy(
v.a, s,
sizeof(int64_t));
1712 s +=
sizeof(int64_t);
1736 rb_bug(
"unexpected integer size for pack: %d", integer_size);
1743 int num_longs = (integer_size+SIZEOF_LONG)/SIZEOF_LONG;
1746 if (signed_p && (
signed char)s[bigendian_p ? 0 : (integer_size-1)] < 0)
1747 memset(
v.a, 0xff,
sizeof(
long)*num_longs);
1749 memset(
v.a, 0,
sizeof(
long)*num_longs);
1751 memcpy(
v.a +
sizeof(
long)*num_longs - integer_size, s, integer_size);
1755 for (i = 0; i < num_longs/2; i++) {
1756 unsigned long t =
v.i[
i];
1757 v.i[
i] =
v.i[num_longs-1-
i];
1758 v.i[num_longs-1-
i] =
t;
1762 for (i = 0; i < num_longs; i++)
1763 v.i[i] = swapl(
v.i[i]);
1778 memcpy(&tmp, s,
sizeof(
float));
1791 memcpy(&tmp, s,
sizeof(
float));
1793 tmp =
VTOHF(tmp,ftmp);
1805 memcpy(&tmp, s,
sizeof(
double));
1806 s +=
sizeof(double);
1807 tmp =
VTOHD(tmp,dtmp);
1818 memcpy(&tmp, s,
sizeof(
double));
1819 s +=
sizeof(double);
1831 memcpy(&tmp, s,
sizeof(
float));
1833 tmp =
NTOHF(tmp,ftmp);
1845 memcpy(&tmp, s,
sizeof(
double));
1846 s +=
sizeof(double);
1847 tmp =
NTOHD(tmp,dtmp);
1854 if (len > send - s) len = send -
s;
1855 while (len > 0 && s < send) {
1856 long alen = send -
s;
1871 while (s < send && *s >
' ' && *s <
'a') {
1876 len = (*s++ -
' ') & 077;
1884 long mlen = len > 3 ? 3 :
len;
1886 if (s < send && *s >=
' ')
1887 a = (*s++ -
' ') & 077;
1890 if (s < send && *s >=
' ')
1891 b = (*s++ -
' ') & 077;
1894 if (s < send && *s >=
' ')
1895 c = (*s++ -
' ') & 077;
1898 if (s < send && *s >=
' ')
1899 d = (*s++ -
' ') & 077;
1902 hunk[0] = (char)(a << 2 | b >> 4);
1903 hunk[1] = (char)(b << 4 | c >> 2);
1904 hunk[2] = (char)(c << 6 | d);
1909 if (*s ==
'\r') s++;
1910 if (*s ==
'\n') s++;
1911 else if (s < send && (s+1 == send || s[1] ==
'\n'))
1924 int a = -1,
b = -1,
c = 0,
d = 0;
1925 static signed char b64_xtable[256];
1927 if (b64_xtable[
'/'] <= 0) {
1930 for (i = 0; i < 256; i++) {
1933 for (i = 0; i < 64; i++) {
1934 b64_xtable[(
unsigned char)b64_table[i]] = (
char)
i;
1940 a = b64_xtable[(
unsigned char)*s++];
1942 b = b64_xtable[(
unsigned char)*s++];
1945 if (s + 2 == send && *(s + 1) ==
'=')
break;
1948 c = b64_xtable[(
unsigned char)*s++];
1950 if (s + 1 == send && *s ==
'=')
break;
1951 d = b64_xtable[(
unsigned char)*s++];
1970 while ((a = b64_xtable[(
unsigned char)*s]) == -1 && s < send) {s++;}
1971 if (s >= send)
break;
1973 while ((
b = b64_xtable[(
unsigned char)*s]) == -1 && s < send) {s++;}
1974 if (s >= send)
break;
1976 while ((
c = b64_xtable[(
unsigned char)*s]) == -1 && s < send) {
if (*s ==
'=')
break; s++;}
1977 if (*s ==
'=' || s >= send)
break;
1979 while ((
d = b64_xtable[(
unsigned char)*s]) == -1 && s < send) {
if (*s ==
'=')
break; s++;}
1980 if (*s ==
'=' || s >= send)
break;
1986 if (a != -1 &&
b != -1) {
1987 if (
c == -1 && *s ==
'=')
1989 else if (
c != -1 && *s ==
'=') {
2008 if (++s == send)
break;
2009 if (s+1 < send && *s ==
'\r' && *(s+1) ==
'\n')
2012 if ((c1 =
hex2num(*s)) == -1)
break;
2013 if (++s == send)
break;
2014 if ((c2 =
hex2num(*s)) == -1)
break;
2050 if (
sizeof(
char *) <= (
size_t)(send - s)) {
2054 memcpy(&t, s,
sizeof(
char *));
2055 s +=
sizeof(
char *);
2087 if (len > (
long)((send - s) /
sizeof(
char *)))
2088 len = (send -
s) /
sizeof(
char *);
2090 if ((
size_t)(send -
s) <
sizeof(
char *))
2096 memcpy(&t, s,
sizeof(
char *));
2097 s +=
sizeof(
char *);
2125 unsigned long ul = 0;
2126 unsigned long ulmask = 0xfeUL << ((
sizeof(
unsigned long) - 1) * 8);
2128 while (len > 0 && s < send) {
2131 if (!(*s++ & 0x80)) {
2136 else if (ul & ulmask) {
2142 if (!(*s++ & 0x80)) {
2155 rb_warning(
"unknown unpack directive '%c' in '%s'",
2174 buf[0] =
castchar(((uv>>6)&0xff)|0xc0);
2179 buf[0] =
castchar(((uv>>12)&0xff)|0xe0);
2180 buf[1] =
castchar(((uv>>6)&0x3f)|0x80);
2184 if (uv <= 0x1fffff) {
2185 buf[0] =
castchar(((uv>>18)&0xff)|0xf0);
2186 buf[1] =
castchar(((uv>>12)&0x3f)|0x80);
2187 buf[2] =
castchar(((uv>>6)&0x3f)|0x80);
2191 if (uv <= 0x3ffffff) {
2192 buf[0] =
castchar(((uv>>24)&0xff)|0xf8);
2193 buf[1] =
castchar(((uv>>18)&0x3f)|0x80);
2194 buf[2] =
castchar(((uv>>12)&0x3f)|0x80);
2195 buf[3] =
castchar(((uv>>6)&0x3f)|0x80);
2199 if (uv <= 0x7fffffff) {
2200 buf[0] =
castchar(((uv>>30)&0xff)|0xfc);
2201 buf[1] =
castchar(((uv>>24)&0x3f)|0x80);
2202 buf[2] =
castchar(((uv>>18)&0x3f)|0x80);
2203 buf[3] =
castchar(((uv>>12)&0x3f)|0x80);
2204 buf[4] =
castchar(((uv>>6)&0x3f)|0x80);
2223 static unsigned long
2226 int c = *p++ & 0xff;
2227 unsigned long uv =
c;
2239 if (!(uv & 0x20)) { n = 2; uv &= 0x1f; }
2240 else if (!(uv & 0x10)) { n = 3; uv &= 0x0f; }
2241 else if (!(uv & 0x08)) { n = 4; uv &= 0x07; }
2242 else if (!(uv & 0x04)) { n = 5; uv &= 0x03; }
2243 else if (!(uv & 0x02)) { n = 6; uv &= 0x01; }
2256 if ((c & 0xc0) != 0x80) {
2267 if (uv < utf8_limits[n]) {
#define RB_TYPE_P(obj, type)
VALUE rb_str_associated(VALUE)
#define MAX_INTEGER_PACK_SIZE
void rb_bug(const char *fmt,...)
VALUE rb_uint2big(VALUE n)
const char * rb_obj_classname(VALUE)
#define NATINT_LEN(type, len)
void rb_big_pack(VALUE val, unsigned long *buf, long num_longs)
#define PACK_ITEM_ADJUST()
VALUE rb_big_plus(VALUE x, VALUE y)
VALUE rb_ary_push(VALUE ary, VALUE item)
int rb_usascii_encindex(void)
static unsigned long num2i32(VALUE x)
void rb_raise(VALUE exc, const char *fmt,...)
static const char uu_table[]
static const char toofew[]
#define DOUBLE_CONVWITH(y)
VALUE rb_big_unpack(unsigned long *buf, long num_longs)
#define STRTOUL(str, endptr, base)
VALUE rb_usascii_str_new(const char *, long)
static VALUE pack_unpack(VALUE str, VALUE fmt)
VALUE rb_big2ulong_pack(VALUE x)
VALUE rb_big_divmod(VALUE x, VALUE y)
memset(y->frac+ix+1, 0,(y->Prec-(ix+1))*sizeof(BDIGIT))
unsigned long long uint64_t
#define ENCODING_CODERANGE_SET(obj, encindex, cr)
static void encodes(VALUE, const char *, long, int, int)
int rb_block_given_p(void)
#define StringValuePtr(v)
static VALUE infected_str_new(const char *ptr, long len, VALUE str)
int rb_ascii8bit_encindex(void)
#define define_swapx(x, xtype)
static void qpencode(VALUE, VALUE, long)
void rb_enc_set_index(VALUE obj, int idx)
unsigned char buf[MIME_BUF_SIZE]
static const char hex_table[]
VALUE rb_str_buf_cat(VALUE, const char *, long)
VALUE rb_obj_as_string(VALUE)
VALUE rb_tainted_str_new(const char *, long)
int rb_uv_to_utf8(char[6], unsigned long)
static int hex2num(char c)
VALUE rb_big_mul(VALUE x, VALUE y)
VALUE rb_str_buf_new(long)
char * strchr(char *, char)
int rb_utf8_encindex(void)
RUBY_EXTERN VALUE rb_cString
#define FLOAT_CONVWITH(y)
#define ENC_CODERANGE_VALID
VALUE rb_obj_taint(VALUE)
static VALUE pack_pack(VALUE ary, VALUE fmt)
static unsigned long utf8_to_uv(const char *, long *)
#define ENC_CODERANGE_7BIT
static const unsigned long utf8_limits[]
void rb_str_associate(VALUE, VALUE)
VALUE rb_str_new(const char *, long)
#define PACK_LENGTH_ADJUST_SIZE(sz)
static const char b64_table[]
void rb_warning(const char *fmt,...)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
#define UNPACK_PUSH(item)
void rb_str_set_len(VALUE, long)