static void
require_libraries(VALUE *req_list)
{
VALUE list = *req_list;
ID require;
rb_thread_t *th = GET_THREAD();
rb_block_t *prev_base_block = th->base_block;
int prev_parse_in_eval = th->parse_in_eval;
th->base_block = 0;
th->parse_in_eval = 0;
Init_ext(); /* should be called here for some reason :-( */
CONST_ID(require, "require");
while (list && RARRAY_LEN(list) > 0) {
VALUE feature = rb_ary_shift(list);
rb_funcall2(rb_vm_top_self(), require, 1, &feature);
}
*req_list = 0;
th->parse_in_eval = prev_parse_in_eval;
th->base_block = prev_base_block;
}
static VALUE
syserr_eqq(VALUE self, VALUE exc)
{
VALUE num, e;
ID en;
CONST_ID(en, "errno");
if (!rb_obj_is_kind_of(exc, rb_eSystemCallError)) {
if (!rb_respond_to(exc, en)) return Qfalse;
}
else if (self == rb_eSystemCallError) return Qtrue;
num = rb_attr_get(exc, rb_intern("errno"));
if (NIL_P(num)) {
num = rb_funcall(exc, en, 0, 0);
}
e = rb_const_get(self, rb_intern("Errno"));
if (FIXNUM_P(num) ? num == e : rb_equal(num, e))
return Qtrue;
return Qfalse;
}
VALUE rho_ruby_getProcBinding(VALUE proc)
{
static ID binding_mid;
CONST_ID(binding_mid, "binding");
return rb_funcall(proc, binding_mid, 0);
}
grn_obj *
rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
grn_obj *bulk,
grn_id type_id, grn_obj *type)
{
const char *string;
unsigned int size;
union {
int8_t int8_value;
uint8_t uint8_value;
int16_t int16_value;
uint16_t uint16_value;
int32_t int32_value;
uint32_t uint32_value;
int64_t int64_value;
uint64_t uint64_value;
int64_t time_value;
double double_value;
grn_geo_point geo_point_value;
grn_id record_id;
} value;
grn_id range;
VALUE rb_type_object;
grn_obj_flags flags = 0;
grn_bool string_p, table_type_p;
string_p = rb_type(object) == T_STRING;
table_type_p = (GRN_TABLE_HASH_KEY <= type->header.type &&
type->header.type <= GRN_TABLE_NO_KEY);
switch (type_id) {
case GRN_DB_INT8:
value.int8_value = NUM2SHORT(object);
string = (const char *)&(value.int8_value);
size = sizeof(value.int8_value);
break;
case GRN_DB_UINT8:
value.uint8_value = NUM2USHORT(object);
string = (const char *)&(value.uint8_value);
size = sizeof(value.uint8_value);
break;
case GRN_DB_INT16:
value.int16_value = NUM2SHORT(object);
string = (const char *)&(value.int16_value);
size = sizeof(value.int16_value);
break;
case GRN_DB_UINT16:
value.uint16_value = NUM2USHORT(object);
string = (const char *)&(value.uint16_value);
size = sizeof(value.uint16_value);
break;
case GRN_DB_INT32:
value.int32_value = NUM2INT(object);
string = (const char *)&(value.int32_value);
size = sizeof(value.int32_value);
break;
case GRN_DB_UINT32:
value.uint32_value = NUM2UINT(object);
string = (const char *)&(value.uint32_value);
size = sizeof(value.uint32_value);
break;
case GRN_DB_INT64:
value.int64_value = NUM2LL(object);
string = (const char *)&(value.int64_value);
size = sizeof(value.int64_value);
break;
case GRN_DB_UINT64:
value.uint64_value = NUM2ULL(object);
string = (const char *)&(value.uint64_value);
size = sizeof(value.uint64_value);
break;
case GRN_DB_FLOAT:
value.double_value = NUM2DBL(object);
string = (const char *)&(value.double_value);
size = sizeof(value.double_value);
break;
case GRN_DB_TIME: {
VALUE rb_sec, rb_usec;
int64_t sec;
int32_t usec;
if (string_p) {
ID id_parse;
CONST_ID(id_parse, "parse");
object = rb_funcall(rb_cTime, id_parse, 1, object);
}
switch (TYPE(object)) {
case T_FIXNUM:
case T_BIGNUM:
sec = NUM2LL(object);
usec = 0;
break;
case T_FLOAT:
rb_sec = rb_funcall(object, rb_intern("to_i"), 0);
rb_usec = rb_funcall(object, rb_intern("remainder"), 1,
INT2NUM(1));
sec = NUM2LL(rb_sec);
usec = (int32_t)(NUM2DBL(rb_usec) * 1000000);
break;
case T_NIL:
sec = 0;
usec = 0;
break;
default:
sec = NUM2LL(rb_funcall(object, rb_intern("to_i"), 0));
usec = NUM2INT(rb_funcall(object, rb_intern("usec"), 0));
break;
}
value.time_value = GRN_TIME_PACK(sec, usec);
string = (const char *)&(value.time_value);
size = sizeof(value.time_value);
break;
}
case GRN_DB_SHORT_TEXT:
case GRN_DB_TEXT:
case GRN_DB_LONG_TEXT:
string = StringValuePtr(object);
size = RSTRING_LEN(object);
range = grn_obj_get_range(context, type);
if (size > range)
rb_raise(rb_eArgError,
"string is too large: expected: %u <= %u",
size, range);
flags |= GRN_OBJ_DO_SHALLOW_COPY;
break;
case GRN_DB_TOKYO_GEO_POINT:
case GRN_DB_WGS84_GEO_POINT: {
VALUE rb_geo_point;
VALUE rb_latitude, rb_longitude;
if (type_id == GRN_DB_TOKYO_GEO_POINT) {
rb_geo_point = rb_funcall(rb_cGrnTokyoGeoPoint,
rb_intern("new"), 1, object);
} else {
rb_geo_point = rb_funcall(rb_cGrnWGS84GeoPoint,
rb_intern("new"), 1, object);
}
rb_geo_point = rb_funcall(rb_geo_point, rb_intern("to_msec"), 0);
rb_latitude = rb_funcall(rb_geo_point, rb_intern("latitude"), 0);
rb_longitude = rb_funcall(rb_geo_point, rb_intern("longitude"), 0);
value.geo_point_value.latitude = NUM2INT(rb_latitude);
value.geo_point_value.longitude = NUM2INT(rb_longitude);
string = (const char *)&(value.geo_point_value);
size = sizeof(value.geo_point_value);
break;
}
case GRN_DB_VOID:
case GRN_DB_DELIMIT:
case GRN_DB_UNIGRAM:
case GRN_DB_BIGRAM:
case GRN_DB_TRIGRAM:
case GRN_DB_MECAB:
rb_type_object = GRNOBJECT2RVAL(Qnil, context, type, GRN_FALSE);
rb_raise(rb_eArgError,
"unbulkable type: %s",
rb_grn_inspect(rb_type_object));
break;
default:
if (table_type_p &&
(NIL_P(object) || (string_p && RSTRING_LEN(object) == 0))) {
value.record_id = GRN_ID_NIL;
string = (const char *)&(value.record_id);
size = sizeof(value.record_id);
if (bulk && bulk->header.domain != type_id) {
grn_obj_reinit(context, bulk, type_id, 0);
}
} else {
return RVAL2GRNBULK(object, context, bulk);
}
break;
}
if (!bulk) {
bulk = grn_obj_open(context, GRN_BULK, flags, GRN_ID_NIL);
rb_grn_context_check(context, object);
}
GRN_TEXT_SET(context, bulk, string, size);
return bulk;
}
ID
rb_id_encoding(void)
{
CONST_ID(id_encoding, "encoding");
return id_encoding;
}
/*RHO static*/ VALUE
eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char *file, int line)
{
int state;
VALUE result = Qundef;
VALUE envval;
rb_binding_t *bind = 0;
rb_thread_t *th = GET_THREAD();
rb_env_t *env = NULL;
rb_block_t block;
volatile int parse_in_eval;
volatile int mild_compile_error;
if (file == 0) {
file = rb_sourcefile();
line = rb_sourceline();
}
parse_in_eval = th->parse_in_eval;
mild_compile_error = th->mild_compile_error;
PUSH_TAG();
if ((state = EXEC_TAG()) == 0) {
rb_iseq_t *iseq;
volatile VALUE iseqval;
if (scope != Qnil) {
if (rb_obj_is_kind_of(scope, rb_cBinding)) {
GetBindingPtr(scope, bind);
envval = bind->env;
}
else {
rb_raise(rb_eTypeError,
"wrong argument type %s (expected Binding)",
rb_obj_classname(scope));
}
GetEnvPtr(envval, env);
th->base_block = &env->block;
}
else {
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
if (cfp != 0) {
block = *RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
th->base_block = █
th->base_block->self = self;
th->base_block->iseq = cfp->iseq; /* TODO */
}
else {
rb_raise(rb_eRuntimeError, "Can't eval on top of Fiber or Thread");
}
}
//RHO
if ( TYPE(src) != T_STRING ){
iseqval = src;
}else
//RHO
{
/* make eval iseq */
th->parse_in_eval++;
th->mild_compile_error++;
iseqval = rb_iseq_compile(src, rb_str_new2(file), INT2FIX(line));
th->mild_compile_error--;
th->parse_in_eval--;
}
vm_set_eval_stack(th, iseqval, cref);
th->base_block = 0;
if (0) { /* for debug */
printf("%s\n", RSTRING_PTR(rb_iseq_disasm(iseqval)));
}
/* save new env */
GetISeqPtr(iseqval, iseq);
if (bind && iseq->local_size > 0) {
bind->env = rb_vm_make_env_object(th, th->cfp);
}
/* kick */
CHECK_STACK_OVERFLOW(th->cfp, iseq->stack_max);
result = vm_exec(th);
}
POP_TAG();
th->mild_compile_error = mild_compile_error;
th->parse_in_eval = parse_in_eval;
if (state) {
if (state == TAG_RAISE) {
VALUE errinfo = th->errinfo;
if (strcmp(file, "(eval)") == 0) {
VALUE mesg, errat, bt2;
extern VALUE rb_get_backtrace(VALUE info);
ID id_mesg;
CONST_ID(id_mesg, "mesg");
errat = rb_get_backtrace(errinfo);
mesg = rb_attr_get(errinfo, id_mesg);
if (!NIL_P(errat) && TYPE(errat) == T_ARRAY &&
(bt2 = vm_backtrace(th, -2), RARRAY_LEN(bt2) > 0)) {
if (!NIL_P(mesg) && TYPE(mesg) == T_STRING && !RSTRING_LEN(mesg)) {
if (OBJ_FROZEN(mesg)) {
VALUE m = rb_str_cat(rb_str_dup(RARRAY_PTR(errat)[0]), ": ", 2);
rb_ivar_set(errinfo, id_mesg, rb_str_append(m, mesg));
}
else {
rb_str_update(mesg, 0, 0, rb_str_new2(": "));
rb_str_update(mesg, 0, 0, RARRAY_PTR(errat)[0]);
}
}
RARRAY_PTR(errat)[0] = RARRAY_PTR(bt2)[0];
}
}
rb_exc_raise(errinfo);
}
JUMP_TAG(state);
}
return result;
}
static NODE *
build_Range_each_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
VALUE param_vars, VALUE local_vars, ID mid)
{
/* Special Block for Range#each
{|e, _last|
_e = e
while _e < _last
e = _e
next_point:
BODY
redo_point:
_e = _e.succ
end
}
{|e, _last|
while e < _last
BODY
redo_point:
e = e.succ
end
}
*/
ID _last;
CONST_ID(_last, "#_last");
if (iseq->argc == 0) {
ID e;
CONST_ID(e, "#e");
rb_ary_push(param_vars, ID2SYM(e));
rb_ary_push(param_vars, ID2SYM(_last));
iseq->argc += 2;
node =
NEW_WHILE(NEW_CALL(NEW_DVAR(e), mid, new_ary(NEW_DVAR(_last), 0)),
new_block(NEW_OPTBLOCK(node),
NEW_DASGN(e,
NEW_CALL(NEW_DVAR(e), idSucc, 0))),
Qundef);
}
else {
ID _e;
ID e = SYM2ID(rb_ary_entry(param_vars, 0));
NODE *assign;
CONST_ID(_e, "#_e");
rb_ary_push(param_vars, ID2SYM(_last));
rb_ary_push(local_vars, ID2SYM(_e));
iseq->argc++;
if (nd_type(lnode) == NODE_DASGN_CURR) {
assign = NEW_DASGN(e, NEW_DVAR(_e));
}
else {
assign = new_assign(lnode, NEW_DVAR(_e));
}
node =
new_block(NEW_DASGN(_e, NEW_DVAR(e)),
NEW_WHILE(NEW_CALL
(NEW_DVAR(_e), mid,
new_ary(NEW_DVAR(_last), 0)),
new_block(assign,
new_block(NEW_OPTBLOCK(node),
NEW_DASGN(_e,
NEW_CALL
(NEW_DVAR(_e),
idSucc, 0)))),
Qundef));
}
return node;
}
static void
ffi_closure_callback(G_GNUC_UNUSED ffi_cif *cif,
void *result,
void **raw_args,
void *data)
{
RBGICallback *callback = data;
RBGICallbackData *callback_data = NULL;
GArray *in_args;
GArray *out_args;
GPtrArray *args_metadata;
VALUE rb_results;
arguments_init(&in_args, &out_args, &args_metadata);
allocate_arguments(callback->callback_info,
in_args,
out_args,
args_metadata);
fill_metadata(args_metadata, callback->callback_info);
arguments_from_raw_data(callback->callback_info,
raw_args,
in_args,
out_args,
args_metadata);
{
guint i;
for (i = 0; i < args_metadata->len; i++) {
RBGIArgMetadata *metadata;
metadata = g_ptr_array_index(args_metadata, i);
if (!metadata->closure_p) {
continue;
}
callback_data = *((RBGICallbackData **)(raw_args[i]));
break;
}
}
{
ID id_call;
GArray *rb_args;
rb_args = g_array_new(FALSE, FALSE, sizeof(VALUE));
in_arguments_to_ruby(in_args,
out_args,
args_metadata,
rb_args);
CONST_ID(id_call, "call");
/* TODO: use rb_protect() */
rb_results = rb_funcallv(callback_data->rb_callback,
id_call,
rb_args->len,
(VALUE *)(rb_args->data));
g_array_free(rb_args, TRUE);
}
out_arguments_to_raw_data(callback->callback_info,
rb_results,
result,
out_args,
args_metadata);
if (callback_data->metadata->scope_type == GI_SCOPE_TYPE_ASYNC) {
rb_gi_callback_data_free(callback_data);
}
}
void RhoRubyStart()
{
const char* szRoot = rho_native_rhopath();
//VALUE moduleRhom;
#ifdef HAVE_LOCALE_H
setlocale(LC_CTYPE, "");
#endif
{
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 1;
#endif
RUBY_INIT_STACK;
ruby_init();
#if defined(WIN32)
rb_w32_sysinit(NULL,NULL);
#endif
#if defined(DEBUG)
//enable_gc_profile();
#endif
//rb_funcall(rb_mGC, rb_intern("stress="), 1, Qtrue);
ruby_init_loadpath(szRoot);
#ifdef RHODES_EMULATOR
{
VALUE load_path = GET_VM()->load_path;
char* app_path = malloc(strlen(szRoot)+100);
rb_ary_clear(load_path);
strcpy(app_path, szRoot);
strcat(app_path, "app");
rb_ary_push(load_path, rb_str_new2(app_path) );
strcpy(app_path, rho_simconf_getRhodesPath());
strcat(app_path, "/lib/framework");
rb_ary_push(load_path, rb_str_new2(app_path) );
}
#endif
Init_strscan();
Init_sqlite3_api();
Init_GeoLocation();
Init_SyncEngine();
Init_AsyncHttp();
Init_System();
Init_Phonebook();
Init_WebView();
Init_RhoConf();
Init_Alert();
Init_SignatureCapture();
Init_RhoBluetooth();
Init_RhodesNativeViewManager();
Init_Camera();
Init_stringio();
Init_DateTimePicker();
Init_NativeBar();
Init_RhoSupport();
Init_MapView();
Init_RingtoneManager();
Init_socket();
Init_NavBar();
Init_RhoEvent();
Init_Calendar();
//TODO: RhoSimulator - load extensions dll dynamically
#if !defined(RHODES_EMULATOR) && !defined(RHO_SYMBIAN)
Init_Extensions();
#endif //RHODES_EMULATOR
#ifdef ENABLE_RUBY_VM_STAT
struct timeval start;
struct timeval end;
gettimeofday (&start, NULL);
#endif
#ifdef RHODES_EMULATOR
rb_const_set(rb_cObject, rb_intern("RHODES_EMULATOR"), Qtrue);
require_compiled(rb_str_new2("rhoframework"), &framework );
framework = rb_const_get(rb_cObject,rb_intern("RHO_FRAMEWORK"));
#else
{
VALUE res = rho_ruby_disable_gc();
require_compiled(rb_str_new2("rhoframework"), &framework );
rho_ruby_enable_gc(res);
}
#endif //RHODES_EMULATOR
if ( framework == 0 || framework == Qnil )
{
RAWLOG_FATAL("RHO framework creating failed. Application will exit.");
}
#ifdef ENABLE_RUBY_VM_STAT
gettimeofday (&end, NULL);
if ( end.tv_sec > 0 )
g_require_compiled_msec += (end.tv_sec - start.tv_sec) * 1000;
else
g_require_compiled_msec += (end.tv_usec - start.tv_usec)/1000;
#endif
rb_gc_register_mark_object(framework);
CONST_ID(framework_mid, "serve");
CONST_ID(framework_mid2, "serve_index");
CONST_ID(initApp_mid, "init_app");
CONST_ID(onConfigConflicts_mid, "on_config_conflicts");
CONST_ID(activateApp_mid, "activate_app");
CONST_ID(deactivateApp_mid, "deactivate_app");
CONST_ID(uiCreated_mid, "ui_created");
CONST_ID(uiDestroyed_mid, "ui_destroyed");
CONST_ID(loadServerSources_mid,"load_server_sources");
CONST_ID(loadAllSyncSources_mid,"load_all_sync_sources");
CONST_ID(resetDBOnSyncUserChanged_mid, "reset_db_on_sync_user_changed");
//moduleRhom = rb_const_get(rb_cObject, rb_intern("Rhom"));
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 0;
#endif
}
}
static VALUE rd_attr_loc_list(VALUE self)
{
rd_attr_t *attr = GetAttr(self);
Dwarf_Error err;
Dwarf_Loc_Head_c loc_head;
Dwarf_Unsigned count;
VALUE lhead;
Dwarf_Unsigned idx;
chkerr1(dwarf_get_loclist_c(attr->attr, &loc_head, &count, &err), &err, self);
lhead = rb_ary_new_capa(count);
for (idx = 0; idx < count; idx++) {
Dwarf_Small lle;
Dwarf_Addr lowpc;
Dwarf_Addr hipc;
Dwarf_Unsigned loclist_count;
Dwarf_Locdesc_c locentry;
Dwarf_Small source;
Dwarf_Unsigned expression_offset;
Dwarf_Unsigned locdesc_offset;
ID id_lle;
ID id_lowpc;
ID id_hipc;
ID id_source;
ID id_expression_offset;
ID id_locdesc_offset;
VALUE llist;
int idx2;
CONST_ID(id_lle, "@lle");
CONST_ID(id_lowpc, "@lowpc");
CONST_ID(id_hipc, "@hipc");
CONST_ID(id_source, "@source");
CONST_ID(id_expression_offset, "@expression_offset");
CONST_ID(id_locdesc_offset, "@locdesc_offset");
chkerr1(dwarf_get_locdesc_entry_c(loc_head, idx, &lle, &lowpc, &hipc,
&loclist_count, &locentry, &source,
&expression_offset, &locdesc_offset, &err),
&err, self);
llist = rb_class_new_instance(0, NULL, rd_cLocList);
rb_ivar_set(llist, id_lle, rb_hash_aref(rdwarf_lle2name, INT2FIX(lle)));
rb_ivar_set(llist, id_lowpc, ULL2NUM(lowpc));
rb_ivar_set(llist, id_hipc, ULL2NUM(hipc));
rb_ivar_set(llist, id_source, INT2FIX(source));
rb_ivar_set(llist, id_expression_offset, ULL2NUM(expression_offset));
rb_ivar_set(llist, id_locdesc_offset, ULL2NUM(locdesc_offset));
for (idx2 = 0; idx2 < loclist_count; idx2++) {
Dwarf_Small atom;
Dwarf_Unsigned operand1;
Dwarf_Unsigned operand2;
Dwarf_Unsigned operand3;
Dwarf_Unsigned offset_for_branch;
ID id_atom;
ID id_operand1;
ID id_operand2;
ID id_operand3;
ID id_offset_for_branch;
VALUE ldesc;
CONST_ID(id_atom, "@atom");
CONST_ID(id_operand1, "@operand1");
CONST_ID(id_operand2, "@operand2");
CONST_ID(id_operand3, "@operand3");
CONST_ID(id_offset_for_branch, "@offset_for_branch");
chkerr1(dwarf_get_location_op_value_c(locentry, idx2, &atom, &operand1, &operand2, &operand3, &offset_for_branch, &err),
&err, self);
ldesc = rb_class_new_instance(0, NULL, rd_cLocDesc);
rb_ivar_set(ldesc, id_atom, rb_hash_aref(rdwarf_op2name, INT2FIX(atom)));
rb_ivar_set(ldesc, id_operand1, ULL2NUM(operand1));
rb_ivar_set(ldesc, id_operand2, ULL2NUM(operand2));
rb_ivar_set(ldesc, id_operand3, ULL2NUM(operand3));
rb_ivar_set(ldesc, id_offset_for_branch, ULL2NUM(offset_for_branch));
rb_ary_store(llist, idx2, ldesc);
}
rb_ary_store(lhead, idx, llist);
}
dwarf_loc_head_c_dealloc(loc_head);
return lhead;
}
int fortitude_append_key_and_value(VALUE key, VALUE value, VALUE key_and_value_data_param) {
struct fortitude_append_key_and_value_data * key_and_value_data = (struct fortitude_append_key_and_value_data *)key_and_value_data_param;
VALUE prefix = key_and_value_data->prefix;
VALUE rb_output = key_and_value_data->rb_output;
VALUE allows_bare_attributes = key_and_value_data->allows_bare_attributes;
VALUE new_prefix_as_string;
ID dup;
ID to_s;
switch(TYPE(value)) {
case T_HASH:
#ifdef CONST_ID
CONST_ID(dup, "dup");
CONST_ID(to_s, "to_s");
#else
dup = rb_intern("dup");
to_s = rb_intern("to_s");
#endif
switch (TYPE(prefix)) {
case T_STRING:
new_prefix_as_string = rb_funcall(prefix, dup, 0);
fortitude_append_to(key, new_prefix_as_string, 0);
break;
case T_NIL:
new_prefix_as_string = rb_str_new("", 0);
fortitude_append_to(key, new_prefix_as_string, 0);
break;
default:
rb_raise(rb_eArgError, "You can only use a String as a prefix (this is a native (C) method)");
break;
}
rb_str_cat2(new_prefix_as_string, "-");
method_append_as_attributes(value, rb_output, new_prefix_as_string, allows_bare_attributes);
break;
case T_NIL:
case T_FALSE:
break;
case T_TRUE:
rb_str_cat2(rb_output, " ");
switch (TYPE(prefix)) {
case T_STRING:
rb_str_append(rb_output, prefix);
break;
case T_NIL:
break;
default:
rb_raise(rb_eArgError, "You can only use a String as a prefix (this is a native (C) method)");
break;
}
fortitude_append_to(key, rb_output, 0);
if (TYPE(allows_bare_attributes) == T_TRUE) {
/* ok */
} else {
rb_str_cat2(rb_output, "=\"");
fortitude_append_to(key, rb_output, 1);
rb_str_cat2(rb_output, "\"");
}
break;
default:
rb_str_cat2(rb_output, " ");
switch (TYPE(prefix)) {
case T_STRING:
rb_str_append(rb_output, prefix);
break;
case T_NIL:
break;
default:
rb_raise(rb_eArgError, "You can only use a String as a prefix (this is a native (C) method)");
break;
}
fortitude_append_to(key, rb_output, 0);
rb_str_cat2(rb_output, "=\"");
fortitude_append_to(value, rb_output, 1);
rb_str_cat2(rb_output, "\"");
break;
}
return 0;
}
void RhoRubyStart()
{
#ifdef HAVE_LOCALE_H
setlocale(LC_CTYPE, "");
#endif
{
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 1;
#endif
RUBY_INIT_STACK;
ruby_init();
#if defined(WIN32)
rb_w32_sysinit(NULL,NULL);
#endif
#if defined(DEBUG)
//enable_gc_profile();
#endif
//rb_funcall(rb_mGC, rb_intern("stress="), 1, Qtrue);
ruby_init_loadpath(RhoGetRootPath());
Init_strscan();
Init_sqlite3_api();
Init_GeoLocation();
Init_SyncEngine();
Init_System();
Init_Phonebook();
Init_WebView();
Init_RhoConf();
Init_Alert();
Init_Camera();
Init_stringio();
Init_RhoSupport();
#ifdef ENABLE_RUBY_VM_STAT
struct timeval start;
struct timeval end;
gettimeofday (&start, NULL);
#endif
require_compiled(rb_str_new2("rhoframework"), &framework );
#ifdef ENABLE_RUBY_VM_STAT
gettimeofday (&end, NULL);
if ( end.tv_sec > 0 )
g_require_compiled_msec += (end.tv_sec - start.tv_sec) * 1000;
else
g_require_compiled_msec += (end.tv_usec - start.tv_usec)/1000;
#endif
rb_gc_register_mark_object(framework);
CONST_ID(framework_mid, "serve");
CONST_ID(framework_mid2, "serve_index");
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 0;
#endif
}
}
void RhoRubyStart()
{
//VALUE moduleRhom;
#ifdef HAVE_LOCALE_H
setlocale(LC_CTYPE, "");
#endif
{
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 1;
#endif
RUBY_INIT_STACK;
ruby_init();
#if defined(WIN32)
rb_w32_sysinit(NULL,NULL);
#endif
#if defined(DEBUG)
//enable_gc_profile();
#endif
//rb_funcall(rb_mGC, rb_intern("stress="), 1, Qtrue);
ruby_init_loadpath(rho_native_rhopath());
Init_strscan();
Init_sqlite3_api();
Init_GeoLocation();
Init_SyncEngine();
Init_AsyncHttp();
Init_System();
Init_Phonebook();
Init_WebView();
Init_RhoConf();
Init_Alert();
Init_SignatureTool();
Init_Camera();
Init_stringio();
Init_DateTimePicker();
Init_NativeBar();
Init_RhoSupport();
Init_MapView();
Init_RingtoneManager();
Init_socket();
Init_NavBar();
Init_Extensions();
#ifdef ENABLE_RUBY_VM_STAT
struct timeval start;
struct timeval end;
gettimeofday (&start, NULL);
#endif
require_compiled(rb_str_new2("rhoframework"), &framework );
#ifdef ENABLE_RUBY_VM_STAT
gettimeofday (&end, NULL);
if ( end.tv_sec > 0 )
g_require_compiled_msec += (end.tv_sec - start.tv_sec) * 1000;
else
g_require_compiled_msec += (end.tv_usec - start.tv_usec)/1000;
#endif
rb_gc_register_mark_object(framework);
CONST_ID(framework_mid, "serve");
CONST_ID(framework_mid2, "serve_index");
CONST_ID(initApp_mid, "init_app");
CONST_ID(activateApp_mid, "activate_app");
CONST_ID(deactivateApp_mid, "deactivate_app");
CONST_ID(loadServerSources_mid,"load_server_sources");
//moduleRhom = rb_const_get(rb_cObject, rb_intern("Rhom"));
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 0;
#endif
}
}
void ruby_backtrace_each(sanspleur_backtrace_iter_func* iterator, void* arg)
{
rb_thread_t* ruby_current_thread = (rb_thread_t*)(DATA_PTR(rb_thread_current()));
rb_control_frame_t *cfp = ruby_current_thread->cfp;
const rb_control_frame_t *cfp_limit = (rb_control_frame_t*)(ruby_current_thread->stack + ruby_current_thread->stack_size);
cfp_limit -= 2;
while (cfp < cfp_limit) {
const char* class_name = NULL;
ID function_id = 0;
VALUE klass = 0;
const char* file_name = NULL;
int line_number = -1;
int no_pos = -1;
rb_iseq_t *iseq = cfp->iseq;
if (!iseq && cfp->me) {
function_id = cfp->me->def->original_id;
klass = cfp->me->klass;
no_pos = 1;
}
while (iseq) {
if (RUBY_VM_IFUNC_P(iseq)) {
CONST_ID(function_id, "<ifunc>");
klass = 0;
break;
}
klass = iseq->klass;
if (iseq->defined_method_id) {
function_id = iseq->defined_method_id;
break;
}
if (iseq->local_iseq == iseq) {
break;
}
iseq = iseq->parent_iseq;
}
if (iseq != 0 && cfp->pc != 0) {
file_name = ISEQ_FILENAME(iseq);
}
const char* function_name = NULL;
if (function_id) function_name = rb_id2name(function_id);
if (cfp->self) {
if (TYPE(cfp->self) == RUBY_T_CLASS || TYPE(cfp->self) == RUBY_T_ICLASS) {
class_name = rb_class2name(cfp->self);
} else if (TYPE(cfp->self) == RUBY_T_MODULE) {
VALUE str = rb_obj_as_string(cfp->self);
char* object_description = RSTRING_PTR(str);
class_name = object_description;
}
}
if (klass && !class_name) {
class_name = rb_class2name(klass);
}
if (no_pos < 0) {
line_number = CFP_LINENO(cfp);
}
ID class_id = 0;
if (VM_FRAME_TYPE(cfp) != 0x51) {
iterator(arg, file_name, line_number, function_name, function_id, class_name, class_id);
}
cfp++;
}
}
static NODE *
build_Array_each_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
VALUE param_vars, VALUE local_vars)
{
/* Special block for Array#each
ary.each{|e|
BODY
}
=>
{|e, _self|
_i = 0
while _i < _self.length
e = _self[_i]
redo_point:
BODY
next_point:
_i = _i.succ
end
}
ary.each{
BODY
}
=>
{|_i, _self|
_i = 0
while _i < _self.length
redo_point:
BODY
next_point:
_i = _i.succ
end
}
*/
ID _self, _i;
CONST_ID(_self, "#_self");
CONST_ID(_i, "#_i");
if (iseq->argc == 0) {
ID _e;
CONST_ID(_e, "#_e");
rb_ary_push(param_vars, ID2SYM(_e));
rb_ary_push(param_vars, ID2SYM(_self));
iseq->argc += 2;
rb_ary_push(local_vars, ID2SYM(_i));
node =
new_block(NEW_DASGN(_i, NEW_LIT(INT2FIX(0))),
NEW_WHILE(NEW_CALL(NEW_DVAR(_i), idLT,
new_ary(NEW_CALL
(NEW_DVAR(_self), idLength,
0), 0)),
new_block(NEW_OPTBLOCK(node),
NEW_DASGN(_i,
NEW_CALL(NEW_DVAR(_i),
idSucc, 0))),
Qundef));
}
else {
ID e = SYM2ID(rb_ary_entry(param_vars, 0));
NODE *assign;
rb_ary_push(param_vars, ID2SYM(_self));
iseq->argc++;
rb_ary_push(local_vars, ID2SYM(_i));
if (nd_type(lnode) == NODE_DASGN_CURR) {
assign = NEW_DASGN(e,
NEW_CALL(NEW_DVAR(_self), idAREF,
new_ary(NEW_DVAR(_i), 0)));
}
else {
assign = new_assign(lnode,
NEW_CALL(NEW_DVAR(_self), idAREF,
new_ary(NEW_DVAR(_i), 0)));
}
node =
new_block(NEW_DASGN(_i, NEW_LIT(INT2FIX(0))),
NEW_WHILE(NEW_CALL(NEW_DVAR(_i), idLT,
new_ary(NEW_CALL
(NEW_DVAR(_self), idLength,
0), 0)), new_block(assign,
new_block
(NEW_OPTBLOCK
(node),
NEW_DASGN
(_i,
NEW_CALL
(NEW_DVAR
(_i),
idSucc,
0)))),
Qundef));
}
return node;
}
void RhoRubyStart()
{
const char* szRoot = rho_native_rhopath();
//VALUE moduleRhom;
#ifdef HAVE_LOCALE_H
setlocale(LC_CTYPE, "");
#endif
{
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 1;
#endif
RUBY_INIT_STACK;
ruby_init();
#if defined(WIN32)
rb_w32_sysinit(NULL,NULL);
#endif
#if defined(DEBUG)
//enable_gc_profile();
#endif
//rb_funcall(rb_mGC, rb_intern("stress="), 1, Qtrue);
ruby_init_loadpath(szRoot);
#if defined(RHODES_EMULATOR) || defined(APP_BUILD_CAPABILITY_MOTOROLA) || defined(OS_WP8)
{
VALUE load_path = GET_VM()->load_path;
char* app_path = malloc(strlen(szRoot)+100);
rb_ary_clear(load_path);
strcpy(app_path, szRoot);
#if defined(RHODES_EMULATOR)
strcat(app_path, "app");
#elif defined(OS_WP8)
strcat(app_path, "/apps/app");
#else
strcat(app_path, "apps/app");
#endif
rb_ary_push(load_path, rb_str_new2(app_path) );
#if defined(APP_BUILD_CAPABILITY_MOTOROLA)
strcpy(app_path, rho_native_reruntimepath());
strcat(app_path, "lib");
#elif defined(OS_WP8)
strcpy(app_path, szRoot);
strcat(app_path, "/lib");
#else
strcpy(app_path, rho_simconf_getRhodesPath());
strcat(app_path, "/lib/framework");
#endif
rb_ary_push(load_path, rb_str_new2(app_path) );
}
#endif
//DO not use it! Keeps for backward compatibility with ruby extensions. Use Rho::System.isRhoSimulator
#ifdef RHODES_EMULATOR
rb_const_set(rb_cObject, rb_intern("RHODES_EMULATOR"), Qtrue);
#endif
#if !defined(OS_WP8)
Init_strscan(); //+
Init_GeoLocation(); //+
Init_Phonebook();
#if !defined(OS_MACOSX) && !defined( OS_WINDOWS_DESKTOP ) && !defined(OS_WINCE) && !defined(OS_ANDROID)
Init_WebView(); //+
#endif
#if !defined(RHO_NO_RUBY)
Init_RhoConf(); //+
#endif
//#if !defined(OS_WINDOWS_DESKTOP) || defined(RHODES_EMULATOR)
// Init_Alert();
//#endif
#if defined(WINDOWS_PLATFORM)
init_rhoext_Signature();
#else
//Init_SignatureCapture();
#endif
Init_RhoBluetooth();
Init_RhodesNativeViewManager();
#if !defined(OS_MACOSX)
Init_Camera();
#endif
Init_stringio(); //+
Init_DateTimePicker();
//#if !defined(WINDOWS_PLATFORM) && !defined(RHODES_EMULATOR) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
// Init_NativeBar();
//#endif
Init_RhoSupport(); //+
Init_MapView();
Init_RingtoneManager();
Init_socket(); //+
//#if !defined(WINDOWS_PLATFORM) && !defined(RHODES_EMULATOR) && !defined(OS_MACOSX)
// Init_NavBar();
//#endif
Init_RhoEvent();
Init_Calendar();
//#if !defined(OS_WINDOWS_DESKTOP) && !defined(RHODES_EMULATOR) && ! defined(OS_WINCE)
// Init_Alert();
//#endif
#if defined(OS_MACOSX)
#ifndef RHO_DISABLE_OLD_CAMERA_SIGNATURE_API
Init_Camera();
Init_SignatureCapture();
#endif
#endif
#if defined(OS_ANDROID)
#ifndef RHO_DISABLE_OLD_CAMERA_SIGNATURE_API
Init_SignatureCapture();
#endif
#endif
//TODO: RhoSimulator - load extensions dll dynamically
#if !defined(RHO_SYMBIAN)
Init_Extensions();
#endif //RHO_SYMBIAN
#else // OS_WP8 is set
Init_strscan();
Init_GeoLocation();
Init_NavBar();
Init_RhoSupport();
Init_RhoConf();
Init_Alert();
Init_socket();
Init_stringio();
Init_Extensions();
#endif //OS_WP8
extensions_loaded = 1;
if ( rho_rcclient_have_rhoconnect_client() ) {
rb_const_set(rb_cObject, rb_intern("RHOCONNECT_CLIENT_PRESENT"), Qtrue);
}
#if defined(APP_BUILD_CAPABILITY_MOTOROLA)
rb_require("rhomotoapi");
#endif //APP_BUILD_CAPABILITY_MOTOROLA
#ifdef ENABLE_RUBY_VM_STAT
struct timeval start;
struct timeval end;
gettimeofday (&start, NULL);
#endif
#ifdef RHODES_EMULATOR
require_compiled(rb_str_new2("rhoframework"), &framework );
framework = rb_const_get(rb_cObject,rb_intern("RHO_FRAMEWORK"));
#else
{
VALUE res = rho_ruby_disable_gc();
require_compiled(rb_str_new2("rhoframework"), &framework );
rho_ruby_enable_gc(res);
}
#endif //RHODES_EMULATOR
if ( framework == 0 || framework == Qnil )
{
RAWLOG_FATAL("RHO framework creating failed. Application will exit.");
}
#ifdef ENABLE_RUBY_VM_STAT
gettimeofday (&end, NULL);
if ( end.tv_sec > 0 )
g_require_compiled_msec += (end.tv_sec - start.tv_sec) * 1000;
else
g_require_compiled_msec += (end.tv_usec - start.tv_usec)/1000;
#endif
rb_gc_register_mark_object(framework);
CONST_ID(framework_mid, "serve");
CONST_ID(framework_mid2, "serve_index");
CONST_ID(initApp_mid, "init_app");
CONST_ID(onConfigConflicts_mid, "on_config_conflicts");
CONST_ID(activateApp_mid, "activate_app");
CONST_ID(deactivateApp_mid, "deactivate_app");
CONST_ID(uiCreated_mid, "ui_created");
CONST_ID(uiDestroyed_mid, "ui_destroyed");
CONST_ID(loadServerSources_mid,"load_server_sources");
CONST_ID(loadAllSyncSources_mid,"load_all_sync_sources");
CONST_ID(resetDBOnSyncUserChanged_mid, "reset_db_on_sync_user_changed");
//moduleRhom = rb_const_get(rb_cObject, rb_intern("Rhom"));
#ifdef ENABLE_RUBY_VM_STAT
g_collect_stat = 0;
#endif
}
}
void rho_ruby_callmethod(const char* szMethodPath)
{
ID rbMethodCall;
CONST_ID(rbMethodCall, szMethodPath);
rb_funcall(Qnil, rbMethodCall, 0);
}
static void
process_arguments_of_image_initialize(int const argc, VALUE* const argv,
VALUE* buffer_ptr,
rb_image_file_image_pixel_format_t* pixel_format_ptr,
long* width_ptr,
long* height_ptr,
long* stride_ptr
)
{
VALUE params;
VALUE buffer = Qnil;
VALUE pixel_format = Qnil;
VALUE width = Qnil;
VALUE height = Qnil;
VALUE stride = Qnil;
rb_image_file_image_pixel_format_t pf;
long wd, ht, st;
long min_len;
ID id_pixel_format, id_data, id_width, id_height, id_row_stride;
CONST_ID(id_data, "data");
CONST_ID(id_pixel_format, "pixel_format");
CONST_ID(id_width, "width");
CONST_ID(id_height, "height");
CONST_ID(id_row_stride, "row_stride");
rb_scan_args(argc, argv, "01", ¶ms);
if (TYPE(params) == T_HASH) {
buffer = rb_hash_lookup(params, ID2SYM(id_data));
pixel_format = rb_hash_lookup(params, ID2SYM(id_pixel_format));
width = rb_hash_lookup(params, ID2SYM(id_width));
height = rb_hash_lookup(params, ID2SYM(id_height));
stride = rb_hash_lookup(params, ID2SYM(id_row_stride));
}
if (!NIL_P(buffer)) {
Check_Type(buffer, T_STRING);
buffer = rb_str_dup(buffer);
}
if (NIL_P(pixel_format))
rb_raise(rb_eArgError, "missing image pixel format");
if (TYPE(pixel_format) == T_STRING)
pixel_format = rb_str_intern(pixel_format);
pf = check_pixel_format(pixel_format);
if (NIL_P(width))
rb_raise(rb_eArgError, "missing image width");
wd = NUM2LONG(width);
if (wd <= 0)
rb_raise(rb_eArgError, "zero or negative image width");
if (NIL_P(height))
rb_raise(rb_eArgError, "missing image height");
ht = NUM2LONG(height);
if (ht <= 0)
rb_raise(rb_eArgError, "zero or negative image height");
if (NIL_P(stride)) {
#ifdef HAVE_RB_CAIRO_H
st = cairo_format_stride_for_width(pixel_format_to_cairo_format(pf), (int)wd) / pixel_format_size(pf);
stride = INT2NUM(st);
#else
stride = width;
#endif
}
st = NUM2LONG(stride);
if (st <= 0)
rb_raise(rb_eArgError, "zero or negative image row-stride");
else if (st < wd) {
rb_warning("the given row-stride is less than the given image width.");
st = wd;
}
min_len = minimum_buffer_size(pf, st, ht);
if (NIL_P(buffer)) {
buffer = rb_str_new(NULL, min_len);
}
else if (RSTRING_LEN(buffer) < min_len) {
void rb_str_modify_expand(VALUE, long);
rb_warning("the size of the given data is too short for the given size of image");
rb_str_modify_expand(buffer, min_len - RSTRING_LEN(buffer));
}
*buffer_ptr = buffer;
*pixel_format_ptr = pf;
*width_ptr = wd;
*height_ptr = ht;
*stride_ptr = st;
}
/*
* call-seq:
* unixsocket.recv_io([klass [, mode]]) => io
*
* UNIXServer.open("/tmp/sock") {|serv|
* UNIXSocket.open("/tmp/sock") {|c|
* s = serv.accept
*
* c.send_io STDOUT
* stdout = s.recv_io
*
* p STDOUT.fileno #=> 1
* p stdout.fileno #=> 7
*
* stdout.puts "hello" # outputs "hello\n" to standard output.
* }
* }
*
*/
static VALUE
unix_recv_io(int argc, VALUE *argv, VALUE sock)
{
VALUE klass, mode;
rb_io_t *fptr;
struct iomsg_arg arg;
struct iovec vec[2];
char buf[1];
int fd;
#if FD_PASSING_BY_MSG_CONTROL
struct {
struct cmsghdr hdr;
char pad[8+sizeof(int)+8];
} cmsg;
#endif
rb_scan_args(argc, argv, "02", &klass, &mode);
if (argc == 0)
klass = rb_cIO;
if (argc <= 1)
mode = Qnil;
GetOpenFile(sock, fptr);
arg.msg.msg_name = NULL;
arg.msg.msg_namelen = 0;
vec[0].iov_base = buf;
vec[0].iov_len = sizeof(buf);
arg.msg.msg_iov = vec;
arg.msg.msg_iovlen = 1;
#if FD_PASSING_BY_MSG_CONTROL
arg.msg.msg_control = (caddr_t)&cmsg;
arg.msg.msg_controllen = (socklen_t)CMSG_SPACE(sizeof(int));
arg.msg.msg_flags = 0;
cmsg.hdr.cmsg_len = (socklen_t)CMSG_LEN(sizeof(int));
cmsg.hdr.cmsg_level = SOL_SOCKET;
cmsg.hdr.cmsg_type = SCM_RIGHTS;
fd = -1;
memcpy(CMSG_DATA(&cmsg.hdr), &fd, sizeof(int));
#else
arg.msg.msg_accrights = (caddr_t)&fd;
arg.msg.msg_accrightslen = sizeof(fd);
fd = -1;
#endif
arg.fd = fptr->fd;
while ((int)BLOCKING_REGION_FD(recvmsg_blocking, &arg) == -1) {
if (!rb_io_wait_readable(arg.fd))
rb_sys_fail("recvmsg(2)");
}
#if FD_PASSING_BY_MSG_CONTROL
if (arg.msg.msg_controllen < (socklen_t)sizeof(struct cmsghdr)) {
rb_raise(rb_eSocket,
"file descriptor was not passed (msg_controllen=%d smaller than sizeof(struct cmsghdr)=%d)",
(int)arg.msg.msg_controllen, (int)sizeof(struct cmsghdr));
}
if (cmsg.hdr.cmsg_level != SOL_SOCKET) {
rb_raise(rb_eSocket,
"file descriptor was not passed (cmsg_level=%d, %d expected)",
cmsg.hdr.cmsg_level, SOL_SOCKET);
}
if (cmsg.hdr.cmsg_type != SCM_RIGHTS) {
rb_raise(rb_eSocket,
"file descriptor was not passed (cmsg_type=%d, %d expected)",
cmsg.hdr.cmsg_type, SCM_RIGHTS);
}
if (arg.msg.msg_controllen < (socklen_t)CMSG_LEN(sizeof(int))) {
rb_raise(rb_eSocket,
"file descriptor was not passed (msg_controllen=%d smaller than CMSG_LEN(sizeof(int))=%d)",
(int)arg.msg.msg_controllen, (int)CMSG_LEN(sizeof(int)));
}
if ((socklen_t)CMSG_SPACE(sizeof(int)) < arg.msg.msg_controllen) {
rb_raise(rb_eSocket,
"file descriptor was not passed (msg_controllen=%d bigger than CMSG_SPACE(sizeof(int))=%d)",
(int)arg.msg.msg_controllen, (int)CMSG_SPACE(sizeof(int)));
}
if (cmsg.hdr.cmsg_len != CMSG_LEN(sizeof(int))) {
rsock_discard_cmsg_resource(&arg.msg, 0);
rb_raise(rb_eSocket,
"file descriptor was not passed (cmsg_len=%d, %d expected)",
(int)cmsg.hdr.cmsg_len, (int)CMSG_LEN(sizeof(int)));
}
#else
if (arg.msg.msg_accrightslen != sizeof(fd)) {
rb_raise(rb_eSocket,
"file descriptor was not passed (accrightslen) : %d != %d",
arg.msg.msg_accrightslen, (int)sizeof(fd));
}
#endif
#if FD_PASSING_BY_MSG_CONTROL
memcpy(&fd, CMSG_DATA(&cmsg.hdr), sizeof(int));
#endif
rb_update_max_fd(fd);
if (klass == Qnil)
return INT2FIX(fd);
else {
ID for_fd;
int ff_argc;
VALUE ff_argv[2];
CONST_ID(for_fd, "for_fd");
ff_argc = mode == Qnil ? 1 : 2;
ff_argv[0] = INT2FIX(fd);
ff_argv[1] = mode;
return rb_funcall2(klass, for_fd, ff_argc, ff_argv);
}
}
static NODE *
build_Integer_times_node(rb_iseq_t *iseq, NODE * node, NODE * lnode,
VALUE param_vars, VALUE local_vars)
{
/* Special Block for Integer#times
{|e, _self|
_e = e
while(e < _self)
e = _e
redo_point:
BODY
next_point:
_e = _e.succ
end
}
{|e, _self|
while(e < _self)
BODY
next_point:
e = e.succ
end
}
*/
ID _self;
CONST_ID(_self, "#_self");
if (iseq->argc == 0) {
ID e;
CONST_ID(e, "#e");
rb_ary_push(param_vars, ID2SYM(e));
rb_ary_push(param_vars, ID2SYM(_self));
iseq->argc += 2;
node =
NEW_WHILE(NEW_CALL
(NEW_DVAR(e), idLT, new_ary(NEW_DVAR(_self), 0)),
new_block(NEW_OPTBLOCK(node),
NEW_DASGN(e,
NEW_CALL(NEW_DVAR(e), idSucc, 0))),
Qundef);
}
else {
ID _e;
ID e = SYM2ID(rb_ary_entry(param_vars, 0));
NODE *assign;
CONST_ID(_e, "#_e");
rb_ary_push(param_vars, ID2SYM(_self));
rb_ary_push(local_vars, ID2SYM(_e));
iseq->argc++;
if (nd_type(lnode) == NODE_DASGN_CURR) {
assign = NEW_DASGN(e, NEW_DVAR(_e));
}
else {
assign = new_assign(lnode, NEW_DVAR(_e));
}
node =
new_block(NEW_DASGN(_e, NEW_DVAR(e)),
NEW_WHILE(NEW_CALL
(NEW_DVAR(_e), idLT,
new_ary(NEW_DVAR(_self), 0)),
new_block(assign,
new_block(NEW_OPTBLOCK(node),
NEW_DASGN(_e,
NEW_CALL
(NEW_DVAR(_e),
idSucc, 0)))),
Qundef));
}
return node;
}
