static VALUE
rb_struct_each_pair(VALUE s)
{
VALUE members;
long i;
RETURN_SIZED_ENUMERATOR(s, 0, 0, rb_struct_size);
members = rb_struct_members(s);
for (i=0; i<RSTRUCT_LEN(s); i++) {
VALUE key = rb_ary_entry(members, i);
VALUE value = RSTRUCT_PTR(s)[i];
rb_yield(rb_assoc_new(key, value));
}
return s;
}
static VALUE
env_assoc(VALUE env, SEL sel, VALUE key)
{
rb_secure(4);
const char *s = StringValuePtr(key);
if (strlen(s) != RSTRING_LEN(key)) {
rb_raise(rb_eArgError, "bad environment variable name");
}
const char *e = getenv(s);
if (e != NULL) {
return rb_assoc_new(key, rb_tainted_str_new2(e));
}
return Qnil;
}
static VALUE
bf_get_icon(VALUE self, VALUE uri)
{
gchar* href;
gchar* mime_type;
GError *error = NULL;
gboolean ret = g_bookmark_file_get_icon(_SELF(self),
(const gchar *)RVAL2CSTR(uri),
&href, &mime_type,
&error);
if (!ret){
if (error) RAISE_GERROR(error);
return Qnil;
}
return rb_assoc_new(CSTR2RVAL_FREE(href), CSTR2RVAL_FREE(mime_type));
}
static VALUE
gdkpmap_colormap_create_from_xpm(VALUE self, VALUE win, VALUE colormap, VALUE tcolor, VALUE fname)
{
GdkPixmap *result;
GdkBitmap *mask;
result = gdk_pixmap_colormap_create_from_xpm(NIL_P(win) ? NULL : GDK_WINDOW(RVAL2GOBJ(win)),
GDK_COLORMAP(RVAL2GOBJ(colormap)),
&mask,
RVAL2GDKCOLOR(tcolor),
RVAL2CSTR(fname));
if (result == NULL)
rb_raise(rb_eArgError, "Pixmap not created from %s", RVAL2CSTR(fname));
return rb_assoc_new(GOBJ2RVAL(result), GOBJ2RVAL(mask));
}
static VALUE
gdkpmap_create_from_xpm_d(VALUE self, VALUE win, VALUE tcolor, VALUE data)
{
GdkPixmap *result;
GdkBitmap *mask;
const gchar **buf = RVAL2STRV(data);
result = gdk_pixmap_create_from_xpm_d(GDK_WINDOW(RVAL2GOBJ(win)),
&mask,
RVAL2GDKCOLOR(tcolor),
(gchar **)buf);
g_free(buf);
return rb_assoc_new(GOBJ2RVAL(result), GOBJ2RVAL(mask));
}
static VALUE
env_to_a(VALUE rcv, SEL sel)
{
rb_secure(4);
VALUE ary = rb_ary_new();
char **env = GET_ENVIRON();
while (*env != NULL) {
const char *s = strchr(*env, '=');
if (s != NULL) {
rb_ary_push(ary, rb_assoc_new(env_str_new(*env, s - *env),
env_str_new2(s + 1)));
}
env++;
}
return ary;
}
static VALUE
rg_x_to_index(VALUE self, VALUE text, VALUE analysis, VALUE x_pos)
{
int index;
int trailing;
StringValue(text);
pango_glyph_string_x_to_index(_SELF(self),
/* NOTE: This is a bug in the signature of
* pango_glyph_string_index_to_x */
(char *)RSTRING_PTR(text),
RSTRING_LEN(text),
RVAL2PANGOANALYSIS(analysis),
NUM2INT(x_pos),
&index, &trailing);
return rb_assoc_new(INT2NUM(index), CBOOL2RVAL(trailing));
}
static VALUE
env_shift(VALUE rcv, SEL sel)
{
rb_secure(4);
char **env = GET_ENVIRON();
if (*env != NULL) {
const char *s = strchr(*env, '=');
if (s != NULL) {
VALUE key = env_str_new(*env, s - *env);
VALUE val = env_str_new2(getenv(RSTRING_PTR(key)));
env_delete(Qnil, key);
return rb_assoc_new(key, val);
}
}
return Qnil;
}
static VALUE
rg_attach_points(VALUE self)
{
GdkPoint* points;
gint n_points, i;
gboolean ret = gtk_icon_info_get_attach_points(_SELF(self), &points, &n_points);
VALUE ary = Qnil;
if (ret){
ary = rb_ary_new();
for (i = 0; i < n_points; i++){
rb_ary_push(ary, rb_assoc_new(INT2NUM(points[i].x), INT2NUM(points[i].y)));
}
g_free(points);
}
return ary;
}
/*
* call-seq: DB.add_message(path) => MESSAGE, isdup
*
* Add a message to the database and return it.
*
* +isdup+ is a boolean that specifies whether the added message was a
* duplicate.
*/
VALUE
notmuch_rb_database_add_message (VALUE self, VALUE pathv)
{
const char *path;
notmuch_status_t ret;
notmuch_message_t *message;
notmuch_database_t *db;
Data_Get_Notmuch_Database (self, db);
SafeStringValue (pathv);
path = RSTRING_PTR (pathv);
ret = notmuch_database_add_message (db, path, &message);
notmuch_rb_status_raise (ret);
return rb_assoc_new (Data_Wrap_Struct (notmuch_rb_cMessage, NULL, NULL, message),
(ret == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) ? Qtrue : Qfalse);
}
static VALUE
ossl_bn_coerce(VALUE self, VALUE other)
{
switch(TYPE(other)) {
case T_STRING:
self = ossl_bn_to_s(0, NULL, self);
break;
case T_FIXNUM:
case T_BIGNUM:
self = ossl_bn_to_i(self);
break;
default:
if (!RTEST(rb_obj_is_kind_of(other, cBN))) {
ossl_raise(rb_eTypeError, "Don't know how to coerce");
}
}
return rb_assoc_new(other, self);
}
static VALUE
settings_rc_property_parse_requisition(VALUE self, VALUE spec, VALUE str)
{
gboolean ret;
GValue prop = {0,};
VALUE val = Qnil;
GString* gstr = g_string_new(RVAL2CSTR(str));
g_value_init(&prop, GTK_TYPE_REQUISITION);
ret = gtk_rc_property_parse_requisition(G_PARAM_SPEC(RVAL2GOBJ(spec)),
gstr, &prop);
if (ret){
GtkRequisition* req = g_value_get_boxed(&prop);
val = rb_assoc_new(INT2NUM(req->width), INT2NUM(req->height));
}
g_string_free(gstr, TRUE);
g_value_unset(&prop);
return val;
}
static VALUE
rg_add_items(VALUE self, VALUE items)
{
gint i, len;
GList* list = (GList*)NULL;
VALUE items_internal = rb_ivar_get(self, id_items_internal);
items = rb_ary_to_ary(items);
len = RARRAY_LEN(items);
for (i = 0; i < len; i ++){
VALUE data = RARRAY_PTR(items)[i];
VALUE item = rb_assoc_new(self, data);
list = g_list_append(list, (gpointer)item);
rb_hash_aset(items_internal, data, item);
}
g_completion_add_items(_SELF(self), list);
return self;
}
static VALUE
rhash_shift(VALUE hash, SEL sel)
{
VALUE args[2] = {0, 0};
rhash_modify(hash);
rhash_foreach(hash, shift_i, (st_data_t)args);
if (args[0] != 0 && args[1] != 0) {
rhash_delete_key(hash, args[0]);
return rb_assoc_new(args[0], args[1]);
}
if (RHASH(hash)->ifnone != Qnil) {
if (RHASH(hash)->has_proc_default) {
return rb_funcall(RHASH(hash)->ifnone, id_yield, 2, hash,
Qnil);
}
return RHASH(hash)->ifnone;
}
return Qnil;
}
static VALUE
rg_complete(VALUE self, VALUE prefix)
{
gchar* new_prefix;
VALUE ary = rb_ary_new();
#if GLIB_CHECK_VERSION(2,4,0)
GList* list = g_completion_complete_utf8(_SELF(self),
(const gchar*)RVAL2CSTR(prefix),
&new_prefix);
#else
GList* list = g_completion_complete(_SELF(self),
RVAL2CSTR(prefix),
&new_prefix);
#endif
while (list) {
rb_ary_push(ary, RARRAY_PTR((VALUE)list->data)[1]);
list = list->next;
}
return rb_assoc_new(ary, new_prefix ? CSTR2RVAL(new_prefix) : Qnil);
}
static VALUE
rg_get_pixel_extents(int argc, VALUE *argv, VALUE self)
{
VALUE ink_rect, logical_rect;
PangoRectangle rink, rlog;
rb_scan_args(argc, argv, "02", &ink_rect, &logical_rect);
if (NIL_P(ink_rect)){
rink.x = 0;
rink.y = 0;
rink.width = 0;
rink.height = 0;
} else {
PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(ink_rect, PANGO_TYPE_RECTANGLE);
rink.x = rect->x;
rink.y = rect->y;
rink.width = rect->width;
rink.height = rect->height;
}
if (NIL_P(logical_rect)){
rlog.x = 0;
rlog.y = 0;
rlog.width = 0;
rlog.height = 0;
} else {
PangoRectangle* rect = (PangoRectangle*)RVAL2BOXED(logical_rect, PANGO_TYPE_RECTANGLE);
rlog.x = rect->x;
rlog.y = rect->y;
rlog.width = rect->width;
rlog.height = rect->height;
}
pango_layout_get_pixel_extents(_SELF(self), &rink, &rlog);
return rb_assoc_new(BOXED2RVAL(&rink, PANGO_TYPE_RECTANGLE),
BOXED2RVAL(&rlog, PANGO_TYPE_RECTANGLE));
}
static VALUE
env_each_pair(VALUE ehash, SEL sel)
{
RETURN_ENUMERATOR(ehash, 0, 0);
rb_secure(4);
VALUE ary = rb_ary_new();
char **env = GET_ENVIRON();
while (*env != NULL) {
const char *s = strchr(*env, '=');
if (s != NULL) {
rb_ary_push(ary, env_str_new(*env, s - *env));
rb_ary_push(ary, env_str_new2(s + 1));
}
env++;
}
for (long i = 0, count = RARRAY_LEN(ary); i < count; i += 2) {
rb_yield(rb_assoc_new(RARRAY_AT(ary, i), RARRAY_AT(ary, i + 1)));
RETURN_IF_BROKEN();
}
return ehash;
}
static VALUE
rglyph_extents(int argc, VALUE *argv, VALUE self)
{
VALUE font, start_index, end_index;
PangoRectangle ink_rect;
PangoRectangle logical_rect;
rb_scan_args(argc, argv, "12", &font, &start_index, &end_index);
if (NIL_P(start_index)){
pango_glyph_string_extents(_SELF(self),
PANGO_FONT(RVAL2GOBJ(font)),
&ink_rect, &logical_rect);
} else {
pango_glyph_string_extents_range(_SELF(self),
NUM2INT(start_index), NUM2INT(end_index),
PANGO_FONT(RVAL2GOBJ(font)),
&ink_rect, &logical_rect);
}
return rb_assoc_new(BOXED2RVAL(&ink_rect, PANGO_TYPE_RECTANGLE),
BOXED2RVAL(&logical_rect, PANGO_TYPE_RECTANGLE));
}
static VALUE
nst_create_member_views(VALUE self)
{
VALUE defs, def, types, type, elmt;
long i, len;
narray_view_t *ne;
defs = nst_definitions(CLASS_OF(self));
len = RARRAY_LEN(defs);
types = rb_ary_new2(len);
//ofsts = rb_ary_new2(len);
for (i=0; i<len; i++) {
def = RARRAY_AREF(defs,i);
type = RARRAY_AREF(def,1);
//ofst = RARRAY_AREF(def,2);
elmt = na_make_view(type);
rb_ary_push(types, elmt);
//rb_ary_push(ofsts, ofst);
GetNArrayView(elmt,ne);
ne->data = na_original_data(self);
}
return rb_assoc_new(types,defs);
}
static VALUE
env_rassoc(VALUE dmy, SEL sel, VALUE obj)
{
rb_secure(4);
obj = rb_check_string_type(obj);
if (NIL_P(obj)) {
return Qnil;
}
char **env = GET_ENVIRON();
while (*env != NULL) {
const char *s = strchr(*env, '=');
if (s++ != NULL) {
const long len = strlen(s);
if (RSTRING_LEN(obj) == len
&& strncmp(s, RSTRING_PTR(obj), len) == 0) {
return rb_assoc_new(rb_tainted_str_new(*env, s - *env - 1),
obj);
}
}
env++;
}
return Qnil;
}
static VALUE
rb_struct_each_pair(VALUE s)
{
VALUE members;
long i;
RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
members = rb_struct_members(s);
if (rb_block_arity() > 1) {
for (i=0; i<RSTRUCT_LEN(s); i++) {
VALUE key = rb_ary_entry(members, i);
VALUE value = RSTRUCT_GET(s, i);
rb_yield_values(2, key, value);
}
}
else {
for (i=0; i<RSTRUCT_LEN(s); i++) {
VALUE key = rb_ary_entry(members, i);
VALUE value = RSTRUCT_GET(s, i);
rb_yield(rb_assoc_new(key, value));
}
}
return s;
}
static VALUE
bdb_i_each_log_get(VALUE obj, int flag)
{
#if ! HAVE_ST_DB_ENV_LOG_CURSOR
bdb_ENV *envst;
#endif
struct dblsnst *lsnst, *lsnst1;
DBT data;
VALUE lsn, lsn1;
VALUE res;
int ret, init, flags;
init = BDB_LOG_INIT;
#if ! HAVE_ST_DB_ENV_LOG_CURSOR
GetEnvDB(obj, envst);
#else
lsn = obj;
Data_Get_Struct(obj, struct dblsnst, lsnst);
flag = lsnst->flags;
if (lsnst->cursor == 0) {
DB_LSN *lsn1;
init = BDB_LOG_SET;
lsn1 = lsnst->lsn;
lsn = bdb_makelsn(lsnst->env);
Data_Get_Struct(lsn, struct dblsnst, lsnst);
MEMCPY(lsnst->lsn, lsn1, DB_LSN, 1);
bdb_log_cursor(lsn);
}
#endif
do {
#if ! HAVE_ST_DB_ENV_LOG_CURSOR
lsn = bdb_makelsn(obj);
Data_Get_Struct(lsn, struct dblsnst, lsnst);
#endif
MEMZERO(&data, DBT, 1);
data.flags |= DB_DBT_MALLOC;
switch (init) {
case BDB_LOG_INIT:
flags = (flag == DB_NEXT)?DB_FIRST:DB_LAST;
break;
case BDB_LOG_SET:
flags = DB_SET;
break;
default:
flags = flag;
break;
}
init = BDB_LOG_NEXT;
#if HAVE_ST_DB_ENV_LG_INFO
if (!envst->envp->lg_info) {
rb_raise(bdb_eFatal, "log region not open");
}
ret = bdb_test_error(log_get(envst->envp->lg_info, lsnst->lsn, &data, flags));
#elif HAVE_ST_DB_ENV_LOG_CURSOR
ret = bdb_test_error(lsnst->cursor->get(lsnst->cursor, lsnst->lsn, &data, flags));
lsn1 = bdb_makelsn(lsnst->env);
Data_Get_Struct(lsn1, struct dblsnst, lsnst1);
MEMCPY(lsnst1->lsn, lsnst->lsn, DB_LSN, 1);
#else
ret = bdb_test_error(log_get(envst->envp, lsnst->lsn, &data, flags));
lsn1 = lsn;
#endif
if (ret == DB_NOTFOUND) {
return Qnil;
}
res = rb_tainted_str_new(data.data, data.size);
free(data.data);
rb_yield(rb_assoc_new(res, lsn));
} while (1);
return Qnil;
}
/*
* call-seq:
* num.polar -> array
*
* Returns an array; [num.abs, num.arg].
*/
static VALUE
numeric_polar(VALUE self)
{
return rb_assoc_new(f_abs(self), f_arg(self));
}
/*
* call-seq:
* num.rect -> array
* num.rectangular -> array
*
* Returns an array; [num, 0].
*/
static VALUE
numeric_rect(VALUE self)
{
return rb_assoc_new(self, INT2FIX(0));
}
/*
* call-seq:
* cmp.rect -> array
* cmp.rectangular -> array
*
* Returns an array; [cmp.real, cmp.imag].
*
* Complex(1, 2).rectangular #=> [1, 2]
*/
static VALUE
nucomp_rect(VALUE self)
{
get_dat1(self);
return rb_assoc_new(dat->real, dat->imag);
}
VALUE
rsock_s_recvfrom(VALUE sock, int argc, VALUE *argv, enum sock_recv_type from)
{
rb_io_t *fptr;
VALUE str, klass;
struct recvfrom_arg arg;
VALUE len, flg;
long buflen;
long slen;
rb_scan_args(argc, argv, "11", &len, &flg);
if (flg == Qnil) arg.flags = 0;
else arg.flags = NUM2INT(flg);
buflen = NUM2INT(len);
GetOpenFile(sock, fptr);
if (rb_io_read_pending(fptr)) {
rb_raise(rb_eIOError, "recv for buffered IO");
}
arg.fd = fptr->fd;
arg.alen = (socklen_t)sizeof(arg.buf);
arg.str = str = rb_tainted_str_new(0, buflen);
klass = RBASIC(str)->klass;
rb_obj_hide(str);
while (rb_io_check_closed(fptr),
rsock_maybe_wait_fd(arg.fd),
(slen = BLOCKING_REGION_FD(recvfrom_blocking, &arg)) < 0) {
if (!rb_io_wait_readable(fptr->fd)) {
rb_sys_fail("recvfrom(2)");
}
if (RBASIC(str)->klass || RSTRING_LEN(str) != buflen) {
rb_raise(rb_eRuntimeError, "buffer string modified");
}
}
rb_obj_reveal(str, klass);
if (slen < RSTRING_LEN(str)) {
rb_str_set_len(str, slen);
}
rb_obj_taint(str);
switch (from) {
case RECV_RECV:
return str;
case RECV_IP:
#if 0
if (arg.alen != sizeof(struct sockaddr_in)) {
rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
}
#endif
if (arg.alen && arg.alen != sizeof(arg.buf)) /* OSX doesn't return a from result for connection-oriented sockets */
return rb_assoc_new(str, rsock_ipaddr(&arg.buf.addr, arg.alen, fptr->mode & FMODE_NOREVLOOKUP));
else
return rb_assoc_new(str, Qnil);
#ifdef HAVE_SYS_UN_H
case RECV_UNIX:
return rb_assoc_new(str, rsock_unixaddr(&arg.buf.un, arg.alen));
#endif
case RECV_SOCKET:
return rb_assoc_new(str, rsock_io_socket_addrinfo(sock, &arg.buf.addr, arg.alen));
default:
rb_bug("rsock_s_recvfrom called with bad value");
}
}
static VALUE
string_to_c_internal(VALUE self)
{
VALUE s;
s = self;
if (RSTRING_LEN(s) == 0)
return rb_assoc_new(Qnil, self);
{
VALUE m, sr, si, re, r, i;
int po;
m = f_match(comp_pat0, s);
if (!NIL_P(m)) {
sr = rb_reg_nth_match(1, m);
si = rb_reg_nth_match(2, m);
re = rb_reg_match_post(m);
po = 1;
}
if (NIL_P(m)) {
m = f_match(comp_pat1, s);
if (!NIL_P(m)) {
sr = Qnil;
si = rb_reg_nth_match(1, m);
if (NIL_P(si))
si = rb_usascii_str_new2("");
{
VALUE t;
t = rb_reg_nth_match(2, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
}
if (NIL_P(m)) {
m = f_match(comp_pat2, s);
if (NIL_P(m))
return rb_assoc_new(Qnil, self);
sr = rb_reg_nth_match(1, m);
if (NIL_P(rb_reg_nth_match(2, m)))
si = Qnil;
else {
VALUE t;
si = rb_reg_nth_match(3, m);
t = rb_reg_nth_match(4, m);
if (NIL_P(t))
t = rb_usascii_str_new2("1");
rb_str_concat(si, t);
}
re = rb_reg_match_post(m);
po = 0;
}
r = INT2FIX(0);
i = INT2FIX(0);
if (!NIL_P(sr)) {
if (strchr(RSTRING_PTR(sr), '/'))
r = f_to_r(sr);
else if (strpbrk(RSTRING_PTR(sr), ".eE"))
r = f_to_f(sr);
else
r = f_to_i(sr);
}
if (!NIL_P(si)) {
if (strchr(RSTRING_PTR(si), '/'))
i = f_to_r(si);
else if (strpbrk(RSTRING_PTR(si), ".eE"))
i = f_to_f(si);
else
i = f_to_i(si);
}
if (po)
return rb_assoc_new(rb_complex_polar(r, i), re);
else
return rb_assoc_new(rb_complex_new2(r, i), re);
}
}
static VALUE array_spec_rb_assoc_new(VALUE self, VALUE first, VALUE second) {
return rb_assoc_new(first, second);
}
VALUE
rsock_s_recvfrom_nonblock(VALUE sock, int argc, VALUE *argv, enum sock_recv_type from)
{
rb_io_t *fptr;
VALUE str;
union_sockaddr buf;
socklen_t alen = (socklen_t)sizeof buf;
VALUE len, flg;
long buflen;
long slen;
int fd, flags;
VALUE addr = Qnil;
socklen_t len0;
rb_scan_args(argc, argv, "11", &len, &flg);
if (flg == Qnil) flags = 0;
else flags = NUM2INT(flg);
buflen = NUM2INT(len);
#ifdef MSG_DONTWAIT
/* MSG_DONTWAIT avoids the race condition between fcntl and recvfrom.
It is not portable, though. */
flags |= MSG_DONTWAIT;
#endif
GetOpenFile(sock, fptr);
if (rb_io_read_pending(fptr)) {
rb_raise(rb_eIOError, "recvfrom for buffered IO");
}
fd = fptr->fd;
str = rb_tainted_str_new(0, buflen);
rb_io_check_closed(fptr);
rb_io_set_nonblock(fptr);
len0 = alen;
slen = recvfrom(fd, RSTRING_PTR(str), buflen, flags, &buf.addr, &alen);
if (slen != -1 && len0 < alen)
alen = len0;
if (slen < 0) {
switch (errno) {
case EAGAIN:
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
rb_readwrite_sys_fail(RB_IO_WAIT_READABLE, "recvfrom(2) would block");
}
rb_sys_fail("recvfrom(2)");
}
if (slen < RSTRING_LEN(str)) {
rb_str_set_len(str, slen);
}
rb_obj_taint(str);
switch (from) {
case RECV_RECV:
return str;
case RECV_IP:
if (alen && alen != sizeof(buf)) /* connection-oriented socket may not return a from result */
addr = rsock_ipaddr(&buf.addr, alen, fptr->mode & FMODE_NOREVLOOKUP);
break;
case RECV_SOCKET:
addr = rsock_io_socket_addrinfo(sock, &buf.addr, alen);
break;
default:
rb_bug("rsock_s_recvfrom_nonblock called with bad value");
}
return rb_assoc_new(str, addr);
}
/**
* filter_html
**/
static VALUE
t_filter_html(VALUE self, VALUE str)
{
node root, now, ret;
bool in_tag;
char *text;
const char* inner_tag;
long i, head_i, tail_i, copy_head_i, total_len;
VALUE change_str, url_base, word;
rb_encoding *enc;
change_str = rb_str_new2(EMPTY_STRING);
enc = rb_enc_get(str);
text = StringValuePtr(str);
Data_Get_Struct(self, struct _node, root);
url_base = rb_iv_get(self, LINK_URL_VARIABLE);
if (url_base == Qnil) {
url_base = rb_str_new2(DEAULT_LINK_URL);
}
now = root;
total_len = strlen(text);
head_i = -1;
tail_i = -1;
copy_head_i = 0;
in_tag = false;
inner_tag = NULL;
for(i = 0; i <= total_len; i++) {
if (!in_tag && text[i] == BEGIN_TAG) {
in_tag = true;
if (strncasecmp(&text[i + 1], A_TAG, strlen(A_TAG)) == 0) {
inner_tag = A_TAG;
} else if (strncasecmp(&text[i + 1], SCRIPT_TAG, strlen(SCRIPT_TAG)) == 0) {
inner_tag = SCRIPT_TAG;
} else if (strncasecmp(&text[i + 1], PRE_TAG, strlen(PRE_TAG)) == 0) {
inner_tag = PRE_TAG;
} else if (strncasecmp(&text[i + 1], IFRAME_TAG, strlen(IFRAME_TAG)) == 0) {
inner_tag = IFRAME_TAG;
} else if (strncasecmp(&text[i + 1], OBJECT_TAG, strlen(OBJECT_TAG)) == 0) {
inner_tag = OBJECT_TAG;
}
continue;
}
if (in_tag && !inner_tag && text[i] == END_TAG) {
in_tag = false;
continue;
}
if (inner_tag && text[i] == BEGIN_TAG) {
if (strncasecmp(&text[i + 2], inner_tag, strlen(inner_tag)) == 0) {
inner_tag = NULL;
continue;
}
}
if (in_tag) {
continue;
}
ret = search_child(now, text[i]);
if (ret && i != total_len) {
if (head_i == -1) {
head_i = i;
}
if (ret->end_flag) {
tail_i = i;
}
now = ret;
} else {
if (head_i != -1) {
if (tail_i != -1) {
if (copy_head_i < head_i) {
rb_funcall(
change_str,
rb_intern("concat"),
1,
add_encode(rb_str_new(&text[copy_head_i], (head_i - copy_head_i)), enc)
);
}
word = rb_str_new(&text[head_i], (tail_i - head_i + 1));
rb_funcall(
change_str,
rb_intern("concat"),
1,
add_encode(rb_funcall(url_base, rb_intern("%"), 1, rb_assoc_new(word, word)), enc)
);
i = tail_i;
copy_head_i = tail_i + 1;
tail_i = -1;
} else {
i = head_i;
}
head_i = -1;
}
now = root;
}
}
if (copy_head_i == 0) {
return str;
} else {
rb_funcall(
change_str,
rb_intern("concat"),
1,
add_encode(rb_str_new(&text[copy_head_i], (total_len - copy_head_i)), enc)
);
return change_str;
}
}