static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
VALUE defaults, opts, block;
ID db_timezone, app_timezone, dbTz, appTz;
unsigned long i;
const char * errstr;
int symbolizeKeys, asArray, castBool, cacheRows, cast;
MYSQL_FIELD * fields = NULL;
GET_RESULT(self);
defaults = rb_iv_get(self, "@query_options");
Check_Type(defaults, T_HASH);
if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
opts = rb_funcall(defaults, intern_merge, 1, opts);
} else {
opts = defaults;
}
symbolizeKeys = RTEST(rb_hash_aref(opts, sym_symbolize_keys));
asArray = rb_hash_aref(opts, sym_as) == sym_array;
castBool = RTEST(rb_hash_aref(opts, sym_cast_booleans));
cacheRows = RTEST(rb_hash_aref(opts, sym_cache_rows));
cast = RTEST(rb_hash_aref(opts, sym_cast));
if (wrapper->is_streaming && cacheRows) {
rb_warn(":cache_rows is ignored if :stream is true");
}
dbTz = rb_hash_aref(opts, sym_database_timezone);
if (dbTz == sym_local) {
db_timezone = intern_local;
} else if (dbTz == sym_utc) {
db_timezone = intern_utc;
} else {
if (!NIL_P(dbTz)) {
rb_warn(":database_timezone option must be :utc or :local - defaulting to :local");
}
db_timezone = intern_local;
}
appTz = rb_hash_aref(opts, sym_application_timezone);
if (appTz == sym_local) {
app_timezone = intern_local;
} else if (appTz == sym_utc) {
app_timezone = intern_utc;
} else {
app_timezone = Qnil;
}
if (wrapper->is_streaming) {
/* When streaming, we will only yield rows, not return them. */
if (wrapper->rows == Qnil) {
wrapper->rows = rb_ary_new();
}
if (!wrapper->streamingComplete) {
VALUE row;
fields = mysql_fetch_fields(wrapper->result);
do {
row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
if (row != Qnil) {
wrapper->numberOfRows++;
if (block != Qnil) {
rb_yield(row);
}
}
} while(row != Qnil);
rb_mysql_result_free_result(wrapper);
wrapper->streamingComplete = 1;
// Check for errors, the connection might have gone out from under us
// mysql_error returns an empty string if there is no error
errstr = mysql_error(wrapper->client_wrapper->client);
if (errstr[0]) {
rb_raise(cMysql2Error, "%s", errstr);
}
} else {
rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery).");
}
} else {
if (wrapper->lastRowProcessed == 0) {
wrapper->numberOfRows = mysql_num_rows(wrapper->result);
if (wrapper->numberOfRows == 0) {
wrapper->rows = rb_ary_new();
return wrapper->rows;
}
wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
} else if (!cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
mysql_data_seek(wrapper->result, 0);
wrapper->lastRowProcessed = 0;
wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
}
if (cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
/* we've already read the entire dataset from the C result into our */
/* internal array. Lets hand that over to the user since it's ready to go */
for (i = 0; i < wrapper->numberOfRows; i++) {
rb_yield(rb_ary_entry(wrapper->rows, i));
}
} else {
unsigned long rowsProcessed = 0;
rowsProcessed = RARRAY_LEN(wrapper->rows);
fields = mysql_fetch_fields(wrapper->result);
for (i = 0; i < wrapper->numberOfRows; i++) {
VALUE row;
if (cacheRows && i < rowsProcessed) {
row = rb_ary_entry(wrapper->rows, i);
} else {
row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
if (cacheRows) {
rb_ary_store(wrapper->rows, i, row);
}
wrapper->lastRowProcessed++;
}
if (row == Qnil) {
/* we don't need the mysql C dataset around anymore, peace it */
if (cacheRows) {
rb_mysql_result_free_result(wrapper);
}
return Qnil;
}
if (block != Qnil) {
rb_yield(row);
}
}
if (wrapper->lastRowProcessed == wrapper->numberOfRows && cacheRows) {
/* we don't need the mysql C dataset around anymore, peace it */
rb_mysql_result_free_result(wrapper);
}
}
}
return wrapper->rows;
}
/* Marks the object as changed, meaning vertices must be updated. */
static
VALUE ray_drawable_set_textured(VALUE self, VALUE val) {
say_drawable_set_textured(ray_rb2drawable(self), RTEST(val));
return self;
}
VALUE
rb_str_format(int argc, const VALUE *argv, VALUE fmt)
{
enum {default_float_precision = 6};
rb_encoding *enc;
const char *p, *end;
char *buf;
long blen, bsiz;
VALUE result;
long scanned = 0;
int coderange = ENC_CODERANGE_7BIT;
int width, prec, flags = FNONE;
int nextarg = 1;
int posarg = 0;
int tainted = 0;
VALUE nextvalue;
VALUE tmp;
VALUE str;
volatile VALUE hash = Qundef;
#define CHECK_FOR_WIDTH(f) \
if ((f) & FWIDTH) { \
rb_raise(rb_eArgError, "width given twice"); \
} \
if ((f) & FPREC0) { \
rb_raise(rb_eArgError, "width after precision"); \
}
#define CHECK_FOR_FLAGS(f) \
if ((f) & FWIDTH) { \
rb_raise(rb_eArgError, "flag after width"); \
} \
if ((f) & FPREC0) { \
rb_raise(rb_eArgError, "flag after precision"); \
}
++argc;
--argv;
if (OBJ_TAINTED(fmt)) tainted = 1;
StringValue(fmt);
enc = rb_enc_get(fmt);
fmt = rb_str_new4(fmt);
p = RSTRING_PTR(fmt);
end = p + RSTRING_LEN(fmt);
blen = 0;
bsiz = 120;
result = rb_str_buf_new(bsiz);
rb_enc_copy(result, fmt);
buf = RSTRING_PTR(result);
memset(buf, 0, bsiz);
ENC_CODERANGE_SET(result, coderange);
for (; p < end; p++) {
const char *t;
int n;
VALUE sym = Qnil;
for (t = p; t < end && *t != '%'; t++) ;
PUSH(p, t - p);
if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &coderange);
ENC_CODERANGE_SET(result, coderange);
}
if (t >= end) {
/* end of fmt string */
goto sprint_exit;
}
p = t + 1; /* skip `%' */
width = prec = -1;
nextvalue = Qundef;
retry:
switch (*p) {
default:
if (rb_enc_isprint(*p, enc))
rb_raise(rb_eArgError, "malformed format string - %%%c", *p);
else
rb_raise(rb_eArgError, "malformed format string");
break;
case ' ':
CHECK_FOR_FLAGS(flags);
flags |= FSPACE;
p++;
goto retry;
case '#':
CHECK_FOR_FLAGS(flags);
flags |= FSHARP;
p++;
goto retry;
case '+':
CHECK_FOR_FLAGS(flags);
flags |= FPLUS;
p++;
goto retry;
case '-':
CHECK_FOR_FLAGS(flags);
flags |= FMINUS;
p++;
goto retry;
case '0':
CHECK_FOR_FLAGS(flags);
flags |= FZERO;
p++;
goto retry;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = 0;
GETNUM(n, width);
if (*p == '$') {
if (nextvalue != Qundef) {
rb_raise(rb_eArgError, "value given twice - %d$", n);
}
nextvalue = GETPOSARG(n);
p++;
goto retry;
}
CHECK_FOR_WIDTH(flags);
width = n;
flags |= FWIDTH;
goto retry;
case '<':
case '{':
{
const char *start = p;
char term = (*p == '<') ? '>' : '}';
int len;
for (; p < end && *p != term; ) {
p += rb_enc_mbclen(p, end, enc);
}
if (p >= end) {
rb_raise(rb_eArgError, "malformed name - unmatched parenthesis");
}
#if SIZEOF_INT < SIZEOF_SIZE_T
if ((size_t)(p - start) >= INT_MAX) {
const int message_limit = 20;
len = (int)(rb_enc_right_char_head(start, start + message_limit, p, enc) - start);
rb_enc_raise(enc, rb_eArgError,
"too long name (%"PRIdSIZE" bytes) - %.*s...%c",
(size_t)(p - start - 2), len, start, term);
}
#endif
len = (int)(p - start + 1); /* including parenthesis */
if (sym != Qnil) {
rb_enc_raise(enc, rb_eArgError, "named%.*s after <%"PRIsVALUE">",
len, start, rb_sym2str(sym));
}
CHECKNAMEARG(start, len, enc);
get_hash(&hash, argc, argv);
sym = rb_check_symbol_cstr(start + 1,
len - 2 /* without parenthesis */,
enc);
if (!NIL_P(sym)) nextvalue = rb_hash_lookup2(hash, sym, Qundef);
if (nextvalue == Qundef) {
if (NIL_P(sym)) {
sym = rb_sym_intern(start + 1,
len - 2 /* without parenthesis */,
enc);
}
nextvalue = rb_hash_default_value(hash, sym);
if (NIL_P(nextvalue)) {
rb_enc_raise(enc, rb_eKeyError, "key%.*s not found", len, start);
}
}
if (term == '}') goto format_s;
p++;
goto retry;
}
case '*':
CHECK_FOR_WIDTH(flags);
flags |= FWIDTH;
GETASTER(width);
if (width < 0) {
flags |= FMINUS;
width = -width;
}
p++;
goto retry;
case '.':
if (flags & FPREC0) {
rb_raise(rb_eArgError, "precision given twice");
}
flags |= FPREC|FPREC0;
prec = 0;
p++;
if (*p == '*') {
GETASTER(prec);
if (prec < 0) { /* ignore negative precision */
flags &= ~FPREC;
}
p++;
goto retry;
}
GETNUM(prec, precision);
goto retry;
case '\n':
case '\0':
p--;
case '%':
if (flags != FNONE) {
rb_raise(rb_eArgError, "invalid format character - %%");
}
PUSH("%", 1);
break;
case 'c':
{
VALUE val = GETARG();
VALUE tmp;
unsigned int c;
int n;
tmp = rb_check_string_type(val);
if (!NIL_P(tmp)) {
if (rb_enc_strlen(RSTRING_PTR(tmp),RSTRING_END(tmp),enc) != 1) {
rb_raise(rb_eArgError, "%%c requires a character");
}
c = rb_enc_codepoint_len(RSTRING_PTR(tmp), RSTRING_END(tmp), &n, enc);
RB_GC_GUARD(tmp);
}
else {
c = NUM2INT(val);
n = rb_enc_codelen(c, enc);
}
if (n <= 0) {
rb_raise(rb_eArgError, "invalid character");
}
if (!(flags & FWIDTH)) {
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
}
else if ((flags & FMINUS)) {
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
if (width > 1) FILL(' ', width-1);
}
else {
if (width > 1) FILL(' ', width-1);
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
}
}
break;
case 's':
case 'p':
format_s:
{
VALUE arg = GETARG();
long len, slen;
if (*p == 'p') {
str = rb_inspect(arg);
}
else {
str = rb_obj_as_string(arg);
}
if (OBJ_TAINTED(str)) tainted = 1;
len = RSTRING_LEN(str);
rb_str_set_len(result, blen);
if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
int cr = coderange;
scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr);
ENC_CODERANGE_SET(result,
(cr == ENC_CODERANGE_UNKNOWN ?
ENC_CODERANGE_BROKEN : (coderange = cr)));
}
enc = rb_enc_check(result, str);
if (flags&(FPREC|FWIDTH)) {
slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc);
if (slen < 0) {
rb_raise(rb_eArgError, "invalid mbstring sequence");
}
if ((flags&FPREC) && (prec < slen)) {
char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
prec, enc);
slen = prec;
len = p - RSTRING_PTR(str);
}
/* need to adjust multi-byte string pos */
if ((flags&FWIDTH) && (width > slen)) {
width -= (int)slen;
if (!(flags&FMINUS)) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
CHECK(len);
memcpy(&buf[blen], RSTRING_PTR(str), len);
RB_GC_GUARD(str);
blen += len;
if (flags&FMINUS) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
rb_enc_associate(result, enc);
break;
}
}
PUSH(RSTRING_PTR(str), len);
RB_GC_GUARD(str);
rb_enc_associate(result, enc);
}
break;
case 'd':
case 'i':
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
case 'u':
{
volatile VALUE val = GETARG();
int valsign;
char nbuf[64], *s;
const char *prefix = 0;
int sign = 0, dots = 0;
char sc = 0;
long v = 0;
int base, bignum = 0;
int len;
switch (*p) {
case 'd':
case 'i':
case 'u':
sign = 1; break;
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
if (flags&(FPLUS|FSPACE)) sign = 1;
break;
}
if (flags & FSHARP) {
switch (*p) {
case 'o':
prefix = "0"; break;
case 'x':
prefix = "0x"; break;
case 'X':
prefix = "0X"; break;
case 'b':
prefix = "0b"; break;
case 'B':
prefix = "0B"; break;
}
}
bin_retry:
switch (TYPE(val)) {
case T_FLOAT:
if (FIXABLE(RFLOAT_VALUE(val))) {
val = LONG2FIX((long)RFLOAT_VALUE(val));
goto bin_retry;
}
val = rb_dbl2big(RFLOAT_VALUE(val));
if (FIXNUM_P(val)) goto bin_retry;
bignum = 1;
break;
case T_STRING:
val = rb_str_to_inum(val, 0, TRUE);
goto bin_retry;
case T_BIGNUM:
bignum = 1;
break;
case T_FIXNUM:
v = FIX2LONG(val);
break;
default:
val = rb_Integer(val);
goto bin_retry;
}
switch (*p) {
case 'o':
base = 8; break;
case 'x':
case 'X':
base = 16; break;
case 'b':
case 'B':
base = 2; break;
case 'u':
case 'd':
case 'i':
default:
base = 10; break;
}
if (base != 10) {
int numbits = ffs(base)-1;
size_t abs_nlz_bits;
size_t numdigits = rb_absint_numwords(val, numbits, &abs_nlz_bits);
long i;
if (INT_MAX-1 < numdigits) /* INT_MAX is used because rb_long2int is used later. */
rb_raise(rb_eArgError, "size too big");
if (sign) {
if (numdigits == 0)
numdigits = 1;
tmp = rb_str_new(NULL, numdigits);
valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
1, CHAR_BIT-numbits, INTEGER_PACK_BIG_ENDIAN);
for (i = 0; i < RSTRING_LEN(tmp); i++)
RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
s = RSTRING_PTR(tmp);
if (valsign < 0) {
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
}
else {
/* Following conditional "numdigits++" guarantees the
* most significant digit as
* - '1'(bin), '7'(oct) or 'f'(hex) for negative numbers
* - '0' for zero
* - not '0' for positive numbers.
*
* It also guarantees the most significant two
* digits will not be '11'(bin), '77'(oct), 'ff'(hex)
* or '00'. */
if (numdigits == 0 ||
((abs_nlz_bits != (size_t)(numbits-1) ||
!rb_absint_singlebit_p(val)) &&
(!bignum ? v < 0 : BIGNUM_NEGATIVE_P(val))))
numdigits++;
tmp = rb_str_new(NULL, numdigits);
valsign = rb_integer_pack(val, RSTRING_PTR(tmp), RSTRING_LEN(tmp),
1, CHAR_BIT-numbits, INTEGER_PACK_2COMP | INTEGER_PACK_BIG_ENDIAN);
for (i = 0; i < RSTRING_LEN(tmp); i++)
RSTRING_PTR(tmp)[i] = ruby_digitmap[((unsigned char *)RSTRING_PTR(tmp))[i]];
s = RSTRING_PTR(tmp);
dots = valsign < 0;
}
len = rb_long2int(RSTRING_END(tmp) - s);
}
else if (!bignum) {
valsign = 1;
if (v < 0) {
v = -v;
sc = '-';
width--;
valsign = -1;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
snprintf(nbuf, sizeof(nbuf), "%ld", v);
s = nbuf;
len = (int)strlen(s);
}
else {
tmp = rb_big2str(val, 10);
s = RSTRING_PTR(tmp);
valsign = 1;
if (s[0] == '-') {
s++;
sc = '-';
width--;
valsign = -1;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
len = rb_long2int(RSTRING_END(tmp) - s);
}
if (dots) {
prec -= 2;
width -= 2;
}
if (*p == 'X') {
char *pp = s;
int c;
while ((c = (int)(unsigned char)*pp) != 0) {
*pp = rb_enc_toupper(c, enc);
pp++;
}
}
if (prefix && !prefix[1]) { /* octal */
if (dots) {
prefix = 0;
}
else if (len == 1 && *s == '0') {
len = 0;
if (flags & FPREC) prec--;
}
else if ((flags & FPREC) && (prec > len)) {
prefix = 0;
}
}
else if (len == 1 && *s == '0') {
prefix = 0;
}
if (prefix) {
width -= (int)strlen(prefix);
}
if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
prec = width;
width = 0;
}
else {
if (prec < len) {
if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
prec = len;
}
width -= prec;
}
if (!(flags&FMINUS)) {
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
if (sc) PUSH(&sc, 1);
if (prefix) {
int plen = (int)strlen(prefix);
PUSH(prefix, plen);
}
CHECK(prec - len);
if (dots) PUSH("..", 2);
if (!sign && valsign < 0) {
char c = sign_bits(base, p);
while (len < prec--) {
buf[blen++] = c;
}
}
else if ((flags & (FMINUS|FPREC)) != FMINUS) {
while (len < prec--) {
buf[blen++] = '0';
}
}
PUSH(s, len);
RB_GC_GUARD(tmp);
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
break;
case 'f':
{
VALUE val = GETARG(), num, den;
int sign = (flags&FPLUS) ? 1 : 0, zero = 0;
long len, done = 0;
int prefix = 0;
if (FIXNUM_P(val) || RB_TYPE_P(val, T_BIGNUM)) {
den = INT2FIX(1);
num = val;
}
else if (RB_TYPE_P(val, T_RATIONAL)) {
den = rb_rational_den(val);
num = rb_rational_num(val);
}
else {
nextvalue = val;
goto float_value;
}
if (!(flags&FPREC)) prec = default_float_precision;
if (FIXNUM_P(num)) {
if ((SIGNED_VALUE)num < 0) {
long n = -FIX2LONG(num);
num = LONG2FIX(n);
sign = -1;
}
}
else if (rb_num_negative_p(num)) {
sign = -1;
num = rb_funcallv(num, idUMinus, 0, 0);
}
if (den != INT2FIX(1) || prec > 1) {
const ID idDiv = rb_intern("div");
VALUE p10 = rb_int_positive_pow(10, prec);
VALUE den_2 = rb_funcall(den, idDiv, 1, INT2FIX(2));
num = rb_funcallv(num, '*', 1, &p10);
num = rb_funcallv(num, '+', 1, &den_2);
num = rb_funcallv(num, idDiv, 1, &den);
}
else if (prec >= 0) {
zero = prec;
}
val = rb_obj_as_string(num);
len = RSTRING_LEN(val) + zero;
if (prec >= len) len = prec + 1; /* integer part 0 */
if (sign || (flags&FSPACE)) ++len;
if (prec > 0) ++len; /* period */
CHECK(len > width ? len : width);
if (sign || (flags&FSPACE)) {
buf[blen++] = sign > 0 ? '+' : sign < 0 ? '-' : ' ';
prefix++;
done++;
}
len = RSTRING_LEN(val) + zero;
t = RSTRING_PTR(val);
if (len > prec) {
memcpy(&buf[blen], t, len - prec);
blen += len - prec;
done += len - prec;
}
else {
buf[blen++] = '0';
done++;
}
if (prec > 0) {
buf[blen++] = '.';
done++;
}
if (zero) {
FILL('0', zero);
done += zero;
}
else if (prec > len) {
FILL('0', prec - len);
memcpy(&buf[blen], t, len);
blen += len;
done += prec;
}
else if (prec > 0) {
memcpy(&buf[blen], t + len - prec, prec);
blen += prec;
done += prec;
}
if ((flags & FWIDTH) && width > done) {
int fill = ' ';
long shifting = 0;
if (!(flags&FMINUS)) {
shifting = done;
if (flags&FZERO) {
shifting -= prefix;
fill = '0';
}
blen -= shifting;
memmove(&buf[blen + width - done], &buf[blen], shifting);
}
FILL(fill, width - done);
blen += shifting;
}
RB_GC_GUARD(val);
break;
}
case 'g':
case 'G':
case 'e':
case 'E':
/* TODO: rational support */
case 'a':
case 'A':
float_value:
{
VALUE val = GETARG();
double fval;
int i, need;
char fbuf[32];
fval = RFLOAT_VALUE(rb_Float(val));
if (isnan(fval) || isinf(fval)) {
const char *expr;
if (isnan(fval)) {
expr = "NaN";
}
else {
expr = "Inf";
}
need = (int)strlen(expr);
if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS))
need++;
if ((flags & FWIDTH) && need < width)
need = width;
CHECK(need + 1);
snprintf(&buf[blen], need + 1, "%*s", need, "");
if (flags & FMINUS) {
if (!isnan(fval) && fval < 0.0)
buf[blen++] = '-';
else if (flags & FPLUS)
buf[blen++] = '+';
else if (flags & FSPACE)
blen++;
memcpy(&buf[blen], expr, strlen(expr));
}
else {
if (!isnan(fval) && fval < 0.0)
buf[blen + need - strlen(expr) - 1] = '-';
else if (flags & FPLUS)
buf[blen + need - strlen(expr) - 1] = '+';
else if ((flags & FSPACE) && need > width)
blen++;
memcpy(&buf[blen + need - strlen(expr)], expr,
strlen(expr));
}
blen += strlen(&buf[blen]);
break;
}
fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
need = 0;
if (*p != 'e' && *p != 'E') {
i = INT_MIN;
frexp(fval, &i);
if (i > 0)
need = BIT_DIGITS(i);
}
need += (flags&FPREC) ? prec : default_float_precision;
if ((flags&FWIDTH) && need < width)
need = width;
need += 20;
CHECK(need);
snprintf(&buf[blen], need, fbuf, fval);
blen += strlen(&buf[blen]);
}
break;
}
flags = FNONE;
}
sprint_exit:
RB_GC_GUARD(fmt);
/* XXX - We cannot validate the number of arguments if (digit)$ style used.
*/
if (posarg >= 0 && nextarg < argc) {
const char *mesg = "too many arguments for format string";
if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg);
if (RTEST(ruby_verbose)) rb_warn("%s", mesg);
}
rb_str_resize(result, blen);
if (tainted) OBJ_TAINT(result);
return result;
}
static VALUE
rb_fairy_xmarshaled_queue_initialize(VALUE self, VALUE policy, VALUE buffers_mon, VALUE buffers_cv)
{
VALUE sz;
VALUE flag;
VALUE dir;
fairy_xmarshaled_queue_t *mq;
GetFairyXMarshaledQueuePtr(self, mq);
sz = rb_fairy_conf("XMARSHAL_QUEUE_CHUNK_SIZE", policy, "chunk_size");
mq->chunk_size = NUM2LONG(sz);
sz = rb_fairy_conf("XMARSHAL_QUEUE_BUFFERS_CACHE_LIMIT",
policy, "buffers_cache_limit");
mq->buffers_cache_limit = NUM2LONG(sz);
flag = rb_fairy_conf("XMARSHAL_QUEUE_USE_STRING_BUFFER",
policy, "use_string_buffer");
mq->use_string_buffer_p = RTEST(flag);
flag = rb_fairy_conf("XMARSHAL_QUEUE_LOG_MSTORE",
policy, "log_mstore");
mq->log_mstore_p = RTEST(flag);
dir = rb_fairy_conf("TMP_DIR", policy, "buffer_dir");
mq->buffer_dir = dir;
mq->push_queue = Qnil;
mq->buffers = rb_xthread_fifo_new();
if (NIL_P(buffers_mon)) {
buffers_mon = rb_xthread_monitor_new();
}
mq->buffers_mon = buffers_mon;
if (NIL_P(buffers_cv)) {
buffers_cv = rb_funcall(buffers_mon, rb_intern("new_cond"), 0);
}
mq->buffers_cv = buffers_cv;
mq->pop_queue = Qnil;
mq->queue_push = rb_fairy_xmarshaled_queue_empty_push;
if (CLASS_OF(mq->buffers_mon) == rb_cXThreadMonitor) {
mq->mon_synchronize = rb_xthread_monitor_synchronize;
mq->cv_wait = rb_fairy_xmarshaled_queue_monitor_cond_wait;
mq->cv_broadcast = rb_xthread_monitor_cond_broadcast;
}
else if (CLASS_OF(mq->buffers_mon) == rb_cFiberMonMonitor) {
mq->mon_synchronize = rb_fibermon_monitor_synchronize;
mq->cv_wait = rb_fibermon_cond_wait;
mq->cv_broadcast = rb_fibermon_cond_broadcast;
}
else {
mq->mon_synchronize = rb_fairy_xmarshaled_queue_genmon_synchronize;
mq->cv_wait = rb_fairy_xmarshaled_queue_gencond_wait;
mq->cv_broadcast = rb_fairy_xmarshaled_queue_gencond_broadcast;
}
return self;
}
VALUE
rb_str_format(int argc, const VALUE *argv, VALUE fmt)
{
rb_encoding *enc;
const char *p, *end;
char *buf;
long blen, bsiz;
VALUE result;
long scanned = 0;
int coderange = ENC_CODERANGE_7BIT;
int width, prec, flags = FNONE;
int nextarg = 1;
int posarg = 0;
int tainted = 0;
VALUE nextvalue;
VALUE tmp;
VALUE str;
volatile VALUE hash = Qundef;
#define CHECK_FOR_WIDTH(f) \
if ((f) & FWIDTH) { \
rb_raise(rb_eArgError, "width given twice"); \
} \
if ((f) & FPREC0) { \
rb_raise(rb_eArgError, "width after precision"); \
}
#define CHECK_FOR_FLAGS(f) \
if ((f) & FWIDTH) { \
rb_raise(rb_eArgError, "flag after width"); \
} \
if ((f) & FPREC0) { \
rb_raise(rb_eArgError, "flag after precision"); \
}
++argc;
--argv;
if (OBJ_TAINTED(fmt)) tainted = 1;
StringValue(fmt);
enc = rb_enc_get(fmt);
fmt = rb_str_new4(fmt);
p = RSTRING_PTR(fmt);
end = p + RSTRING_LEN(fmt);
blen = 0;
bsiz = 120;
result = rb_str_buf_new(bsiz);
rb_enc_copy(result, fmt);
buf = RSTRING_PTR(result);
memset(buf, 0, bsiz);
ENC_CODERANGE_SET(result, coderange);
for (; p < end; p++) {
const char *t;
int n;
ID id = 0;
for (t = p; t < end && *t != '%'; t++) ;
PUSH(p, t - p);
if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &coderange);
ENC_CODERANGE_SET(result, coderange);
}
if (t >= end) {
/* end of fmt string */
goto sprint_exit;
}
p = t + 1; /* skip `%' */
width = prec = -1;
nextvalue = Qundef;
retry:
switch (*p) {
default:
if (rb_enc_isprint(*p, enc))
rb_raise(rb_eArgError, "malformed format string - %%%c", *p);
else
rb_raise(rb_eArgError, "malformed format string");
break;
case ' ':
CHECK_FOR_FLAGS(flags);
flags |= FSPACE;
p++;
goto retry;
case '#':
CHECK_FOR_FLAGS(flags);
flags |= FSHARP;
p++;
goto retry;
case '+':
CHECK_FOR_FLAGS(flags);
flags |= FPLUS;
p++;
goto retry;
case '-':
CHECK_FOR_FLAGS(flags);
flags |= FMINUS;
p++;
goto retry;
case '0':
CHECK_FOR_FLAGS(flags);
flags |= FZERO;
p++;
goto retry;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = 0;
GETNUM(n, width);
if (*p == '$') {
if (nextvalue != Qundef) {
rb_raise(rb_eArgError, "value given twice - %d$", n);
}
nextvalue = GETPOSARG(n);
p++;
goto retry;
}
CHECK_FOR_WIDTH(flags);
width = n;
flags |= FWIDTH;
goto retry;
case '<':
case '{':
{
const char *start = p;
char term = (*p == '<') ? '>' : '}';
for (; p < end && *p != term; ) {
p += rb_enc_mbclen(p, end, enc);
}
if (p >= end) {
rb_raise(rb_eArgError, "malformed name - unmatched parenthesis");
}
if (id) {
rb_raise(rb_eArgError, "name%.*s after <%s>",
(int)(p - start + 1), start, rb_id2name(id));
}
id = rb_intern3(start + 1, p - start - 1, enc);
nextvalue = GETNAMEARG(ID2SYM(id), start, (int)(p - start + 1));
if (nextvalue == Qundef) {
rb_raise(rb_eKeyError, "key%.*s not found", (int)(p - start + 1), start);
}
if (term == '}') goto format_s;
p++;
goto retry;
}
case '*':
CHECK_FOR_WIDTH(flags);
flags |= FWIDTH;
GETASTER(width);
if (width < 0) {
flags |= FMINUS;
width = -width;
}
p++;
goto retry;
case '.':
if (flags & FPREC0) {
rb_raise(rb_eArgError, "precision given twice");
}
flags |= FPREC|FPREC0;
prec = 0;
p++;
if (*p == '*') {
GETASTER(prec);
if (prec < 0) { /* ignore negative precision */
flags &= ~FPREC;
}
p++;
goto retry;
}
GETNUM(prec, precision);
goto retry;
case '\n':
case '\0':
p--;
case '%':
if (flags != FNONE) {
rb_raise(rb_eArgError, "invalid format character - %%");
}
PUSH("%", 1);
break;
case 'c':
{
VALUE val = GETARG();
VALUE tmp;
unsigned int c;
int n;
tmp = rb_check_string_type(val);
if (!NIL_P(tmp)) {
if (rb_enc_strlen(RSTRING_PTR(tmp),RSTRING_END(tmp),enc) != 1) {
rb_raise(rb_eArgError, "%%c requires a character");
}
c = rb_enc_codepoint_len(RSTRING_PTR(tmp), RSTRING_END(tmp), &n, enc);
}
else {
c = NUM2INT(val);
n = rb_enc_codelen(c, enc);
}
if (n <= 0) {
rb_raise(rb_eArgError, "invalid character");
}
if (!(flags & FWIDTH)) {
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
}
else if ((flags & FMINUS)) {
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
FILL(' ', width-1);
}
else {
FILL(' ', width-1);
CHECK(n);
rb_enc_mbcput(c, &buf[blen], enc);
blen += n;
}
}
break;
case 's':
case 'p':
format_s:
{
VALUE arg = GETARG();
long len, slen;
if (*p == 'p') arg = rb_inspect(arg);
str = rb_obj_as_string(arg);
if (OBJ_TAINTED(str)) tainted = 1;
len = RSTRING_LEN(str);
rb_str_set_len(result, blen);
if (coderange != ENC_CODERANGE_BROKEN && scanned < blen) {
int cr = coderange;
scanned += rb_str_coderange_scan_restartable(buf+scanned, buf+blen, enc, &cr);
ENC_CODERANGE_SET(result,
(cr == ENC_CODERANGE_UNKNOWN ?
ENC_CODERANGE_BROKEN : (coderange = cr)));
}
enc = rb_enc_check(result, str);
if (flags&(FPREC|FWIDTH)) {
slen = rb_enc_strlen(RSTRING_PTR(str),RSTRING_END(str),enc);
if (slen < 0) {
rb_raise(rb_eArgError, "invalid mbstring sequence");
}
if ((flags&FPREC) && (prec < slen)) {
char *p = rb_enc_nth(RSTRING_PTR(str), RSTRING_END(str),
prec, enc);
slen = prec;
len = p - RSTRING_PTR(str);
}
/* need to adjust multi-byte string pos */
if ((flags&FWIDTH) && (width > slen)) {
width -= (int)slen;
if (!(flags&FMINUS)) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
CHECK(len);
memcpy(&buf[blen], RSTRING_PTR(str), len);
blen += len;
if (flags&FMINUS) {
CHECK(width);
while (width--) {
buf[blen++] = ' ';
}
}
rb_enc_associate(result, enc);
break;
}
}
PUSH(RSTRING_PTR(str), len);
rb_enc_associate(result, enc);
}
break;
case 'd':
case 'i':
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
case 'u':
{
volatile VALUE tmp1;
volatile VALUE val = GETARG();
char fbuf[32], nbuf[64], *s;
const char *prefix = 0;
int sign = 0, dots = 0;
char sc = 0;
long v = 0;
int base, bignum = 0;
int len;
switch (*p) {
case 'd':
case 'i':
case 'u':
sign = 1; break;
case 'o':
case 'x':
case 'X':
case 'b':
case 'B':
if (flags&(FPLUS|FSPACE)) sign = 1;
break;
}
if (flags & FSHARP) {
switch (*p) {
case 'o':
prefix = "0"; break;
case 'x':
prefix = "0x"; break;
case 'X':
prefix = "0X"; break;
case 'b':
prefix = "0b"; break;
case 'B':
prefix = "0B"; break;
}
}
bin_retry:
switch (TYPE(val)) {
case T_FLOAT:
if (FIXABLE(RFLOAT_VALUE(val))) {
val = LONG2FIX((long)RFLOAT_VALUE(val));
goto bin_retry;
}
val = rb_dbl2big(RFLOAT_VALUE(val));
if (FIXNUM_P(val)) goto bin_retry;
bignum = 1;
break;
case T_STRING:
val = rb_str_to_inum(val, 0, TRUE);
goto bin_retry;
case T_BIGNUM:
bignum = 1;
break;
case T_FIXNUM:
v = FIX2LONG(val);
break;
default:
val = rb_Integer(val);
goto bin_retry;
}
switch (*p) {
case 'o':
base = 8; break;
case 'x':
case 'X':
base = 16; break;
case 'b':
case 'B':
base = 2; break;
case 'u':
case 'd':
case 'i':
default:
base = 10; break;
}
if (!bignum) {
if (base == 2) {
val = rb_int2big(v);
goto bin_retry;
}
if (sign) {
char c = *p;
if (c == 'i') c = 'd'; /* %d and %i are identical */
if (v < 0) {
v = -v;
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
snprintf(nbuf, sizeof(nbuf), fbuf, v);
s = nbuf;
}
else {
s = nbuf;
if (v < 0) {
dots = 1;
}
snprintf(fbuf, sizeof(fbuf), "%%l%c", *p == 'X' ? 'x' : *p);
snprintf(++s, sizeof(nbuf) - 1, fbuf, v);
if (v < 0) {
char d = 0;
s = remove_sign_bits(s, base);
switch (base) {
case 16:
d = 'f'; break;
case 8:
d = '7'; break;
}
if (d && *s != d) {
*--s = d;
}
}
}
len = (int)strlen(s);
}
else {
if (sign) {
tmp = rb_big2str(val, base);
s = RSTRING_PTR(tmp);
if (s[0] == '-') {
s++;
sc = '-';
width--;
}
else if (flags & FPLUS) {
sc = '+';
width--;
}
else if (flags & FSPACE) {
sc = ' ';
width--;
}
}
else {
if (!RBIGNUM_SIGN(val)) {
val = rb_big_clone(val);
rb_big_2comp(val);
}
tmp1 = tmp = rb_big2str0(val, base, RBIGNUM_SIGN(val));
s = RSTRING_PTR(tmp);
if (*s == '-') {
dots = 1;
if (base == 10) {
rb_warning("negative number for %%u specifier");
}
s = remove_sign_bits(++s, base);
switch (base) {
case 16:
if (s[0] != 'f') *--s = 'f'; break;
case 8:
if (s[0] != '7') *--s = '7'; break;
case 2:
if (s[0] != '1') *--s = '1'; break;
}
}
}
len = rb_long2int(RSTRING_END(tmp) - s);
}
if (dots) {
prec -= 2;
width -= 2;
}
if (*p == 'X') {
char *pp = s;
int c;
while ((c = (int)(unsigned char)*pp) != 0) {
*pp = rb_enc_toupper(c, enc);
pp++;
}
}
if (prefix && !prefix[1]) { /* octal */
if (dots) {
prefix = 0;
}
else if (len == 1 && *s == '0') {
len = 0;
if (flags & FPREC) prec--;
}
else if ((flags & FPREC) && (prec > len)) {
prefix = 0;
}
}
else if (len == 1 && *s == '0') {
prefix = 0;
}
if (prefix) {
width -= (int)strlen(prefix);
}
if ((flags & (FZERO|FMINUS|FPREC)) == FZERO) {
prec = width;
width = 0;
}
else {
if (prec < len) {
if (!prefix && prec == 0 && len == 1 && *s == '0') len = 0;
prec = len;
}
width -= prec;
}
if (!(flags&FMINUS)) {
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
if (sc) PUSH(&sc, 1);
if (prefix) {
int plen = (int)strlen(prefix);
PUSH(prefix, plen);
}
CHECK(prec - len);
if (dots) PUSH("..", 2);
if (!bignum && v < 0) {
char c = sign_bits(base, p);
while (len < prec--) {
buf[blen++] = c;
}
}
else if ((flags & (FMINUS|FPREC)) != FMINUS) {
char c;
if (!sign && bignum && !RBIGNUM_SIGN(val))
c = sign_bits(base, p);
else
c = '0';
while (len < prec--) {
buf[blen++] = c;
}
}
PUSH(s, len);
CHECK(width);
while (width-- > 0) {
buf[blen++] = ' ';
}
}
break;
case 'f':
case 'g':
case 'G':
case 'e':
case 'E':
case 'a':
case 'A':
{
VALUE val = GETARG();
double fval;
int i, need = 6;
char fbuf[32];
fval = RFLOAT_VALUE(rb_Float(val));
if (isnan(fval) || isinf(fval)) {
const char *expr;
if (isnan(fval)) {
expr = "NaN";
}
else {
expr = "Inf";
}
need = (int)strlen(expr);
if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS))
need++;
if ((flags & FWIDTH) && need < width)
need = width;
CHECK(need + 1);
snprintf(&buf[blen], need + 1, "%*s", need, "");
if (flags & FMINUS) {
if (!isnan(fval) && fval < 0.0)
buf[blen++] = '-';
else if (flags & FPLUS)
buf[blen++] = '+';
else if (flags & FSPACE)
blen++;
memcpy(&buf[blen], expr, strlen(expr));
}
else {
if (!isnan(fval) && fval < 0.0)
buf[blen + need - strlen(expr) - 1] = '-';
else if (flags & FPLUS)
buf[blen + need - strlen(expr) - 1] = '+';
else if ((flags & FSPACE) && need > width)
blen++;
memcpy(&buf[blen + need - strlen(expr)], expr,
strlen(expr));
}
blen += strlen(&buf[blen]);
break;
}
fmt_setup(fbuf, sizeof(fbuf), *p, flags, width, prec);
need = 0;
if (*p != 'e' && *p != 'E') {
i = INT_MIN;
frexp(fval, &i);
if (i > 0)
need = BIT_DIGITS(i);
}
need += (flags&FPREC) ? prec : 6;
if ((flags&FWIDTH) && need < width)
need = width;
need += 20;
CHECK(need);
snprintf(&buf[blen], need, fbuf, fval);
blen += strlen(&buf[blen]);
}
break;
}
flags = FNONE;
}
sprint_exit:
/* XXX - We cannot validate the number of arguments if (digit)$ style used.
*/
if (posarg >= 0 && nextarg < argc) {
const char *mesg = "too many arguments for format string";
if (RTEST(ruby_debug)) rb_raise(rb_eArgError, "%s", mesg);
if (RTEST(ruby_verbose)) rb_warn("%s", mesg);
}
rb_str_resize(result, blen);
if (tainted) OBJ_TAINT(result);
return result;
}
/*
* call-seq:
* QueryParser.new(options = {}) -> QueryParser
*
* Create a new QueryParser. The QueryParser is used to convert string
* queries into Query objects. The options are;
*
* === Options
*
* :default_field:: Default: "*" (all fields). The default field to
* search when no field is specified in the search
* string. It can also be an array of fields.
* :analyzer:: Default: StandardAnalyzer. Analyzer used by the
* query parser to parse query terms
* :wild_card_downcase:: Default: true. Specifies whether wild-card queries
* and range queries should be downcased or not since
* they are not passed through the parser
* :fields:: Default: []. Lets the query parser know what
* fields are available for searching, particularly
* when the "*" is specified as the search field
* :tokenized_fields:: Default: :fields. Lets the query parser know which
* fields are tokenized so it knows which fields to
* run the analyzer over.
* :validate_fields:: Default: false. Set to true if you want an
* exception to be raised if there is an attempt to
* search a non-existent field
* :or_default:: Default: true. Use "OR" as the default boolean
* operator
* :default_slop:: Default: 0. Default slop to use in PhraseQuery
* :handle_parse_errors:: Default: true. QueryParser will quietly handle all
* parsing errors internally. If you'd like to handle
* them yourself, set this parameter to false.
* :clean_string:: Default: true. QueryParser will do a quick
* once-over the query string make sure that quotes
* and brackets match up and special characters are
* escaped
* :max_clauses:: Default: 512. the maximum number of clauses
* allowed in boolean queries and the maximum number
* of terms allowed in multi, prefix, wild-card or
* fuzzy queries when those queries are generated by
* rewriting other queries
*/
static VALUE
frt_qp_init(int argc, VALUE *argv, VALUE self)
{
VALUE roptions;
VALUE rval;
Analyzer *analyzer = NULL;
bool has_options = false;
HashSet *all_fields = NULL;
HashSet *tkz_fields = NULL;
HashSet *def_fields = NULL;
QParser *qp;
if (rb_scan_args(argc, argv, "01", &roptions) > 0) {
if (TYPE(roptions) == T_HASH) {
has_options = true;
if (Qnil != (rval = rb_hash_aref(roptions, sym_default_field))) {
def_fields = frt_get_fields(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_analyzer))) {
analyzer = frt_get_cwrapped_analyzer(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_all_fields))) {
all_fields = frt_get_fields(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_fields))) {
all_fields = frt_get_fields(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_tkz_fields))) {
tkz_fields = frt_get_fields(rval);
}
} else {
def_fields = frt_get_fields(roptions);
}
}
if (all_fields == NULL) {
all_fields = hs_new_str(&free);
}
if (!analyzer) {
analyzer = mb_standard_analyzer_new(true);
}
qp = qp_new(all_fields, def_fields, tkz_fields, analyzer);
qp->allow_any_fields = true;
qp->clean_str = true;
qp->handle_parse_errors = true;
/* handle options */
if (argc > 0) {
if (Qnil != (rval = rb_hash_aref(roptions, sym_handle_parse_errors))) {
qp->handle_parse_errors = RTEST(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_validate_fields))) {
qp->allow_any_fields = !RTEST(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_wild_card_downcase))) {
qp->wild_lower = RTEST(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_or_default))) {
qp->or_default = RTEST(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_default_slop))) {
qp->def_slop = FIX2INT(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_clean_string))) {
qp->clean_str = RTEST(rval);
}
if (Qnil != (rval = rb_hash_aref(roptions, sym_max_clauses))) {
qp->max_clauses = FIX2INT(rval);
}
}
Frt_Wrap_Struct(self, frt_qp_mark, frt_qp_free, qp);
object_add(qp, self);
return self;
}
/*
ポリゴン描画
*/
static VALUE drawing_draw_polygon(int argc, VALUE *argv, VALUE self)
{
VALUE vdst;
VALUE pairs;
VALUE mcolor;
VALUE fill;
VALUE aa;
Uint8 alpha;
Uint32 color;
int i, vertexes;
rb_scan_args(argc, argv, "32", &vdst, &pairs, &mcolor, &fill, &aa);
// bitmapメソッドを持っていれば、メソッドの値をvdstとする
VALUE methods = rb_funcall(vdst, rb_intern("methods"), 0);
if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qfalse &&
rb_ary_includes(methods, rb_str_intern(rb_str_new2("bitmap"))) == Qfalse
)
rb_raise(eMiyakoError, "this method needs sprite have to_method or bitmap method!");
if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qtrue)
vdst = rb_funcall(vdst, rb_intern("to_unit"), 0);
vdst = rb_funcall(vdst, rb_intern("bitmap"), 0);
vertexes = RARRAY_LEN(pairs);
// 頂点数チェック
if(vertexes > 65536)
rb_raise(eMiyakoError, "too many pairs. pairs is less than 65536.");
// 範囲チェック
for(i=0; i<vertexes; i++)
{
VALUE vertex = *(RARRAY_PTR(pairs)+i);
Sint16 x, y;
get_position(vertex, &x, &y);
}
SDL_Surface *dst = GetSurface(vdst)->surface;
color = value_2_color(rb_funcall(cColor, rb_intern("to_rgb"), 1, mcolor), dst->format, &alpha);
if(RTEST(fill) && RTEST(aa) && alpha < 255)
rb_raise(eMiyakoError, "can't draw filled antialiased alpha polygon");
Sint16 *px = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
Sint16 *py = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
for(i=0; i<vertexes; i++)
{
VALUE vertex = *(RARRAY_PTR(pairs)+i);
get_position(vertex, px+i, py+i);
}
if(!RTEST(fill) && !RTEST(aa) && alpha == 255)
{
for(i=0; i<vertexes-1; i++)
sge_Line(dst, px[i], py[i], px[i+1], py[i+1], color);
sge_Line(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
}
else if(!RTEST(fill) && !RTEST(aa) && alpha < 255)
{
for(i=0; i<vertexes-1; i++)
sge_LineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
sge_LineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
}
else if(!RTEST(fill) && RTEST(aa) && alpha == 255)
{
for(i=0; i<vertexes-1; i++)
sge_AALine(dst, px[i], py[i], px[i+1], py[i+1], color);
sge_AALine(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
}
else if(!RTEST(fill) && RTEST(aa) && alpha < 255)
{
for(i=0; i<vertexes-1; i++)
sge_AALineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
sge_AALineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
}
else if(RTEST(fill) && !RTEST(aa) && alpha == 255)
sge_FilledPolygon(dst, (Uint16)vertexes, px, py, color);
else if(RTEST(fill) && !RTEST(aa) && alpha < 255)
sge_FilledPolygonAlpha(dst, (Uint16)vertexes, px, py, color, alpha);
else if(RTEST(fill) && RTEST(aa) && alpha == 255)
sge_AAFilledPolygon(dst, (Uint16)vertexes, px, py, color);
free(py);
free(px);
return Qnil;
}
static inline void event_callback (struct em_event* e)
{
const unsigned long signature = e->signature;
int event = e->event;
const char *data_str = e->data_str;
const unsigned long data_num = e->data_num;
switch (event) {
case EM_CONNECTION_READ:
{
VALUE conn = rb_hash_aref (EmConnsHash, ULONG2NUM (signature));
if (conn == Qnil)
rb_raise (EM_eConnectionNotBound, "received %lu bytes of data for unknown signature: %lu", data_num, signature);
rb_funcall (conn, Intern_receive_data, 1, rb_str_new (data_str, data_num));
return;
}
case EM_CONNECTION_ACCEPTED:
{
rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), ULONG2NUM(data_num));
return;
}
case EM_CONNECTION_UNBOUND:
{
rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), ULONG2NUM(data_num));
return;
}
case EM_CONNECTION_COMPLETED:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_connection_completed, 0);
return;
}
case EM_CONNECTION_NOTIFY_READABLE:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_notify_readable, 0);
return;
}
case EM_CONNECTION_NOTIFY_WRITABLE:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_notify_writable, 0);
return;
}
case EM_LOOPBREAK_SIGNAL:
{
rb_funcall (EmModule, Intern_run_deferred_callbacks, 0);
return;
}
case EM_TIMER_FIRED:
{
VALUE timer = rb_funcall (EmTimersHash, Intern_delete, 1, ULONG2NUM (data_num));
if (timer == Qnil) {
rb_raise (EM_eUnknownTimerFired, "no such timer: %lu", data_num);
} else if (timer == Qfalse) {
/* Timer Canceled */
} else {
rb_funcall (timer, Intern_call, 0);
}
return;
}
#ifdef WITH_SSL
case EM_SSL_HANDSHAKE_COMPLETED:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_ssl_handshake_completed, 0);
return;
}
case EM_SSL_VERIFY:
{
VALUE conn = ensure_conn(signature);
VALUE should_accept = rb_funcall (conn, Intern_ssl_verify_peer, 1, rb_str_new(data_str, data_num));
if (RTEST(should_accept))
evma_accept_ssl_peer (signature);
return;
}
#endif
case EM_PROXY_TARGET_UNBOUND:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_proxy_target_unbound, 0);
return;
}
case EM_PROXY_COMPLETED:
{
VALUE conn = ensure_conn(signature);
rb_funcall (conn, Intern_proxy_completed, 0);
return;
}
}
}
INT
Test_NtUserCountClipboardFormats(PTESTINFO pti)
{
RTEST(NtUserCountClipboardFormats() < 1000);
return APISTATUS_NORMAL;
}
static VALUE
Game_initialize(int argc, VALUE* argv, VALUE self)
{
if (!NIL_P(Game_s_current(rb_cGame))) {
rb_raise(strb_GetStarRubyErrorClass(), "already run");
}
volatile VALUE rbWidth, rbHeight, rbOptions;
rb_scan_args(argc, argv, "21", &rbWidth, &rbHeight, &rbOptions);
if (NIL_P(rbOptions)) {
rbOptions = rb_hash_new();
} else {
Check_Type(rbOptions, T_HASH);
}
Game* game;
Data_Get_Struct(self, Game, game);
if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER)) {
rb_raise_sdl_error();
}
const int width = NUM2INT(rbWidth);
const int height = NUM2INT(rbHeight);
volatile VALUE rbFps = rb_hash_aref(rbOptions, symbol_fps);
Game_fps_eq(self, !NIL_P(rbFps) ? rbFps : INT2FIX(30));
volatile VALUE rbTitle = rb_hash_aref(rbOptions, symbol_title);
Game_title_eq(self, !NIL_P(rbTitle) ? rbTitle : rb_str_new2(""));
bool cursor = false;
volatile VALUE val;
Check_Type(rbOptions, T_HASH);
if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_cursor))) {
cursor = RTEST(val);
}
if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_fullscreen))) {
game->isFullscreen = RTEST(val);
}
if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_window_scale))) {
game->windowScale = NUM2INT(val);
if (game->windowScale < 1) {
rb_raise(rb_eArgError, "invalid window scale: %d",
game->windowScale);
}
}
if (!NIL_P(val = rb_hash_aref(rbOptions, symbol_vsync))) {
game->isVsync = RTEST(val);
}
SDL_ShowCursor(cursor ? SDL_ENABLE : SDL_DISABLE);
volatile VALUE rbScreen =
rb_class_new_instance(2, (VALUE[]){INT2NUM(width), INT2NUM(height)},
strb_GetTextureClass());
game->screen = rbScreen;
InitializeScreen(game);
rb_iv_set(rb_cGame, "current", self);
return Qnil;
}
static int
is_integer_p(VALUE v)
{
VALUE is_int = rb_check_funcall(v, id_integer_p, 0, 0);
return RTEST(is_int) && is_int != Qundef;
}
static VALUE
range_step(int argc, VALUE *argv, VALUE range)
{
VALUE b, e, step, tmp;
RETURN_SIZED_ENUMERATOR(range, argc, argv, range_step_size);
b = RANGE_BEG(range);
e = RANGE_END(range);
if (argc == 0) {
step = INT2FIX(1);
}
else {
rb_scan_args(argc, argv, "01", &step);
if (!rb_obj_is_kind_of(step, rb_cNumeric)) {
step = rb_to_int(step);
}
if (rb_funcall(step, '<', 1, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be negative");
}
else if (!rb_funcall(step, '>', 1, INT2FIX(0))) {
rb_raise(rb_eArgError, "step can't be 0");
}
}
if (FIXNUM_P(b) && FIXNUM_P(e) && FIXNUM_P(step)) { /* fixnums are special */
long end = FIX2LONG(e);
long i, unit = FIX2LONG(step);
if (!EXCL(range))
end += 1;
i = FIX2LONG(b);
while (i < end) {
rb_yield(LONG2NUM(i));
if (i + unit < i) break;
i += unit;
}
}
else if (SYMBOL_P(b) && SYMBOL_P(e)) { /* symbols are special */
VALUE args[2], iter[2];
args[0] = rb_sym_to_s(e);
args[1] = EXCL(range) ? Qtrue : Qfalse;
iter[0] = INT2FIX(1);
iter[1] = step;
rb_block_call(rb_sym_to_s(b), rb_intern("upto"), 2, args, sym_step_i, (VALUE)iter);
}
else if (ruby_float_step(b, e, step, EXCL(range))) {
/* done */
}
else if (rb_obj_is_kind_of(b, rb_cNumeric) ||
!NIL_P(rb_check_to_integer(b, "to_int")) ||
!NIL_P(rb_check_to_integer(e, "to_int"))) {
ID op = EXCL(range) ? '<' : idLE;
VALUE v = b;
int i = 0;
while (RTEST(rb_funcall(v, op, 1, e))) {
rb_yield(v);
i++;
v = rb_funcall(b, '+', 1, rb_funcall(INT2NUM(i), '*', 1, step));
}
}
else {
tmp = rb_check_string_type(b);
if (!NIL_P(tmp)) {
VALUE args[2], iter[2];
b = tmp;
args[0] = e;
args[1] = EXCL(range) ? Qtrue : Qfalse;
iter[0] = INT2FIX(1);
iter[1] = step;
rb_block_call(b, rb_intern("upto"), 2, args, step_i, (VALUE)iter);
}
else {
VALUE args[2];
if (!discrete_object_p(b)) {
rb_raise(rb_eTypeError, "can't iterate from %s",
rb_obj_classname(b));
}
args[0] = INT2FIX(1);
args[1] = step;
range_each_func(range, step_i, (VALUE)args);
}
}
return range;
}
static VALUE dm_init_all(VALUE mod)
{
return C2RbBool(RTEST(dm_init_video_engine(mod)) && RTEST(dm_init_audio_engine(mod)));
}
INT
Test_NtGdiGetRandomRgn(PTESTINFO pti)
{
HWND hWnd;
HDC hDC;
HRGN hrgn, hrgn2;
/* Create a window */
hWnd = CreateWindowW(L"BUTTON", L"TestWindow", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, 100, 100,
NULL, NULL, g_hInstance, 0);
// UpdateWindow(hWnd);
hDC = GetDC(hWnd);
ASSERT(hDC != NULL);
hrgn = CreateRectRgn(0,0,0,0);
hrgn2 = CreateRectRgn(3,3,10,10);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn(0, hrgn, 0) == -1);
RTEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn((HDC)2345, hrgn, 1) == -1);
RTEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn((HDC)2345, hrgn, 10) == -1);
RTEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn((HDC)2345, (HRGN)10, 10) == -1);
RTEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn((HDC)2345, 0, 1) == -1);
RTEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn(hDC, 0, 0) == 0);
RTEST(NtGdiGetRandomRgn(hDC, 0, 1) == 0);
RTEST(NtGdiGetRandomRgn(hDC, (HRGN)-5, 0) == 0);
RTEST(NtGdiGetRandomRgn(hDC, (HRGN)-5, 1) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 0) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 1) == 0);
TEST(NtGdiGetRandomRgn(hDC, hrgn, 2) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 3) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 4) == 1);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 5) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 10) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, -10) == 0);
RTEST(GetLastError() == ERROR_SUCCESS);
SelectClipRgn(hDC, hrgn2);
RTEST(NtGdiGetRandomRgn(hDC, 0, 1) == -1);
RTEST(GetLastError() == ERROR_SUCCESS);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 1) == 1);
RTEST(CombineRgn(hrgn, hrgn, hrgn, RGN_OR) == SIMPLEREGION);
RTEST(CombineRgn(hrgn, hrgn, hrgn2, RGN_XOR) == NULLREGION);
SetRectRgn(hrgn2,0,0,0,0);
SelectClipRgn(hDC, hrgn2);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 1) == 1);
RTEST(CombineRgn(hrgn2, hrgn, hrgn2, RGN_XOR) == NULLREGION);
RTEST(CombineRgn(hrgn2, hrgn, hrgn, RGN_OR) == NULLREGION);
SelectClipRgn(hDC, NULL);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 1) == 0);
RTEST(NtGdiGetRandomRgn(hDC, hrgn, 4) == 1);
RTEST(GetLastError() == ERROR_SUCCESS);
ReleaseDC(hWnd, hDC);
DestroyWindow(hWnd);
return APISTATUS_NORMAL;
}
/*
Method: ImageList#quantize(<number_colors<, colorspace<, dither<, tree_depth<, measure_error>>>>>)
defaults: 256, Magick::RGBColorspace, true, 0, false
Purpose: call QuantizeImages
Returns: a new ImageList with quantized images. 'scene' is set to the same
value as self.scene
*/
VALUE
ImageList_quantize(int argc, VALUE *argv, VALUE self)
{
Image *images, *new_images;
Image *new_image;
QuantizeInfo quantize_info;
ExceptionInfo exception;
volatile VALUE new_imagelist, scene;
GetQuantizeInfo(&quantize_info);
switch (argc)
{
case 5:
quantize_info.measure_error = (MagickBooleanType) RTEST(argv[4]);
case 4:
quantize_info.tree_depth = (unsigned long)NUM2INT(argv[3]);
case 3:
quantize_info.dither = (MagickBooleanType) RTEST(argv[2]);
case 2:
VALUE_TO_ENUM(argv[1], quantize_info.colorspace, ColorspaceType);
case 1:
quantize_info.number_colors = NUM2ULONG(argv[0]);
case 0:
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0 to 5)", argc);
break;
}
if (imagelist_length(self) == 0L)
{
rb_raise(rb_eArgError, "no images in this image list");
}
// Convert image array to image sequence, clone image sequence.
GetExceptionInfo(&exception);
images = images_from_imagelist(self);
new_images = CloneImageList(images, &exception);
rm_split(images);
rm_check_exception(&exception, new_images, DestroyOnError);
(void) DestroyExceptionInfo(&exception);
rm_ensure_result(new_images);
(void) QuantizeImages(&quantize_info, new_images);
rm_check_exception(&exception, new_images, DestroyOnError);
// Create new ImageList object, convert mapped image sequence to images,
// append to images array.
new_imagelist = ImageList_new();
while ((new_image = ShiftImageList(&new_images)))
{
imagelist_push(new_imagelist, rm_image_new(new_image));
}
// Set @scene in new ImageList object to same value as in self.
scene = rb_iv_get(self, "@scene");
(void) rb_iv_set(new_imagelist, "@scene", scene);
return new_imagelist;
}
static int
rf_getattr(const char *path, struct stat *stbuf) {
/* If it doesn't exist, it doesn't exist. Simple as that. */
VALUE retval;
char *value;
size_t len;
debug("rf_getattr(%s)\n", path );
/* Zero out the stat buffer */
memset(stbuf, 0, sizeof(struct stat));
/* "/" is automatically a dir. */
if (strcmp(path,"/") == 0) {
stbuf->st_mode = S_IFDIR | 0555;
stbuf->st_size = 4096;
stbuf->st_nlink = 1;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = rf_intval(path,id_mtime,init_time);
stbuf->st_atime = rf_intval(path,id_atime,init_time);
stbuf->st_ctime = rf_intval(path,id_ctime,init_time);
return 0;
}
/* If we created it with mknod, then it "exists" */
debug(" Checking for created file ...");
if (created_file && (strcmp(created_file,path) == 0)) {
/* It's created */
debug(" created.\n");
stbuf->st_mode = S_IFREG | 0666;
stbuf->st_nlink = 1 + file_openedP(path);
stbuf->st_size = 0;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = created_time;
stbuf->st_atime = created_time;
stbuf->st_ctime = created_time;
return 0;
}
debug(" no.\n");
/* debug(" Checking file_opened ...");
if (file_openedP(path)) {
debug(" opened.\n");
stbuf->st_mode = S_IFREG | 0666;
stbuf->st_nlink = 1 + file_openedP(path);
stbuf->st_size = 0;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = init_time;
stbuf->st_atime = init_time;
stbuf->st_ctime = init_time;
return 0;
}
debug(" no.\n");
*/
debug(" Checking if editor file...");
switch (editor_fileP(path)) {
case 2:
debug(" Yes, and does exist.\n");
stbuf->st_mode = S_IFREG | 0444;
stbuf->st_nlink = 1;
stbuf->st_size = 0;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = init_time;
stbuf->st_atime = init_time;
stbuf->st_ctime = init_time;
return 0;
case 1:
debug(" Yes, but doesn't exist.\n");
return -ENOENT;
default:
debug("No.\n");
}
/* If FuseRoot says the path is a directory, we set it 0555.
* If FuseRoot says the path is a file, it's 0444.
*
* Otherwise, -ENOENT */
debug("Checking filetype ...");
if (RTEST(rf_call(path, is_directory,Qnil))) {
debug(" directory.\n");
stbuf->st_mode = S_IFDIR | 0555;
stbuf->st_nlink = 1;
stbuf->st_size = 4096;
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = rf_intval(path,id_mtime,init_time);
stbuf->st_atime = rf_intval(path,id_atime,init_time);
stbuf->st_ctime = rf_intval(path,id_ctime,init_time);
return 0;
} else if (RTEST(rf_call(path, is_file,Qnil))) {
debug(" file.\n");
stbuf->st_mode = S_IFREG | 0444;
if (RTEST(rf_call(path,can_write,Qnil))) {
stbuf->st_mode |= 0666;
}
if (RTEST(rf_call(path,is_executable,Qnil))) {
stbuf->st_mode |= 0111;
}
stbuf->st_nlink = 1 + file_openedP(path);
stbuf->st_size = rf_intval(path,id_size,0);
stbuf->st_uid = getuid();
stbuf->st_gid = getgid();
stbuf->st_mtime = rf_intval(path,id_mtime,init_time);
stbuf->st_atime = rf_intval(path,id_atime,init_time);
stbuf->st_ctime = rf_intval(path,id_ctime,init_time);
return 0;
}
debug(" nonexistant.\n");
return -ENOENT;
}
static VALUE string_spec_rb_cstr_to_inum(VALUE self, VALUE str, VALUE inum, VALUE badcheck) {
int num = FIX2INT(inum);
return rb_cstr_to_inum(RSTRING_PTR(str), num, RTEST(badcheck));
}
/* rf_mknod
*
* Used when: This is called when a file is created.
*
* Note that this is actually almost useless to RubyFuse, so all we do is check
* if a path is writable? and if so, return true. The open() will do the
* actual work of creating the file.
*/
static int
rf_mknod(const char *path, mode_t umode, dev_t rdev) {
opened_file *ptr;
debug("rf_mknod(%s)\n", path);
/* Make sure it's not already open. */
debug(" Checking if it's opened ...");
if (file_openedP(path)) {
debug(" yes.\n");
return -EACCES;
}
debug(" no.\n");
/* We ONLY permit regular files. No blocks, characters, fifos, etc. */
debug(" Checking if an IFREG is requested ...");
if (!S_ISREG(umode)) {
debug(" no.\n");
return -EACCES;
}
debug(" yes.\n");
debug(" Checking if it's an editor file ...");
switch (editor_fileP(path)) {
case 2:
debug(" yes, and it exists.\n");
return -EEXIST;
case 1:
debug(" yes, and it doesn't exist.\n");
editor_file *eptr;
eptr = ALLOC(editor_file);
eptr->writesize = FILE_GROW_SIZE;
eptr->value = ALLOC_N(char,eptr->writesize);
eptr->path = strdup(path);
eptr->size = 0;
eptr->raw = 0;
eptr->zero_offset = 0;
eptr->modified = 0;
*(eptr->value) = '\0';
eptr->next = editor_head;
editor_head = eptr;
return 0;
default:
debug("no.\n");
}
debug(" Checking if it's a file ..." );
if (RTEST(rf_call(path, is_file,Qnil))) {
debug(" yes.\n");
return -EEXIST;
}
debug(" no.\n");
/* Is this writable to */
debug(" Checking if it's writable to ...");
if (!RTEST(rf_call(path,can_write,Qnil))) {
debug(" no.\n");
debug(" Checking if it looks like an editor tempfile...");
if (editor_head && (which_editor == EDITOR_VIM)) {
char *ptr = strrchr(path,'/');
while (ptr && isdigit(*ptr)) ptr++;
if (ptr && (*ptr == '\0')) {
debug(" yes.\n");
editor_file *eptr;
eptr = ALLOC(editor_file);
eptr->writesize = FILE_GROW_SIZE;
eptr->value = ALLOC_N(char,eptr->writesize);
eptr->path = strdup(path);
eptr->raw = 0;
eptr->size = 0;
eptr->zero_offset = 0;
eptr->modified = 0;
*(eptr->value) = '\0';
eptr->next = editor_head;
editor_head = eptr;
return 0;
}
static VALUE rec_pi(VALUE obj, VALUE arg) {
if(RTEST(rb_inspecting_p(obj))) return arg;
return Qfalse;
}
inline static VALUE mArray_json_transfrom(VALUE self, VALUE Vstate, VALUE Vdepth) {
long i, len = RARRAY_LEN(self);
VALUE shift, result;
long depth = NIL_P(Vdepth) ? 0 : FIX2LONG(Vdepth);
VALUE delim = rb_str_new2(",");
GET_STATE(Vstate);
check_max_nesting(state, depth);
if (state->check_circular) {
VALUE self_id = rb_obj_id(self);
rb_hash_aset(state->seen, self_id, Qtrue);
result = rb_str_buf_new(len);
if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl);
shift = rb_str_times(state->indent, LONG2FIX(depth + 1));
rb_str_buf_cat2(result, "[");
OBJ_INFECT(result, self);
rb_str_buf_append(result, state->array_nl);
for (i = 0; i < len; i++) {
VALUE element = RARRAY_AT(self, i);
if (RTEST(rb_hash_aref(state->seen, rb_obj_id(element)))) {
rb_raise(eCircularDatastructure,
"circular data structures not supported!");
}
OBJ_INFECT(result, element);
if (i > 0) rb_str_buf_append(result, delim);
rb_str_buf_append(result, shift);
element = rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1));
Check_Type(element, T_STRING);
rb_str_buf_append(result, element);
}
if (RSTRING_LEN(state->array_nl)) {
rb_str_buf_append(result, state->array_nl);
rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth)));
}
rb_str_buf_cat2(result, "]");
rb_hash_delete(state->seen, self_id);
} else {
result = rb_str_buf_new(len);
OBJ_INFECT(result, self);
if (RSTRING_LEN(state->array_nl)) rb_str_append(delim, state->array_nl);
shift = rb_str_times(state->indent, LONG2FIX(depth + 1));
rb_str_buf_cat2(result, "[");
rb_str_buf_append(result, state->array_nl);
for (i = 0; i < len; i++) {
VALUE element = RARRAY_AT(self, i);
OBJ_INFECT(result, element);
if (i > 0) rb_str_buf_append(result, delim);
rb_str_buf_append(result, shift);
element = rb_funcall(element, i_to_json, 2, Vstate, LONG2FIX(depth + 1));
Check_Type(element, T_STRING);
rb_str_buf_append(result, element);
}
rb_str_buf_append(result, state->array_nl);
if (RSTRING_LEN(state->array_nl)) {
rb_str_buf_append(result, rb_str_times(state->indent, LONG2FIX(depth)));
}
rb_str_buf_cat2(result, "]");
}
return result;
}
static VALUE
cr_has_current_point(VALUE self)
{
return RTEST (cairo_has_current_point (_SELF));
}
/*
* call-seq: configure(opts)
*
* Configure this State instance with the Hash _opts_, and return
* itself.
*/
static inline VALUE cState_configure(VALUE self, VALUE opts)
{
VALUE tmp;
GET_STATE(self);
tmp = rb_convert_type(opts, T_HASH, "Hash", "to_hash");
if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
if (NIL_P(tmp)) {
rb_raise(rb_eArgError, "opts has to be hash like or convertable into a hash");
}
opts = tmp;
tmp = rb_hash_aref(opts, ID2SYM(i_indent));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->indent = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->space = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->space_before = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->array_nl = tmp;
}
tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
if (RTEST(tmp)) {
Check_Type(tmp, T_STRING);
state->object_nl = tmp;
}
tmp = ID2SYM(i_check_circular);
#if WITH_OBJC
if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) {
#else
if (st_lookup(RHASH_TBL(opts), tmp, 0)) {
#endif
tmp = rb_hash_aref(opts, ID2SYM(i_check_circular));
state->check_circular = RTEST(tmp);
} else {
state->check_circular = 1;
}
tmp = ID2SYM(i_max_nesting);
state->max_nesting = 19;
#if WITH_OBJC
if (CFDictionaryGetValueIfPresent((CFDictionaryRef)opts, (const void *)RB2OC(tmp), 0)) {
#else
if (st_lookup(RHASH_TBL(opts), tmp, 0)) {
#endif
VALUE max_nesting = rb_hash_aref(opts, tmp);
if (RTEST(max_nesting)) {
Check_Type(max_nesting, T_FIXNUM);
state->max_nesting = FIX2LONG(max_nesting);
} else {
state->max_nesting = 0;
}
}
tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
state->allow_nan = RTEST(tmp);
return self;
}
/*
* call-seq: to_h
*
* Returns the configuration instance variables as a hash, that can be
* passed to the configure method.
*/
static VALUE cState_to_h(VALUE self)
{
VALUE result = rb_hash_new();
GET_STATE(self);
rb_hash_aset(result, ID2SYM(i_indent), state->indent);
rb_hash_aset(result, ID2SYM(i_space), state->space);
rb_hash_aset(result, ID2SYM(i_space_before), state->space_before);
rb_hash_aset(result, ID2SYM(i_object_nl), state->object_nl);
rb_hash_aset(result, ID2SYM(i_array_nl), state->array_nl);
rb_hash_aset(result, ID2SYM(i_check_circular), state->check_circular ? Qtrue : Qfalse);
rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
return result;
}
/*
* call-seq: new(opts = {})
*
* Instantiates a new State object, configured by _opts_.
*
* _opts_ can have the following keys:
*
* * *indent*: a string used to indent levels (default: ''),
* * *space*: a string that is put after, a : or , delimiter (default: ''),
* * *space_before*: a string that is put before a : pair delimiter (default: ''),
* * *object_nl*: a string that is put at the end of a JSON object (default: ''),
* * *array_nl*: a string that is put at the end of a JSON array (default: ''),
* * *check_circular*: true if checking for circular data structures
* should be done, false (the default) otherwise.
* * *allow_nan*: true if NaN, Infinity, and -Infinity should be
* generated, otherwise an exception is thrown, if these values are
* encountered. This options defaults to false.
*/
static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE opts;
GET_STATE(self);
rb_scan_args(argc, argv, "01", &opts);
state->indent = rb_str_new2("");
state->space = rb_str_new2("");
state->space_before = rb_str_new2("");
state->array_nl = rb_str_new2("");
state->object_nl = rb_str_new2("");
if (NIL_P(opts)) {
state->check_circular = 1;
state->allow_nan = 0;
state->max_nesting = 19;
} else {
cState_configure(self, opts);
}
state->seen = rb_hash_new();
state->memo = Qnil;
state->depth = INT2FIX(0);
return self;
}
String* String::transform(STATE, Tuple* tbl, Object* respect_kcode) {
uint8_t invalid[5];
if(tbl->num_fields() < 256) {
return force_as<String>(Primitives::failure());
}
Object** tbl_ptr = tbl->field;
kcode::table* kcode_tbl = 0;
if(RTEST(respect_kcode)) {
kcode_tbl = state->shared.kcode_table();
} else {
kcode_tbl = kcode::null_table();
}
// Pointers to iterate input bytes.
uint8_t* in_p = byte_address();
native_int str_size = size();
native_int data_size = as<CharArray>(data_)->size();
if(unlikely(str_size > data_size)) {
str_size = data_size;
}
uint8_t* in_end = in_p + str_size;
// Optimistic estimate that output size will be 1.25 x input.
native_int out_chunk = str_size * 5 / 4;
native_int out_size = out_chunk;
uint8_t* output = (uint8_t*)malloc(out_size);
uint8_t* out_p = output;
uint8_t* out_end = out_p + out_size;
while(in_p < in_end) {
native_int len = 0;
uint8_t byte = *in_p;
uint8_t* cur_p = 0;
if(kcode::mbchar_p(kcode_tbl, byte)) {
len = kcode::mbclen(kcode_tbl, byte);
native_int rem = in_end - in_p;
// if the character length is greater than the remaining
// bytes, we have a malformed character. Handled below.
if(rem >= len) {
cur_p = in_p;
in_p += len;
}
} else if(String* str = try_as<String>(tbl_ptr[byte])) {
cur_p = str->byte_address();
len = str->size();
in_p++;
} else {
Tuple* tbl = as<Tuple>(tbl_ptr[byte]);
for(native_int i = 0; i < tbl->num_fields(); i += 2) {
String* key = as<String>(tbl->at(i));
native_int rem = in_end - in_p;
native_int klen = key->size();
if(rem < klen) continue;
if(memcmp(in_p, key->byte_address(), klen) == 0) {
String* str = as<String>(tbl->at(i+1));
cur_p = str->byte_address();
len = str->size();
in_p += klen;
break;
}
}
}
// We could not map this byte, so we add it to the output
// in stringified octal notation (ie \nnn).
if(!cur_p) {
snprintf((char*)invalid, 5, "\\%03o", *((char*)in_p) & 0377);
in_p++;
cur_p = invalid;
len = 4;
}
if(out_p + len > out_end) {
native_int pos = out_p - output;
out_size += (len > out_chunk ? len : out_chunk);
output = (uint8_t*)realloc(output, out_size);
out_p = output + pos;
out_end = output + out_size;
}
switch(len) {
case 1:
*out_p++ = *cur_p;
break;
case 2:
*out_p++ = *cur_p++;
*out_p++ = *cur_p;
break;
case 3:
*out_p++ = *cur_p++;
*out_p++ = *cur_p++;
*out_p++ = *cur_p;
break;
default:
memcpy(out_p, cur_p, len);
out_p += len;
break;
}
}
String* result = String::create(state,
reinterpret_cast<const char*>(output),
out_p - output);
free(output);
if(tainted_p(state)) result->taint(state);
return result;
}
/*
* call-seq:
* ctx.setup => Qtrue # first time
* ctx.setup => nil # thereafter
*
* This method is called automatically when a new SSLSocket is created.
* Normally you do not need to call this method (unless you are writing an extension in C).
*/
static VALUE
ossl_sslctx_setup(VALUE self)
{
SSL_CTX *ctx;
X509 *cert = NULL, *client_ca = NULL;
X509_STORE *store;
EVP_PKEY *key = NULL;
char *ca_path = NULL, *ca_file = NULL;
int i, verify_mode;
VALUE val;
if(OBJ_FROZEN(self)) return Qnil;
Data_Get_Struct(self, SSL_CTX, ctx);
#if !defined(OPENSSL_NO_DH)
if (RTEST(ossl_sslctx_get_tmp_dh_cb(self))){
SSL_CTX_set_tmp_dh_callback(ctx, ossl_tmp_dh_callback);
}
else{
SSL_CTX_set_tmp_dh_callback(ctx, ossl_default_tmp_dh_callback);
}
#endif
SSL_CTX_set_ex_data(ctx, ossl_ssl_ex_ptr_idx, (void*)self);
val = ossl_sslctx_get_cert_store(self);
if(!NIL_P(val)){
/*
* WORKAROUND:
* X509_STORE can count references, but
* X509_STORE_free() doesn't care it.
* So we won't increment it but mark it by ex_data.
*/
store = GetX509StorePtr(val); /* NO NEED TO DUP */
SSL_CTX_set_cert_store(ctx, store);
SSL_CTX_set_ex_data(ctx, ossl_ssl_ex_store_p, (void*)1);
}
val = ossl_sslctx_get_extra_cert(self);
if(!NIL_P(val)){
rb_block_call(val, rb_intern("each"), 0, 0, ossl_sslctx_add_extra_chain_cert_i, self);
}
/* private key may be bundled in certificate file. */
val = ossl_sslctx_get_cert(self);
cert = NIL_P(val) ? NULL : GetX509CertPtr(val); /* NO DUP NEEDED */
val = ossl_sslctx_get_key(self);
key = NIL_P(val) ? NULL : GetPKeyPtr(val); /* NO DUP NEEDED */
if (cert && key) {
if (!SSL_CTX_use_certificate(ctx, cert)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_certificate:");
}
if (!SSL_CTX_use_PrivateKey(ctx, key)) {
/* Adds a ref => Safe to FREE */
ossl_raise(eSSLError, "SSL_CTX_use_PrivateKey:");
}
if (!SSL_CTX_check_private_key(ctx)) {
ossl_raise(eSSLError, "SSL_CTX_check_private_key:");
}
}
val = ossl_sslctx_get_client_ca(self);
if(!NIL_P(val)){
if(TYPE(val) == T_ARRAY){
for(i = 0; i < RARRAY_LEN(val); i++){
client_ca = GetX509CertPtr(RARRAY_PTR(val)[i]);
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
else{
client_ca = GetX509CertPtr(val); /* NO DUP NEEDED. */
if (!SSL_CTX_add_client_CA(ctx, client_ca)){
/* Copies X509_NAME => FREE it. */
ossl_raise(eSSLError, "SSL_CTX_add_client_CA");
}
}
}
val = ossl_sslctx_get_ca_file(self);
ca_file = NIL_P(val) ? NULL : StringValuePtr(val);
val = ossl_sslctx_get_ca_path(self);
ca_path = NIL_P(val) ? NULL : StringValuePtr(val);
if(ca_file || ca_path){
if (!SSL_CTX_load_verify_locations(ctx, ca_file, ca_path))
rb_warning("can't set verify locations");
}
val = ossl_sslctx_get_verify_mode(self);
verify_mode = NIL_P(val) ? SSL_VERIFY_NONE : NUM2INT(val);
SSL_CTX_set_verify(ctx, verify_mode, ossl_ssl_verify_callback);
if (RTEST(ossl_sslctx_get_client_cert_cb(self)))
SSL_CTX_set_client_cert_cb(ctx, ossl_client_cert_cb);
val = ossl_sslctx_get_timeout(self);
if(!NIL_P(val)) SSL_CTX_set_timeout(ctx, NUM2LONG(val));
val = ossl_sslctx_get_verify_dep(self);
if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2LONG(val));
val = ossl_sslctx_get_options(self);
if(!NIL_P(val)) SSL_CTX_set_options(ctx, NUM2LONG(val));
rb_obj_freeze(self);
val = ossl_sslctx_get_sess_id_ctx(self);
if (!NIL_P(val)){
StringValue(val);
if (!SSL_CTX_set_session_id_context(ctx, RSTRING_PTR(val),
RSTRING_LEN(val))){
ossl_raise(eSSLError, "SSL_CTX_set_session_id_context:");
}
}
if (RTEST(rb_iv_get(self, "@session_get_cb"))) {
SSL_CTX_sess_set_get_cb(ctx, ossl_sslctx_session_get_cb);
OSSL_Debug("SSL SESSION get callback added");
}
if (RTEST(rb_iv_get(self, "@session_new_cb"))) {
SSL_CTX_sess_set_new_cb(ctx, ossl_sslctx_session_new_cb);
OSSL_Debug("SSL SESSION new callback added");
}
if (RTEST(rb_iv_get(self, "@session_remove_cb"))) {
SSL_CTX_sess_set_remove_cb(ctx, ossl_sslctx_session_remove_cb);
OSSL_Debug("SSL SESSION remove callback added");
}
return Qtrue;
}
static VALUE
rbosa_app_send_event (VALUE self, VALUE event_class, VALUE event_id, VALUE params, VALUE need_retval)
{
OSErr error;
AppleEvent ae;
AppleEvent reply;
VALUE rb_timeout;
SInt32 timeout;
VALUE rb_reply;
unsigned has_direct_param;
error = AECreateAppleEvent (RVAL2FOURCHAR (event_class),
RVAL2FOURCHAR (event_id),
rbosa_element_aedesc (self),
kAutoGenerateReturnID,
kAnyTransactionID,
&ae);
if (error != noErr)
rb_raise (rb_eArgError, "Cannot create Apple Event '%s%s' : %s (%d)",
RVAL2CSTR (event_class), RVAL2CSTR (event_id), error_code_to_string (error), error);
has_direct_param = 0;
if (!NIL_P (params)) {
unsigned i;
for (i = 0; i < RARRAY (params)->len; i++) {
VALUE ary;
VALUE type;
VALUE element;
FourCharCode code;
ary = RARRAY (params)->ptr[i];
if (NIL_P (ary) || RARRAY (ary)->len != 2)
continue;
type = RARRAY (ary)->ptr[0];
element = RARRAY (ary)->ptr[1];
code = RVAL2FOURCHAR (type);
if (code == '----')
has_direct_param = 1;
error = AEPutParamDesc (&ae, RVAL2FOURCHAR (type), rbosa_element_aedesc (element));
if (error != noErr) {
AEDisposeDesc (&ae);
rb_raise (rb_eArgError, "Cannot add Apple Event parameter '%s' : %s (%d)",
RVAL2CSTR (type), error_code_to_string (error), error);
}
}
}
rb_timeout = rb_iv_get (mOSA, "@timeout");
timeout = NIL_P (rb_timeout) ? kAEDefaultTimeout : NUM2INT (rb_timeout);
if (has_direct_param == 0)
AEPutAttributePtr (&ae, 'subj', typeNull, NULL, 0);
error = AESend (&ae, &reply, (RVAL2CBOOL(need_retval) ? kAEWaitReply : kAENoReply) | kAECanInteract | kAECanSwitchLayer,
kAENormalPriority, timeout, NULL, NULL);
AEDisposeDesc (&ae);
if (error != noErr)
rb_raise (rb_eRuntimeError, "Cannot send Apple Event '%s%s' : %s (%d)",
RVAL2CSTR (event_class), RVAL2CSTR (event_id), error_code_to_string (error), error);
__rbosa_raise_potential_app_error (&reply);
if (RTEST (need_retval)) {
AEDesc replyObject;
AEGetParamDesc (&reply, keyDirectObject, typeWildCard, &replyObject);
rb_reply = rbosa_element_make (cOSAElement, &replyObject, self);
}
else {
rb_reply = Qnil;
}
AEDisposeDesc (&reply);
return rb_reply;
}
void
obj_dump(VALUE obj, yajl_gen gen)
{
int type;
yajl_gen_map_open(gen);
yajl_gen_cstr(gen, "_id");
yajl_gen_value(gen, obj);
struct obj_track *tracker = NULL;
if (st_lookup(objs, (st_data_t)obj, (st_data_t *)&tracker) && BUILTIN_TYPE(obj) != T_NODE) {
yajl_gen_cstr(gen, "file");
yajl_gen_cstr(gen, tracker->source);
yajl_gen_cstr(gen, "line");
yajl_gen_integer(gen, tracker->line);
}
yajl_gen_cstr(gen, "type");
switch (type=BUILTIN_TYPE(obj)) {
case T_DATA:
yajl_gen_cstr(gen, "data");
if (RBASIC(obj)->klass) {
yajl_gen_cstr(gen, "class");
yajl_gen_value(gen, RBASIC(obj)->klass);
yajl_gen_cstr(gen, "class_name");
VALUE name = rb_classname(RBASIC(obj)->klass);
if (RTEST(name))
yajl_gen_cstr(gen, RSTRING(name)->ptr);
else
yajl_gen_cstr(gen, 0);
}
break;
case T_FILE:
yajl_gen_cstr(gen, "file");
break;
case T_FLOAT:
yajl_gen_cstr(gen, "float");
yajl_gen_cstr(gen, "data");
yajl_gen_double(gen, RFLOAT(obj)->value);
break;
case T_BIGNUM:
yajl_gen_cstr(gen, "bignum");
yajl_gen_cstr(gen, "negative");
yajl_gen_bool(gen, RBIGNUM(obj)->sign == 0);
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RBIGNUM(obj)->len);
yajl_gen_cstr(gen, "data");
yajl_gen_string(gen, RBIGNUM(obj)->digits, RBIGNUM(obj)->len);
break;
case T_MATCH:
yajl_gen_cstr(gen, "match");
yajl_gen_cstr(gen, "data");
yajl_gen_value(gen, RMATCH(obj)->str);
break;
case T_REGEXP:
yajl_gen_cstr(gen, "regexp");
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RREGEXP(obj)->len);
yajl_gen_cstr(gen, "data");
yajl_gen_cstr(gen, RREGEXP(obj)->str);
break;
case T_SCOPE:
yajl_gen_cstr(gen, "scope");
struct SCOPE *scope = (struct SCOPE *)obj;
if (scope->local_tbl) {
int i = 1;
int n = scope->local_tbl[0];
VALUE *list = &scope->local_vars[-1];
VALUE cur = *list++;
yajl_gen_cstr(gen, "node");
yajl_gen_value(gen, cur);
if (n) {
yajl_gen_cstr(gen, "variables");
yajl_gen_map_open(gen);
while (n--) {
cur = *list++;
yajl_gen_cstr(gen, scope->local_tbl[i] == 95 ? "_" : rb_id2name(scope->local_tbl[i]));
yajl_gen_value(gen, cur);
i++;
}
yajl_gen_map_close(gen);
}
}
break;
case T_NODE:
yajl_gen_cstr(gen, "node");
yajl_gen_cstr(gen, "node_type");
yajl_gen_cstr(gen, nd_type_str(obj));
yajl_gen_cstr(gen, "file");
yajl_gen_cstr(gen, RNODE(obj)->nd_file);
yajl_gen_cstr(gen, "line");
yajl_gen_integer(gen, nd_line(obj));
yajl_gen_cstr(gen, "node_code");
yajl_gen_integer(gen, nd_type(obj));
switch (nd_type(obj)) {
case NODE_SCOPE:
break;
}
break;
case T_STRING:
yajl_gen_cstr(gen, "string");
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, RSTRING(obj)->len);
if (FL_TEST(obj, ELTS_SHARED|FL_USER3)) {
yajl_gen_cstr(gen, "shared");
yajl_gen_value(gen, RSTRING(obj)->aux.shared);
yajl_gen_cstr(gen, "flags");
yajl_gen_array_open(gen);
if (FL_TEST(obj, ELTS_SHARED))
yajl_gen_cstr(gen, "elts_shared");
if (FL_TEST(obj, FL_USER3))
yajl_gen_cstr(gen, "str_assoc");
yajl_gen_array_close(gen);
} else {
yajl_gen_cstr(gen, "data");
yajl_gen_string(gen, (unsigned char *)RSTRING(obj)->ptr, RSTRING(obj)->len);
}
break;
case T_VARMAP:
yajl_gen_cstr(gen, "varmap");
struct RVarmap *vars = (struct RVarmap *)obj;
if (vars->next) {
yajl_gen_cstr(gen, "next");
yajl_gen_value(gen, (VALUE)vars->next);
}
if (vars->id) {
yajl_gen_cstr(gen, "data");
yajl_gen_map_open(gen);
yajl_gen_cstr(gen, rb_id2name(vars->id));
yajl_gen_value(gen, vars->val);
yajl_gen_map_close(gen);
}
break;
case T_CLASS:
case T_MODULE:
case T_ICLASS:
yajl_gen_cstr(gen, type==T_CLASS ? "class" : type==T_MODULE ? "module" : "iclass");
yajl_gen_cstr(gen, "name");
VALUE name = rb_classname(obj);
if (RTEST(name))
yajl_gen_cstr(gen, RSTRING(name)->ptr);
else
yajl_gen_cstr(gen, 0);
yajl_gen_cstr(gen, "super");
yajl_gen_value(gen, RCLASS(obj)->super);
yajl_gen_cstr(gen, "super_name");
VALUE super_name = rb_classname(RCLASS(obj)->super);
if (RTEST(super_name))
yajl_gen_cstr(gen, RSTRING(super_name)->ptr);
else
yajl_gen_cstr(gen, 0);
if (FL_TEST(obj, FL_SINGLETON)) {
yajl_gen_cstr(gen, "singleton");
yajl_gen_bool(gen, 1);
}
if (RCLASS(obj)->iv_tbl && RCLASS(obj)->iv_tbl->num_entries) {
yajl_gen_cstr(gen, "ivars");
yajl_gen_map_open(gen);
st_foreach(RCLASS(obj)->iv_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
if (type != T_ICLASS && RCLASS(obj)->m_tbl && RCLASS(obj)->m_tbl->num_entries) {
yajl_gen_cstr(gen, "methods");
yajl_gen_map_open(gen);
st_foreach(RCLASS(obj)->m_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
break;
case T_OBJECT:
yajl_gen_cstr(gen, "object");
yajl_gen_cstr(gen, "class");
yajl_gen_value(gen, RBASIC(obj)->klass);
yajl_gen_cstr(gen, "class_name");
yajl_gen_cstr(gen, rb_obj_classname(obj));
struct RClass *klass = RCLASS(obj);
if (klass->iv_tbl && klass->iv_tbl->num_entries) {
yajl_gen_cstr(gen, "ivars");
yajl_gen_map_open(gen);
st_foreach(klass->iv_tbl, each_ivar, (st_data_t)gen);
yajl_gen_map_close(gen);
}
break;
case T_ARRAY:
yajl_gen_cstr(gen, "array");
struct RArray *ary = RARRAY(obj);
yajl_gen_cstr(gen, "length");
yajl_gen_integer(gen, ary->len);
if (FL_TEST(obj, ELTS_SHARED)) {
yajl_gen_cstr(gen, "shared");
yajl_gen_value(gen, ary->aux.shared);
} else if (ary->len) {
yajl_gen_cstr(gen, "data");
yajl_gen_array_open(gen);
int i;
for(i=0; i < ary->len; i++)
yajl_gen_value(gen, ary->ptr[i]);
yajl_gen_array_close(gen);
}
break;
case T_HASH:
yajl_gen_cstr(gen, "hash");
struct RHash *hash = RHASH(obj);
yajl_gen_cstr(gen, "length");
if (hash->tbl)
yajl_gen_integer(gen, hash->tbl->num_entries);
else
yajl_gen_integer(gen, 0);
yajl_gen_cstr(gen, "default");
yajl_gen_value(gen, hash->ifnone);
if (hash->tbl && hash->tbl->num_entries) {
yajl_gen_cstr(gen, "data");
//yajl_gen_map_open(gen);
yajl_gen_array_open(gen);
st_foreach(hash->tbl, each_hash_entry, (st_data_t)gen);
yajl_gen_array_close(gen);
//yajl_gen_map_close(gen);
}
break;
default:
yajl_gen_cstr(gen, "unknown");
}
yajl_gen_cstr(gen, "code");
yajl_gen_integer(gen, BUILTIN_TYPE(obj));
yajl_gen_map_close(gen);
}
/*
* call-seq: configure(opts)
*
* Configure this State instance with the Hash _opts_, and return
* itself.
*/
static VALUE cState_configure(VALUE self, VALUE opts)
{
VALUE tmp;
GET_STATE(self);
tmp = rb_check_convert_type(opts, T_HASH, "Hash", "to_hash");
if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
opts = tmp;
tmp = rb_hash_aref(opts, ID2SYM(i_indent));
if (RTEST(tmp)) {
unsigned long len;
Check_Type(tmp, T_STRING);
len = RSTRING_LEN(tmp);
state->indent = fstrndup(RSTRING_PTR(tmp), len + 1);
state->indent_len = len;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space));
if (RTEST(tmp)) {
unsigned long len;
Check_Type(tmp, T_STRING);
len = RSTRING_LEN(tmp);
state->space = fstrndup(RSTRING_PTR(tmp), len + 1);
state->space_len = len;
}
tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
if (RTEST(tmp)) {
unsigned long len;
Check_Type(tmp, T_STRING);
len = RSTRING_LEN(tmp);
state->space_before = fstrndup(RSTRING_PTR(tmp), len + 1);
state->space_before_len = len;
}
tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
if (RTEST(tmp)) {
unsigned long len;
Check_Type(tmp, T_STRING);
len = RSTRING_LEN(tmp);
state->array_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
state->array_nl_len = len;
}
tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
if (RTEST(tmp)) {
unsigned long len;
Check_Type(tmp, T_STRING);
len = RSTRING_LEN(tmp);
state->object_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
state->object_nl_len = len;
}
tmp = ID2SYM(i_max_nesting);
state->max_nesting = 100;
if (option_given_p(opts, tmp)) {
VALUE max_nesting = rb_hash_aref(opts, tmp);
if (RTEST(max_nesting)) {
Check_Type(max_nesting, T_FIXNUM);
state->max_nesting = FIX2LONG(max_nesting);
} else {
state->max_nesting = 0;
}
}
tmp = ID2SYM(i_depth);
state->depth = 0;
if (option_given_p(opts, tmp)) {
VALUE depth = rb_hash_aref(opts, tmp);
if (RTEST(depth)) {
Check_Type(depth, T_FIXNUM);
state->depth = FIX2LONG(depth);
} else {
state->depth = 0;
}
}
tmp = ID2SYM(i_buffer_initial_length);
if (option_given_p(opts, tmp)) {
VALUE buffer_initial_length = rb_hash_aref(opts, tmp);
if (RTEST(buffer_initial_length)) {
long initial_length;
Check_Type(buffer_initial_length, T_FIXNUM);
initial_length = FIX2LONG(buffer_initial_length);
if (initial_length > 0) state->buffer_initial_length = initial_length;
}
}
tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
state->allow_nan = RTEST(tmp);
tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
state->ascii_only = RTEST(tmp);
return self;
}
static VALUE
memprof_dump(int argc, VALUE *argv, VALUE self)
{
VALUE str;
FILE *out = NULL;
if (!track_objs)
rb_raise(rb_eRuntimeError, "object tracking disabled, call Memprof.start first");
rb_scan_args(argc, argv, "01", &str);
if (RTEST(str)) {
out = fopen(StringValueCStr(str), "w");
if (!out)
rb_raise(rb_eArgError, "unable to open output file");
}
yajl_gen_config conf = { .beautify = 1, .indentString = " " };
yajl_gen gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
track_objs = 0;
yajl_gen_array_open(gen);
st_foreach(objs, objs_each_dump, (st_data_t)gen);
yajl_gen_array_close(gen);
yajl_gen_free(gen);
if (out)
fclose(out);
track_objs = 1;
return Qnil;
}
static VALUE
memprof_dump_all(int argc, VALUE *argv, VALUE self)
{
char *heaps = *(char**)bin_find_symbol("heaps",0);
int heaps_used = *(int*)bin_find_symbol("heaps_used",0);
#ifndef sizeof__RVALUE
size_t sizeof__RVALUE = bin_type_size("RVALUE");
#endif
#ifndef sizeof__heaps_slot
size_t sizeof__heaps_slot = bin_type_size("heaps_slot");
#endif
#ifndef offset__heaps_slot__limit
int offset__heaps_slot__limit = bin_type_member_offset("heaps_slot", "limit");
#endif
#ifndef offset__heaps_slot__slot
int offset__heaps_slot__slot = bin_type_member_offset("heaps_slot", "slot");
#endif
char *p, *pend;
int i, limit;
if (sizeof__RVALUE == 0 || sizeof__heaps_slot == 0)
rb_raise(eUnsupported, "could not find internal heap");
VALUE str;
FILE *out = NULL;
rb_scan_args(argc, argv, "01", &str);
if (RTEST(str)) {
out = fopen(StringValueCStr(str), "w");
if (!out)
rb_raise(rb_eArgError, "unable to open output file");
}
yajl_gen_config conf = { .beautify = 0, .indentString = " " };
yajl_gen gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
track_objs = 0;
//yajl_gen_array_open(gen);
for (i=0; i < heaps_used; i++) {
p = *(char**)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__slot);
limit = *(int*)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__limit);
pend = p + (sizeof__RVALUE * limit);
while (p < pend) {
if (RBASIC(p)->flags) {
obj_dump((VALUE)p, gen);
// XXX ugh
yajl_gen_clear(gen);
yajl_gen_free(gen);
gen = yajl_gen_alloc2((yajl_print_t)&json_print, &conf, NULL, (void*)out);
while(fputc('\n', out ? out : stdout) == EOF);
}
p += sizeof__RVALUE;
}
}
//yajl_gen_array_close(gen);
yajl_gen_clear(gen);
yajl_gen_free(gen);
if (out)
fclose(out);
track_objs = 1;
return Qnil;
}
void
Init_memprof()
{
VALUE memprof = rb_define_module("Memprof");
eUnsupported = rb_define_class_under(memprof, "Unsupported", rb_eStandardError);
rb_define_singleton_method(memprof, "start", memprof_start, 0);
rb_define_singleton_method(memprof, "stop", memprof_stop, 0);
rb_define_singleton_method(memprof, "stats", memprof_stats, -1);
rb_define_singleton_method(memprof, "stats!", memprof_stats_bang, -1);
rb_define_singleton_method(memprof, "track", memprof_track, -1);
rb_define_singleton_method(memprof, "dump", memprof_dump, -1);
rb_define_singleton_method(memprof, "dump_all", memprof_dump_all, -1);
pagesize = getpagesize();
objs = st_init_numtable();
bin_init();
create_tramp_table();
gc_hook = Data_Wrap_Struct(rb_cObject, sourcefile_marker, NULL, NULL);
rb_global_variable(&gc_hook);
ptr_to_rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL);
rb_classname = bin_find_symbol("classname", 0);
rb_add_freelist = bin_find_symbol("add_freelist", 0);
insert_tramp("rb_newobj", newobj_tramp);
insert_tramp("add_freelist", freelist_tramp);
if (getenv("MEMPROF"))
track_objs = 1;
return;
}
/*
* call-seq:
* new
*
* Create a new document
*/
static VALUE new(int argc, VALUE *argv, VALUE klass)
{
VALUE uri, external_id, rest, rb_doc;
rb_scan_args(argc, argv, "0*", &rest);
uri = rb_ary_entry(rest, (long)0);
external_id = rb_ary_entry(rest, (long)1);
htmlDocPtr doc = htmlNewDoc(
RTEST(uri) ? (const xmlChar *)StringValuePtr(uri) : NULL,
RTEST(external_id) ? (const xmlChar *)StringValuePtr(external_id) : NULL
);
rb_doc = Nokogiri_wrap_xml_document(klass, doc);
rb_obj_call_init(rb_doc, argc, argv);
return rb_doc ;
}
/*
* call-seq:
* read_io(io, url, encoding, options)
*
* Read the HTML document from +io+ with given +url+, +encoding+,
* and +options+. See Nokogiri::HTML.parse
*/
static VALUE read_io( VALUE klass,
static VALUE
initialize_params(VALUE vparams, VALUE parser, VALUE arg, VALUE lexer, VALUE lexmid)
{
struct cparse_params *v;
Data_Get_Struct(vparams, struct cparse_params, v);
v->value_v = vparams;
v->parser = parser;
v->lexer = lexer;
if (! NIL_P(lexmid))
v->lexmid = value_to_id(lexmid);
v->debug = RTEST(rb_ivar_get(parser, id_yydebug));
Check_Type(arg, T_ARRAY);
if (!(13 <= RARRAY_LEN(arg) && RARRAY_LEN(arg) <= 14))
rb_raise(RaccBug, "[Racc Bug] wrong arg.size %ld", RARRAY_LEN(arg));
v->action_table = assert_array (RARRAY_PTR(arg)[ 0]);
v->action_check = assert_array (RARRAY_PTR(arg)[ 1]);
v->action_default = assert_array (RARRAY_PTR(arg)[ 2]);
v->action_pointer = assert_array (RARRAY_PTR(arg)[ 3]);
v->goto_table = assert_array (RARRAY_PTR(arg)[ 4]);
v->goto_check = assert_array (RARRAY_PTR(arg)[ 5]);
v->goto_default = assert_array (RARRAY_PTR(arg)[ 6]);
v->goto_pointer = assert_array (RARRAY_PTR(arg)[ 7]);
v->nt_base = assert_integer(RARRAY_PTR(arg)[ 8]);
v->reduce_table = assert_array (RARRAY_PTR(arg)[ 9]);
v->token_table = assert_hash (RARRAY_PTR(arg)[10]);
v->shift_n = assert_integer(RARRAY_PTR(arg)[11]);
v->reduce_n = assert_integer(RARRAY_PTR(arg)[12]);
if (RARRAY_LEN(arg) > 13) {
v->use_result_var = RTEST(RARRAY_PTR(arg)[13]);
}
else {
v->use_result_var = TRUE;
}
v->tstack = v->debug ? NEW_STACK() : Qnil;
v->vstack = NEW_STACK();
v->state = NEW_STACK();
v->curstate = 0;
PUSH(v->state, INT2FIX(0));
v->t = INT2FIX(FINAL_TOKEN + 1); /* must not init to FINAL_TOKEN */
v->nerr = 0;
v->errstatus = 0;
rb_ivar_set(parser, id_errstatus, LONG2NUM(v->errstatus));
v->retval = Qnil;
v->fin = 0;
v->lex_is_iterator = FALSE;
rb_iv_set(parser, "@vstack", v->vstack);
if (v->debug) {
rb_iv_set(parser, "@tstack", v->tstack);
}
else {
rb_iv_set(parser, "@tstack", Qnil);
}
return vparams;
}