16#include "internal/array.h"
17#include "internal/bits.h"
18#include "internal/error.h"
19#include "internal/gc.h"
20#include "internal/numeric.h"
21#include "internal/string.h"
22#include "internal/io.h"
25VALUE rb_eIOBufferLockedError;
26VALUE rb_eIOBufferAllocationError;
27VALUE rb_eIOBufferAccessError;
28VALUE rb_eIOBufferInvalidatedError;
29VALUE rb_eIOBufferMaskError;
31size_t RUBY_IO_BUFFER_PAGE_SIZE;
32size_t RUBY_IO_BUFFER_DEFAULT_SIZE;
41 RB_IO_BUFFER_HEXDUMP_DEFAULT_WIDTH = 16,
42 RB_IO_BUFFER_HEXDUMP_MAXIMUM_WIDTH = 1024,
44 RB_IO_BUFFER_INSPECT_HEXDUMP_MAXIMUM_SIZE = 256,
45 RB_IO_BUFFER_INSPECT_HEXDUMP_WIDTH = 16,
48 RB_IO_BUFFER_FLAGS_MASK = RB_IO_BUFFER_EXTERNAL | RB_IO_BUFFER_INTERNAL | RB_IO_BUFFER_MAPPED | RB_IO_BUFFER_SHARED | RB_IO_BUFFER_LOCKED | RB_IO_BUFFER_PRIVATE | RB_IO_BUFFER_READONLY,
50 RB_IO_BUFFER_DEBUG = 0,
56 enum rb_io_buffer_flags flags;
66io_buffer_map_memory(
size_t size,
int flags)
69 void * base = VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);
72 rb_sys_fail(
"io_buffer_map_memory:VirtualAlloc");
75 int mmap_flags = MAP_ANONYMOUS;
76 if (flags & RB_IO_BUFFER_SHARED) {
77 mmap_flags |= MAP_SHARED;
80 mmap_flags |= MAP_PRIVATE;
83 void * base = mmap(NULL, size, PROT_READ | PROT_WRITE, mmap_flags, -1, 0);
85 if (base == MAP_FAILED) {
86 rb_sys_fail(
"io_buffer_map_memory:mmap");
89 ruby_annotate_mmap(base, size,
"Ruby:io_buffer_map_memory");
96io_buffer_map_file(
struct rb_io_buffer *buffer,
int descriptor,
size_t size, rb_off_t offset,
enum rb_io_buffer_flags flags)
99 HANDLE file = (HANDLE)_get_osfhandle(descriptor);
100 if (!file) rb_sys_fail(
"io_buffer_map_descriptor:_get_osfhandle");
102 DWORD protect = PAGE_READONLY, access = FILE_MAP_READ;
104 if (flags & RB_IO_BUFFER_READONLY) {
105 buffer->flags |= RB_IO_BUFFER_READONLY;
108 protect = PAGE_READWRITE;
109 access = FILE_MAP_WRITE;
112 if (flags & RB_IO_BUFFER_PRIVATE) {
113 protect = PAGE_WRITECOPY;
114 access = FILE_MAP_COPY;
115 buffer->flags |= RB_IO_BUFFER_PRIVATE;
119 buffer->flags |= RB_IO_BUFFER_EXTERNAL;
120 buffer->flags |= RB_IO_BUFFER_SHARED;
123 HANDLE mapping = CreateFileMapping(file, NULL, protect, 0, 0, NULL);
124 if (RB_IO_BUFFER_DEBUG) fprintf(stderr,
"io_buffer_map_file:CreateFileMapping -> %p\n", mapping);
125 if (!mapping) rb_sys_fail(
"io_buffer_map_descriptor:CreateFileMapping");
127 void *base = MapViewOfFile(mapping, access, (DWORD)(offset >> 32), (DWORD)(offset & 0xFFFFFFFF), size);
130 CloseHandle(mapping);
131 rb_sys_fail(
"io_buffer_map_file:MapViewOfFile");
134 buffer->mapping = mapping;
136 int protect = PROT_READ, access = 0;
138 if (flags & RB_IO_BUFFER_READONLY) {
139 buffer->flags |= RB_IO_BUFFER_READONLY;
142 protect |= PROT_WRITE;
145 if (flags & RB_IO_BUFFER_PRIVATE) {
146 buffer->flags |= RB_IO_BUFFER_PRIVATE;
147 access |= MAP_PRIVATE;
151 buffer->flags |= RB_IO_BUFFER_EXTERNAL;
152 buffer->flags |= RB_IO_BUFFER_SHARED;
153 access |= MAP_SHARED;
156 void *base = mmap(NULL, size, protect, access, descriptor, offset);
158 if (base == MAP_FAILED) {
159 rb_sys_fail(
"io_buffer_map_file:mmap");
166 buffer->flags |= RB_IO_BUFFER_MAPPED;
167 buffer->flags |= RB_IO_BUFFER_FILE;
171io_buffer_experimental(
void)
173 static int warned = 0;
181 "IO::Buffer is experimental and both the Ruby and C interface may change in the future!"
192 buffer->mapping = NULL;
194 buffer->source =
Qnil;
198io_buffer_initialize(
VALUE self,
struct rb_io_buffer *buffer,
void *base,
size_t size,
enum rb_io_buffer_flags flags,
VALUE source)
205 if (flags & RB_IO_BUFFER_INTERNAL) {
206 base = calloc(size, 1);
208 else if (flags & RB_IO_BUFFER_MAPPED) {
209 base = io_buffer_map_memory(size, flags);
213 rb_raise(rb_eIOBufferAllocationError,
"Could not allocate buffer!");
223 buffer->flags = flags;
227 buffer->mapping = NULL;
235 if (buffer->flags & RB_IO_BUFFER_INTERNAL) {
239 if (buffer->flags & RB_IO_BUFFER_MAPPED) {
241 if (buffer->flags & RB_IO_BUFFER_FILE) {
242 UnmapViewOfFile(buffer->base);
245 VirtualFree(buffer->base, 0, MEM_RELEASE);
248 munmap(buffer->base, buffer->size);
262 buffer->source =
Qnil;
266 if (buffer->mapping) {
267 if (RB_IO_BUFFER_DEBUG) fprintf(stderr,
"io_buffer_free:CloseHandle -> %p\n", buffer->mapping);
268 if (!CloseHandle(buffer->mapping)) {
269 fprintf(stderr,
"io_buffer_free:GetLastError -> %lu\n", GetLastError());
271 buffer->mapping = NULL;
277rb_io_buffer_type_mark(
void *_buffer)
280 if (buffer->source !=
Qnil) {
281 if (RB_TYPE_P(buffer->source,
T_STRING)) {
284 rb_gc_mark(buffer->source);
286 rb_gc_mark_movable(buffer->source);
292rb_io_buffer_type_compact(
void *_buffer)
295 if (buffer->source !=
Qnil) {
296 if (RB_TYPE_P(buffer->source,
T_STRING)) {
300 buffer->source = rb_gc_location(buffer->source);
306rb_io_buffer_type_free(
void *_buffer)
310 io_buffer_free(buffer);
314rb_io_buffer_type_size(
const void *_buffer)
320 total += buffer->size;
327 .wrap_struct_name =
"IO::Buffer",
329 .dmark = rb_io_buffer_type_mark,
330 .dfree = rb_io_buffer_type_free,
331 .dsize = rb_io_buffer_type_size,
332 .dcompact = rb_io_buffer_type_compact,
335 .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
338static inline enum rb_io_buffer_flags
339io_buffer_extract_flags(
VALUE argument)
341 if (rb_int_negative_p(argument)) {
342 rb_raise(rb_eArgError,
"Flags can't be negative!");
345 enum rb_io_buffer_flags flags = RB_NUM2UINT(argument);
348 return flags & RB_IO_BUFFER_FLAGS_MASK;
353io_buffer_extract_offset(
VALUE argument)
355 if (rb_int_negative_p(argument)) {
356 rb_raise(rb_eArgError,
"Offset can't be negative!");
366io_buffer_extract_length(
VALUE argument)
368 if (rb_int_negative_p(argument)) {
369 rb_raise(rb_eArgError,
"Length can't be negative!");
378io_buffer_extract_size(
VALUE argument)
380 if (rb_int_negative_p(argument)) {
381 rb_raise(rb_eArgError,
"Size can't be negative!");
390io_buffer_extract_width(
VALUE argument,
size_t minimum)
392 if (rb_int_negative_p(argument)) {
393 rb_raise(rb_eArgError,
"Width can't be negative!");
398 if (width < minimum) {
399 rb_raise(rb_eArgError,
"Width must be at least %" PRIuSIZE
"!", minimum);
402 if (width > RB_IO_BUFFER_HEXDUMP_MAXIMUM_WIDTH) {
403 rb_raise(rb_eArgError,
"Width must be at most %" PRIuSIZE
"!", (
size_t)RB_IO_BUFFER_HEXDUMP_MAXIMUM_WIDTH);
414io_buffer_default_length(
const struct rb_io_buffer *buffer,
size_t offset)
416 if (offset > buffer->size) {
417 rb_raise(rb_eArgError,
"The given offset is bigger than the buffer size!");
421 return buffer->size - offset;
430io_buffer_extract_length_offset(
VALUE self,
int argc,
VALUE argv[],
size_t *length,
size_t *offset)
435 if (argc >= 2 && !
NIL_P(argv[1])) {
436 *offset = io_buffer_extract_offset(argv[1]);
442 if (argc >= 1 && !
NIL_P(argv[0])) {
443 *length = io_buffer_extract_length(argv[0]);
446 *length = io_buffer_default_length(buffer, *offset);
462io_buffer_extract_offset_length(
VALUE self,
int argc,
VALUE argv[],
size_t *offset,
size_t *length)
467 if (argc >= 1 && !
NIL_P(argv[0])) {
468 *offset = io_buffer_extract_offset(argv[0]);
474 if (argc >= 2 && !
NIL_P(argv[1])) {
475 *length = io_buffer_extract_length(argv[1]);
478 *length = io_buffer_default_length(buffer, *offset);
485rb_io_buffer_type_allocate(
VALUE self)
487 io_buffer_experimental();
492 io_buffer_zero(buffer);
497static VALUE io_buffer_for_make_instance(
VALUE klass,
VALUE string,
enum rb_io_buffer_flags flags)
499 VALUE instance = rb_io_buffer_type_allocate(klass);
504 flags |= RB_IO_BUFFER_EXTERNAL;
506 if (RB_OBJ_FROZEN(
string))
507 flags |= RB_IO_BUFFER_READONLY;
509 if (!(flags & RB_IO_BUFFER_READONLY))
510 rb_str_modify(
string);
512 io_buffer_initialize(instance, buffer, RSTRING_PTR(
string), RSTRING_LEN(
string), flags,
string);
521 enum rb_io_buffer_flags flags;
525io_buffer_for_yield_instance(
VALUE _arguments)
529 arguments->instance = io_buffer_for_make_instance(arguments->klass, arguments->string, arguments->flags);
531 if (!RB_OBJ_FROZEN(arguments->string)) {
535 return rb_yield(arguments->instance);
539io_buffer_for_yield_instance_ensure(
VALUE _arguments)
543 if (arguments->instance !=
Qnil) {
544 rb_io_buffer_free(arguments->instance);
547 if (!RB_OBJ_FROZEN(arguments->string)) {
591rb_io_buffer_type_for(
VALUE klass,
VALUE string)
605 return rb_ensure(io_buffer_for_yield_instance, (
VALUE)&arguments, io_buffer_for_yield_instance_ensure, (
VALUE)&arguments);
609 string = rb_str_tmp_frozen_acquire(
string);
610 return io_buffer_for_make_instance(klass,
string, RB_IO_BUFFER_READONLY);
628rb_io_buffer_type_string(
VALUE klass,
VALUE length)
638 rb_ensure(io_buffer_for_yield_instance, (
VALUE)&arguments, io_buffer_for_yield_instance_ensure, (
VALUE)&arguments);
644rb_io_buffer_new(
void *base,
size_t size,
enum rb_io_buffer_flags flags)
646 VALUE instance = rb_io_buffer_type_allocate(rb_cIOBuffer);
651 io_buffer_initialize(instance, buffer, base, size, flags,
Qnil);
657rb_io_buffer_map(
VALUE io,
size_t size, rb_off_t offset,
enum rb_io_buffer_flags flags)
659 VALUE instance = rb_io_buffer_type_allocate(rb_cIOBuffer);
666 io_buffer_map_file(buffer, descriptor, size, offset, flags);
716io_buffer_map(
int argc,
VALUE *argv,
VALUE klass)
718 rb_check_arity(argc, 1, 4);
723 rb_off_t file_size = rb_file_size(io);
725 if (UNLIKELY(file_size <= 0)) {
726 rb_raise(rb_eArgError,
"Invalid negative or zero file size!");
729 else if (UNLIKELY((uintmax_t)file_size > SIZE_MAX)) {
730 rb_raise(rb_eArgError,
"File larger than address space!");
734 if (argc >= 2 && !RB_NIL_P(argv[1])) {
735 size = io_buffer_extract_size(argv[1]);
736 if (UNLIKELY(size == 0)) {
737 rb_raise(rb_eArgError,
"Size can't be zero!");
739 if (UNLIKELY(size > (
size_t)file_size)) {
740 rb_raise(rb_eArgError,
"Size can't be larger than file size!");
745 size = (size_t)file_size;
752 if (UNLIKELY(offset < 0)) {
753 rb_raise(rb_eArgError,
"Offset can't be negative!");
755 if (UNLIKELY(offset >= file_size)) {
756 rb_raise(rb_eArgError,
"Offset too large!");
758 if (RB_NIL_P(argv[1])) {
760 size = (size_t)(file_size - offset);
762 else if (UNLIKELY((
size_t)(file_size - offset) < size)) {
763 rb_raise(rb_eArgError,
"Offset too large!");
767 enum rb_io_buffer_flags flags = 0;
769 flags = io_buffer_extract_flags(argv[3]);
772 return rb_io_buffer_map(io, size, offset, flags);
776static inline enum rb_io_buffer_flags
777io_flags_for_size(
size_t size)
779 if (size >= RUBY_IO_BUFFER_PAGE_SIZE) {
780 return RB_IO_BUFFER_MAPPED;
783 return RB_IO_BUFFER_INTERNAL;
811rb_io_buffer_initialize(
int argc,
VALUE *argv,
VALUE self)
813 rb_check_arity(argc, 0, 2);
820 size = io_buffer_extract_size(argv[0]);
823 size = RUBY_IO_BUFFER_DEFAULT_SIZE;
826 enum rb_io_buffer_flags flags = 0;
828 flags = io_buffer_extract_flags(argv[1]);
831 flags |= io_flags_for_size(size);
834 io_buffer_initialize(self, buffer, NULL, size, flags,
Qnil);
840io_buffer_validate_slice(
VALUE source,
void *base,
size_t size)
842 void *source_base = NULL;
843 size_t source_size = 0;
849 rb_io_buffer_get_bytes(source, &source_base, &source_size);
853 if (source_base == NULL)
return 0;
856 if (base < source_base)
return 0;
858 const void *source_end = (
char*)source_base + source_size;
859 const void *end = (
char*)base + size;
862 if (end > source_end)
return 0;
871 if (buffer->source !=
Qnil) {
873 return io_buffer_validate_slice(buffer->source, buffer->base, buffer->size);
880enum rb_io_buffer_flags
881rb_io_buffer_get_bytes(
VALUE self,
void **base,
size_t *size)
886 if (io_buffer_validate(buffer)) {
888 *base = buffer->base;
889 *size = buffer->size;
891 return buffer->flags;
903io_buffer_validate_for_writing(
struct rb_io_buffer *buffer)
905 if (buffer->flags & RB_IO_BUFFER_READONLY ||
907 rb_raise(rb_eIOBufferAccessError,
"Buffer is not writable!");
910 if (!io_buffer_validate(buffer)) {
911 rb_raise(rb_eIOBufferInvalidatedError,
"Buffer is invalid!");
916get_io_buffer_for_writing(
VALUE self)
920 io_buffer_validate_for_writing(buffer);
925io_buffer_get_bytes_for_writing(
struct rb_io_buffer *buffer,
void **base,
size_t *size)
927 io_buffer_validate_for_writing(buffer);
930 *base = buffer->base;
931 *size = buffer->size;
939rb_io_buffer_get_bytes_for_writing(
VALUE self,
void **base,
size_t *size)
944 io_buffer_get_bytes_for_writing(buffer, base, size);
948io_buffer_validate_for_reading(
struct rb_io_buffer *buffer)
950 if (!io_buffer_validate(buffer)) {
951 rb_raise(rb_eIOBufferInvalidatedError,
"Buffer has been invalidated!");
956io_buffer_get_bytes_for_reading(
struct rb_io_buffer *buffer,
const void **base,
size_t *size)
958 io_buffer_validate_for_reading(buffer);
961 *base = buffer->base;
962 *size = buffer->size;
970rb_io_buffer_get_bytes_for_reading(
VALUE self,
const void **base,
size_t *size)
975 io_buffer_get_bytes_for_reading(buffer, base, size);
988rb_io_buffer_to_s(
VALUE self)
996 rb_str_catf(result,
" %p+%"PRIdSIZE, buffer->base, buffer->size);
998 if (buffer->base == NULL) {
1002 if (buffer->flags & RB_IO_BUFFER_EXTERNAL) {
1006 if (buffer->flags & RB_IO_BUFFER_INTERNAL) {
1010 if (buffer->flags & RB_IO_BUFFER_MAPPED) {
1014 if (buffer->flags & RB_IO_BUFFER_FILE) {
1018 if (buffer->flags & RB_IO_BUFFER_SHARED) {
1022 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1026 if (buffer->flags & RB_IO_BUFFER_PRIVATE) {
1030 if (buffer->flags & RB_IO_BUFFER_READONLY) {
1034 if (buffer->source !=
Qnil) {
1038 if (!io_buffer_validate(buffer)) {
1048io_buffer_hexdump_output_size(
size_t width,
size_t size,
int first)
1051 size_t total = size;
1053 size_t whole_lines = (size / width);
1054 size_t partial_line = (size % width) ? 1 : 0;
1059 total += (whole_lines + partial_line) * (1 + 10 + width*3 + 1 + 1);
1062 if (size && first) total -= 1;
1071io_buffer_hexdump(
VALUE string,
size_t width,
const char *base,
size_t length,
size_t offset,
int first)
1073 char *text = alloca(width+1);
1076 for (; offset < length; offset += width) {
1077 memset(text,
'\0', width);
1079 rb_str_catf(
string,
"0x%08" PRIxSIZE
" ", offset);
1083 rb_str_catf(
string,
"\n0x%08" PRIxSIZE
" ", offset);
1086 for (
size_t i = 0; i < width; i += 1) {
1087 if (offset+i < length) {
1088 unsigned char value = ((
unsigned char*)base)[offset+i];
1090 if (value < 127 && isprint(value)) {
1091 text[i] = (char)value;
1097 rb_str_catf(
string,
" %02x", value);
1104 rb_str_catf(
string,
" %s", text);
1123rb_io_buffer_inspect(
VALUE self)
1128 VALUE result = rb_io_buffer_to_s(self);
1130 if (io_buffer_validate(buffer)) {
1132 size_t size = buffer->size;
1135 if (size > RB_IO_BUFFER_INSPECT_HEXDUMP_MAXIMUM_SIZE) {
1136 size = RB_IO_BUFFER_INSPECT_HEXDUMP_MAXIMUM_SIZE;
1140 io_buffer_hexdump(result, RB_IO_BUFFER_INSPECT_HEXDUMP_WIDTH, buffer->base, size, 0, 0);
1143 rb_str_catf(result,
"\n(and %" PRIuSIZE
" more bytes not printed)", buffer->size - size);
1157rb_io_buffer_size(
VALUE self)
1174rb_io_buffer_valid_p(
VALUE self)
1179 return RBOOL(io_buffer_validate(buffer));
1197rb_io_buffer_null_p(
VALUE self)
1202 return RBOOL(buffer->base == NULL);
1213rb_io_buffer_empty_p(
VALUE self)
1218 return RBOOL(buffer->size == 0);
1233rb_io_buffer_external_p(
VALUE self)
1238 return RBOOL(buffer->flags & RB_IO_BUFFER_EXTERNAL);
1258rb_io_buffer_internal_p(
VALUE self)
1263 return RBOOL(buffer->flags & RB_IO_BUFFER_INTERNAL);
1280rb_io_buffer_mapped_p(
VALUE self)
1285 return RBOOL(buffer->flags & RB_IO_BUFFER_MAPPED);
1312rb_io_buffer_shared_p(
VALUE self)
1317 return RBOOL(buffer->flags & RB_IO_BUFFER_SHARED);
1335rb_io_buffer_locked_p(
VALUE self)
1340 return RBOOL(buffer->flags & RB_IO_BUFFER_LOCKED);
1366rb_io_buffer_private_p(
VALUE self)
1371 return RBOOL(buffer->flags & RB_IO_BUFFER_PRIVATE);
1375rb_io_buffer_readonly_p(
VALUE self)
1380 return buffer->flags & RB_IO_BUFFER_READONLY;
1392io_buffer_readonly_p(
VALUE self)
1394 return RBOOL(rb_io_buffer_readonly_p(self));
1400 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1404 buffer->flags |= RB_IO_BUFFER_LOCKED;
1411 if (!io_buffer_try_lock(buffer)) {
1412 rb_raise(rb_eIOBufferLockedError,
"Buffer already locked!");
1417rb_io_buffer_lock(
VALUE self)
1422 io_buffer_lock(buffer);
1430 if (!(buffer->flags & RB_IO_BUFFER_LOCKED)) {
1431 rb_raise(rb_eIOBufferLockedError,
"Buffer not locked!");
1434 buffer->flags &= ~RB_IO_BUFFER_LOCKED;
1438rb_io_buffer_unlock(
VALUE self)
1443 io_buffer_unlock(buffer);
1449rb_io_buffer_try_unlock(
VALUE self)
1454 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1455 buffer->flags &= ~RB_IO_BUFFER_LOCKED;
1463rb_io_buffer_locked_ensure(
VALUE self)
1468 buffer->flags &= ~RB_IO_BUFFER_LOCKED;
1504rb_io_buffer_locked(
VALUE self)
1509 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1510 rb_raise(rb_eIOBufferLockedError,
"Buffer already locked!");
1513 buffer->flags |= RB_IO_BUFFER_LOCKED;
1544rb_io_buffer_free(
VALUE self)
1549 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1550 rb_raise(rb_eIOBufferLockedError,
"Buffer is locked!");
1553 io_buffer_free(buffer);
1563 io_buffer_unlock(buffer);
1564 io_buffer_free(buffer);
1570size_sum_is_bigger_than(
size_t a,
size_t b,
size_t x)
1572 struct rbimpl_size_overflow_tag size = rbimpl_size_add_overflow(a, b);
1573 return size.overflowed || size.result > x;
1579io_buffer_validate_range(
struct rb_io_buffer *buffer,
size_t offset,
size_t length)
1581 io_buffer_validate_for_reading(buffer);
1583 if (size_sum_is_bigger_than(offset, length, buffer->size)) {
1584 rb_raise(rb_eArgError,
"Specified offset+length is bigger than the buffer size!");
1605rb_io_buffer_hexdump(
int argc,
VALUE *argv,
VALUE self)
1607 rb_check_arity(argc, 0, 3);
1609 size_t offset, length;
1610 struct rb_io_buffer *buffer = io_buffer_extract_offset_length(self, argc, argv, &offset, &length);
1612 size_t width = RB_IO_BUFFER_HEXDUMP_DEFAULT_WIDTH;
1614 width = io_buffer_extract_width(argv[2], 1);
1618 io_buffer_validate_range(buffer, offset, length);
1622 if (io_buffer_validate(buffer) && buffer->base) {
1623 result =
rb_str_buf_new(io_buffer_hexdump_output_size(width, length, 1));
1625 io_buffer_hexdump(result, width, buffer->base, offset+length, offset, 1);
1632rb_io_buffer_slice(
struct rb_io_buffer *buffer,
VALUE self,
size_t offset,
size_t length)
1634 io_buffer_validate_range(buffer, offset, length);
1636 VALUE instance = rb_io_buffer_type_allocate(rb_class_of(self));
1640 slice->flags |= (buffer->flags & RB_IO_BUFFER_READONLY);
1641 slice->base = (
char*)buffer->base + offset;
1642 slice->size = length;
1645 if (buffer->source !=
Qnil) {
1646 RB_OBJ_WRITE(instance, &slice->source, buffer->source);
1706io_buffer_slice(
int argc,
VALUE *argv,
VALUE self)
1708 rb_check_arity(argc, 0, 2);
1710 size_t offset, length;
1711 struct rb_io_buffer *buffer = io_buffer_extract_offset_length(self, argc, argv, &offset, &length);
1713 return rb_io_buffer_slice(buffer, self, offset, length);
1735rb_io_buffer_transfer(
VALUE self)
1740 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1741 rb_raise(rb_eIOBufferLockedError,
"Cannot transfer ownership of locked buffer!");
1744 VALUE instance = rb_io_buffer_type_allocate(rb_class_of(self));
1748 *transferred = *buffer;
1749 io_buffer_zero(buffer);
1755io_buffer_resize_clear(
struct rb_io_buffer *buffer,
void* base,
size_t size)
1757 if (size > buffer->size) {
1758 memset((
unsigned char*)base+buffer->size, 0, size - buffer->size);
1767 io_buffer_initialize(self, &resized, NULL, size, io_flags_for_size(size),
Qnil);
1770 size_t preserve = buffer->size;
1771 if (preserve > size) preserve = size;
1772 memcpy(resized.base, buffer->base, preserve);
1774 io_buffer_resize_clear(buffer, resized.base, size);
1777 io_buffer_free(buffer);
1782rb_io_buffer_resize(
VALUE self,
size_t size)
1787 io_buffer_validate_for_reading(buffer);
1789 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
1790 rb_raise(rb_eIOBufferLockedError,
"Cannot resize locked buffer!");
1793 if (buffer->base == NULL) {
1794 io_buffer_initialize(self, buffer, NULL, size, io_flags_for_size(size),
Qnil);
1798 if (buffer->flags & RB_IO_BUFFER_EXTERNAL) {
1799 rb_raise(rb_eIOBufferAccessError,
"Cannot resize external buffer!");
1802#if defined(HAVE_MREMAP) && defined(MREMAP_MAYMOVE)
1803 if (buffer->flags & RB_IO_BUFFER_MAPPED) {
1804 void *base = mremap(buffer->base, buffer->size, size, MREMAP_MAYMOVE);
1806 if (base == MAP_FAILED) {
1807 rb_sys_fail(
"rb_io_buffer_resize:mremap");
1810 io_buffer_resize_clear(buffer, base, size);
1812 buffer->base = base;
1813 buffer->size = size;
1819 if (buffer->flags & RB_IO_BUFFER_INTERNAL) {
1821 io_buffer_free(buffer);
1825 void *base = realloc(buffer->base, size);
1828 rb_sys_fail(
"rb_io_buffer_resize:realloc");
1831 io_buffer_resize_clear(buffer, base, size);
1833 buffer->base = base;
1834 buffer->size = size;
1839 io_buffer_resize_copy(self, buffer, size);
1863 rb_io_buffer_resize(self, io_buffer_extract_size(size));
1877 const void *ptr1, *ptr2;
1878 size_t size1, size2;
1880 rb_io_buffer_get_bytes_for_reading(self, &ptr1, &size1);
1881 rb_io_buffer_get_bytes_for_reading(other, &ptr2, &size2);
1883 if (size1 < size2) {
1887 if (size1 > size2) {
1891 return RB_INT2NUM(memcmp(ptr1, ptr2, size1));
1895io_buffer_validate_type(
size_t size,
size_t offset,
size_t extend)
1897 if (size_sum_is_bigger_than(offset, extend, size)) {
1898 rb_raise(rb_eArgError,
"Type extends beyond end of buffer! (offset=%"PRIdSIZE
" > size=%"PRIdSIZE
")", offset, size);
1923#define ruby_swap8(value) value
1931ruby_swapf32(
float value)
1933 union swapf32 swap = {.value = value};
1934 swap.integral = ruby_swap32(swap.integral);
1944ruby_swapf64(
double value)
1946 union swapf64 swap = {.value = value};
1947 swap.integral = ruby_swap64(swap.integral);
1955static inline rb_uint128_t
1956ruby_swap128_uint(rb_uint128_t x)
1958 rb_uint128_t result;
1959#ifdef HAVE_UINT128_T
1960#if __has_builtin(__builtin_bswap128)
1961 result.value = __builtin_bswap128(x.value);
1964 uint64_t low = (uint64_t)x.value;
1965 uint64_t high = (uint64_t)(x.value >> 64);
1966 low = ruby_swap64(low);
1967 high = ruby_swap64(high);
1968 result.value = ((uint128_t)low << 64) | high;
1975 result.parts.low = ruby_swap64(x.parts.high);
1976 result.parts.high = ruby_swap64(x.parts.low);
1981static inline rb_int128_t
1982ruby_swap128_int(rb_int128_t x)
1987 conversion.uint128 = ruby_swap128_uint(conversion.uint128);
1988 return conversion.int128;
1991#define IO_BUFFER_VALIDATE_TYPE_FOR_WRITING(buffer, base, size, offset, type) \
1992 (io_buffer_get_bytes_for_writing(buffer, &(base), &(size)), \
1993 io_buffer_validate_type(size, offset, sizeof(type)))
1995#define IO_BUFFER_DECLARE_TYPE(name, type, endian, wrap, unwrap, swap) \
1996static ID RB_IO_BUFFER_DATA_TYPE_##name; \
1999io_buffer_read_##name(const void* base, size_t size, size_t *offset) \
2001 io_buffer_validate_type(size, *offset, sizeof(type)); \
2003 memcpy(&value, (char*)base + *offset, sizeof(type)); \
2004 if (endian != RB_IO_BUFFER_HOST_ENDIAN) value = swap(value); \
2005 *offset += sizeof(type); \
2006 return wrap(value); \
2010io_buffer_write_##name(struct rb_io_buffer* buffer, size_t *offset, VALUE _value) \
2012 void* base; size_t size; \
2013 IO_BUFFER_VALIDATE_TYPE_FOR_WRITING(buffer, base, size, *offset, type); \
2014 type value = unwrap(_value); \
2015 IO_BUFFER_VALIDATE_TYPE_FOR_WRITING(buffer, base, size, *offset, type); \
2016 if (endian != RB_IO_BUFFER_HOST_ENDIAN) value = swap(value); \
2017 memcpy((char*)base + *offset, &value, sizeof(type)); \
2018 *offset += sizeof(type); \
2022 RB_IO_BUFFER_DATA_TYPE_##name##_SIZE = sizeof(type) \
2025IO_BUFFER_DECLARE_TYPE(U8, uint8_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_UINT2NUM, RB_NUM2UINT, ruby_swap8)
2028IO_BUFFER_DECLARE_TYPE(u16, uint16_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_UINT2NUM, RB_NUM2UINT, ruby_swap16)
2029IO_BUFFER_DECLARE_TYPE(U16, uint16_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_UINT2NUM, RB_NUM2UINT, ruby_swap16)
2030IO_BUFFER_DECLARE_TYPE(s16, int16_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_INT2NUM,
RB_NUM2INT, ruby_swap16)
2031IO_BUFFER_DECLARE_TYPE(S16, int16_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_INT2NUM,
RB_NUM2INT, ruby_swap16)
2033IO_BUFFER_DECLARE_TYPE(u32, uint32_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_UINT2NUM, RB_NUM2UINT, ruby_swap32)
2034IO_BUFFER_DECLARE_TYPE(U32, uint32_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_UINT2NUM, RB_NUM2UINT, ruby_swap32)
2035IO_BUFFER_DECLARE_TYPE(s32, int32_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_INT2NUM,
RB_NUM2INT, ruby_swap32)
2036IO_BUFFER_DECLARE_TYPE(S32, int32_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_INT2NUM,
RB_NUM2INT, ruby_swap32)
2038IO_BUFFER_DECLARE_TYPE(u64, uint64_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_ULL2NUM,
RB_NUM2ULL, ruby_swap64)
2039IO_BUFFER_DECLARE_TYPE(U64, uint64_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_ULL2NUM,
RB_NUM2ULL, ruby_swap64)
2040IO_BUFFER_DECLARE_TYPE(s64, int64_t, RB_IO_BUFFER_LITTLE_ENDIAN,
RB_LL2NUM,
RB_NUM2LL, ruby_swap64)
2041IO_BUFFER_DECLARE_TYPE(S64, int64_t, RB_IO_BUFFER_BIG_ENDIAN,
RB_LL2NUM,
RB_NUM2LL, ruby_swap64)
2043IO_BUFFER_DECLARE_TYPE(u128, rb_uint128_t, RB_IO_BUFFER_LITTLE_ENDIAN, rb_uint128_to_numeric, rb_numeric_to_uint128, ruby_swap128_uint)
2044IO_BUFFER_DECLARE_TYPE(U128, rb_uint128_t, RB_IO_BUFFER_BIG_ENDIAN, rb_uint128_to_numeric, rb_numeric_to_uint128, ruby_swap128_uint)
2045IO_BUFFER_DECLARE_TYPE(s128, rb_int128_t, RB_IO_BUFFER_LITTLE_ENDIAN, rb_int128_to_numeric, rb_numeric_to_int128, ruby_swap128_int)
2046IO_BUFFER_DECLARE_TYPE(S128, rb_int128_t, RB_IO_BUFFER_BIG_ENDIAN, rb_int128_to_numeric, rb_numeric_to_int128, ruby_swap128_int)
2048IO_BUFFER_DECLARE_TYPE(f32,
float, RB_IO_BUFFER_LITTLE_ENDIAN,
DBL2NUM,
NUM2DBL, ruby_swapf32)
2049IO_BUFFER_DECLARE_TYPE(F32,
float, RB_IO_BUFFER_BIG_ENDIAN,
DBL2NUM,
NUM2DBL, ruby_swapf32)
2050IO_BUFFER_DECLARE_TYPE(f64,
double, RB_IO_BUFFER_LITTLE_ENDIAN,
DBL2NUM,
NUM2DBL, ruby_swapf64)
2051IO_BUFFER_DECLARE_TYPE(F64,
double, RB_IO_BUFFER_BIG_ENDIAN,
DBL2NUM,
NUM2DBL, ruby_swapf64)
2052#undef IO_BUFFER_DECLARE_TYPE
2055io_buffer_buffer_type_size(
ID buffer_type)
2057#define IO_BUFFER_DATA_TYPE_SIZE(name) if (buffer_type == RB_IO_BUFFER_DATA_TYPE_##name) return RB_IO_BUFFER_DATA_TYPE_##name##_SIZE;
2058 IO_BUFFER_DATA_TYPE_SIZE(U8)
2059 IO_BUFFER_DATA_TYPE_SIZE(S8)
2060 IO_BUFFER_DATA_TYPE_SIZE(u16)
2061 IO_BUFFER_DATA_TYPE_SIZE(U16)
2062 IO_BUFFER_DATA_TYPE_SIZE(s16)
2063 IO_BUFFER_DATA_TYPE_SIZE(S16)
2064 IO_BUFFER_DATA_TYPE_SIZE(u32)
2065 IO_BUFFER_DATA_TYPE_SIZE(U32)
2066 IO_BUFFER_DATA_TYPE_SIZE(s32)
2067 IO_BUFFER_DATA_TYPE_SIZE(S32)
2068 IO_BUFFER_DATA_TYPE_SIZE(u64)
2069 IO_BUFFER_DATA_TYPE_SIZE(U64)
2070 IO_BUFFER_DATA_TYPE_SIZE(s64)
2071 IO_BUFFER_DATA_TYPE_SIZE(S64)
2072 IO_BUFFER_DATA_TYPE_SIZE(u128)
2073 IO_BUFFER_DATA_TYPE_SIZE(U128)
2074 IO_BUFFER_DATA_TYPE_SIZE(s128)
2075 IO_BUFFER_DATA_TYPE_SIZE(S128)
2076 IO_BUFFER_DATA_TYPE_SIZE(f32)
2077 IO_BUFFER_DATA_TYPE_SIZE(F32)
2078 IO_BUFFER_DATA_TYPE_SIZE(f64)
2079 IO_BUFFER_DATA_TYPE_SIZE(F64)
2080#undef IO_BUFFER_DATA_TYPE_SIZE
2082 rb_raise(rb_eArgError,
"Invalid type name!");
2096io_buffer_size_of(
VALUE klass,
VALUE buffer_type)
2098 if (RB_TYPE_P(buffer_type,
T_ARRAY)) {
2100 for (
long i = 0; i <
RARRAY_LEN(buffer_type); i++) {
2111rb_io_buffer_get_value(
const void* base,
size_t size,
ID buffer_type,
size_t *offset)
2113#define IO_BUFFER_GET_VALUE(name) if (buffer_type == RB_IO_BUFFER_DATA_TYPE_##name) return io_buffer_read_##name(base, size, offset);
2114 IO_BUFFER_GET_VALUE(U8)
2115 IO_BUFFER_GET_VALUE(S8)
2117 IO_BUFFER_GET_VALUE(u16)
2118 IO_BUFFER_GET_VALUE(U16)
2119 IO_BUFFER_GET_VALUE(s16)
2120 IO_BUFFER_GET_VALUE(S16)
2122 IO_BUFFER_GET_VALUE(u32)
2123 IO_BUFFER_GET_VALUE(U32)
2124 IO_BUFFER_GET_VALUE(s32)
2125 IO_BUFFER_GET_VALUE(S32)
2127 IO_BUFFER_GET_VALUE(u64)
2128 IO_BUFFER_GET_VALUE(U64)
2129 IO_BUFFER_GET_VALUE(s64)
2130 IO_BUFFER_GET_VALUE(S64)
2132 IO_BUFFER_GET_VALUE(u128)
2133 IO_BUFFER_GET_VALUE(U128)
2134 IO_BUFFER_GET_VALUE(s128)
2135 IO_BUFFER_GET_VALUE(S128)
2137 IO_BUFFER_GET_VALUE(f32)
2138 IO_BUFFER_GET_VALUE(F32)
2139 IO_BUFFER_GET_VALUE(f64)
2140 IO_BUFFER_GET_VALUE(F64)
2141#undef IO_BUFFER_GET_VALUE
2143 rb_raise(rb_eArgError,
"Invalid type name!");
2189 size_t offset = io_buffer_extract_offset(_offset);
2191 rb_io_buffer_get_bytes_for_reading(self, &base, &size);
2193 return rb_io_buffer_get_value(base, size,
RB_SYM2ID(
type), &offset);
2209 size_t offset = io_buffer_extract_offset(_offset);
2213 rb_io_buffer_get_bytes_for_reading(self, &base, &size);
2215 if (!RB_TYPE_P(buffer_types,
T_ARRAY)) {
2216 rb_raise(rb_eArgError,
"Argument buffer_types should be an array!");
2221 for (
long i = 0; i <
RARRAY_LEN(buffer_types); i++) {
2233io_buffer_extract_count(
VALUE argument)
2235 if (rb_int_negative_p(argument)) {
2236 rb_raise(rb_eArgError,
"Count can't be negative!");
2243io_buffer_extract_offset_count(
ID buffer_type,
size_t size,
int argc,
VALUE *argv,
size_t *offset,
size_t *count)
2246 *offset = io_buffer_extract_offset(argv[0]);
2253 *count = io_buffer_extract_count(argv[1]);
2256 if (*offset > size) {
2257 rb_raise(rb_eArgError,
"The given offset is bigger than the buffer size!");
2260 *count = (size - *offset) / io_buffer_buffer_type_size(buffer_type);
2281io_buffer_each(
int argc,
VALUE *argv,
VALUE self)
2288 rb_io_buffer_get_bytes_for_reading(self, &base, &size);
2295 buffer_type = RB_IO_BUFFER_DATA_TYPE_U8;
2298 size_t offset, count;
2299 io_buffer_extract_offset_count(buffer_type, size, argc-1, argv+1, &offset, &count);
2301 for (
size_t i = 0; i < count; i++) {
2302 size_t current_offset = offset;
2303 VALUE value = rb_io_buffer_get_value(base, size, buffer_type, &offset);
2321io_buffer_values(
int argc,
VALUE *argv,
VALUE self)
2326 rb_io_buffer_get_bytes_for_reading(self, &base, &size);
2333 buffer_type = RB_IO_BUFFER_DATA_TYPE_U8;
2336 size_t offset, count;
2337 io_buffer_extract_offset_count(buffer_type, size, argc-1, argv+1, &offset, &count);
2341 for (
size_t i = 0; i < count; i++) {
2342 VALUE value = rb_io_buffer_get_value(base, size, buffer_type, &offset);
2365io_buffer_each_byte(
int argc,
VALUE *argv,
VALUE self)
2372 rb_io_buffer_get_bytes_for_reading(self, &base, &size);
2374 size_t offset, count;
2375 io_buffer_extract_offset_count(RB_IO_BUFFER_DATA_TYPE_U8, size, argc, argv, &offset, &count);
2377 if (size_sum_is_bigger_than(offset, count, size)) {
2378 rb_raise(rb_eArgError,
"Specified offset+count is bigger than the buffer size!");
2381 for (
size_t i = 0; i < count; i++) {
2382 unsigned char *value = (
unsigned char *)base + i + offset;
2393#define IO_BUFFER_SET_VALUE(name) if (type == RB_IO_BUFFER_DATA_TYPE_##name) {io_buffer_write_##name(buffer, offset, value); return;}
2394 IO_BUFFER_SET_VALUE(U8);
2395 IO_BUFFER_SET_VALUE(S8);
2397 IO_BUFFER_SET_VALUE(u16);
2398 IO_BUFFER_SET_VALUE(U16);
2399 IO_BUFFER_SET_VALUE(s16);
2400 IO_BUFFER_SET_VALUE(S16);
2402 IO_BUFFER_SET_VALUE(u32);
2403 IO_BUFFER_SET_VALUE(U32);
2404 IO_BUFFER_SET_VALUE(s32);
2405 IO_BUFFER_SET_VALUE(S32);
2407 IO_BUFFER_SET_VALUE(u64);
2408 IO_BUFFER_SET_VALUE(U64);
2409 IO_BUFFER_SET_VALUE(s64);
2410 IO_BUFFER_SET_VALUE(S64);
2412 IO_BUFFER_SET_VALUE(u128);
2413 IO_BUFFER_SET_VALUE(U128);
2414 IO_BUFFER_SET_VALUE(s128);
2415 IO_BUFFER_SET_VALUE(S128);
2417 IO_BUFFER_SET_VALUE(f32);
2418 IO_BUFFER_SET_VALUE(F32);
2419 IO_BUFFER_SET_VALUE(f64);
2420 IO_BUFFER_SET_VALUE(F64);
2421#undef IO_BUFFER_SET_VALUE
2423 rb_raise(rb_eArgError,
"Invalid type name!");
2433io_buffer_set_value_try(
VALUE arguments)
2436 size_t offset = args->offset;
2437 rb_io_buffer_set_value(args->buffer, args->type, &offset, args->value);
2475 .buffer = get_io_buffer_for_writing(self),
2476 .offset = io_buffer_extract_offset(_offset),
2481 if (!io_buffer_try_lock(arguments.buffer)) {
2482 return io_buffer_set_value_try((
VALUE)&arguments);
2484 return rb_ensure(io_buffer_set_value_try, (
VALUE)&arguments, rb_io_buffer_locked_ensure, self);
2488io_buffer_set_values_try(
VALUE arguments)
2491 size_t offset = args->offset;
2493 for (
long i = 0; i <
RARRAY_LEN(args->type); i++) {
2496 rb_io_buffer_set_value(args->buffer,
type, &offset, value);
2520 .buffer = get_io_buffer_for_writing(self),
2523 if (!RB_TYPE_P(buffer_types,
T_ARRAY)) {
2524 rb_raise(rb_eArgError,
"Argument buffer_types should be an array!");
2526 arguments.type = buffer_types;
2528 arguments.offset = io_buffer_extract_offset(_offset);
2530 if (!RB_TYPE_P(values,
T_ARRAY)) {
2531 rb_raise(rb_eArgError,
"Argument values should be an array!");
2533 arguments.value = values;
2536 rb_raise(rb_eArgError,
"Argument buffer_types and values should have the same length!");
2539 if (!io_buffer_try_lock(arguments.buffer)) {
2540 return io_buffer_set_values_try((
VALUE)&arguments);
2542 return rb_ensure(io_buffer_set_values_try, (
VALUE)&arguments, rb_io_buffer_locked_ensure, self);
2546static size_t IO_BUFFER_BLOCKING_SIZE = 1024*1024;
2549 unsigned char * destination;
2550 const unsigned char * source;
2555io_buffer_memmove_blocking(
void *data)
2559 memmove(arguments->destination, arguments->source, arguments->length);
2565io_buffer_memmove_unblock(
void *data)
2571io_buffer_memmove(
struct rb_io_buffer *buffer,
size_t offset,
const void *source_base,
size_t source_offset,
size_t source_size,
size_t length)
2575 io_buffer_get_bytes_for_writing(buffer, &base, &size);
2577 io_buffer_validate_range(buffer, offset, length);
2579 if (size_sum_is_bigger_than(source_offset, length, source_size)) {
2580 rb_raise(rb_eArgError,
"The computed source range exceeds the size of the source buffer!");
2584 .destination = (
unsigned char*)base+offset,
2585 .source = (
unsigned char*)source_base+source_offset,
2589 if (arguments.length >= IO_BUFFER_BLOCKING_SIZE) {
2591 }
else if (arguments.length != 0) {
2592 memmove(arguments.destination, arguments.source, arguments.length);
2598io_buffer_copy_from(
struct rb_io_buffer *buffer,
const void *source_base,
size_t source_size,
int argc,
VALUE *argv)
2602 size_t source_offset;
2606 offset = io_buffer_extract_offset(argv[0]);
2611 source_offset = io_buffer_extract_offset(argv[2]);
2613 if (source_offset > source_size) {
2614 rb_raise(rb_eArgError,
"The given source offset is bigger than the source itself!");
2622 if (argc >= 2 && !RB_NIL_P(argv[1])) {
2623 length = io_buffer_extract_length(argv[1]);
2627 length = source_size - source_offset;
2630 io_buffer_memmove(buffer, offset, source_base, source_offset, source_size, length);
2653rb_io_buffer_initialize_copy(
VALUE self,
VALUE source)
2658 const void *source_base;
2661 rb_io_buffer_get_bytes_for_reading(source, &source_base, &source_size);
2663 io_buffer_initialize(self, buffer, NULL, source_size, io_flags_for_size(source_size),
Qnil);
2665 VALUE result = io_buffer_copy_from(buffer, source_base, source_size, 0, NULL);
2739io_buffer_copy(
int argc,
VALUE *argv,
VALUE self)
2741 rb_check_arity(argc, 1, 4);
2746 VALUE source = argv[0];
2747 const void *source_base;
2750 rb_io_buffer_get_bytes_for_reading(source, &source_base, &source_size);
2752 VALUE result = io_buffer_copy_from(buffer, source_base, source_size, argc-1, argv+1);
2772io_buffer_get_string(
int argc,
VALUE *argv,
VALUE self)
2774 rb_check_arity(argc, 0, 3);
2776 size_t offset, length;
2777 struct rb_io_buffer *buffer = io_buffer_extract_offset_length(self, argc, argv, &offset, &length);
2779 rb_encoding *encoding;
2781 encoding = rb_find_encoding(argv[2]);
2784 encoding = rb_ascii8bit_encoding();
2789 io_buffer_get_bytes_for_reading(buffer, &base, &size);
2791 io_buffer_validate_range(buffer, offset, length);
2793 return rb_enc_str_new((
const char*)base + offset, length, encoding);
2820io_buffer_set_string(
int argc,
VALUE *argv,
VALUE self)
2822 rb_check_arity(argc, 1, 4);
2829 const void *source_base = RSTRING_PTR(
string);
2830 size_t source_size = RSTRING_LEN(
string);
2832 VALUE result = io_buffer_copy_from(buffer, source_base, source_size, argc-1, argv+1);
2838rb_io_buffer_clear(
VALUE self, uint8_t value,
size_t offset,
size_t length)
2845 io_buffer_get_bytes_for_writing(buffer, &base, &size);
2847 io_buffer_validate_range(buffer, offset, length);
2849 memset((
char*)base + offset, value, length);
2884io_buffer_clear(
int argc,
VALUE *argv,
VALUE self)
2886 rb_check_arity(argc, 0, 3);
2893 size_t offset, length;
2894 io_buffer_extract_offset_length(self, argc-1, argv+1, &offset, &length);
2896 rb_io_buffer_clear(self, value, offset, length);
2902io_buffer_default_size(
size_t page_size)
2905 const size_t platform_agnostic_default_size = 64*1024;
2908 const char *default_size = getenv(
"RUBY_IO_BUFFER_DEFAULT_SIZE");
2911 int value = atoi(default_size);
2919 if (platform_agnostic_default_size < page_size) {
2923 return platform_agnostic_default_size;
2929 rb_blocking_function_t *function;
2934io_buffer_blocking_region_begin(
VALUE _argument)
2938 return rb_io_blocking_region(argument->io, argument->function, argument->data);
2942io_buffer_blocking_region_ensure(
VALUE _argument)
2946 io_buffer_unlock(argument->buffer);
2952io_buffer_blocking_region(
VALUE io,
struct rb_io_buffer *buffer, rb_blocking_function_t *function,
void *data)
2954 struct rb_io *ioptr;
2960 .function = function,
2965 if (buffer->flags & RB_IO_BUFFER_LOCKED) {
2966 return io_buffer_blocking_region_begin((
VALUE)&argument);
2970 io_buffer_lock(buffer);
2972 return rb_ensure(io_buffer_blocking_region_begin, (
VALUE)&argument, io_buffer_blocking_region_ensure, (
VALUE)&argument);
2988io_buffer_read_internal(
void *_argument)
2994 ssize_t result = read(argument->descriptor, argument->base, argument->size);
2997 return rb_fiber_scheduler_io_result(result,
errno);
2999 else if (result == 0) {
3000 return rb_fiber_scheduler_io_result(total, 0);
3005 if (total >= argument->length) {
3006 return rb_fiber_scheduler_io_result(total, 0);
3009 argument->base = argument->base + result;
3010 argument->size = argument->size - result;
3016rb_io_buffer_read(
VALUE self,
VALUE io,
size_t length,
size_t offset)
3021 if (scheduler !=
Qnil) {
3024 if (!UNDEF_P(result)) {
3032 io_buffer_validate_range(buffer, offset, length);
3038 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3040 base = (
unsigned char*)base + offset;
3041 size = size - offset;
3044 .descriptor = descriptor,
3050 return io_buffer_blocking_region(io, buffer, io_buffer_read_internal, &argument);
3080io_buffer_read(
int argc,
VALUE *argv,
VALUE self)
3082 rb_check_arity(argc, 1, 3);
3086 size_t length, offset;
3087 io_buffer_extract_length_offset(self, argc-1, argv+1, &length, &offset);
3089 return rb_io_buffer_read(self, io, length, offset);
3106io_buffer_pread_internal(
void *_argument)
3112 ssize_t result = pread(argument->descriptor, argument->base, argument->size, argument->offset);
3115 return rb_fiber_scheduler_io_result(result,
errno);
3117 else if (result == 0) {
3118 return rb_fiber_scheduler_io_result(total, 0);
3123 if (total >= argument->length) {
3124 return rb_fiber_scheduler_io_result(total, 0);
3127 argument->base = argument->base + result;
3128 argument->size = argument->size - result;
3129 argument->offset = argument->offset + result;
3135rb_io_buffer_pread(
VALUE self,
VALUE io, rb_off_t from,
size_t length,
size_t offset)
3140 if (scheduler !=
Qnil) {
3143 if (!UNDEF_P(result)) {
3151 io_buffer_validate_range(buffer, offset, length);
3157 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3159 base = (
unsigned char*)base + offset;
3160 size = size - offset;
3163 .descriptor = descriptor,
3170 return io_buffer_blocking_region(io, buffer, io_buffer_pread_internal, &argument);
3204io_buffer_pread(
int argc,
VALUE *argv,
VALUE self)
3206 rb_check_arity(argc, 2, 4);
3211 size_t length, offset;
3212 io_buffer_extract_length_offset(self, argc-2, argv+2, &length, &offset);
3214 return rb_io_buffer_pread(self, io, from, length, offset);
3229io_buffer_write_internal(
void *_argument)
3235 ssize_t result = write(argument->descriptor, argument->base, argument->size);
3238 return rb_fiber_scheduler_io_result(result,
errno);
3240 else if (result == 0) {
3241 return rb_fiber_scheduler_io_result(total, 0);
3246 if (total >= argument->length) {
3247 return rb_fiber_scheduler_io_result(total, 0);
3250 argument->base = argument->base + result;
3251 argument->size = argument->size - result;
3257rb_io_buffer_write(
VALUE self,
VALUE io,
size_t length,
size_t offset)
3262 if (scheduler !=
Qnil) {
3265 if (!UNDEF_P(result)) {
3273 io_buffer_validate_range(buffer, offset, length);
3279 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3281 base = (
unsigned char*)base + offset;
3282 size = size - offset;
3285 .descriptor = descriptor,
3291 return io_buffer_blocking_region(io, buffer, io_buffer_write_internal, &argument);
3314io_buffer_write(
int argc,
VALUE *argv,
VALUE self)
3316 rb_check_arity(argc, 1, 3);
3320 size_t length, offset;
3321 io_buffer_extract_length_offset(self, argc-1, argv+1, &length, &offset);
3323 return rb_io_buffer_write(self, io, length, offset);
3340io_buffer_pwrite_internal(
void *_argument)
3346 ssize_t result = pwrite(argument->descriptor, argument->base, argument->size, argument->offset);
3349 return rb_fiber_scheduler_io_result(result,
errno);
3351 else if (result == 0) {
3352 return rb_fiber_scheduler_io_result(total, 0);
3357 if (total >= argument->length) {
3358 return rb_fiber_scheduler_io_result(total, 0);
3361 argument->base = argument->base + result;
3362 argument->size = argument->size - result;
3363 argument->offset = argument->offset + result;
3369rb_io_buffer_pwrite(
VALUE self,
VALUE io, rb_off_t from,
size_t length,
size_t offset)
3374 if (scheduler !=
Qnil) {
3377 if (!UNDEF_P(result)) {
3385 io_buffer_validate_range(buffer, offset, length);
3391 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3393 base = (
unsigned char*)base + offset;
3394 size = size - offset;
3397 .descriptor = descriptor,
3412 return io_buffer_blocking_region(io, buffer, io_buffer_pwrite_internal, &argument);
3440io_buffer_pwrite(
int argc,
VALUE *argv,
VALUE self)
3442 rb_check_arity(argc, 2, 4);
3447 size_t length, offset;
3448 io_buffer_extract_length_offset(self, argc-2, argv+2, &length, &offset);
3450 return rb_io_buffer_pwrite(self, io, from, length, offset);
3454io_buffer_check_mask_size(
size_t size)
3457 rb_raise(rb_eIOBufferMaskError,
"Zero-length mask given!");
3461memory_and(
unsigned char * restrict output,
const unsigned char * restrict base,
size_t size,
const unsigned char * restrict mask,
size_t mask_size)
3463 for (
size_t offset = 0; offset < size; offset += 1) {
3464 output[offset] = base[offset] & mask[offset % mask_size];
3491 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3493 const void *mask_base;
3495 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3497 io_buffer_check_mask_size(mask_size);
3499 VALUE output = rb_io_buffer_new(NULL, size, io_flags_for_size(size));
3503 memory_and(output_buffer->base, base, size, mask_base, mask_size);
3509memory_or(
unsigned char * restrict output,
const unsigned char * restrict base,
size_t size,
const unsigned char * restrict mask,
size_t mask_size)
3511 for (
size_t offset = 0; offset < size; offset += 1) {
3512 output[offset] = base[offset] | mask[offset % mask_size];
3539 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3541 const void *mask_base;
3543 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3545 io_buffer_check_mask_size(mask_size);
3547 VALUE output = rb_io_buffer_new(NULL, size, io_flags_for_size(size));
3551 memory_or(output_buffer->base, base, size, mask_base, mask_size);
3557memory_xor(
unsigned char * restrict output,
const unsigned char * restrict base,
size_t size,
const unsigned char * restrict mask,
size_t mask_size)
3559 for (
size_t offset = 0; offset < size; offset += 1) {
3560 output[offset] = base[offset] ^ mask[offset % mask_size];
3587 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3589 const void *mask_base;
3591 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3593 io_buffer_check_mask_size(mask_size);
3595 VALUE output = rb_io_buffer_new(NULL, size, io_flags_for_size(size));
3599 memory_xor(output_buffer->base, base, size, mask_base, mask_size);
3605memory_not(
unsigned char * restrict output,
const unsigned char * restrict base,
size_t size)
3607 for (
size_t offset = 0; offset < size; offset += 1) {
3608 output[offset] = ~base[offset];
3625io_buffer_not(
VALUE self)
3632 io_buffer_get_bytes_for_reading(buffer, &base, &size);
3634 VALUE output = rb_io_buffer_new(NULL, size, io_flags_for_size(size));
3638 memory_not(output_buffer->base, base, size);
3646 if (a->base > b->base) {
3647 return io_buffer_overlaps(b, a);
3650 return (b->base >= a->base) && (b->base < (
void*)((
unsigned char *)a->base + a->size));
3656 if (io_buffer_overlaps(a, b))
3657 rb_raise(rb_eIOBufferMaskError,
"Mask overlaps source buffer!");
3661memory_and_inplace(
unsigned char * restrict base,
size_t size,
unsigned char * restrict mask,
size_t mask_size)
3663 for (
size_t offset = 0; offset < size; offset += 1) {
3664 base[offset] &= mask[offset % mask_size];
3694 io_buffer_check_mask_size(mask_buffer->size);
3695 io_buffer_check_overlaps(buffer, mask_buffer);
3699 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3701 const void *mask_base;
3703 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3705 memory_and_inplace(base, size, mask_buffer->base, mask_buffer->size);
3711memory_or_inplace(
unsigned char * restrict base,
size_t size,
unsigned char * restrict mask,
size_t mask_size)
3713 for (
size_t offset = 0; offset < size; offset += 1) {
3714 base[offset] |= mask[offset % mask_size];
3744 io_buffer_check_mask_size(mask_buffer->size);
3745 io_buffer_check_overlaps(buffer, mask_buffer);
3749 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3751 const void *mask_base;
3753 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3755 memory_or_inplace(base, size, mask_buffer->base, mask_buffer->size);
3761memory_xor_inplace(
unsigned char * restrict base,
size_t size,
unsigned char * restrict mask,
size_t mask_size)
3763 for (
size_t offset = 0; offset < size; offset += 1) {
3764 base[offset] ^= mask[offset % mask_size];
3794 io_buffer_check_mask_size(mask_buffer->size);
3795 io_buffer_check_overlaps(buffer, mask_buffer);
3799 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3801 const void *mask_base;
3803 io_buffer_get_bytes_for_reading(mask_buffer, &mask_base, &mask_size);
3805 memory_xor_inplace(base, size, mask_buffer->base, mask_buffer->size);
3811memory_not_inplace(
unsigned char * restrict base,
size_t size)
3813 for (
size_t offset = 0; offset < size; offset += 1) {
3814 base[offset] = ~base[offset];
3836io_buffer_not_inplace(
VALUE self)
3843 io_buffer_get_bytes_for_writing(buffer, &base, &size);
3845 memory_not_inplace(base, size);
3963 GetSystemInfo(&info);
3964 RUBY_IO_BUFFER_PAGE_SIZE = info.dwPageSize;
3966 RUBY_IO_BUFFER_PAGE_SIZE = sysconf(_SC_PAGESIZE);
3969 RUBY_IO_BUFFER_DEFAULT_SIZE = io_buffer_default_size(RUBY_IO_BUFFER_PAGE_SIZE);
3972 rb_define_const(rb_cIOBuffer,
"PAGE_SIZE",
SIZET2NUM(RUBY_IO_BUFFER_PAGE_SIZE));
3977 rb_define_const(rb_cIOBuffer,
"DEFAULT_SIZE",
SIZET2NUM(RUBY_IO_BUFFER_DEFAULT_SIZE));
3982 rb_define_method(rb_cIOBuffer,
"initialize_copy", rb_io_buffer_initialize_copy, 1);
3992 rb_define_const(rb_cIOBuffer,
"EXTERNAL",
RB_INT2NUM(RB_IO_BUFFER_EXTERNAL));
3995 rb_define_const(rb_cIOBuffer,
"INTERNAL",
RB_INT2NUM(RB_IO_BUFFER_INTERNAL));
3998 rb_define_const(rb_cIOBuffer,
"MAPPED",
RB_INT2NUM(RB_IO_BUFFER_MAPPED));
4001 rb_define_const(rb_cIOBuffer,
"SHARED",
RB_INT2NUM(RB_IO_BUFFER_SHARED));
4004 rb_define_const(rb_cIOBuffer,
"LOCKED",
RB_INT2NUM(RB_IO_BUFFER_LOCKED));
4007 rb_define_const(rb_cIOBuffer,
"PRIVATE",
RB_INT2NUM(RB_IO_BUFFER_PRIVATE));
4010 rb_define_const(rb_cIOBuffer,
"READONLY",
RB_INT2NUM(RB_IO_BUFFER_READONLY));
4013 rb_define_const(rb_cIOBuffer,
"LITTLE_ENDIAN",
RB_INT2NUM(RB_IO_BUFFER_LITTLE_ENDIAN));
4016 rb_define_const(rb_cIOBuffer,
"BIG_ENDIAN",
RB_INT2NUM(RB_IO_BUFFER_BIG_ENDIAN));
4019 rb_define_const(rb_cIOBuffer,
"HOST_ENDIAN",
RB_INT2NUM(RB_IO_BUFFER_HOST_ENDIAN));
4022 rb_define_const(rb_cIOBuffer,
"NETWORK_ENDIAN",
RB_INT2NUM(RB_IO_BUFFER_NETWORK_ENDIAN));
4048#define IO_BUFFER_DEFINE_DATA_TYPE(name) RB_IO_BUFFER_DATA_TYPE_##name = rb_intern_const(#name)
4049 IO_BUFFER_DEFINE_DATA_TYPE(U8);
4050 IO_BUFFER_DEFINE_DATA_TYPE(S8);
4052 IO_BUFFER_DEFINE_DATA_TYPE(u16);
4053 IO_BUFFER_DEFINE_DATA_TYPE(U16);
4054 IO_BUFFER_DEFINE_DATA_TYPE(s16);
4055 IO_BUFFER_DEFINE_DATA_TYPE(S16);
4057 IO_BUFFER_DEFINE_DATA_TYPE(u32);
4058 IO_BUFFER_DEFINE_DATA_TYPE(U32);
4059 IO_BUFFER_DEFINE_DATA_TYPE(s32);
4060 IO_BUFFER_DEFINE_DATA_TYPE(S32);
4062 IO_BUFFER_DEFINE_DATA_TYPE(u64);
4063 IO_BUFFER_DEFINE_DATA_TYPE(U64);
4064 IO_BUFFER_DEFINE_DATA_TYPE(s64);
4065 IO_BUFFER_DEFINE_DATA_TYPE(S64);
4067 IO_BUFFER_DEFINE_DATA_TYPE(u128);
4068 IO_BUFFER_DEFINE_DATA_TYPE(U128);
4069 IO_BUFFER_DEFINE_DATA_TYPE(s128);
4070 IO_BUFFER_DEFINE_DATA_TYPE(S128);
4072 IO_BUFFER_DEFINE_DATA_TYPE(f32);
4073 IO_BUFFER_DEFINE_DATA_TYPE(F32);
4074 IO_BUFFER_DEFINE_DATA_TYPE(f64);
4075 IO_BUFFER_DEFINE_DATA_TYPE(F64);
4076#undef IO_BUFFER_DEFINE_DATA_TYPE
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
int rb_block_given_p(void)
Determines if the current method is given a block.
#define T_STRING
Old name of RUBY_T_STRING.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define CLASS_OF
Old name of rb_class_of.
#define SIZET2NUM
Old name of RB_SIZE2NUM.
#define NUM2UINT
Old name of RB_NUM2UINT.
#define NUM2DBL
Old name of rb_num2dbl.
#define Qnil
Old name of RUBY_Qnil.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define DBL2NUM
Old name of rb_float_new.
#define NUM2SIZET
Old name of RB_NUM2SIZE.
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
@ RB_WARN_CATEGORY_EXPERIMENTAL
Warning is for experimental features.
VALUE rb_mComparable
Comparable module.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
#define RETURN_ENUMERATOR_KW(obj, argc, argv, kw_splat)
Identical to RETURN_SIZED_ENUMERATOR_KW(), except its size is unknown.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
VALUE rb_str_locktmp(VALUE str)
Obtains a "temporary lock" of the string.
VALUE rb_str_unlocktmp(VALUE str)
Releases a lock formerly obtained by rb_str_locktmp().
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
#define RB_SYM2ID
Just another name of rb_sym2id.
VALUE rb_io_get_io(VALUE io)
Identical to rb_io_check_io(), except it raises exceptions on conversion failures.
int rb_io_descriptor(VALUE io)
Returns an integer representing the numeric file descriptor for io.
#define RB_IO_POINTER(obj, fp)
Queries the underlying IO pointer.
VALUE rb_io_get_write_io(VALUE io)
Queries the tied IO for writing.
void * rb_nogvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2, int flags)
Identical to rb_thread_call_without_gvl(), except it additionally takes "flags" that change the behav...
#define RB_NOGVL_OFFLOAD_SAFE
Passing this flag to rb_nogvl() indicates that the passed function is safe to offload to a background...
#define RB_NUM2INT
Just another name of rb_num2int_inline.
#define RB_UINT2NUM
Just another name of rb_uint2num_inline.
#define RB_INT2NUM
Just another name of rb_int2num_inline.
#define RB_LL2NUM
Just another name of rb_ll2num_inline.
#define RB_ULL2NUM
Just another name of rb_ull2num_inline.
#define RB_NUM2ULL
Just another name of rb_num2ull_inline.
#define RB_NUM2LL
Just another name of rb_num2ll_inline.
VALUE rb_yield_values(int n,...)
Identical to rb_yield(), except it takes variadic number of parameters and pass them to the block.
VALUE rb_yield(VALUE val)
Yields the block.
#define RB_NUM2LONG
Just another name of rb_num2long_inline.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define NUM2OFFT
Converts an instance of rb_cNumeric into C's off_t.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define StringValue(v)
Ensures that the parameter object is a String.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
VALUE rb_str_to_str(VALUE obj)
Identical to rb_check_string_type(), except it raises exceptions in case of conversion failures.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
#define errno
Ractor-aware version of errno.
#define RB_NO_KEYWORDS
Do not pass keywords.
VALUE rb_fiber_scheduler_current(void)
Identical to rb_fiber_scheduler_get(), except it also returns RUBY_Qnil in case of a blocking fiber.
VALUE rb_fiber_scheduler_io_pwrite(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t length, size_t offset)
Non-blocking write to the passed IO at the specified offset.
VALUE rb_fiber_scheduler_io_read(VALUE scheduler, VALUE io, VALUE buffer, size_t length, size_t offset)
Non-blocking read from the passed IO.
VALUE rb_fiber_scheduler_io_pread(VALUE scheduler, VALUE io, rb_off_t from, VALUE buffer, size_t length, size_t offset)
Non-blocking read from the passed IO at the specified offset.
VALUE rb_fiber_scheduler_io_write(VALUE scheduler, VALUE io, VALUE buffer, size_t length, size_t offset)
Non-blocking write to the passed IO.
Ruby's IO, metadata and buffers.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.