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;