size 36 .ext/include/ruby/digest.h rb_digest_##name##_update(void *ctx, unsigned char *ptr, size_t size) \
size 40 .ext/include/ruby/digest.h for (; size > stride; size -= stride, ptr += stride) { \
size 43 .ext/include/ruby/digest.h if (size > 0) name##_Update(ctx, ptr, size); \
size 407 addr2line.c char *debug_line_end = debug_line + size;
size 137 array.c while (size--) {
size 146 array.c rb_mem_clear(ptr + beg, size);
size 153 array.c while (size--) {
size 162 array.c memfill(ptr + beg, size, val);
size 725 array.c VALUE size, val;
size 740 array.c rb_scan_args(argc, argv, "02", &size, &val);
size 741 array.c if (argc == 1 && !FIXNUM_P(size)) {
size 742 array.c val = rb_check_array_type(size);
size 749 array.c len = NUM2LONG(size);
size 4918 array.c #define tmpbuf(n, size) rb_str_tmp_new((n)*(size))
size 5008 array.c if (comb > size-comb) {
size 5009 array.c comb = size-comb;
size 5014 array.c r = descending_factorial(size, comb);
size 1067 bignum.c ((size == SIZEOF_BDIGIT && u == 0) ? -2 : -1) :
size 1068 bignum.c ((u >> (size * CHAR_BIT - 1)) ? -1 : 1);
size 1070 bignum.c u |= LSHIFTX(BDIGMAX, size * CHAR_BIT);
size 4967 bignum.c size_t size;
size 4975 bignum.c size = mpz_sizeinbase(mx, base);
size 4979 bignum.c str = rb_usascii_str_new(0, size+1);
size 4982 bignum.c str = rb_usascii_str_new(0, size);
size 768 compile.c if (size == sizeof(VALUE) && padding == sizeof(VALUE)) {
size 784 compile.c size_t padding = calc_padding((void *)&storage->buff[storage->pos], size);
size 789 compile.c if (size >= INT_MAX - padding) rb_memerror();
size 790 compile.c if (storage->pos + size + padding > storage->size) {
size 791 compile.c unsigned int alloc_size = storage->size;
size 793 compile.c while (alloc_size < size + PADDING_SIZE_MAX) {
size 802 compile.c storage->size = alloc_size;
size 804 compile.c padding = calc_padding((void *)&storage->buff[storage->pos], size);
size 813 compile.c storage->pos += (int)size;
size 1066 compile.c size_t size = kw_arg != NULL ? sizeof(struct rb_call_info_with_kwarg) : sizeof(struct rb_call_info);
size 1067 compile.c struct rb_call_info *ci = (struct rb_call_info *)compile_data_alloc(iseq, size);
size 1254 compile.c iseq->body->param.size = iseq->body->param.block_start + 1;
size 1257 compile.c iseq->body->param.size = iseq->body->param.keyword->rest_start + 1;
size 1260 compile.c iseq->body->param.size = iseq->body->param.keyword->bits_start + 1;
size 1263 compile.c iseq->body->param.size = iseq->body->param.post_start + iseq->body->param.post_num;
size 1266 compile.c iseq->body->param.size = iseq->body->param.rest_start + 1;
size 1269 compile.c iseq->body->param.size = iseq->body->param.lead_num + iseq->body->param.opt_num;
size 1276 compile.c iseq->body->param.size = iseq->body->param.lead_num;
size 1469 compile.c int size;
size 1472 compile.c size = (int)*tbl;
size 1476 compile.c size = 0;
size 1479 compile.c if (size > 0) {
size 1480 compile.c ID *ids = (ID *)ALLOC_N(ID, size);
size 1481 compile.c MEMCPY(ids, tbl, ID, size);
size 1485 compile.c iseq->body->local_size = iseq->body->local_table_size = size;
size 1879 compile.c table->size = tlen;
size 1881 compile.c for (i = 0; i < table->size; i++) {
size 2372 compile.c case idSize: SP_INSN(size); return COMPILE_OK;
size 2480 compile.c for (i = 0; i < size; i++) {
size 2493 compile.c for (i = 0; i < size; i++) {
size 6959 compile.c iseq->body->param.size = 0;
size 6975 compile.c iseq->body->param.size = 1;
size 7011 compile.c unsigned int size;
size 7063 compile.c rb_str_cat(dump->str, (const char *)buff, size);
size 7073 compile.c if ((unsigned long)(size + offset) > (unsigned long)RSTRING_LEN(str))
size 7075 compile.c memcpy(ptr + offset, buff, size);
size 7081 compile.c void *buff = ruby_xmalloc(size);
size 7082 compile.c memcpy(buff, load->buff + offset, size);
size 7417 compile.c const int size = iseq->body->local_size - 1;
size 7418 compile.c ID *table = ALLOCA_N(ID, size);
size 7421 compile.c for (i=0; i<size; i++) {
size 7425 compile.c return IBF_W(table, ID, size);
size 7431 compile.c const int size = body->local_size - 1;
size 7433 compile.c if (size > 0) {
size 7434 compile.c ID *table = IBF_R(body->local_table, ID, size);
size 7437 compile.c for (i=0; i<size; i++) {
size 7453 compile.c int byte_size = iseq_catch_table_bytes(iseq->body->catch_table->size);
size 7456 compile.c dump_table->size = table->size;
size 7457 compile.c for (i=0; i<table->size; i++) {
size 7474 compile.c unsigned int size;
size 7475 compile.c size = *(unsigned int *)(load->buff + IBF_OFFSET(body->catch_table));
size 7476 compile.c table = ibf_load_alloc(load, IBF_OFFSET(body->catch_table), iseq_catch_table_bytes(size));
size 7477 compile.c for (i=0; i<size; i++) {
size 7635 compile.c const long size = RARRAY_LEN(dump->iseq_list);
size 7636 compile.c ibf_offset_t *list = ALLOCA_N(ibf_offset_t, size);
size 7639 compile.c for (i=0; i<size; i++) {
size 7643 compile.c header->iseq_list_offset = ibf_dump_write(dump, list, sizeof(ibf_offset_t) * size);
size 7644 compile.c header->iseq_list_size = (unsigned int)size;
size 7675 compile.c const long size = dump->id_table->num_entries;
size 7677 compile.c arg.list = ALLOCA_N(long, size);
size 7683 compile.c header->id_list_offset = ibf_dump_write(dump, arg.list, sizeof(long) * size);
size 7684 compile.c header->id_list_size = (unsigned int)size;
size 8223 compile.c int i, size;
size 8230 compile.c size = i;
size 8233 compile.c for (i=0; i<size; i++) {
size 8238 compile.c header->object_list_size = size;
size 8269 compile.c size_t size = sizeof(*dump);
size 8270 compile.c if (dump->iseq_table) size += st_memsize(dump->iseq_table);
size 8271 compile.c if (dump->id_table) size += st_memsize(dump->id_table);
size 8272 compile.c return size;
size 8326 compile.c header.size = ibf_dump_pos(dump);
size 8424 compile.c if (RSTRING_LENINT(str) < (int)load->header->size) {
size 8496 compile.c extra_str = rb_str_new(load->buff + load->header->size, load->header->extra_size);
size 120 cont.c size_t size;
size 276 cont.c size_t size = 0;
size 278 cont.c size = sizeof(*cont);
size 285 cont.c size += n * sizeof(*cont->vm_stack);
size 289 cont.c size += cont->machine.stack_size * sizeof(*cont->machine.stack);
size 293 cont.c size += cont->machine.register_stack_size * sizeof(*cont->machine.register_stack);
size 296 cont.c return size;
size 338 cont.c size_t size = 0;
size 340 cont.c size = sizeof(*fib);
size 343 cont.c size += st_memsize(fib->cont.saved_thread.local_storage);
size 345 cont.c size += cont_memsize(&fib->cont);
size 346 cont.c return size;
size 363 cont.c size_t size;
size 371 cont.c size = cont->machine.stack_size = th->machine.stack_start - th->machine.stack_end;
size 375 cont.c size = cont->machine.stack_size = th->machine.stack_end - th->machine.stack_start;
size 380 cont.c REALLOC_N(cont->machine.stack, VALUE, size);
size 383 cont.c cont->machine.stack = ALLOC_N(VALUE, size);
size 387 cont.c MEMCPY(cont->machine.stack, cont->machine.stack_src, VALUE, size);
size 391 cont.c size = cont->machine.register_stack_size = th->machine.register_stack_end - th->machine.register_stack_start;
size 394 cont.c REALLOC_N(cont->machine.register_stack, VALUE, size);
size 397 cont.c cont->machine.register_stack = ALLOC_N(VALUE, size);
size 400 cont.c MEMCPY(cont->machine.register_stack, cont->machine.register_stack_src, VALUE, size);
size 500 cont.c int size = 0;
size 503 cont.c size++;
size 504 cont.c entry = cont->ensure_array = ALLOC_N(rb_ensure_entry_t,size+1);
size 616 cont.c if (machine_stack_cache[machine_stack_cache_index - 1].size == (size / sizeof(VALUE))) {
size 620 cont.c machine_stack_cache[machine_stack_cache_index].size = 0;
size 632 cont.c ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, FIBER_STACK_FLAGS, -1, 0);
size 638 cont.c page = ptr + STACK_DIR_UPPER(size - RB_PAGE_SIZE, 0);
size 658 cont.c fib->fib_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL);
size 662 cont.c fib->fib_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL);
size 667 cont.c sth->machine.stack_maxsize = size;
size 674 cont.c ptr = fiber_machine_stack_alloc(size);
size 677 cont.c context->uc_stack.ss_size = size;
size 679 cont.c fib->ss_size = size;
size 681 cont.c sth->machine.stack_start = (VALUE*)(ptr + STACK_DIR_UPPER(0, size));
size 682 cont.c sth->machine.stack_maxsize = size - RB_PAGE_SIZE;
size 1373 cont.c machine_stack_cache[machine_stack_cache_index].size = terminated_machine_stack.size;
size 1378 cont.c munmap((void*)terminated_machine_stack.ptr, terminated_machine_stack.size * sizeof(VALUE));
size 1385 cont.c terminated_machine_stack.size = 0;
size 1486 cont.c terminated_machine_stack.size = fib->ss_size / sizeof(VALUE);
size 88 dir.c # define RUP32(size) ((size)+3/4)
size 1221 dir.c #define GLOB_REALLOC(ptr, size) realloc((ptr), (size))
size 195 dln.c int size;
size 198 dln.c size = read(fd, hdrp, sizeof(struct exec));
size 199 dln.c if (size == -1) {
size 203 dln.c if (size != sizeof(struct exec) || N_BADMAG(*hdrp)) {
size 266 dln.c int size;
size 269 dln.c size = hdrp->a_trsize + hdrp->a_drsize;
size 270 dln.c reloc = (struct relocation_info*)xmalloc(size);
size 276 dln.c if (read(fd, reloc, size) != size) {
size 292 dln.c int size;
size 295 dln.c if (read(fd, &size, sizeof(int)) != sizeof(int)) {
size 299 dln.c buffer = (struct nlist*)xmalloc(hdrp->a_syms + size);
size 306 dln.c if (read(fd, buffer, hdrp->a_syms + size) != hdrp->a_syms + size) {
size 423 dln.c int size;
size 427 dln.c size = hdrp->a_text + hdrp->a_data;
size 429 dln.c if (bss == -1) size += hdrp->a_bss;
size 430 dln.c else if (bss > 1) size += bss;
size 432 dln.c addr = (unsigned char*)xmalloc(size);
size 438 dln.c if (read(fd, addr, size) != size) {
size 915 dln.c int fd, size;
size 949 dln.c size = read(fd, armagic, SARMAG);
size 950 dln.c if (size == -1) goto syserr;
size 952 dln.c if (size != SARMAG) {
size 956 dln.c size = read(fd, &ahdr, sizeof(ahdr));
size 957 dln.c if (size == -1) goto syserr;
size 958 dln.c if (size != sizeof(ahdr) || sscanf(ahdr.ar_size, "%d", &size) != 1) {
size 966 dln.c data = (int*)xmalloc(size);
size 968 dln.c size = read(fd, data, size);
size 1005 dln.c size = read(fd, &ahdr, sizeof(ahdr));
size 1006 dln.c if (size == -1) goto syserr;
size 1007 dln.c if (size == 0) break;
size 1008 dln.c if (size != sizeof(ahdr)
size 1009 dln.c || sscanf(ahdr.ar_size, "%d", &size) != 1) {
size 1033 dln.c offset += size;
size 1127 dln.c size_t len = snprintf(message, size, "%d: ", error);
size 1132 dln.c message + len, size - len, NULL)
size 1206 dln.c ULONG size;
size 1209 dln.c desc = ImageDirectoryEntryToData(ext, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size);
size 81 dln_find.c buf = dln_find_1(fname, path, buf, size, 1 DLN_FIND_EXTRA_ARG);
size 91 dln_find.c return dln_find_1(fname, path, buf, size, 0 DLN_FIND_EXTRA_ARG);
size 126 dln_find.c if (fnlen >= size) {
size 179 dln_find.c if (i + 1 > size) goto toolong;
size 180 dln_find.c fspace = size - i - 1;
size 206 dln_find.c fspace = size - 2;
size 57 encoding.c int size;
size 273 encoding.c if (enc_table.size >= newsize) return newsize;
size 277 encoding.c memset(ent + enc_table.size, 0, sizeof(*ent)*(newsize - enc_table.size));
size 279 encoding.c enc_table.size = newsize;
size 353 enum.c VALUE size = rb_check_funcall(obj, id_size, 0, 0);
size 354 enum.c if (!FIXNUM_P(size)) return n;
size 355 enum.c limit = FIX2ULONG(size);
size 362 enum.c VALUE size = rb_check_funcall(obj, id_size, 0, 0);
size 363 enum.c if (!FIXNUM_P(size)) return 0;
size 364 enum.c return ((unsigned long)n > FIX2ULONG(size));
size 2270 enum.c long size = memo->u3.cnt;
size 2275 enum.c if (RARRAY_LEN(ary) == size) {
size 2279 enum.c MEMO_V1_SET(memo, rb_ary_new2(size));
size 2292 enum.c VALUE n, size;
size 2296 enum.c size = enum_size(obj, 0, 0);
size 2297 enum.c if (size == Qnil) return Qnil;
size 2299 enum.c n = rb_funcall(size, '+', 1, LONG2NUM(slice_size-1));
size 2322 enum.c long size = NUM2LONG(n);
size 2327 enum.c if (size <= 0) rb_raise(rb_eArgError, "invalid slice size");
size 2329 enum.c size = limit_by_enum_size(obj, size);
size 2330 enum.c ary = rb_ary_new2(size);
size 2332 enum.c memo = MEMO_NEW(ary, dont_recycle_block_arg(arity), size);
size 2346 enum.c long size = memo->u3.cnt;
size 2349 enum.c if (RARRAY_LEN(ary) == size) {
size 2353 enum.c if (RARRAY_LEN(ary) == size) {
size 2365 enum.c VALUE n, size;
size 2369 enum.c size = enum_size(obj, 0, 0);
size 2370 enum.c if (size == Qnil) return Qnil;
size 2372 enum.c n = rb_funcall(size, '+', 1, LONG2NUM(1 - cons_size));
size 2400 enum.c long size = NUM2LONG(n);
size 2404 enum.c if (size <= 0) rb_raise(rb_eArgError, "invalid size");
size 2407 enum.c if (enum_size_over_p(obj, size)) return Qnil;
size 2408 enum.c memo = MEMO_NEW(rb_ary_new2(size), dont_recycle_block_arg(arity), size);
size 2774 enum.c VALUE size = enum_size(self, args, 0);
size 2776 enum.c if (size == Qnil) return Qnil;
size 2784 enum.c return rb_funcall(size, '*', 1, LONG2FIX(mul));
size 120 enumerator.c VALUE size;
size 151 enumerator.c rb_gc_mark(ptr->size);
size 250 enumerator.c enumerator_ptr(enumerator)->size = rb_block_proc();
size 287 enumerator.c ptr->size = size;
size 335 enumerator.c VALUE size = Qnil;
size 343 enumerator.c size = argv[0];
size 346 enumerator.c size = rb_to_int(argv[0]);
size 361 enumerator.c return enumerator_init(obj, recv, meth, argc, argv, 0, size);
size 389 enumerator.c ptr1->size = ptr0->size;
size 1041 enumerator.c VALUE size;
size 1050 enumerator.c size = rb_check_funcall(e->size, id_call, argc, argv);
size 1051 enumerator.c if (size != Qundef) return size;
size 1052 enumerator.c return e->size;
size 1385 enumerator.c VALUE obj, size = Qnil;
size 1394 enumerator.c size = argv[1];
size 1398 enumerator.c enumerator_init(self, generator, sym_each, 0, 0, 0, size);
size 1502 enumerator.c enumerator_ptr(lazy)->size = rb_block_proc();
size 50 ext/-test-/bignum/intpack.c size_t size;
size 52 ext/-test-/bignum/intpack.c size = rb_absint_numwords(val, 1, NULL) - (neg && rb_absint_singlebit_p(val));
size 53 ext/-test-/bignum/intpack.c return SIZET2NUM(size);
size 61 ext/-test-/bignum/intpack.c size_t size = rb_absint_size(val, &nlz_bits);
size 63 ext/-test-/bignum/intpack.c size++;
size 64 ext/-test-/bignum/intpack.c return SIZET2NUM(size);
size 31 ext/-test-/string/qsort.c VALUE beg, len, size;
size 35 ext/-test-/string/qsort.c rb_scan_args(argc, argv, "03", &beg, &len, &size);
size 40 ext/-test-/string/qsort.c if (!NIL_P(size) && (s = NUM2INT(size)) < 0) {
size 6528 ext/date/date_core.c size_t size, len, flen;
size 6538 ext/date/date_core.c for (size=1024; ; size*=2) {
size 6539 ext/date/date_core.c *buf = xmalloc(size);
size 6541 ext/date/date_core.c len = date_strftime(*buf, size, format, tmx);
size 6551 ext/date/date_core.c if (size >= 1024 * flen) {
size 6986 ext/date/date_core.c snprintf(fmt, size, "%c%02ld" ".%%m.%%d", c, FIX2INT(y) - s);
size 72 ext/dbm/dbm.c size_t size = 0;
size 75 ext/dbm/dbm.c size += sizeof(*dbmp);
size 76 ext/dbm/dbm.c if (dbmp->di_dbm) size += DBM_SIZEOF_DBM;
size 78 ext/dbm/dbm.c return size;
size 36 ext/digest/digest.h rb_digest_##name##_update(void *ctx, unsigned char *ptr, size_t size) \
size 40 ext/digest/digest.h for (; size > stride; size -= stride, ptr += stride) { \
size 43 ext/digest/digest.h if (size > 0) name##_Update(ctx, ptr, size); \
size 930 ext/etc/etc.c size_t size;
size 951 ext/etc/etc.c size = CPU_ALLOC_SIZE(n);
size 952 ext/etc/etc.c if (size >= 1024) {
size 953 ext/etc/etc.c cpuset = xcalloc(1, size);
size 957 ext/etc/etc.c cpuset = alloca(size);
size 958 ext/etc/etc.c CPU_ZERO_S(size, cpuset);
size 961 ext/etc/etc.c ret = sched_getaffinity(0, size, cpuset);
size 964 ext/etc/etc.c ret = CPU_COUNT_S(size, cpuset);
size 967 ext/etc/etc.c if (size >= 1024) {
size 42 ext/fiddle/closure.c size_t size = 0;
size 44 ext/fiddle/closure.c size += sizeof(*cls);
size 46 ext/fiddle/closure.c size += ffi_raw_size(&cls->cif);
size 48 ext/fiddle/closure.c size += sizeof(*cls->argv);
size 49 ext/fiddle/closure.c size += sizeof(ffi_closure);
size 51 ext/fiddle/closure.c return size;
size 51 ext/fiddle/fiddle.c ptr = (void*)ruby_xmalloc(NUM2SIZET(size));
size 67 ext/fiddle/fiddle.c ptr = (void*)ruby_xrealloc(ptr, NUM2SIZET(size));
size 43 ext/fiddle/function.c size_t size = 0;
size 45 ext/fiddle/function.c size += sizeof(*ptr);
size 47 ext/fiddle/function.c size += ffi_raw_size(ptr);
size 50 ext/fiddle/function.c return size;
size 25 ext/fiddle/pointer.c long size;
size 75 ext/fiddle/pointer.c return sizeof(*data) + data->size;
size 92 ext/fiddle/pointer.c data->size = size;
size 101 ext/fiddle/pointer.c return rb_fiddle_ptr_new2(rb_cPointer, ptr, size, func);
size 109 ext/fiddle/pointer.c ptr = ruby_xmalloc((size_t)size);
size 110 ext/fiddle/pointer.c memset(ptr,0,(size_t)size);
size 111 ext/fiddle/pointer.c return rb_fiddle_ptr_new(ptr, size, func);
size 142 ext/fiddle/pointer.c data->size = 0;
size 161 ext/fiddle/pointer.c VALUE ptr, sym, size, wrap = 0, funcwrap = 0;
size 167 ext/fiddle/pointer.c if (rb_scan_args(argc, argv, "12", &ptr, &size, &sym) >= 1) {
size 173 ext/fiddle/pointer.c s = NUM2LONG(size);
size 188 ext/fiddle/pointer.c data->size = s;
size 209 ext/fiddle/pointer.c VALUE size, sym, obj, wrap = 0;
size 213 ext/fiddle/pointer.c switch (rb_scan_args(argc, argv, "11", &size, &sym)) {
size 215 ext/fiddle/pointer.c s = NUM2LONG(size);
size 219 ext/fiddle/pointer.c s = NUM2LONG(size);
size 417 ext/fiddle/pointer.c val = rb_tainted_str_new((char*)(data->ptr),data->size);
size 443 ext/fiddle/pointer.c RB_OBJ_CLASSNAME(self), data, data->ptr, data->size, data->free);
size 500 ext/fiddle/pointer.c long num, size;
size 503 ext/fiddle/pointer.c size = RPTR_DATA(self)->size;
size 505 ext/fiddle/pointer.c return rb_fiddle_ptr_new((char *)ptr + num, size - num, 0);
size 518 ext/fiddle/pointer.c long num, size;
size 521 ext/fiddle/pointer.c size = RPTR_DATA(self)->size;
size 523 ext/fiddle/pointer.c return rb_fiddle_ptr_new((char *)ptr - num, size + num, 0);
size 619 ext/fiddle/pointer.c RPTR_DATA(self)->size = NUM2LONG(size);
size 620 ext/fiddle/pointer.c return size;
size 631 ext/fiddle/pointer.c return LONG2NUM(RPTR_DATA(self)->size);
size 127 ext/gdbm/gdbm.c size_t size = 0;
size 130 ext/gdbm/gdbm.c size += sizeof(*dbmp);
size 131 ext/gdbm/gdbm.c if (dbmp->di_dbm) size += DBM_SIZEOF_DBM;
size 133 ext/gdbm/gdbm.c return size;
size 540 ext/io/console/console.c size = rb_Array(size);
size 541 ext/io/console/console.c rb_check_arity(RARRAY_LENINT(size), 2, 4);
size 542 ext/io/console/console.c sz = RARRAY_CONST_PTR(size);
size 689 ext/nkf/nkf-utf8/nkf.c if (size == 0) size = 1;
size 691 ext/nkf/nkf-utf8/nkf.c ptr = malloc(size);
size 703 ext/nkf/nkf-utf8/nkf.c if (size == 0) size = 1;
size 705 ext/nkf/nkf-utf8/nkf.c ptr = realloc(ptr, size);
size 1965 ext/nkf/nkf-utf8/nkf.c for (i = 0; i < size; i++) \
size 89 ext/nkf/nkf-utf8/nkf.h #define setvbuffer(fp, buf, size) setvbuf(fp, buf, _IOFBF, size)
size 91 ext/nkf/nkf-utf8/nkf.h #define setvbuffer(fp, buf, size) setbuffer(fp, buf, size)
size 130 ext/openssl/ossl.c return rb_str_new(0, size);
size 83 ext/openssl/ossl_pkey_dh.c int size;
size 93 ext/openssl/ossl_pkey_dh.c gen->result = DH_generate_parameters_ex(gen->dh, gen->size, gen->gen, gen->cb);
size 115 ext/openssl/ossl_pkey_dh.c gen_arg.size = size;
size 162 ext/openssl/ossl_pkey_dh.c VALUE size, gen, obj;
size 164 ext/openssl/ossl_pkey_dh.c if (rb_scan_args(argc, argv, "11", &size, &gen) == 2) {
size 167 ext/openssl/ossl_pkey_dh.c dh = dh_generate(NUM2INT(size), g);
size 97 ext/openssl/ossl_pkey_dsa.c int size;
size 110 ext/openssl/ossl_pkey_dsa.c gen->result = DSA_generate_parameters_ex(gen->dsa, gen->size, gen->seed, gen->seed_len, gen->counter, gen->h, gen->cb);
size 138 ext/openssl/ossl_pkey_dsa.c gen_arg.size = size;
size 188 ext/openssl/ossl_pkey_dsa.c DSA *dsa = dsa_generate(NUM2INT(size)); /* err handled by dsa_instance */
size 100 ext/openssl/ossl_pkey_rsa.c int size;
size 109 ext/openssl/ossl_pkey_rsa.c gen->result = RSA_generate_key_ex(gen->rsa, gen->size, gen->e, gen->cb);
size 145 ext/openssl/ossl_pkey_rsa.c gen_arg.size = size;
size 184 ext/openssl/ossl_pkey_rsa.c VALUE size, exp;
size 187 ext/openssl/ossl_pkey_rsa.c rb_scan_args(argc, argv, "11", &size, &exp);
size 189 ext/openssl/ossl_pkey_rsa.c rsa = rsa_generate(NUM2INT(size), NIL_P(exp) ? RSA_F4 : NUM2ULONG(exp)); /* err handled by rsa_instance */
size 26 ext/psych/psych_emitter.c VALUE str = rb_enc_str_new((const char *)buffer, (long)size, rb_utf8_encoding());
size 28 ext/psych/psych_emitter.c VALUE str = rb_str_new((const char *)buffer, (long)size);
size 30 ext/psych/psych_parser.c VALUE string = rb_funcall(io, id_read, 1, INT2NUM(size));
size 33 ext/psych/yaml/api.c return malloc(size ? size : 1);
size 43 ext/psych/yaml/api.c return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
size 253 ext/psych/yaml/api.c if (size > (size_t)(parser->input.string.end
size 255 ext/psych/yaml/api.c size = parser->input.string.end - parser->input.string.current;
size 258 ext/psych/yaml/api.c memcpy(buffer, parser->input.string.current, size);
size 259 ext/psych/yaml/api.c parser->input.string.current += size;
size 260 ext/psych/yaml/api.c *size_read = size;
size 274 ext/psych/yaml/api.c *size_read = fread(buffer, 1, size, parser->input.file);
size 295 ext/psych/yaml/api.c parser->input.string.end = input+size;
size 418 ext/psych/yaml/api.c if (emitter->output.string.size + *emitter->output.string.size_written
size 419 ext/psych/yaml/api.c < size) {
size 423 ext/psych/yaml/api.c emitter->output.string.size
size 425 ext/psych/yaml/api.c *emitter->output.string.size_written = emitter->output.string.size;
size 430 ext/psych/yaml/api.c + *emitter->output.string.size_written, buffer, size);
size 431 ext/psych/yaml/api.c *emitter->output.string.size_written += size;
size 444 ext/psych/yaml/api.c return (fwrite(buffer, 1, size, emitter->output.file) == size);
size 462 ext/psych/yaml/api.c emitter->output.string.size = size;
size 169 ext/psych/yaml/reader.c size_t size = parser->buffer.last - parser->buffer.pointer;
size 170 ext/psych/yaml/reader.c memmove(parser->buffer.start, parser->buffer.pointer, size);
size 172 ext/psych/yaml/reader.c parser->buffer.last = parser->buffer.start + size;
size 1342 ext/psych/yaml/yaml.h const unsigned char *input, size_t size);
size 1559 ext/psych/yaml/yaml.h size_t size;
size 1804 ext/psych/yaml/yaml.h unsigned char *output, size_t size, size_t *size_written);
size 98 ext/psych/yaml/yaml_private.h (buffer).end = (buffer).start+(size), \
size 136 ext/psych/yaml/yaml_private.h (((string).start = yaml_malloc(size)) ? \
size 138 ext/psych/yaml/yaml_private.h (string).end = (string).start+(size), \
size 139 ext/psych/yaml/yaml_private.h memset((string).start, 0, (size)), \
size 429 ext/psych/yaml/yaml_private.h (stack).end = (stack).start+(size), \
size 443 ext/psych/yaml/yaml_private.h ((stack).top - (stack).start < (size) ? \
size 461 ext/psych/yaml/yaml_private.h (((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \
size 463 ext/psych/yaml/yaml_private.h (queue).end = (queue).start+(size), \
size 17 ext/rbconfig/sizeof/sizes.c #define DEFINE(type, size) rb_hash_aset(s, rb_str_new_cstr(#type), INT2FIX(SIZEOF_##size))
size 97 ext/ripper/ripper.c #define YYMALLOC(size) rb_parser_malloc(parser, (size))
size 98 ext/ripper/ripper.c #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
size 99 ext/ripper/ripper.c #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
size 16601 ext/ripper/ripper.c size_t size = sizeof(*parser);
size 16603 ext/ripper/ripper.c size += toksiz;
size 16605 ext/ripper/ripper.c size += sizeof(*local);
size 16606 ext/ripper/ripper.c if (local->vars) size += local->vars->capa * sizeof(ID);
size 16608 ext/ripper/ripper.c return size;
size 16746 ext/ripper/ripper.c #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
size 16754 ext/ripper/ripper.c size_t cnt = HEAPCNT(1, size);
size 16756 ext/ripper/ripper.c void *ptr = xmalloc(size);
size 16764 ext/ripper/ripper.c size_t cnt = HEAPCNT(nelem, size);
size 16766 ext/ripper/ripper.c void *ptr = xcalloc(nelem, size);
size 16775 ext/ripper/ripper.c size_t cnt = HEAPCNT(1, size);
size 16780 ext/ripper/ripper.c n->u1.node = ptr = xrealloc(ptr, size);
size 16787 ext/ripper/ripper.c ptr = xrealloc(ptr, size);
size 43 ext/ripper/ripper.y #define YYMALLOC(size) rb_parser_malloc(parser, (size))
size 44 ext/ripper/ripper.y #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
size 45 ext/ripper/ripper.y #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
size 10852 ext/ripper/ripper.y size_t size = sizeof(*parser);
size 10854 ext/ripper/ripper.y size += toksiz;
size 10856 ext/ripper/ripper.y size += sizeof(*local);
size 10857 ext/ripper/ripper.y if (local->vars) size += local->vars->capa * sizeof(ID);
size 10859 ext/ripper/ripper.y return size;
size 10997 ext/ripper/ripper.y #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
size 11005 ext/ripper/ripper.y size_t cnt = HEAPCNT(1, size);
size 11007 ext/ripper/ripper.y void *ptr = xmalloc(size);
size 11015 ext/ripper/ripper.y size_t cnt = HEAPCNT(nelem, size);
size 11017 ext/ripper/ripper.y void *ptr = xcalloc(nelem, size);
size 11026 ext/ripper/ripper.y size_t cnt = HEAPCNT(1, size);
size 11031 ext/ripper/ripper.y n->u1.node = ptr = xrealloc(ptr, size);
size 11038 ext/ripper/ripper.y ptr = xrealloc(ptr, size);
size 103 ext/sdbm/init.c size_t size = 0;
size 106 ext/sdbm/init.c size += sizeof(*dbmp);
size 107 ext/sdbm/init.c if (dbmp->di_dbm) size += sizeof(DBM);
size 109 ext/sdbm/init.c return size;
size 31 ext/socket/option.c ((len) == (size) ? \
size 33 ext/socket/option.c rb_raise(rb_eTypeError, "size differ. expected as "#size"=%d but %ld", \
size 34 ext/socket/option.c (int)size, (long)(len)))
size 10002 ext/tk/tcltklib.c size_t size;
size 10007 ext/tk/tcltklib.c size = strlen(form)
size 10018 ext/tk/tcltklib.c info = ALLOC_N(char, size);
size 351 ext/tk/tkutil/tkutil.c long idx, idx2, size, size2;
size 375 ext/tk/tkutil/tkutil.c size = 0;
size 378 ext/tk/tkutil/tkutil.c size += 2 * RHASH_SIZE(RARRAY_AREF(ary, idx));
size 380 ext/tk/tkutil/tkutil.c size++;
size 384 ext/tk/tkutil/tkutil.c dst = rb_ary_new2(size);
size 505 ext/tk/tkutil/tkutil.c long idx, size;
size 528 ext/tk/tkutil/tkutil.c size = RARRAY_LEN(ary);
size 529 ext/tk/tkutil/tkutil.c dst = rb_ary_new2(size);
size 983 ext/tk/tkutil/tkutil.c long size;
size 996 ext/tk/tkutil/tkutil.c for(size = 0, idx = 2; idx < argc; idx++) {
size 998 ext/tk/tkutil/tkutil.c size += 2 * RHASH_SIZE(argv[idx]);
size 1000 ext/tk/tkutil/tkutil.c size++;
size 1004 ext/tk/tkutil/tkutil.c dst = rb_ary_new2(size);
size 699 ext/win32ole/win32ole.c &dw, cWIN32OLE_cp, pw, NULL, pm, size);
size 702 ext/win32ole/win32ole.c HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \
size 710 ext/win32ole/win32ole.c #define ole_wc2mb_conv(pw, pm, size) WideCharToMultiByte(cWIN32OLE_cp, 0, (pw), -1, (pm), (size), NULL, NULL)
size 716 ext/win32ole/win32ole.c UINT size = 0;
size 719 ext/win32ole/win32ole.c ole_ml_wc2mb_conv(pw, NULL, size, {});
size 720 ext/win32ole/win32ole.c pm = alloc(size, arg);
size 721 ext/win32ole/win32ole.c if (size) ole_ml_wc2mb_conv(pw, pm, size, xfree(pm));
size 722 ext/win32ole/win32ole.c pm[size] = '\0';
size 726 ext/win32ole/win32ole.c size = ole_wc2mb_conv(pw, NULL, 0);
size 727 ext/win32ole/win32ole.c pm = alloc(size, arg);
size 728 ext/win32ole/win32ole.c if (size) ole_wc2mb_conv(pw, pm, size);
size 729 ext/win32ole/win32ole.c pm[size] = '\0';
size 736 ext/win32ole/win32ole.c return ALLOC_N(char, size + 1);
size 899 ext/win32ole/win32ole.c UINT size = 0;
size 907 ext/win32ole/win32ole.c &dw, cp, pm, &n, NULL, &size);
size 911 ext/win32ole/win32ole.c pw = SysAllocStringLen(NULL, size);
size 914 ext/win32ole/win32ole.c &dw, cp, pm, &n, pw, &size);
size 921 ext/win32ole/win32ole.c size = MultiByteToWideChar(cp, 0, pm, len, NULL, 0);
size 922 ext/win32ole/win32ole.c pw = SysAllocStringLen(NULL, size);
size 923 ext/win32ole/win32ole.c pw[size-1] = 0;
size 924 ext/win32ole/win32ole.c MultiByteToWideChar(cp, 0, pm, len, pw, size);
size 931 ext/win32ole/win32ole.c VALUE str = rb_enc_str_new(NULL, size, cWIN32OLE_enc);
size 1711 ext/win32ole/win32ole.c DWORD size = 0;
size 1713 ext/win32ole/win32ole.c LONG err = RegQueryValueEx(hkey, subkey, NULL, &dwtype, NULL, &size);
size 1716 ext/win32ole/win32ole.c pbuf = ALLOC_N(char, size + 1);
size 1717 ext/win32ole/win32ole.c err = RegQueryValueEx(hkey, subkey, NULL, &dwtype, (BYTE *)pbuf, &size);
size 1719 ext/win32ole/win32ole.c pbuf[size] = '\0';
size 90 ext/win32ole/win32ole_record.c ULONG size = 0;
size 97 ext/win32ole/win32ole_record.c hr = pri->lpVtbl->GetSize(pri, &size);
size 104 ext/win32ole/win32ole_record.c prec->pdata = ALLOC_N(char, size);
size 106 ext/win32ole/win32ole_record.c rb_raise(rb_eRuntimeError, "failed to memory allocation of %lu bytes", (unsigned long)size);
size 230 ext/win32ole/win32ole_record.c ULONG size = 0;
size 235 ext/win32ole/win32ole_record.c hr = pvar->pri->lpVtbl->GetSize(pvar->pri, &size);
size 237 ext/win32ole/win32ole_record.c s += size;
size 582 ext/zlib/zlib.c voidpf p = xmalloc2(items, size);
size 587 ext/zlib/zlib.c (void)VALGRIND_MAKE_MEM_DEFINED(p, items * size);
size 673 ext/zlib/zlib.c z->buf = rb_str_new(0, size);
size 676 ext/zlib/zlib.c z->stream.avail_out = MAX_UINT(size);
size 679 ext/zlib/zlib.c else if (z->stream.avail_out != size) {
size 680 ext/zlib/zlib.c rb_str_resize(z->buf, z->buf_filled + size);
size 682 ext/zlib/zlib.c z->stream.avail_out = MAX_UINT(size);
size 1366 ext/zlib/zlib.c Check_Type(size, T_FIXNUM);
size 1367 ext/zlib/zlib.c zstream_expand_buffer_into(z, FIX2INT(size));
size 1368 ext/zlib/zlib.c return size;
size 2275 ext/zlib/zlib.c size_t size = sizeof(struct gzfile);
size 2278 ext/zlib/zlib.c size += GZFILE_CBUF_CAPA;
size 2280 ext/zlib/zlib.c return size;
size 2407 ext/zlib/zlib.c while (NIL_P(gz->z.input) || RSTRING_LEN(gz->z.input) < size) {
size 2771 file.c int size = 100;
size 2777 file.c v = rb_enc_str_new(0, size, enc);
size 2778 file.c while ((rv = readlink(RSTRING_PTR(path), RSTRING_PTR(v), size)) == size
size 2783 file.c rb_str_modify_expand(v, size);
size 2784 file.c size *= 2;
size 2785 file.c rb_str_set_len(v, size);
size 5422 file.c off_t size = get_stat(obj)->st_size;
size 5424 file.c if (size == 0) return Qnil;
size 5425 file.c return OFFT2NUM(size);
size 564 gc.c size_t size;
size 1368 gc.c size_t size = next_length * sizeof(struct heap_page *);
size 1370 gc.c gc_report(3, objspace, "heap_pages_expand_sorted: next_length: %d, size: %d\n", (int)next_length, (int)size);
size 1373 gc.c sorted = (struct heap_page **)realloc(heap_pages_sorted, size);
size 1377 gc.c sorted = heap_pages_sorted = (struct heap_page **)malloc(size);
size 1987 gc.c DATA_PTR(obj) = xcalloc(1, size);
size 2007 gc.c DATA_PTR(obj) = xcalloc(1, size);
size 3116 gc.c size_t size = 0;
size 3123 gc.c size += rb_generic_ivar_memsize(obj);
size 3130 gc.c size += ROBJECT(obj)->as.heap.numiv * sizeof(VALUE);
size 3136 gc.c size += rb_id_table_memsize(RCLASS_M_TBL(obj));
size 3140 gc.c size += st_memsize(RCLASS_IV_TBL(obj));
size 3143 gc.c size += st_memsize(RCLASS_IV_INDEX_TBL(obj));
size 3146 gc.c size += st_memsize(RCLASS(obj)->ptr->iv_tbl);
size 3149 gc.c size += rb_id_table_memsize(RCLASS(obj)->ptr->const_tbl);
size 3151 gc.c size += sizeof(rb_classext_t);
size 3157 gc.c size += rb_id_table_memsize(RCLASS_M_TBL(obj));
size 3162 gc.c size += rb_str_memsize(obj);
size 3165 gc.c size += rb_ary_memsize(obj);
size 3169 gc.c size += st_memsize(RHASH(obj)->ntbl);
size 3174 gc.c size += onig_memsize(RREGEXP_PTR(obj));
size 3178 gc.c if (use_all_types) size += rb_objspace_data_type_memsize(obj);
size 3183 gc.c size += onig_region_memsize(&rm->regs);
size 3184 gc.c size += sizeof(struct rmatch_offset) * rm->char_offset_num_allocated;
size 3185 gc.c size += sizeof(struct rmatch);
size 3190 gc.c size += rb_io_memsize(RFILE(obj)->fptr);
size 3204 gc.c size += BIGNUM_LEN(obj) * sizeof(BDIGIT);
size 3209 gc.c if (use_all_types) size += rb_node_memsize(obj);
size 3215 gc.c size += sizeof(VALUE) * RSTRUCT_LEN(obj);
size 3227 gc.c return size + sizeof(RVALUE);
size 3730 gc.c size_t size = stack->index;
size 3734 gc.c size += stack->limit;
size 3737 gc.c return size;
size 4735 gc.c int size;
size 4742 gc.c refs->size = 1;
size 4743 gc.c refs->list = ALLOC_N(VALUE, refs->size);
size 4759 gc.c if (refs->pos == refs->size) {
size 4760 gc.c refs->size *= 2;
size 4761 gc.c SIZED_REALLOC_N(refs->list, VALUE, refs->size, refs->size/2);
size 7589 gc.c res = __mingw_aligned_malloc(size, alignment);
size 7592 gc.c res = _aligned_malloc(size, alignment);
size 7594 gc.c if (posix_memalign(&res, alignment, size) == 0) {
size 7601 gc.c res = memalign(alignment, size);
size 7604 gc.c res = malloc(alignment + size + sizeof(void*));
size 7744 gc.c if (size == 0) size = 1;
size 7747 gc.c size += sizeof(size_t);
size 7750 gc.c return size;
size 7757 gc.c ((size_t *)mem)[0] = size;
size 7781 gc.c size = objspace_malloc_prepare(objspace, size);
size 7782 gc.c TRY_WITH_GC(mem = malloc(size));
size 7783 gc.c size = objspace_malloc_size(objspace, mem, size);
size 7784 gc.c objspace_malloc_increase(objspace, mem, size, 0, MEMOP_TYPE_MALLOC);
size 7785 gc.c return objspace_malloc_fixup(objspace, mem, size);
size 7791 gc.c if ((ssize_t)size < 0) {
size 7794 gc.c return objspace_xmalloc0(objspace, size);
size 7810 gc.c return objspace_xmalloc0(&rb_objspace, xmalloc2_size(n, size));
size 7867 gc.c return objspace_xmalloc0(&rb_objspace, size);
size 7873 gc.c return objspace_xmalloc(&rb_objspace, size);
size 7887 gc.c return objspace_xmalloc2(&rb_objspace, n, size);
size 7894 gc.c size_t size;
size 7896 gc.c size = xmalloc2_size(count, elsize);
size 7897 gc.c size = objspace_malloc_prepare(objspace, size);
size 7899 gc.c TRY_WITH_GC(mem = calloc(1, size));
size 7900 gc.c size = objspace_malloc_size(objspace, mem, size);
size 7901 gc.c objspace_malloc_increase(objspace, mem, size, 0, MEMOP_TYPE_MALLOC);
size 7902 gc.c return objspace_malloc_fixup(objspace, mem, size);
size 7908 gc.c return objspace_xcalloc(&rb_objspace, n, size);
size 7932 gc.c size_t len = size * n;
size 7933 gc.c if (n != 0 && size != len / n) {
size 7936 gc.c return objspace_xrealloc(&rb_objspace, ptr, len, old_n * size);
size 7942 gc.c return ruby_sized_xrealloc2(ptr, n, size, 0);
size 7952 gc.c objspace_xfree(&rb_objspace, x, size);
size 7970 gc.c size += sizeof(size_t);
size 7972 gc.c mem = malloc(size);
size 7998 gc.c ptr = ruby_xmalloc0(size);
size 8121 gc.c size_t size;
size 8123 gc.c size = sizeof(*w);
size 8124 gc.c size += st_memsize(w->obj2wmap);
size 8125 gc.c size += st_memsize(w->wmap2obj);
size 8126 gc.c st_foreach(w->obj2wmap, wmap_memsize_map, (st_data_t)&size);
size 8127 gc.c return size;
size 8154 gc.c VALUE wmap, *ptr, size, i, j;
size 8157 gc.c for (i = j = 1, size = ptr[0]; i <= size; ++i) {
size 8178 gc.c VALUE obj, *rids, i, size;
size 8189 gc.c size = *rids++;
size 8190 gc.c for (i = 0; i < size; ++i) {
size 8194 gc.c ruby_sized_xfree((VALUE *)data, (size + 1) * sizeof(VALUE));
size 8377 gc.c VALUE size, *ptr, *optr;
size 8379 gc.c size = (ptr = optr = (VALUE *)*val)[0];
size 8380 gc.c ++size;
size 8381 gc.c ptr = ruby_sized_xrealloc2(ptr, size + 1, sizeof(VALUE), size);
size 8385 gc.c size = 1;
size 8388 gc.c ptr[0] = size;
size 8389 gc.c ptr[size] = (VALUE)arg;
size 8522 gc.c objspace->profile.size = GC_PROFILE_RECORD_DEFAULT_SIZE;
size 8523 gc.c objspace->profile.records = malloc(sizeof(gc_profile_record) * objspace->profile.size);
size 8525 gc.c if (index >= objspace->profile.size) {
size 8527 gc.c objspace->profile.size += 1000;
size 8528 gc.c ptr = realloc(objspace->profile.records, sizeof(gc_profile_record) * objspace->profile.size);
size 8701 gc.c if (GC_PROFILE_RECORD_DEFAULT_SIZE * 2 < objspace->profile.size) {
size 8702 gc.c objspace->profile.size = GC_PROFILE_RECORD_DEFAULT_SIZE * 2;
size 8703 gc.c objspace->profile.records = realloc(objspace->profile.records, sizeof(gc_profile_record) * objspace->profile.size);
size 8708 gc.c MEMZERO(objspace->profile.records, gc_profile_record, objspace->profile.size);
size 1929 hash.c st_index_t size = RHASH_SIZE(hash);
size 1931 hash.c keys = rb_ary_new_capa(size);
size 1932 hash.c if (size == 0) return keys;
size 1939 hash.c size = st_keys_check(table, ptr, size, Qundef);
size 1941 hash.c rb_ary_set_len(keys, size);
size 1973 hash.c st_index_t size = RHASH_SIZE(hash);
size 1975 hash.c values = rb_ary_new_capa(size);
size 1976 hash.c if (size == 0) return values;
size 1983 hash.c size = st_values_check(table, ptr, size, Qundef);
size 1985 hash.c rb_ary_set_len(values, size);
size 2206 hash.c st_index_t size = RHASH_SIZE(hash);
size 2207 hash.c st_index_t hval = rb_hash_start(size);
size 2209 hash.c if (size) {
size 2670 hash.c return st_init_table_with_size(&identhash, size);
size 256 id_table.c tbl->st = st_init_numtable_with_size(size);
size 283 id_table.c return (struct st_id_table *)st_init_numtable_with_size(size);
size 449 id_table.c const int size = sizeof(id_key_t) * capa + sizeof(VALUE) * capa;
size 472 id_table.c tbl->keys = (id_key_t *)xrealloc(tbl->keys, size);
size 813 id_table.c sa_init_table(table, (sa_index_t)size);
size 986 id_table.c sa_index_t size = num_entries >> 3;
size 987 id_table.c size |= size >> 1;
size 988 id_table.c size |= size >> 2;
size 989 id_table.c size |= size >> 4;
size 990 id_table.c size |= size >> 8;
size 991 id_table.c size |= size >> 16;
size 992 id_table.c return (size + 1) << 3;
size 1432 id_table.c } size;
size 1438 id_table.c #define LIST_LIMIT_P(mix) ((mix)->aux.size.num == ID_TABLE_USE_MIX_LIST_MAX_CAPA)
size 1439 id_table.c #define LIST_P(mix) ((mix)->aux.size.capa <= ID_TABLE_USE_MIX_LIST_MAX_CAPA)
size 1445 id_table.c list_id_table_init((struct list_id_table *)mix, size);
size 151 include/ruby/io.h ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);
size 875 include/ruby/oniguruma.h int onig_set_match_stack_limit_size P_((unsigned int size));
size 1119 include/ruby/ruby.h VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type);
size 1138 include/ruby/ruby.h VALUE result = rb_data_object_zalloc((klass), (size), \
size 1158 include/ruby/ruby.h VALUE result = rb_data_typed_object_zalloc(klass, size, data_type); \
size 1380 include/ruby/ruby.h rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **datap, size_t size)
size 1382 include/ruby/ruby.h Data_Make_Struct0(result, klass, void, size, mark_func, free_func, *datap);
size 1387 include/ruby/ruby.h rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size)
size 1389 include/ruby/ruby.h TypedData_Make_Struct0(result, klass, void, size, type, *datap);
size 1625 include/ruby/ruby.h size_t size, max = LONG_MAX - sizeof(VALUE) + 1;
size 1626 include/ruby/ruby.h if (RB_UNLIKELY(rb_mul_size_overflow(count, elsize, max, &size))) {
size 1629 include/ruby/ruby.h cnt = (size + sizeof(VALUE) - 1) / sizeof(VALUE);
size 125 include/ruby/st.h st_index_t st_keys(st_table *table, st_data_t *keys, st_index_t size);
size 126 include/ruby/st.h st_index_t st_keys_check(st_table *table, st_data_t *keys, st_index_t size, st_data_t never);
size 127 include/ruby/st.h st_index_t st_values(st_table *table, st_data_t *values, st_index_t size);
size 128 include/ruby/st.h st_index_t st_values_check(st_table *table, st_data_t *values, st_index_t size, st_data_t never);
size 1448 io.c return (ssize_t)io_binwrite(0, buf, (long)size, fptr, 0);
size 2152 io.c io_setstrbuf(&str, offset + size);
size 2154 io.c arg.len = size;
size 2169 io.c return (ssize_t)io_bufread(buf, (long)size, fptr);
size 2230 io.c if (size < IO_CBUF_CAPA_MIN) size = IO_CBUF_CAPA_MIN;
size 2231 io.c fptr->cbuf.capa = size;
size 4335 io.c size_t size = sizeof(rb_io_t);
size 4336 io.c size += fptr->rbuf.capa;
size 4337 io.c size += fptr->wbuf.capa;
size 4338 io.c size += fptr->cbuf.capa;
size 4339 io.c if (fptr->readconv) size += rb_econv_memsize(fptr->readconv);
size 4340 io.c if (fptr->writeconv) size += rb_econv_memsize(fptr->writeconv);
size 4341 io.c return size;
size 7789 io.c size_t size = sizeof(*p);
size 7790 io.c if (p->inplace) size += strlen(p->inplace) + 1;
size 7791 io.c return size;
size 139 iseq.c size_t size = 0;
size 141 iseq.c if (!pkw) return size;
size 143 iseq.c size += sizeof(struct rb_iseq_param_keyword);
size 144 iseq.c size += sizeof(VALUE) * (pkw->num - pkw->required_num);
size 146 iseq.c return size;
size 152 iseq.c size_t size = 0; /* struct already counted as RVALUE size */
size 161 iseq.c size += sizeof(struct rb_iseq_constant_body);
size 162 iseq.c size += body->iseq_size * sizeof(VALUE);
size 163 iseq.c size += body->line_info_size * sizeof(struct iseq_line_info_entry);
size 164 iseq.c size += body->local_table_size * sizeof(ID);
size 166 iseq.c size += iseq_catch_table_bytes(body->catch_table->size);
size 168 iseq.c size += (body->param.opt_num + 1) * sizeof(VALUE);
size 169 iseq.c size += param_keyword_size(body->param.keyword);
size 172 iseq.c size += body->is_size * sizeof(union iseq_inline_storage_entry);
size 175 iseq.c size += body->ci_size * sizeof(struct rb_call_info);
size 176 iseq.c size += body->ci_kw_size * sizeof(struct rb_call_info_with_kwarg);
size 179 iseq.c size += body->ci_size * sizeof(struct rb_call_cache);
size 180 iseq.c size += body->ci_kw_size * sizeof(struct rb_call_cache);
size 189 iseq.c size += rb_call_info_kw_arg_bytes(kw_arg->keyword_len);
size 199 iseq.c size += sizeof(struct iseq_compile_data);
size 203 iseq.c size += cur->size + SIZEOF_ISEQ_COMPILE_DATA_STORAGE;
size 208 iseq.c return size;
size 300 iseq.c ISEQ_COMPILE_DATA(iseq)->storage_head->size =
size 1174 iseq.c size_t i = 0, size = iseq->body->line_info_size;
size 1179 iseq.c printf("size: %"PRIdSIZE"\n", size);
size 1184 iseq.c if (size == 0) {
size 1187 iseq.c else if (size == 1) {
size 1191 iseq.c for (i=1; i<size; i++) {
size 1475 iseq.c unsigned int size;
size 1484 iseq.c size = iseq->body->iseq_size;
size 1500 iseq.c for (i = 0; i < iseq->body->catch_table->size; i++) {
size 1570 iseq.c for (n = 0; n < size;) {
size 2012 iseq.c if (iseq->body->catch_table) for (i=0; i<iseq->body->catch_table->size; i++) {
size 2054 iseq.c rb_hash_aset(misc, ID2SYM(rb_intern("arg_size")), INT2FIX(iseq->body->param.size));
size 2085 iseq.c VALUE a, args = rb_ary_new2(iseq->body->param.size);
size 72 iseq.h VALUE str = rb_str_tmp_new(size * sizeof(VALUE));
size 183 iseq.h unsigned int size;
size 1174 marshal.c STRINGIZE(SIZEOF_LONG)", given %d)", size);
size 179 missing/alloca.c if (size == 0)
size 185 missing/alloca.c register pointer new = xmalloc (sizeof (header) + size);
size 945 node.c int size = tbl ? (int)*tbl++ : 0;
size 946 node.c if (size == 0) A("(empty)");
size 947 node.c for (i = 0; i < size; i++) {
size 948 node.c A_ID(tbl[i]); if (i < size - 1) A(",");
size 997 node.c size_t size = 0;
size 1001 node.c size += (RNODE(obj)->nd_tbl[0]+1) * sizeof(*RNODE(obj)->nd_tbl);
size 1006 node.c size += sizeof(*RNODE(obj)->nd_ainfo);
size 1010 node.c size += RNODE(obj)->nd_cnt * sizeof(VALUE);
size 1013 node.c return size;
size 97 parse.c #define YYMALLOC(size) rb_parser_malloc(parser, (size))
size 98 parse.c #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
size 99 parse.c #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
size 16525 parse.c size_t size = sizeof(*parser);
size 16527 parse.c size += toksiz;
size 16529 parse.c size += sizeof(*local);
size 16530 parse.c if (local->vars) size += local->vars->capa * sizeof(ID);
size 16532 parse.c return size;
size 16670 parse.c #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
size 16678 parse.c size_t cnt = HEAPCNT(1, size);
size 16680 parse.c void *ptr = xmalloc(size);
size 16688 parse.c size_t cnt = HEAPCNT(nelem, size);
size 16690 parse.c void *ptr = xcalloc(nelem, size);
size 16699 parse.c size_t cnt = HEAPCNT(1, size);
size 16704 parse.c n->u1.node = ptr = xrealloc(ptr, size);
size 16711 parse.c ptr = xrealloc(ptr, size);
size 43 parse.y #define YYMALLOC(size) rb_parser_malloc(parser, (size))
size 44 parse.y #define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size))
size 45 parse.y #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size))
size 10852 parse.y size_t size = sizeof(*parser);
size 10854 parse.y size += toksiz;
size 10856 parse.y size += sizeof(*local);
size 10857 parse.y if (local->vars) size += local->vars->capa * sizeof(ID);
size 10859 parse.y return size;
size 10997 parse.y #define HEAPCNT(n, size) ((n) * (size) / sizeof(YYSTYPE))
size 11005 parse.y size_t cnt = HEAPCNT(1, size);
size 11007 parse.y void *ptr = xmalloc(size);
size 11015 parse.y size_t cnt = HEAPCNT(nelem, size);
size 11017 parse.y void *ptr = xcalloc(nelem, size);
size 11026 parse.y size_t cnt = HEAPCNT(1, size);
size 11031 parse.y n->u1.node = ptr = xrealloc(ptr, size);
size 11038 parse.y ptr = xrealloc(ptr, size);
size 3323 process.c ssize_t size;
size 3324 process.c if ((size = read_retry(fd, &err, sizeof(err))) < 0) {
size 3328 process.c if (size == sizeof(err) &&
size 3336 process.c return size != 0;
size 454 random.c ret = read(fd, seed, size);
size 457 random.c if (ret < 0 || (size_t)ret < size) return -1;
size 469 random.c arc4random_buf(buf, size);
size 505 random.c CryptGenRandom(prov, size, seed);
size 525 random.c ret = syscall(SYS_getrandom, seed, size, flags);
size 530 random.c if ((size_t)ret == size) return 0;
size 541 random.c int ret = fill_random_bytes_syscall(seed, size, need_secure);
size 543 random.c return fill_random_bytes_urandom(seed, size);
size 615 random.c long n = NUM2ULONG(size);
size 153 regcomp.c if (size <= 0) {
size 154 regcomp.c size = 0;
size 158 regcomp.c buf->p = (UChar* )xmalloc(size);
size 162 regcomp.c buf->alloc = (unsigned int )size;
size 175 regcomp.c p = (UnsetAddr* )xmalloc(sizeof(UnsetAddr)* size);
size 178 regcomp.c uslist->alloc = size;
size 194 regcomp.c int size;
size 197 regcomp.c size = uslist->alloc * 2;
size 198 regcomp.c p = (UnsetAddr* )xrealloc(uslist->us, sizeof(UnsetAddr) * size);
size 200 regcomp.c uslist->alloc = size;
size 5619 regcomp.c size_t size = sizeof(regex_t);
size 5621 regcomp.c if (IS_NOT_NULL(reg->p)) size += reg->alloc;
size 5622 regcomp.c if (IS_NOT_NULL(reg->exact)) size += reg->exact_end - reg->exact;
size 5623 regcomp.c if (IS_NOT_NULL(reg->int_map)) size += sizeof(int) * ONIG_CHAR_TABLE_SIZE;
size 5624 regcomp.c if (IS_NOT_NULL(reg->int_map_backward)) size += sizeof(int) * ONIG_CHAR_TABLE_SIZE;
size 5625 regcomp.c if (IS_NOT_NULL(reg->repeat_range)) size += reg->repeat_range_alloc * sizeof(OnigRepeatRange);
size 5626 regcomp.c if (IS_NOT_NULL(reg->chain)) size += onig_memsize(reg->chain);
size 5628 regcomp.c return size;
size 5634 regcomp.c size_t size = sizeof(*regs);
size 5636 regcomp.c size += regs->allocated * (sizeof(*regs->beg) + sizeof(*regs->end));
size 5637 regcomp.c return size;
size 899 regenc.c size_t size;
size 902 regenc.c size = sizeof(OnigCodePoint*) * new_size;
size 904 regenc.c list = (const OnigCodePoint** )xmalloc(size);
size 909 regenc.c tmp = (const OnigCodePoint** )xrealloc((void* )list, size);
size 431 regexec.c unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\
size 433 regexec.c if (size > 0 && offset < size && size < STATE_CHECK_BUFF_MAX_SIZE) {\
size 434 regexec.c if (size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) {\
size 435 regexec.c (msa).state_check_buff = (void* )xmalloc(size);\
size 439 regexec.c (msa).state_check_buff = (void* )xalloca(size);\
size 441 regexec.c (size_t )(size - (offset))); \
size 442 regexec.c (msa).state_check_buff_size = size;\
size 521 regexec.c MatchStackLimitSize = size;
size 493 regint.h #define BBUF_INIT(buf,size) onig_bbuf_init((BBuf* )(buf), (size))
size 513 regint.h while (new_alloc < (unsigned int )(size)) { new_alloc *= 2; }\
size 383 regparse.c onig_st_init_table_with_size(&hashType, size);
size 1848 regparse.c int size = (n - high) * 2 * SIZE_CODE_POINT;
size 1849 regparse.c BBUF_MOVE_RIGHT(bbuf, from_pos, to_pos, size);
size 525 signal.c rb_atomic_t size;
size 550 signal.c int size = 16*1024;
size 553 signal.c if (size < MINSIGSTKSZ)
size 554 signal.c size = MINSIGSTKSZ;
size 560 signal.c if (size < pagesize)
size 561 signal.c size = pagesize;
size 565 signal.c return size;
size 690 signal.c ATOMIC_INC(signal_buff.size);
size 710 signal.c return signal_buff.size;
size 742 signal.c if (signal_buff.size != 0) {
size 746 signal.c ATOMIC_DEC(signal_buff.size);
size 1216 sprintf.c char *end = buf + size;
size 99 st.c #define st_alloc_bins(size) (st_table_entry **)calloc(size, sizeof(st_table_entry *))
size 163 st.c if (size && (size & ~(size - 1)) == size) /* already a power-of-two? */
size 164 st.c return size;
size 166 st.c n = next_pow2(size);
size 167 st.c if (n > size)
size 227 st.c tbl->entries_packed = size <= MAX_PACKED_HASH;
size 229 st.c size = ST_DEFAULT_PACKED_TABLE_SIZE;
size 233 st.c size = new_size(size); /* round up to power-of-two */
size 236 st.c tbl->num_bins = size;
size 237 st.c tbl->bins = st_alloc_bins(size);
size 257 st.c return st_init_table_with_size(&type_numhash, size);
size 269 st.c return st_init_table_with_size(&type_strhash, size);
size 281 st.c return st_init_table_with_size(&type_strcasehash, size);
size 1050 st.c if (size > table->real_entries) size = table->real_entries;
size 1051 st.c for (i = 0; i < size; i++) {
size 1059 st.c st_data_t *keys_end = keys + size;
size 1075 st.c return get_keys(table, keys, size, 0, 0);
size 1081 st.c return get_keys(table, keys, size, 1, never);
size 1094 st.c if (size > table->real_entries) size = table->real_entries;
size 1095 st.c for (i = 0; i < size; i++) {
size 1103 st.c st_data_t *values_end = values + size;
size 1119 st.c return get_values(table, values, size, 0, 0);
size 1125 st.c return get_values(table, values, size, 1, never);
size 8467 string.c long n, size, llen, rlen, llen2 = 0, rlen2 = 0;
size 8495 string.c size = RSTRING_LEN(str);
size 8498 string.c (len += llen2 + rlen2) >= LONG_MAX - size) {
size 8501 string.c len += size;
size 8519 string.c memcpy(p, RSTRING_PTR(str), size);
size 8520 string.c p += size;
size 602 struct.c int size, i;
size 605 struct.c size = rb_long2int(num_members(klass));
size 606 struct.c if (size > numberof(tmpargs)) {
size 607 struct.c tmpargs[0] = rb_ary_tmp_new(size);
size 611 struct.c for (i=0; i<size; i++) {
size 616 struct.c return rb_class_new_instance(size, mem, klass);
size 3447 thread.c size_t size = howmany(rb_fd_max(src), NFDBITS) * sizeof(fd_mask);
size 3449 thread.c if (size < sizeof(fd_set))
size 3450 thread.c size = sizeof(fd_set);
size 3452 thread.c dst->fdset = xmalloc(size);
size 3453 thread.c memcpy(dst->fdset, src->fdset, size);
size 3511 thread.c size_t size = howmany(max, NFDBITS) * sizeof(fd_mask);
size 3513 thread.c if (size < sizeof(fd_set)) size = sizeof(fd_set);
size 3515 thread.c dst->fdset = xrealloc(dst->fdset, size);
size 3516 thread.c memcpy(dst->fdset, src, size);
size 3522 thread.c size_t size = howmany(rb_fd_max(src), NFDBITS) * sizeof(fd_mask);
size 3524 thread.c if (size < sizeof(fd_set))
size 3525 thread.c size = sizeof(fd_set);
size 3527 thread.c dst->fdset = xrealloc(dst->fdset, size);
size 3528 thread.c memcpy(dst->fdset, src->fdset, size);
size 540 thread_pthread.c size_t size;
size 548 thread_pthread.c pthread_attr_getstacksize(attr, &size);
size 549 thread_pthread.c *addr = (void *)((size_t)((char *)_Asm_get_sp() - size) & ~(pagesize - 1));
size 563 thread_pthread.c # define get_main_stack(addr, size) get_stack(addr, size)
size 581 thread_pthread.c CHECK_ERR(pthread_attr_getstack(&attr, addr, size));
size 582 thread_pthread.c STACK_DIR_UPPER((void)0, (void)(*addr = (char *)*addr + *size));
size 585 thread_pthread.c CHECK_ERR(pthread_attr_getstacksize(&attr, size));
size 588 thread_pthread.c *size -= guard;
size 595 thread_pthread.c CHECK_ERR(pthread_attr_getstack(&attr, addr, size));
size 598 thread_pthread.c CHECK_ERR(pthread_attr_getstacksize(&attr, size));
size 600 thread_pthread.c STACK_DIR_UPPER((void)0, (void)(*addr = (char *)*addr + *size));
size 605 thread_pthread.c *size = pthread_get_stacksize_np(th);
size 614 thread_pthread.c *size = stk.ss_size;
size 627 thread_pthread.c *size = thinfo.__pi_stackend - thinfo.__pi_stackaddr;
size 628 thread_pthread.c STACK_DIR_UPPER((void)0, (void)(*addr = (char *)*addr + *size));
size 634 thread_pthread.c *size = (uintptr_t)info.stack_end - (uintptr_t)info.stack_base;
size 635 thread_pthread.c STACK_DIR_UPPER((void)0, (void)(*addr = (char *)*addr + *size));
size 690 thread_pthread.c if (size < stack_check_margin) return;
size 691 thread_pthread.c size -= stack_check_margin;
size 693 thread_pthread.c size -= sizeof(buf); /* margin */
size 696 thread_pthread.c limit += size;
size 711 thread_pthread.c limit -= size;
size 727 thread_pthread.c # define reserve_stack(limit, size) ((void)(limit), (void)(size))
size 747 thread_pthread.c size_t size;
size 748 thread_pthread.c if (get_main_stack(&stackaddr, &size) == 0) {
size 749 thread_pthread.c native_main_thread.stack_maxsize = size;
size 751 thread_pthread.c reserve_stack(stackaddr, size);
size 778 thread_pthread.c size_t size = PTHREAD_STACK_DEFAULT;
size 780 thread_pthread.c size_t size = RUBY_VM_THREAD_VM_STACK_SIZE;
size 787 thread_pthread.c size = (size_t)rlim.rlim_cur;
size 791 thread_pthread.c space = ((size_t)((char *)addr + size) / pagesize) * pagesize - (size_t)addr;
size 794 thread_pthread.c space = (size_t)addr - ((size_t)((char *)addr - size) / pagesize + 1) * pagesize;
size 838 thread_pthread.c size_t size;
size 840 thread_pthread.c if (get_stack(&start, &size) == 0) {
size 842 thread_pthread.c th->machine.stack_maxsize = size;
size 1696 thread_pthread.c size_t size;
size 1701 thread_pthread.c if (get_stack(&base, &size) == 0) {
size 1705 thread_pthread.c if (getrlimit(RLIMIT_STACK, &rlim) == 0 && rlim.rlim_cur > size) {
size 1706 thread_pthread.c size = (size_t)rlim.rlim_cur;
size 1710 thread_pthread.c base = (char *)base + STACK_DIR_UPPER(+size, -size);
size 1715 thread_pthread.c size = th->machine.stack_maxsize;
size 1716 thread_pthread.c base = (char *)th->machine.stack_start - STACK_DIR_UPPER(0, size);
size 1721 thread_pthread.c size /= RUBY_STACK_SPACE_RATIO;
size 1722 thread_pthread.c if (size > water_mark) size = water_mark;
size 1724 thread_pthread.c if (size > ~(size_t)base+1) size = ~(size_t)base+1;
size 1725 thread_pthread.c if (addr > base && addr <= (void *)((char *)base + size)) return 1;
size 1728 thread_pthread.c if (size > (size_t)base) size = (size_t)base;
size 1729 thread_pthread.c if (addr > (void *)((char *)base - size) && addr <= base) return 1;
size 558 thread_win32.c DWORD size, space;
size 564 thread_win32.c size = end - base;
size 565 thread_win32.c space = size / 5;
size 568 thread_win32.c th->machine.stack_maxsize = size - space;
size 835 transcode.c size_t size = sizeof(rb_transcoding);
size 839 transcode.c size += tr->state_size;
size 842 transcode.c size += tr->max_input;
size 845 transcode.c size += tr->max_output;
size 847 transcode.c return size;
size 1718 transcode.c size_t size = sizeof(rb_econv_t);
size 1722 transcode.c size += ec->replacement_len;
size 1725 transcode.c size += rb_transcoding_memsize(ec->elems[i].tc);
size 1728 transcode.c size += ec->elems[i].out_buf_end - ec->elems[i].out_buf_start;
size 1731 transcode.c size += ec->in_buf_end - ec->in_buf_start;
size 1732 transcode.c size += sizeof(rb_econv_elem_t) * ec->num_allocated;
size 1734 transcode.c return size;
size 195 util.c # define qsort_r(base, nel, size, arg, cmp) qsort_s(base, nel, size, cmp, arg)
size 220 util.c qsort_r(base, nel, size, &args, cmp_bsd_qsort);
size 234 util.c if (((VALUE)(base) % sizeof(mmtype)) == 0 && ((size) % sizeof(mmtype)) == 0) \
size 235 util.c if ((size) >= mmstep) mmkind = 1;\
size 238 util.c high = ((size) / mmstep) * mmstep;\
size 239 util.c low = ((size) % mmstep);\
size 242 util.c #define mmarg mmkind, size, high, low
size 243 util.c #define mmargdecl int mmkind, size_t size, size_t high, size_t low
size 277 util.c register char *t = a + size, s;
size 315 util.c register char *t = a + size, s;
size 345 util.c char *R = (char*)base + size*(nel-1); /* right end of current region */
size 354 util.c mmprepare(base, size);
size 363 util.c if (L + size == R) { /* 2 elements */
size 368 util.c n = (r - l + size) / size; /* number of elements */
size 369 util.c m = l + size * (n >> 1); /* calculate median value */
size 375 util.c n = size*(n>>3); /* number of bytes in splitting 8 */
size 388 util.c n = size*(n>>2); /* number of bytes in splitting 4 */
size 400 util.c for (p=l; p<r; p+=size) if ((*cmp)(p,p+size,d) > 0) goto fail;
size 417 util.c for (p=l; p<r; p+=size) if ((*cmp)(p,p+size,d) < 0) goto fail2;
size 418 util.c while (l<r) {mmswap(l,r); l+=size; r-=size;} /* reverse region */
size 435 util.c if ((l += size) == r) goto nxt; /*5-5-5*/
size 444 util.c if ((l += size) == r)
size 445 util.c {l -= size; if (l != m) mmswap(m,l); l -= size; goto fin;}
size 451 util.c if (l == (r -= size))
size 452 util.c {l -= size; if (l != m) mmswap(m,l); l -= size; goto fin;}
size 463 util.c if (l == (r -= size))
size 464 util.c {r += size; if (r != m) mmswap(r,m); r += size; goto fin;}
size 470 util.c if ((l += size) == r)
size 471 util.c {r += size; if (r != m) mmswap(r,m); r += size; goto fin;}
size 511 util.c int size = 200;
size 512 util.c char *buf = xmalloc(size);
size 514 util.c while (!getcwd(buf, size)) {
size 520 util.c size *= 2;
size 521 util.c buf = xrealloc(buf, size);
size 523 vm.c size_t size = sizeof(rb_env_t);
size 525 vm.c size += (env->env_size - 1) * sizeof(VALUE);
size 526 vm.c return size;
size 914 vm.c int arg_size = iseq->body->param.size;
size 930 vm.c int arg_size = iseq->body->param.size;
size 1703 vm.c if (ct) for (i = 0; i < ct->size; i++) {
size 1739 vm.c if (ct) for (i = 0; i < ct->size; i++) {
size 1755 vm.c if (ct) for (i = 0; i < ct->size; i++) {
size 1782 vm.c if (ct) for (i = 0; i < ct->size; i++) {
size 1820 vm.c if (ct) for (i = 0; i < ct->size; i++) {
size 2084 vm.c size_t size = sizeof(rb_vm_t);
size 2086 vm.c size += vmobj->living_thread_num * sizeof(rb_thread_t);
size 2089 vm.c size += DEFINED_EXPR * sizeof(VALUE);
size 2091 vm.c return size;
size 2137 vm.c size_t size = *sizep;
size 2141 vm.c if (size < PTHREAD_STACK_MIN) {
size 2202 vm.c return ALLOC_N(VALUE, size);
size 2207 vm.c #define thread_recycle_stack(size) ALLOC_N(VALUE, (size))
size 2328 vm.c size_t size = sizeof(rb_thread_t);
size 2331 vm.c size += th->stack_size * sizeof(VALUE);
size 2334 vm.c size += st_memsize(th->local_storage);
size 2336 vm.c return size;
size 535 vm_args.c for (i=calling->argc; i<iseq->body->param.size; i++) {
size 684 vm_args.c for (i=0; i<iseq->body->param.size; i++) {
size 434 vm_backtrace.c ptrdiff_t size, i;
size 451 vm_backtrace.c size = 0;
size 454 vm_backtrace.c size = start_cfp - last_cfp + 1;
size 457 vm_backtrace.c init(arg, size);
size 460 vm_backtrace.c for (i=0, cfp = start_cfp; i<size; i++, cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp)) {
size 488 vm_backtrace.c arg->bt->backtrace_base = arg->bt->backtrace = ruby_xmalloc(sizeof(rb_backtrace_location_t) * size);
size 566 vm_backtrace.c int size;
size 570 vm_backtrace.c size = bt->backtrace_size;
size 573 vm_backtrace.c n = size;
size 575 vm_backtrace.c if (lev > size) {
size 613 vm_backtrace.c int size;
size 617 vm_backtrace.c size = bt->backtrace_size;
size 620 vm_backtrace.c n = size;
size 622 vm_backtrace.c if (lev > size) {
size 324 vm_core.h unsigned int size;
size 951 vm_insnhelper.c const int ct_size = ct->size;
size 1337 vm_insnhelper.c int param = iseq->body->param.size;
size 1380 vm_insnhelper.c const int param_size = iseq->body->param.size;
size 1439 vm_insnhelper.c for (i=0; i < iseq->body->param.size; i++) {
size 1446 vm_insnhelper.c iseq->body->local_size - iseq->body->param.size,
size 2447 vm_insnhelper.c const int arg_size = iseq->body->param.size;
size 50 vm_method.c unsigned int size;
size 2048 vm_method.c global_method_cache.size = val;
size 2056 vm_method.c global_method_cache.entries = (struct cache_entry *)calloc(global_method_cache.size, sizeof(struct cache_entry));
size 566 vsnprintf.c int size; /* size of converted field or string */
size 799 vsnprintf.c size = 1;
size 841 vsnprintf.c size = fieldsz < prec ? (int)fieldsz : prec;
size 900 vsnprintf.c size = 3;
size 905 vsnprintf.c size = 3;
size 922 vsnprintf.c size = expsize + ndig;
size 924 vsnprintf.c ++size; /* floating point */
size 929 vsnprintf.c size = expsize + ndig;
size 931 vsnprintf.c ++fprec, ++size;
size 934 vsnprintf.c size = expt;
size 936 vsnprintf.c size += prec + 1;
size 938 vsnprintf.c size = 1;
size 940 vsnprintf.c size += 1;
size 942 vsnprintf.c size = prec + 2;
size 944 vsnprintf.c size = expt;
size 946 vsnprintf.c ++size;
size 948 vsnprintf.c size = ndig + (expt > 0 ?
size 1017 vsnprintf.c size = (int)(p - cp);
size 1019 vsnprintf.c size = prec;
size 1091 vsnprintf.c size = (int)(ebuf - cp);
size 1099 vsnprintf.c size = 1;
size 1118 vsnprintf.c fieldsz = size;
size 21 win32/dir.h long size;
size 129 win32/file.c if (size <= prime_len || _wcsnicmp(wfullpath + size - prime_len, prime, prime_len) != 0)
size 130 win32/file.c return size;
size 134 win32/file.c if (wfullpath[size - (prime_len + 1)] == ':') {
size 136 win32/file.c size -= prime_len + 1; /* prime */
size 137 win32/file.c wfullpath[size] = L'\0';
size 141 win32/file.c wchar_t *pos = wfullpath + size - (prime_len + 1);
size 144 win32/file.c size -= prime_len; /* alternative */
size 145 win32/file.c wfullpath[size] = L'\0';
size 151 win32/file.c return size;
size 236 win32/file.c if (size == 3 && pos[1] == L':' && pos[2] == L'\\' && pos[3] == L'\0') {
size 238 win32/file.c return size;
size 243 win32/file.c return size;
size 246 win32/file.c pos = *wfullpath + size - 1;
size 252 win32/file.c return size;
size 262 win32/file.c size_t oldsize = size;
size 265 win32/file.c size = trail_pos + file_len;
size 266 win32/file.c if (size > (buffer_size ? buffer_size-1 : oldsize)) {
size 267 win32/file.c wchar_t *buf = (wchar_t *)xmalloc((size + 1) * sizeof(wchar_t));
size 275 win32/file.c return size;
size 316 win32/file.c size_t size = 0, whome_len = 0;
size 592 win32/file.c size = GetFullPathNameW(buffer, PATH_BUFFER_SIZE, wfullpath_buffer, NULL);
size 593 win32/file.c if (size > PATH_BUFFER_SIZE) {
size 595 win32/file.c wfullpath = (wchar_t *)xmalloc(size * sizeof(wchar_t));
size 596 win32/file.c size = GetFullPathNameW(buffer, size, wfullpath, NULL);
size 603 win32/file.c if (IS_DIR_SEPARATOR_P(wfullpath[size - 1]) &&
size 604 win32/file.c wfullpath[size - 2] != L':' &&
size 605 win32/file.c !(size == 2 && IS_DIR_UNC_P(wfullpath))) {
size 606 win32/file.c size -= 1;
size 607 win32/file.c wfullpath[size] = L'\0';
size 611 win32/file.c if (wfullpath[size - 1] == L'.') {
size 612 win32/file.c size -= 1;
size 613 win32/file.c wfullpath[size] = L'\0';
size 617 win32/file.c size = remove_invalid_alternative_data(wfullpath, size);
size 622 win32/file.c size = replace_to_long_name(&wfullpath, size, bufsize);
size 630 win32/file.c result = append_wstr(result, wfullpath, size, cp, path_cp, path_encoding);
size 683 win32/file.c size_t size = rb_w32_reparse_buffer_size(len + 1);
size 684 win32/file.c rp = ALLOCV(wtmp, size);
size 685 win32/file.c e = rb_w32_read_reparse_point(wpath, rp, size, &wbuf, &len);
size 82 win32/win32.c #define dln_find_exe_r(fname, path, buf, size) rb_w32_udln_find_exe_r(fname, path, buf, size, cp)
size 83 win32/win32.c #define dln_find_file_r(fname, path, buf, size) rb_w32_udln_find_file_r(fname, path, buf, size, cp)
size 1990 win32/win32.c p->size = idx;
size 2073 win32/win32.c if (dirp->curr >= (dirp->start + dirp->size)) {
size 3303 win32/win32.c *len = size;
size 3308 win32/win32.c result = WSAGetOverlappedResult(s, wol, &size, TRUE, &flg);
size 3312 win32/win32.c *len = size;
size 3322 win32/win32.c *len = size;
size 3391 win32/win32.c DWORD size;
size 3401 win32/win32.c ret = WSARecvFrom(s, &wbuf, 1, &size, &flg, addr, addrlen,
size 3404 win32/win32.c ret = WSARecv(s, &wbuf, 1, &size, &flg, &wol, NULL);
size 3408 win32/win32.c ret = WSASendTo(s, &wbuf, 1, &size, flags, addr, *addrlen,
size 3411 win32/win32.c ret = WSASend(s, &wbuf, 1, &size, flags, &wol, NULL);
size 3415 win32/win32.c finish_overlapped_socket(input, s, &wol, ret, &rlen, size);
size 3525 win32/win32.c DWORD size;
size 3530 win32/win32.c ret = pWSARecvMsg(s, &wsamsg, &size, &wol, NULL);
size 3533 win32/win32.c ret = finish_overlapped_socket(TRUE, s, &wol, ret, &len, size);
size 3582 win32/win32.c DWORD size;
size 3587 win32/win32.c ret = pWSASendMsg(s, &wsamsg, flags, &size, &wol, NULL);
size 3590 win32/win32.c finish_overlapped_socket(FALSE, s, &wol, ret, &len, size);
size 4000 win32/win32.c ULONG size = 0;
size 4005 win32/win32.c ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
size 4010 win32/win32.c root = ruby_xmalloc(size);
size 4011 win32/win32.c ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, root, &size);
size 4565 win32/win32.c if (size < len) {
size 4572 win32/win32.c size = len;
size 4579 win32/win32.c if (!GetCurrentDirectory(size, p)) {
size 4804 win32/win32.c rp, size, &ret, NULL)) {
size 4827 win32/win32.c size_t size = rb_w32_reparse_buffer_size(len + 1);
size 4828 win32/win32.c rp = ALLOCV(wtmp, size);
size 4829 win32/win32.c e = rb_w32_read_reparse_point(path, rp, size, &wbuf, &len);
size 4890 win32/win32.c size_t size = rb_w32_reparse_buffer_size(len);
size 4891 win32/win32.c WCHAR *wname, *wpath = ALLOCV(wtmp, size + sizeof(WCHAR) * len);
size 4897 win32/win32.c e = rb_w32_read_reparse_point(wpath, rp, size, &wname, &len);
size 5533 win32/win32.c int ret, size;
size 5540 win32/win32.c size = lstrlenW(path) + 2;
size 5541 win32/win32.c buf1 = ALLOCV_N(WCHAR, v, size);
size 5556 win32/win32.c int ret, size;
size 5563 win32/win32.c size = lstrlenW(path) + 2;
size 5564 win32/win32.c buf1 = ALLOCV_N(WCHAR, v, size);
size 5707 win32/win32.c usize = (long)(size >> 32);
size 5708 win32/win32.c lsize = (long)size;
size 6790 win32/win32.c DWORD low = ol->Offset + size;
size 6814 win32/win32.c return rb_w32_recv(fd, buf, size, 0);
size 6822 win32/win32.c return _read(fd, buf, size);
size 6827 win32/win32.c if (!size || _osfile(fd) & FEOFLAG) {
size 6852 win32/win32.c len = size;
size 6853 win32/win32.c size -= len;
size 6924 win32/win32.c !(isconsole && len == 1 && (!islineinput || *((char *)buf - 1) == '\n')) && size > 0)
size 6950 win32/win32.c return rb_w32_send(fd, buf, size, 0);
size 6959 win32/win32.c return _write(fd, buf, size);
size 6964 win32/win32.c if (!size || _osfile(fd) & FEOFLAG) {
size 6972 win32/win32.c len = (_osfile(fd) & FDEV) ? min(32 * 1024, size) : size;
size 6973 win32/win32.c size -= len;
size 7020 win32/win32.c if (size > 0)
size 7026 win32/win32.c size += len - newlen;