static void rbclt_container_each_callback (ClutterActor *actor, gpointer data) { rb_yield (GOBJ2RVAL (actor)); }
static VALUE each_i(VALUE v, void *arg) { rb_yield(v); return Qnil; }
static VALUE ossl_asn1_decode0(unsigned char **pp, long length, long *offset, long depth, int once, int yield) { unsigned char *start, *p; const unsigned char *p0; long len, off = *offset; int hlen, tag, tc, j, infinite = 0; VALUE ary, asn1data, value, tag_class; ary = rb_ary_new(); p = *pp; while(length > 0){ start = p; p0 = p; j = ASN1_get_object(&p0, &len, &tag, &tc, length); p = (unsigned char *)p0; if(j & 0x80) ossl_raise(eASN1Error, NULL); hlen = rb_long2int(p - start); if(yield){ VALUE arg = rb_ary_new(); rb_ary_push(arg, LONG2NUM(depth)); rb_ary_push(arg, LONG2NUM(off)); rb_ary_push(arg, LONG2NUM(hlen)); rb_ary_push(arg, LONG2NUM(len)); rb_ary_push(arg, (j & V_ASN1_CONSTRUCTED) ? Qtrue : Qfalse); rb_ary_push(arg, ossl_asn1_class2sym(tc)); rb_ary_push(arg, INT2NUM(tag)); rb_yield(arg); } length -= hlen; off += hlen; if(len > length) ossl_raise(eASN1Error, "value is too short"); if((tc & V_ASN1_PRIVATE) == V_ASN1_PRIVATE) tag_class = sPRIVATE; else if((tc & V_ASN1_CONTEXT_SPECIFIC) == V_ASN1_CONTEXT_SPECIFIC) tag_class = sCONTEXT_SPECIFIC; else if((tc & V_ASN1_APPLICATION) == V_ASN1_APPLICATION) tag_class = sAPPLICATION; else tag_class = sUNIVERSAL; if(j & V_ASN1_CONSTRUCTED){ if((j == 0x21) && (len == 0)){ long lastoff = off; infinite = 1; value = ossl_asn1_decode0(&p, length, &off, depth+1, 0, yield); len = off - lastoff; } else value = ossl_asn1_decode0(&p, len, &off, depth+1, 0, yield); } else{ if ((j & 0x01) && (len == 0)) { ossl_raise(eASN1Error, "Infinite length for primitive value"); } value = rb_str_new((const char *)p, len); p += len; off += len; } if(tag_class == sUNIVERSAL && tag < ossl_asn1_info_size && ossl_asn1_info[tag].klass){ VALUE klass = *ossl_asn1_info[tag].klass; long flag = 0; if(!rb_obj_is_kind_of(value, rb_cArray)){ int l = rb_long2int(hlen + len); switch(tag){ case V_ASN1_BOOLEAN: value = decode_bool(start, l); break; case V_ASN1_INTEGER: value = decode_int(start, l); break; case V_ASN1_BIT_STRING: value = decode_bstr(start, l, &flag); break; case V_ASN1_NULL: value = decode_null(start, l); break; case V_ASN1_ENUMERATED: value = decode_enum(start, l); break; case V_ASN1_OBJECT: value = decode_obj(start, l); break; case V_ASN1_UTCTIME: /* FALLTHROUGH */ case V_ASN1_GENERALIZEDTIME: value = decode_time(start, l); break; default: /* use original value */ break; } } if (infinite && !(tag == V_ASN1_SEQUENCE || tag == V_ASN1_SET)){ asn1data = rb_funcall(cASN1Constructive, rb_intern("new"), 4, value, INT2NUM(tag), Qnil, ID2SYM(tag_class)); } else{ if (tag == V_ASN1_EOC){ asn1data = rb_funcall(cASN1EndOfContent, rb_intern("new"), 0); } else{ asn1data = rb_funcall(klass, rb_intern("new"), 1, value); } } if(tag == V_ASN1_BIT_STRING){ rb_iv_set(asn1data, "@unused_bits", LONG2NUM(flag)); } } else{ asn1data = rb_funcall(cASN1Data, rb_intern("new"), 3, value, INT2NUM(tag), ID2SYM(tag_class)); } if (infinite) ossl_asn1_set_infinite_length(asn1data, Qtrue); else ossl_asn1_set_infinite_length(asn1data, Qfalse); rb_ary_push(ary, asn1data); length -= len; if(once) break; } *pp = p; *offset = off; return ary; }
static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) { VALUE query, reader; VALUE field_names, field_types; unsigned int field_count; unsigned int i; char guess_default_field_types = 0; VALUE connection = rb_iv_get(self, "@connection"); VALUE mysql_connection = rb_iv_get(connection, "@connection"); if (Qnil == mysql_connection) { rb_raise(eConnectionError, "This connection has already been closed."); } MYSQL *db = DATA_PTR(mysql_connection); MYSQL_RES *response = 0; MYSQL_FIELD *field; query = build_query_from_args(self, argc, argv); response = cCommand_execute(self, connection, db, query); if (!response) { return Qnil; } field_count = mysql_field_count(db); reader = rb_funcall(cReader, ID_NEW, 0); rb_iv_set(reader, "@connection", connection); rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, response)); rb_iv_set(reader, "@opened", Qfalse); rb_iv_set(reader, "@field_count", INT2NUM(field_count)); field_names = rb_ary_new(); field_types = rb_iv_get(self, "@field_types"); if ( field_types == Qnil || 0 == RARRAY_LEN(field_types) ) { field_types = rb_ary_new(); guess_default_field_types = 1; } else if (RARRAY_LEN(field_types) != field_count) { // Whoops... wrong number of types passed to set_types. Close the reader and raise // and error rb_funcall(reader, rb_intern("close"), 0); rb_raise(rb_eArgError, "Field-count mismatch. Expected %ld fields, but the query yielded %d", RARRAY_LEN(field_types), field_count); } for(i = 0; i < field_count; i++) { field = mysql_fetch_field_direct(response, i); rb_ary_push(field_names, rb_str_new2(field->name)); if (1 == guess_default_field_types) { rb_ary_push(field_types, infer_ruby_type(field)); } } rb_iv_set(reader, "@fields", field_names); rb_iv_set(reader, "@field_types", field_types); if (rb_block_given_p()) { rb_yield(reader); rb_funcall(reader, rb_intern("close"), 0); } return reader; }
static VALUE foreach(int argc, VALUE* argv, VALUE self) { char *DELIM=DEF_DELIM; char *line = NULL; char *line2 =NULL, *new_line=NULL; size_t len = 0, len2=0, i, pairs_count; char *token,*start,*nobackslash,*t2; size_t idx,count,searchfield,flag,array_length,range_i; long check; int was_read; FILE *file; ID min_method, max_method; VALUE min_val, max_val; VALUE tmp_value, rest_args, filename; ID array_length_method; /*----------------------------------------*/ struct pair_st pairs[MAX_INTERVALS]; VALUE ary; rb_scan_args(argc,argv,"1*", &filename, &rest_args); /* if (argc == 0) { // there should only be 1 or 2 arguments rb_raise(rb_eArgError, "wrong number of arguments"); } file = fopen(StringValueCStr(argv[0]), "r"); if (file == NULL) rb_raise(rb_eRuntimeError, "File not found"); */ file = fopen(StringValueCStr(filename), "r"); if(file==NULL){ rb_raise(rb_eRuntimeError, "File not found"); } if (argc >1 ) { /* delimiter */ tmp_value=rb_ary_entry(rest_args,0); DELIM=StringValueCStr(tmp_value);; } if (argc >2 ) { /* search index */ tmp_value=rb_ary_entry(rest_args,1); searchfield=NUM2INT(tmp_value); } else{ searchfield=-1; } array_length_method=rb_funcall(rest_args,rb_intern("length"), 0); array_length=NUM2INT(array_length_method); min_method = rb_intern("first"); max_method = rb_intern("last"); /*------------test_id = rb_intern("class");*/ range_i=0; for(idx=2;idx<array_length;++idx){ min_val=rb_funcall(rb_ary_entry(rest_args,idx),rb_intern("length"), 0); len2=NUM2INT(min_val); for(i=0;i<len2;++i){ VALUE e=rb_ary_entry(rb_ary_entry(rest_args,idx),i); if(range_i>MAX_INTERVALS) rb_raise(rb_eRuntimeError, "Too much ranges passed"); if(TYPE(e) == T_NIL){ pairs[range_i].low=LONG_MIN; pairs[range_i].high=LONG_MAX; continue; /* just skip nil */ } if (! (rb_respond_to(e, min_method) & rb_respond_to(e, max_method))) rb_raise(rb_eRuntimeError, "Not range passed to Ccsv.foreach"); min_val=rb_funcall(e, min_method, 0); max_val=rb_funcall(e, max_method, 0); pairs[range_i].low=NUM2LONG(min_val); pairs[range_i].high=NUM2LONG(max_val); range_i++; } } pairs_count=range_i; /* main loop lines reading */ while ((was_read=getline(&line, &len, file)) != -1) { if(was_read<1) continue; len=was_read-1; /* try to join escaped lines */ for(;;) { /* check for backslashed newline */ if(line[len]!=EOL) break; if(line[len]==CR){ len-=1; } //rb_warn("NONLAST (%c,%c)",line[len],line[len]); count=0; t2=line+len-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ /* get another line... */ line2=NULL; len2=0; if((was_read=getline(&line2, &len2, file)) != -1) { len2=was_read; if(new_line) free(new_line); //!!!! new_line=malloc(len+len2+1); strcpy(new_line,line); new_line[len-1]='\n'; strcpy(new_line+len,line2); line=new_line; //nobackslash=len+1; start=new_line; len+=len2-1; nobackslash=start; free(line); free(line2); continue; } } break; } /* chomp! */ if(line[len]==EOL){ if(line[len-1]==CR) len-=1; line[len]='\0'; } /* skip empty line */ if(len<2) continue; ary = rb_ary_new(); start=line; nobackslash=line; idx = 0; flag=1; while (nobackslash != NULL) { /* get full field */ while(token=strstr(nobackslash, DELIM)){ count=0; t2=token-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ nobackslash=token; continue; } break; } if(token) *token='\0'; else token=start+strlen(start); if(searchfield==idx){ flag=0; /* do check! */ sscanf(start,"%ld",&check); for(i=0;i<pairs_count;++i){ /*rb_warn("check %ld: [%ld .. %ld]",check,pairs[i].low,pairs[i].high);*/ if(pairs[i].low<check && pairs[i].high>check){ /*rb_warn("check passed");*/ flag=1; /* yahooo! */ break; } } } /* not in ranges! */ if(flag==0) break; rb_ary_store(ary, idx, rb_str_new(start, token-start)); idx++; nobackslash=start=token+strlen(DELIM); while(token=strstr(nobackslash, DELIM)){ count=0; t2=token-1; while((t2>=line) && (*t2=='\\')) {++count;--t2;} if(count%2 ==1){ /* backslashed! skip */ nobackslash=token+strlen(DELIM); continue; } break; } nobackslash=token; } if(flag==0) continue; /* last item */ rb_ary_store(ary, idx, rb_str_new(start, strlen(start))); /* OBJ_FREEZE(ary); */ rb_yield(ary); /* FL_UNSET((ary), FL_FREEZE); */ /* for(idx = 0; idx < RARRAY_LEN(ary); idx ++) { rb_ary_store(ary, idx, Qnil); } */ } fclose(file); free(line); return Qnil; }
static VALUE each_entry_i(VALUE elt, VALUE klass, int argc, VALUE *argv) { return rb_yield(rb_class_new_instance(1, &elt, klass)); }
/* * call-seq: * ProcTable.ps(pid=nil) * ProcTable.ps(pid=nil){ |ps| ... } * * In block form, yields a ProcTableStruct for each process entry that you * have rights to. This method returns an array of ProcTableStruct's in * non-block form. * * If a +pid+ is provided, then only a single ProcTableStruct is yielded or * returned, or nil if no process information is found for that +pid+. */ static VALUE pt_ps(int argc, VALUE* argv, VALUE klass){ int err; char state[8]; struct kinfo_proc* procs; VALUE v_pid, v_tty_num, v_tty_dev, v_start_time; VALUE v_pstruct = Qnil; VALUE v_array = rb_ary_new(); size_t length, count; size_t i = 0; int g; VALUE v_cmdline, v_exe, v_environ, v_groups; // Passed into sysctl call static const int name_mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0}; rb_scan_args(argc, argv, "01", &v_pid); // Get size of proc kproc buffer err = sysctl( (int *) name_mib, PROC_MIB_LEN, NULL, &length, NULL, 0); if(err == -1) rb_raise(cProcTableError, "sysctl: %s", strerror(errno)); // Populate the kproc buffer procs = ruby_xmalloc(length); err = sysctl( (int *) name_mib, PROC_MIB_LEN, procs, &length, NULL, 0); if(err == -1) rb_raise(cProcTableError, "sysctl: %s", strerror(errno)); // If we're here, we got our list count = length / sizeof(struct kinfo_proc); for(i = 0; i < count; i++) { v_tty_num = Qnil; v_tty_dev = Qnil; v_start_time = Qnil; // If a PID is provided, skip unless the PID matches if( (!NIL_P(v_pid)) && (procs[i].kp_proc.p_pid != NUM2INT(v_pid)) ) continue; // cmdline will be set only if process exists and belongs to current user or // current user is root v_cmdline = Qnil; v_exe = Qnil; v_environ = Qnil; argv_of_pid(procs[i].kp_proc.p_pid, &v_cmdline, &v_exe, &v_environ); // Get the start time of the process v_start_time = rb_time_new( procs[i].kp_proc.p_un.__p_starttime.tv_sec, procs[i].kp_proc.p_un.__p_starttime.tv_usec ); // Get the state of the process switch(procs[i].kp_proc.p_stat) { case SIDL: strcpy(state, "idle"); break; case SRUN: strcpy(state, "run"); break; case SSLEEP: strcpy(state, "sleep"); break; case SSTOP: strcpy(state, "stop"); break; case SZOMB: strcpy(state, "zombie"); break; default: strcpy(state, "unknown"); break; } // Get ttynum and ttydev. If ttynum is -1, there is no tty. if(procs[i].kp_eproc.e_tdev != -1){ v_tty_num = INT2FIX(procs[i].kp_eproc.e_tdev), v_tty_dev = rb_str_new2(devname(procs[i].kp_eproc.e_tdev, S_IFCHR)); } v_groups = rb_ary_new(); for (g = 0; g < procs[i].kp_eproc.e_ucred.cr_ngroups; ++g) rb_ary_push(v_groups, INT2FIX(procs[i].kp_eproc.e_ucred.cr_groups[g])); v_pstruct = rb_struct_new( sProcStruct, INT2FIX(procs[i].kp_proc.p_pid), INT2FIX(procs[i].kp_eproc.e_ppid), INT2FIX(procs[i].kp_eproc.e_pgid), INT2FIX(procs[i].kp_eproc.e_pcred.p_ruid), INT2FIX(procs[i].kp_eproc.e_pcred.p_rgid), INT2FIX(procs[i].kp_eproc.e_ucred.cr_uid), rb_ary_entry(v_groups, 0), v_groups, INT2FIX(procs[i].kp_eproc.e_pcred.p_svuid), INT2FIX(procs[i].kp_eproc.e_pcred.p_svgid), rb_str_new2(procs[i].kp_proc.p_comm), rb_str_new2(state), rb_float_new(procs[i].kp_proc.p_pctcpu), Qnil, v_tty_num, v_tty_dev, rb_str_new2(procs[i].kp_eproc.e_wmesg), INT2FIX(procs[i].kp_proc.p_rtime.tv_sec), INT2FIX(procs[i].kp_proc.p_priority), INT2FIX(procs[i].kp_proc.p_usrpri), INT2FIX(procs[i].kp_proc.p_nice), v_cmdline, v_exe, v_environ, v_start_time, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_maxrss) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_ixrss) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_idrss) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_isrss) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_minflt) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_majflt) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nswap) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_inblock) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_oublock) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgsnd) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_msgrcv) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nsignals) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nvcsw) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_nivcsw) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_utime.tv_sec) : Qnil, (procs[i].kp_proc.p_ru && procs[i].kp_proc.p_stat != 5) ? LONG2NUM(procs[i].kp_proc.p_ru->ru_stime.tv_sec) : Qnil ); OBJ_FREEZE(v_pstruct); // This is read-only data if(rb_block_given_p()) rb_yield(v_pstruct); else rb_ary_push(v_array, v_pstruct); } if(procs) free(procs); if(!rb_block_given_p()){ if(NIL_P(v_pid)) return v_array; else return v_pstruct; } return Qnil; }
static void dict_each_key (const char *key, xmmsv_t *value, void *udata) { rb_yield (ID2SYM (rb_intern (key))); }
static VALUE each(VALUE self) { VALUE block; MYSQL_STMT *stmt; MYSQL_RES *result; Data_Get_Struct(self, MYSQL_STMT, stmt); result = mysql_stmt_result_metadata(stmt); if (result) { MYSQL_BIND *result_buffers; my_bool *is_null; my_bool *error; unsigned long *length; MYSQL_FIELD *fields; unsigned long field_count; unsigned long i; if (mysql_stmt_store_result(stmt)) { rb_raise(cMysql2Error, "%s", mysql_stmt_error(stmt)); } fields = mysql_fetch_fields(result); field_count = mysql_num_fields(result); result_buffers = xcalloc(field_count, sizeof(MYSQL_BIND)); is_null = xcalloc(field_count, sizeof(my_bool)); error = xcalloc(field_count, sizeof(my_bool)); length = xcalloc(field_count, sizeof(unsigned long)); for (i = 0; i < field_count; i++) { result_buffers[i].buffer_type = fields[i].type; // mysql type | C type switch(fields[i].type) { case MYSQL_TYPE_NULL: // NULL break; case MYSQL_TYPE_TINY: // signed char result_buffers[i].buffer = xcalloc(1, sizeof(signed char)); result_buffers[i].buffer_length = sizeof(signed char); break; case MYSQL_TYPE_SHORT: // short int result_buffers[i].buffer = xcalloc(1, sizeof(short int)); result_buffers[i].buffer_length = sizeof(short int); break; case MYSQL_TYPE_INT24: // int case MYSQL_TYPE_LONG: // int case MYSQL_TYPE_YEAR: // int result_buffers[i].buffer = xcalloc(1, sizeof(int)); result_buffers[i].buffer_length = sizeof(int); break; case MYSQL_TYPE_LONGLONG: // long long int result_buffers[i].buffer = xcalloc(1, sizeof(long long int)); result_buffers[i].buffer_length = sizeof(long long int); break; case MYSQL_TYPE_FLOAT: // float case MYSQL_TYPE_DOUBLE: // double result_buffers[i].buffer = xcalloc(1, sizeof(double)); result_buffers[i].buffer_length = sizeof(double); break; case MYSQL_TYPE_TIME: // MYSQL_TIME case MYSQL_TYPE_DATE: // MYSQL_TIME case MYSQL_TYPE_NEWDATE: // MYSQL_TIME case MYSQL_TYPE_DATETIME: // MYSQL_TIME case MYSQL_TYPE_TIMESTAMP: // MYSQL_TIME result_buffers[i].buffer = xcalloc(1, sizeof(MYSQL_TIME)); result_buffers[i].buffer_length = sizeof(MYSQL_TIME); break; case MYSQL_TYPE_DECIMAL: // char[] case MYSQL_TYPE_NEWDECIMAL: // char[] case MYSQL_TYPE_STRING: // char[] case MYSQL_TYPE_VAR_STRING: // char[] case MYSQL_TYPE_VARCHAR: // char[] case MYSQL_TYPE_TINY_BLOB: // char[] case MYSQL_TYPE_BLOB: // char[] case MYSQL_TYPE_MEDIUM_BLOB: // char[] case MYSQL_TYPE_LONG_BLOB: // char[] case MYSQL_TYPE_BIT: // char[] case MYSQL_TYPE_SET: // char[] case MYSQL_TYPE_ENUM: // char[] case MYSQL_TYPE_GEOMETRY: // char[] result_buffers[i].buffer = malloc(fields[i].max_length); result_buffers[i].buffer_length = fields[i].max_length; break; default: rb_raise(cMysql2Error, "unhandled mysql type: %d", fields[i].type); } result_buffers[i].is_null = &is_null[i]; result_buffers[i].length = &length[i]; result_buffers[i].error = &error[i]; result_buffers[i].is_unsigned = ((fields[i].flags & UNSIGNED_FLAG) != 0); } if(mysql_stmt_bind_result(stmt, result_buffers)) { for(i = 0; i < field_count; i++) { if (result_buffers[i].buffer) { free(result_buffers[i].buffer); } } free(result_buffers); free(is_null); free(error); free(length); rb_raise(cMysql2Error, "%s", mysql_stmt_error(stmt)); } block = rb_block_proc(); while(!mysql_stmt_fetch(stmt)) { VALUE row = rb_ary_new2((long)field_count); for(i = 0; i < field_count; i++) { VALUE column = Qnil; MYSQL_TIME *ts; if (is_null[i]) { column = Qnil; } else { switch(result_buffers[i].buffer_type) { case MYSQL_TYPE_TINY: // signed char if (result_buffers[i].is_unsigned) { column = UINT2NUM(*((unsigned char*)result_buffers[i].buffer)); } else { column = INT2NUM(*((signed char*)result_buffers[i].buffer)); } break; case MYSQL_TYPE_SHORT: // short int if (result_buffers[i].is_unsigned) { column = UINT2NUM(*((unsigned short int*)result_buffers[i].buffer)); } else { column = INT2NUM(*((short int*)result_buffers[i].buffer)); } break; case MYSQL_TYPE_INT24: // int case MYSQL_TYPE_LONG: // int case MYSQL_TYPE_YEAR: // int if (result_buffers[i].is_unsigned) { column = UINT2NUM(*((unsigned int*)result_buffers[i].buffer)); } else { column = INT2NUM(*((int*)result_buffers[i].buffer)); } break; case MYSQL_TYPE_LONGLONG: // long long int if (result_buffers[i].is_unsigned) { column = ULL2NUM(*((unsigned long long int*)result_buffers[i].buffer)); } else { column = LL2NUM(*((long long int*)result_buffers[i].buffer)); } break; case MYSQL_TYPE_FLOAT: // float column = rb_float_new((double)(*((float*)result_buffers[i].buffer))); break; case MYSQL_TYPE_DOUBLE: // double column = rb_float_new((double)(*((double*)result_buffers[i].buffer))); break; case MYSQL_TYPE_DATE: // MYSQL_TIME ts = (MYSQL_TIME*)result_buffers[i].buffer; column = rb_funcall(cDate, rb_intern("new"), 3, INT2NUM(ts->year), INT2NUM(ts->month), INT2NUM(ts->day)); break; case MYSQL_TYPE_TIME: // MYSQL_TIME ts = (MYSQL_TIME*)result_buffers[i].buffer; column = rb_funcall(rb_cTime, rb_intern("mktime"), 6, UINT2NUM(Qnil), UINT2NUM(Qnil), UINT2NUM(Qnil), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second)); break; case MYSQL_TYPE_NEWDATE: // MYSQL_TIME case MYSQL_TYPE_DATETIME: // MYSQL_TIME case MYSQL_TYPE_TIMESTAMP: // MYSQL_TIME ts = (MYSQL_TIME*)result_buffers[i].buffer; column = rb_funcall(rb_cTime, rb_intern("mktime"), 6, UINT2NUM(ts->year), UINT2NUM(ts->month), UINT2NUM(ts->day), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second)); break; case MYSQL_TYPE_DECIMAL: // char[] case MYSQL_TYPE_NEWDECIMAL: // char[] column = rb_funcall(cBigDecimal, rb_intern("new"), 1, rb_str_new(result_buffers[i].buffer, *(result_buffers[i].length))); break; case MYSQL_TYPE_STRING: // char[] case MYSQL_TYPE_VAR_STRING: // char[] case MYSQL_TYPE_VARCHAR: // char[] case MYSQL_TYPE_TINY_BLOB: // char[] case MYSQL_TYPE_BLOB: // char[] case MYSQL_TYPE_MEDIUM_BLOB: // char[] case MYSQL_TYPE_LONG_BLOB: // char[] case MYSQL_TYPE_BIT: // char[] case MYSQL_TYPE_SET: // char[] case MYSQL_TYPE_ENUM: // char[] case MYSQL_TYPE_GEOMETRY: // char[] column = rb_str_new(result_buffers[i].buffer, *(result_buffers[i].length)); break; default: rb_raise(cMysql2Error, "unhandled buffer type: %d", result_buffers[i].buffer_type); break; } } rb_ary_store(row, (long)i, column); } rb_yield(row); } free(result_buffers); free(is_null); free(error); free(length); } return self; }
/* call-seq: draw(hash = nil) { ... } Three keys are checked in the given hash : ":buffer" which is the buffer on which manipulation are done (by default, the actual buffer is taken), ":painter", which tell us to yield a +Joyau::Painter+ instead of a +Joyau::Buffer+ when true (false by default), and ":auto_update" which tell us whether we should update the buffer (true by default). It is mandatory to give a block to this function. Examples: Joyau.draw(:buffer => a_buffer, :painter => true) Joyau.draw(:auto_update => false) Joyau.draw(:painter => true) Joyau.draw(:buffer => a_buffer) */ VALUE Joyau_draw(int argc, VALUE *argv, VALUE self) { static bool can_draw = false; VALUE hash, block; rb_scan_args(argc, argv, "01&", &hash, &block); OSL_IMAGE *oldBuffer = oslGetDrawBuffer(); Buffer *buffer = NULL; VALUE rbPainter = Qnil; bool painter = false; bool auto_update = true; bool ruby_buf = false; bool could_draw = can_draw; if (!NIL_P(hash)) { if (TYPE(hash) != T_HASH) rb_raise(rb_eTypeError, "Hash expected for Joyau::draw."); VALUE rbBuffer = rb_hash_aref(hash, ID2SYM(rb_intern("buffer"))); if (rb_obj_is_kind_of(rbBuffer, getClass("Buffer")) == Qfalse) { if (rbBuffer != Qnil) rb_raise(rb_eTypeError, ":buffer should be a Buffer (or nil)."); } else { buffer = getPtr<Buffer>(rbBuffer); ruby_buf = true; } if (!buffer) buffer = new Buffer(oldBuffer); if (rb_hash_aref(hash, ID2SYM(rb_intern("painter"))) == Qtrue) { painter = true; Painter painter(buffer); rbPainter = createObject(getClass("Painter"), painter); } if (rb_hash_aref(hash, ID2SYM(rb_intern("auto_update"))) == Qfalse) auto_update = false; } else { if (!buffer) buffer = new Buffer(oldBuffer); } if (buffer->isScreen() && !can_draw) { can_draw = true; Graphics_startDraw(Qnil); } if (!NIL_P(block)) { buffer->setActual(); if (painter) rb_yield(rbPainter); else { VALUE rbBuffer = createObject(getClass("Buffer"), *buffer, true); rb_yield(rbBuffer); } if (buffer->isScreen() && !could_draw) { can_draw = false; Graphics_endDraw(Qnil); } if (auto_update && buffer->isScreen()) Graphics_sync(Qnil); } else rb_raise(rb_eArgError, "Block expected."); if (!ruby_buf) // We do not delete the buffer if it comes from Ruby. delete buffer; oslSetDrawBuffer(oldBuffer); return Qnil; }
static VALUE enumerator_iter_i(VALUE i, VALUE enum_obj, int argc, VALUE *argv) { struct enumerator *e = (struct enumerator *)enum_obj; return rb_yield(proc_call(e->proc, i)); }
static VALUE obj_new_with_block_body(VALUE arg) { return rb_yield(arg); }
static VALUE sync_body(VALUE a) { return rb_yield(Qundef); }
static VALUE iter_yield(VALUE el, VALUE ary) { rb_yield(el); return Qnil; }
static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) { /* Local Vars */ VALUE qopts, opts, block; ID timezone; int symbolize_keys = 0, as_array = 0, cache_rows = 0, first = 0, empty_sets = 0; tinytds_client_userdata *userdata; GET_RESULT_WRAPPER(self); userdata = (tinytds_client_userdata *)dbgetuserdata(rwrap->client); /* Merge Options Hash To Query Options. Populate Opts & Block Var. */ qopts = rb_iv_get(self, "@query_options"); if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) qopts = rb_funcall(qopts, intern_merge, 1, opts); rb_iv_set(self, "@query_options", qopts); /* Locals From Options */ if (rb_hash_aref(qopts, sym_first) == Qtrue) first = 1; if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue) symbolize_keys = 1; if (rb_hash_aref(qopts, sym_as) == sym_array) as_array = 1; if (rb_hash_aref(qopts, sym_cache_rows) == Qtrue) cache_rows = 1; if (rb_hash_aref(qopts, sym_timezone) == sym_local) { timezone = intern_local; } else if (rb_hash_aref(qopts, sym_timezone) == sym_utc) { timezone = intern_utc; } else { rb_warn(":timezone option must be :utc or :local - defaulting to :local"); timezone = intern_local; } if (rb_hash_aref(qopts, sym_empty_sets) == Qtrue) empty_sets = 1; /* Make The Results Or Yield Existing */ if (NIL_P(rwrap->results)) { RETCODE dbsqlok_rc, dbresults_rc; rwrap->results = rb_ary_new(); dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client); dbresults_rc = rb_tinytds_result_dbresults_retcode(self); while ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED)) { int has_rows = (DBROWS(rwrap->client) == SUCCEED) ? 1 : 0; if (has_rows || empty_sets || (rwrap->number_of_results == 0)) rb_tinytds_result_fields(self); if ((has_rows || empty_sets) && rwrap->number_of_fields > 0) { /* Create rows for this result set. */ unsigned long rowi = 0; VALUE result = rb_ary_new(); while (nogvl_dbnextrow(rwrap->client) != NO_MORE_ROWS) { VALUE row = rb_tinytds_result_fetch_row(self, timezone, symbolize_keys, as_array); if (cache_rows) rb_ary_store(result, rowi, row); if (!NIL_P(block)) rb_yield(row); if (first) { dbcanquery(rwrap->client); userdata->dbcancel_sent = 1; } rowi++; } rwrap->number_of_rows = rowi; /* Store the result. */ if (cache_rows) { if (rwrap->number_of_results == 0) { rwrap->results = result; } else if (rwrap->number_of_results == 1) { VALUE multi_resultsets = rb_ary_new(); rb_ary_store(multi_resultsets, 0, rwrap->results); rb_ary_store(multi_resultsets, 1, result); rwrap->results = multi_resultsets; } else { rb_ary_store(rwrap->results, rwrap->number_of_results, result); } } // If we find results increment the counter that helpers use and setup the next loop. rwrap->number_of_results = rwrap->number_of_results + 1; dbresults_rc = rb_tinytds_result_dbresults_retcode(self); rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil); } else { // If we do not find results, side step the rb_tinytds_result_dbresults_retcode helper and // manually populate its memoized array while nullifing any memoized fields too before loop. dbresults_rc = nogvl_dbresults(rwrap->client); rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, INT2FIX(dbresults_rc)); rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil); } } if (dbresults_rc == FAIL) rb_warn("TinyTDS: Something in the dbresults() while loop set the return code to FAIL.\n"); userdata->dbsql_sent = 0; } else if (!NIL_P(block)) { unsigned long i; for (i = 0; i < rwrap->number_of_rows; i++) { rb_yield(rb_ary_entry(rwrap->results, i)); } } return rwrap->results; }
static VALUE sb_yield(VALUE self) { return rb_yield(INT2FIX(5)); }
/* call-seq: SQLite3::Database.new(file, options = {}) * * Create a new Database object that opens the given file. If utf16 * is +true+, the filename is interpreted as a UTF-16 encoded string. * * By default, the new database will return result rows as arrays * (#results_as_hash) and has type translation disabled (#type_translation=). */ static VALUE initialize(int argc, VALUE *argv, VALUE self) { sqlite3RubyPtr ctx; VALUE file; VALUE opts; VALUE zvfs; #ifdef HAVE_SQLITE3_OPEN_V2 int mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; #endif int status; Data_Get_Struct(self, sqlite3Ruby, ctx); rb_scan_args(argc, argv, "12", &file, &opts, &zvfs); #if defined StringValueCStr StringValuePtr(file); rb_check_safe_obj(file); #else Check_SafeStr(file); #endif if(NIL_P(opts)) opts = rb_hash_new(); else Check_Type(opts, T_HASH); #ifdef HAVE_RUBY_ENCODING_H if(UTF16_LE_P(file) || UTF16_BE_P(file)) { status = sqlite3_open16(utf16_string_value_ptr(file), &ctx->db); } else { #endif if(Qtrue == rb_hash_aref(opts, sym_utf16)) { status = sqlite3_open16(utf16_string_value_ptr(file), &ctx->db); } else { #ifdef HAVE_RUBY_ENCODING_H if(!UTF8_P(file)) { file = rb_str_export_to_enc(file, rb_utf8_encoding()); } #endif if (Qtrue == rb_hash_aref(opts, ID2SYM(rb_intern("readonly")))) { #ifdef HAVE_SQLITE3_OPEN_V2 mode = SQLITE_OPEN_READONLY; #else rb_raise(rb_eNotImpError, "sqlite3-ruby was compiled against a version of sqlite that does not support readonly databases"); #endif } #ifdef HAVE_SQLITE3_OPEN_V2 status = sqlite3_open_v2( StringValuePtr(file), &ctx->db, mode, NIL_P(zvfs) ? NULL : StringValuePtr(zvfs) ); #else status = sqlite3_open( StringValuePtr(file), &ctx->db ); #endif } #ifdef HAVE_RUBY_ENCODING_H } #endif CHECK(ctx->db, status) rb_iv_set(self, "@tracefunc", Qnil); rb_iv_set(self, "@authorizer", Qnil); rb_iv_set(self, "@encoding", Qnil); rb_iv_set(self, "@busy_handler", Qnil); rb_iv_set(self, "@collations", rb_hash_new()); rb_iv_set(self, "@functions", rb_hash_new()); rb_iv_set(self, "@results_as_hash", rb_hash_aref(opts, sym_results_as_hash)); rb_iv_set(self, "@type_translation", rb_hash_aref(opts, sym_type_translation)); #ifdef HAVE_SQLITE3_OPEN_V2 rb_iv_set(self, "@readonly", mode == SQLITE_OPEN_READONLY ? Qtrue : Qfalse); #else rb_iv_set(self, "@readonly", Qfalse); #endif if(rb_block_given_p()) { rb_yield(self); rb_funcall(self, rb_intern("close"), 0); } return self; }
static VALUE sym_each_i(VALUE v, void *arg) { rb_yield(rb_str_intern(v)); return Qnil; }
static void yield_pair(VALUE pair) { rb_yield(pair); }
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; }
/* @overload gsub(pattern, replacement) * * Returns the receiver with all matches of PATTERN replaced by REPLACEMENT, * inheriting any taint and untrust from the receiver and from REPLACEMENT. * * The REPLACEMENT is used as a specification for what to replace matches * with: * * <table> * <thead> * <tr><th>Specification</th><th>Replacement</th></tr> * </thead> * <tbody> * <tr> * <td><code>\1</code>, <code>\2</code>, …, <code>\</code><em>n</em></td> * <td>Numbered sub-match <em>n</em></td> * </tr> * <tr> * <td><code>\k<</code><em>name</em><code>></code></td> * <td>Named sub-match <em>name</em></td> * </tr> * </tbody> * </table> * * The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …, * `$`_n_ are updated accordingly. * * @param [Regexp, #to_str] pattern * @param [#to_str] replacement * @return [U::String] * * @overload gsub(pattern, replacements) * * Returns the receiver with all matches of PATTERN replaced by * REPLACEMENTS#[_match_], where _match_ is the matched substring, inheriting * any taint and untrust from the receiver and from the * REPLACEMENTS#[_match_]es, as well as any taint on REPLACEMENTS. * * The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …, * `$`_n_ are updated accordingly. * * @param [Regexp, #to_str] pattern * @param [#to_hash] replacements * @raise [RuntimeError] If any replacement is the result being constructed * @raise [Exception] Any error raised by REPLACEMENTS#default, if it gets * called * @return [U::String] * * @overload gsub(pattern){ |match| … } * * Returns the receiver with all matches of PATTERN replaced by the results * of the given block, inheriting any taint and untrust from the receiver and * from the results of the given block. * * The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …, * `$`_n_ are updated accordingly. * * @param [Regexp, #to_str] pattern * @yieldparam [U::String] match * @yieldreturn [#to_str] * @return [U::String] * * @overload gsub(pattern) * * Returns an Enumerator over the matches of PATTERN in the receiver. * * The Regexp special variables `$&`, `$'`, <code>$\`</code>, `$1`, `$2`, …, * `$`_n_ will be updated accordingly. * * @param [Regexp, #to_str] pattern * @return [Enumerator] */ VALUE rb_u_string_gsub(int argc, VALUE *argv, VALUE self) { VALUE pattern, replacement; VALUE replacements = Qnil; bool use_block = false; bool tainted = false; if (argc == 1) { RETURN_ENUMERATOR(self, argc, argv); use_block = true; } if (rb_scan_args(argc, argv, "11", &pattern, &replacement) == 2) { replacements = rb_check_convert_type(replacement, T_HASH, "Hash", "to_hash"); if (NIL_P(replacements)) StringValue(replacement); if (OBJ_TAINTED(replacement)) tainted = true; } pattern = rb_u_pattern_argument(pattern, true); VALUE str = rb_str_to_str(self); long begin = rb_reg_search(pattern, str, 0, 0); if (begin < 0) return self; const char *base = RSTRING_PTR(str); const char *p = base; const char *end = RSTRING_END(str); VALUE substituted = rb_u_str_buf_new(RSTRING_LEN(str) + 30); do { VALUE match = rb_backref_get(); struct re_registers *registers = RMATCH_REGS(match); VALUE result; if (use_block || !NIL_P(replacements)) { if (use_block) { VALUE ustr = rb_u_string_new_rb(rb_reg_nth_match(0, match)); result = rb_u_string_object_as_string(rb_yield(ustr)); } else { VALUE ustr = rb_u_string_new_c(self, base + registers->beg[0], registers->end[0] - registers->beg[0]); result = rb_u_string_object_as_string(rb_hash_aref(replacements, ustr)); } if (result == substituted) rb_u_raise(rb_eRuntimeError, "result of block is string being built; please try not to cheat"); } else result = #ifdef HAVE_RB_REG_REGSUB4 rb_reg_regsub(replacement, str, registers, pattern); #else rb_reg_regsub(replacement, str, registers); #endif if (OBJ_TAINTED(result)) tainted = true; const struct rb_u_string *value = RVAL2USTRING_ANY(result); rb_str_buf_cat(substituted, p, registers->beg[0] - (p - base)); rb_str_buf_cat(substituted, USTRING_STR(value), USTRING_LENGTH(value)); OBJ_INFECT(substituted, result); p = base + registers->end[0]; if (registers->beg[0] == registers->end[0]) p = u_next(p); if (p >= end) break; begin = rb_reg_search(pattern, str, registers->end[0], 0); } while (begin >= 0); if (p < end) rb_str_buf_cat(substituted, p, end - p); rb_reg_search(pattern, str, end - p, 0); RBASIC(substituted)->klass = rb_obj_class(str); OBJ_INFECT(substituted, str); if (tainted) OBJ_TAINT(substituted); return rb_u_string_new_rb(substituted); }
Value yield(const Value& value) { return rb::Value(rb_yield(value.to<VALUE>())); }
static void each(const char *p, size_t n, VALUE *self) { rb_yield(rb_u_string_new_c(*self, p, n)); }
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 range_step(VALUE range, SEL sel, int argc, VALUE *argv) { VALUE b, e, step, tmp; RETURN_ENUMERATOR(range, argc, argv); 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); } VALUE zero = INT2FIX(0); if (rb_vm_call(step, selLT, 1, &zero)) { rb_raise(rb_eArgError, "step can't be negative"); } else if (!rb_vm_call(step, selGT, 1, &zero)) { 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)); RETURN_IF_BROKEN(); if (i + unit < i) break; i += unit; } } else if (SYMBOL_P(b) && SYMBOL_P(e)) { /* symbols are special */ VALUE args[2]; VALUE iter[2]; args[0] = rb_sym_to_s(e); args[1] = EXCL(range) ? Qtrue : Qfalse; iter[0] = INT2FIX(1); iter[1] = step; rb_objc_block_call(rb_sym_to_s(b), selUpto, 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"))) { SEL op = EXCL(range) ? selLT : selLE; VALUE v = b; int i = 0; while (RTEST(rb_vm_call(v, op, 1, &e))) { rb_yield(v); RETURN_IF_BROKEN(); i++; VALUE tmp = rb_vm_call(INT2NUM(i), selMULT, 1, &step); v = rb_vm_call(b, selPLUS, 1, &tmp); } } 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_objc_block_call(b, selUpto, 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; return range_each_func(range, step_i, args); } } return range; }
static VALUE each_i(RB_BLOCK_CALL_FUNC_ARGLIST(v, arg)) { rb_yield(v); return Qnil; }
static VALUE sym_each_i(VALUE v, void *arg) { rb_yield(ID2SYM(rb_intern_str(v))); return Qnil; }
static VALUE sym_each_i(RB_BLOCK_CALL_FUNC_ARGLIST(v, arg)) { rb_yield(rb_str_intern(v)); return Qnil; }
static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) { VALUE defaults, opts, block; ID db_timezone, app_timezone, dbTz, appTz; mysql2_result_wrapper * wrapper; unsigned long i; const char * errstr; int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1, streaming = 0; MYSQL_FIELD * fields = NULL; GetMysql2Result(self, wrapper); 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; } if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) { symbolizeKeys = 1; } if (rb_hash_aref(opts, sym_as) == sym_array) { asArray = 1; } if (rb_hash_aref(opts, sym_cast_booleans) == Qtrue) { castBool = 1; } if (rb_hash_aref(opts, sym_cache_rows) == Qfalse) { cacheRows = 0; } if (rb_hash_aref(opts, sym_cast) == Qfalse) { cast = 0; } if(rb_hash_aref(opts, sym_stream) == Qtrue) { streaming = 1; } if(streaming && cacheRows) { rb_warn("cacheRows is ignored if streaming 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->lastRowProcessed == 0) { if (streaming) { /* We can't get number of rows if we're streaming, */ /* until we've finished fetching all rows */ wrapper->numberOfRows = 0; wrapper->rows = rb_ary_new(); } else { 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); } } if (streaming) { 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 (block != Qnil && row != Qnil) { rb_yield(row); wrapper->lastRowProcessed++; } } while(row != Qnil); rb_mysql_result_free_result(wrapper); wrapper->numberOfRows = wrapper->lastRowProcessed; 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 (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 */ rb_mysql_result_free_result(wrapper); return Qnil; } if (block != Qnil) { rb_yield(row); } } if (wrapper->lastRowProcessed == wrapper->numberOfRows) { /* we don't need the mysql C dataset around anymore, peace it */ rb_mysql_result_free_result(wrapper); } } } return wrapper->rows; }
static void operands_each (xmmsv_t *operand, void *user_data) { rb_yield (TO_XMMS_CLIENT_COLLECTION (xmmsv_ref (operand))); }