kotovalexarian-likes-github
/
ruby--ruby
mirror of https://github.com/ruby/ruby.git
1
0
Fork 0
Code Releases Activity

Add basic binary operators (and, or, xor, not) to `IO::Buffer`. (#5893)

This commit is contained in:
Samuel Williams 2022-05-09 17:19:01 +12:00 committed by GitHub
parent df0bcb3385
commit cea34bd808
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
Notes: git 2022-05-09 14:19:24 +09:00 
Merged-By: ioquatix <samuel@codeotaku.com>
2 changed files with 427 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

405
io_buffer.c
View File

@ -20,6 +20,7 @@ VALUE rb_eIOBufferLockedError;
VALUE rb_eIOBufferAllocationError;
VALUE rb_eIOBufferAccessError;
VALUE rb_eIOBufferInvalidatedError;
VALUE rb_eIOBufferMaskError;
size_t RUBY_IO_BUFFER_PAGE_SIZE;
size_t RUBY_IO_BUFFER_DEFAULT_SIZE;
@ -1692,6 +1693,40 @@ io_buffer_copy_from(struct rb_io_buffer *data, const void *source_base, size_t s
return SIZET2NUM(length);
}
/*
* call-seq:
* dup -> io_buffer
* clone -> io_buffer
*
* Make an internal copy of the source buffer. Updates to the copy will not
* affect the source buffer.
*
* source = IO::Buffer.for("Hello World")
* # =>
* # #<IO::Buffer 0x00007fd598466830+11 EXTERNAL READONLY SLICE>
* # 0x00000000 48 65 6c 6c 6f 20 57 6f 72 6c 64 Hello World
* buffer = source.dup
* # =>
* # #<IO::Buffer 0x0000558cbec03320+11 INTERNAL>
* # 0x00000000 48 65 6c 6c 6f 20 57 6f 72 6c 64 Hello World
*
*/
static VALUE
rb_io_buffer_initialize_copy(VALUE self, VALUE source)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
const void *source_base;
size_t source_size;
rb_io_buffer_get_bytes_for_reading(source, &source_base, &source_size);
io_buffer_initialize(data, NULL, source_size, io_flags_for_size(source_size), Qnil);
return io_buffer_copy_from(data, source_base, source_size, 0, NULL);
}
/*
* call-seq:
* copy(source, [offset, [length, [source_offset]]]) -> size
@ -2120,6 +2155,363 @@ io_buffer_pwrite(VALUE self, VALUE io, VALUE length, VALUE offset)
return rb_io_buffer_pwrite(self, io, RB_NUM2SIZE(length), NUM2OFFT(offset));
}
static inline void
io_buffer_check_mask(const struct rb_io_buffer *buffer)
{
if (buffer->size == 0)
rb_raise(rb_eIOBufferMaskError, "Zero-length mask given!");
}
static void
memory_and(unsigned char * restrict output, unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
output[offset] = base[offset] & mask[offset % mask_size];
}
}
/*
* call-seq:
* source & mask -> io_buffer
*
* Generate a new buffer the same size as the source by applying the binary AND
* operation to the source, using the mask, repeating as necessary.
*
* IO::Buffer.for("1234567890") & IO::Buffer.for("\xFF\x00\x00\xFF")
* # =>
* # #<IO::Buffer 0x00005589b2758480+4 INTERNAL>
* # 0x00000000 31 00 00 34 35 00 00 38 39 00 1..45..89.
*/
static VALUE
io_buffer_and(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
VALUE output = rb_io_buffer_new(NULL, data->size, io_flags_for_size(data->size));
struct rb_io_buffer *output_data = NULL;
TypedData_Get_Struct(output, struct rb_io_buffer, &rb_io_buffer_type, output_data);
memory_and(output_data->base, data->base, data->size, mask_data->base, mask_data->size);
return output;
}
static void
memory_or(unsigned char * restrict output, unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
output[offset] = base[offset] | mask[offset % mask_size];
}
}
/*
* call-seq:
* source | mask -> io_buffer
*
* Generate a new buffer the same size as the source by applying the binary OR
* operation to the source, using the mask, repeating as necessary.
*
* IO::Buffer.for("1234567890") | IO::Buffer.for("\xFF\x00\x00\xFF")
* # =>
* # #<IO::Buffer 0x0000561785ae3480+10 INTERNAL>
* # 0x00000000 ff 32 33 ff ff 36 37 ff ff 30 .23..67..0
*/
static VALUE
io_buffer_or(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
VALUE output = rb_io_buffer_new(NULL, data->size, io_flags_for_size(data->size));
struct rb_io_buffer *output_data = NULL;
TypedData_Get_Struct(output, struct rb_io_buffer, &rb_io_buffer_type, output_data);
memory_or(output_data->base, data->base, data->size, mask_data->base, mask_data->size);
return output;
}
static void
memory_xor(unsigned char * restrict output, unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
output[offset] = base[offset] ^ mask[offset % mask_size];
}
}
/*
* call-seq:
* source ^ mask -> io_buffer
*
* Generate a new buffer the same size as the source by applying the binary XOR
* operation to the source, using the mask, repeating as necessary.
*
* IO::Buffer.for("1234567890") ^ IO::Buffer.for("\xFF\x00\x00\xFF")
* # =>
* # #<IO::Buffer 0x000055a2d5d10480+10 INTERNAL>
* # 0x00000000 ce 32 33 cb ca 36 37 c7 c6 30 .23..67..0
*/
static VALUE
io_buffer_xor(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
VALUE output = rb_io_buffer_new(NULL, data->size, io_flags_for_size(data->size));
struct rb_io_buffer *output_data = NULL;
TypedData_Get_Struct(output, struct rb_io_buffer, &rb_io_buffer_type, output_data);
memory_xor(output_data->base, data->base, data->size, mask_data->base, mask_data->size);
return output;
}
static void
memory_not(unsigned char * restrict output, unsigned char * restrict base, size_t size)
{
for (size_t offset = 0; offset < size; offset += 1) {
output[offset] = ~base[offset];
}
}
/*
* call-seq:
* ~source -> io_buffer
*
* Generate a new buffer the same size as the source by applying the binary NOT
* operation to the source.
*
* ~IO::Buffer.for("1234567890")
* # =>
* # #<IO::Buffer 0x000055a5ac42f120+10 INTERNAL>
* # 0x00000000 ce cd cc cb ca c9 c8 c7 c6 cf ..........
*/
static VALUE
io_buffer_not(VALUE self)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
VALUE output = rb_io_buffer_new(NULL, data->size, io_flags_for_size(data->size));
struct rb_io_buffer *output_data = NULL;
TypedData_Get_Struct(output, struct rb_io_buffer, &rb_io_buffer_type, output_data);
memory_not(output_data->base, data->base, data->size);
return output;
}
static inline int
io_buffer_overlaps(const struct rb_io_buffer *a, const struct rb_io_buffer *b)
{
if (a->base > b->base) {
return io_buffer_overlaps(b, a);
}
return (b->base >= a->base) && (b->base <= (void*)((unsigned char *)a->base + a->size));
}
static inline void
io_buffer_check_overlaps(struct rb_io_buffer *a, struct rb_io_buffer *b)
{
if (io_buffer_overlaps(a, b))
rb_raise(rb_eIOBufferMaskError, "Mask overlaps source data!");
}
static void
memory_and_inplace(unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
base[offset] &= mask[offset % mask_size];
}
}
/*
* call-seq:
* source.and!(mask) -> io_buffer
*
* Modify the source buffer in place by applying the binary AND
* operation to the source, using the mask, repeating as necessary.
*
* source = IO::Buffer.for("1234567890").dup # Make a read/write copy.
* # =>
* # #<IO::Buffer 0x000056307a0d0c20+10 INTERNAL>
* # 0x00000000 31 32 33 34 35 36 37 38 39 30 1234567890
*
* source.and!(IO::Buffer.for("\xFF\x00\x00\xFF"))
* # =>
* # #<IO::Buffer 0x000056307a0d0c20+10 INTERNAL>
* # 0x00000000 31 00 00 34 35 00 00 38 39 00 1..45..89.
*/
static VALUE
io_buffer_and_inplace(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
io_buffer_check_overlaps(data, mask_data);
void *base;
size_t size;
io_buffer_get_bytes_for_writing(data, &base, &size);
memory_and_inplace(base, size, mask_data->base, mask_data->size);
return self;
}
static void
memory_or_inplace(unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
base[offset] |= mask[offset % mask_size];
}
}
/*
* call-seq:
* source.or!(mask) -> io_buffer
*
* Modify the source buffer in place by applying the binary OR
* operation to the source, using the mask, repeating as necessary.
*
* source = IO::Buffer.for("1234567890").dup # Make a read/write copy.
* # =>
* # #<IO::Buffer 0x000056307a272350+10 INTERNAL>
* # 0x00000000 31 32 33 34 35 36 37 38 39 30 1234567890
*
* source.or!(IO::Buffer.for("\xFF\x00\x00\xFF"))
* # =>
* # #<IO::Buffer 0x000056307a272350+10 INTERNAL>
* # 0x00000000 ff 32 33 ff ff 36 37 ff ff 30 .23..67..0
*/
static VALUE
io_buffer_or_inplace(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
io_buffer_check_overlaps(data, mask_data);
void *base;
size_t size;
io_buffer_get_bytes_for_writing(data, &base, &size);
memory_or_inplace(base, size, mask_data->base, mask_data->size);
return self;
}
static void
memory_xor_inplace(unsigned char * restrict base, size_t size, unsigned char * restrict mask, size_t mask_size)
{
for (size_t offset = 0; offset < size; offset += 1) {
base[offset] ^= mask[offset % mask_size];
}
}
/*
* call-seq:
* source.xor!(mask) -> io_buffer
*
* Modify the source buffer in place by applying the binary XOR
* operation to the source, using the mask, repeating as necessary.
*
* source = IO::Buffer.for("1234567890").dup # Make a read/write copy.
* # =>
* # #<IO::Buffer 0x000056307a25b3e0+10 INTERNAL>
* # 0x00000000 31 32 33 34 35 36 37 38 39 30 1234567890
*
* source.xor!(IO::Buffer.for("\xFF\x00\x00\xFF"))
* # =>
* # #<IO::Buffer 0x000056307a25b3e0+10 INTERNAL>
* # 0x00000000 ce 32 33 cb ca 36 37 c7 c6 30 .23..67..0
*/
static VALUE
io_buffer_xor_inplace(VALUE self, VALUE mask)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
struct rb_io_buffer *mask_data = NULL;
TypedData_Get_Struct(mask, struct rb_io_buffer, &rb_io_buffer_type, mask_data);
io_buffer_check_mask(mask_data);
io_buffer_check_overlaps(data, mask_data);
void *base;
size_t size;
io_buffer_get_bytes_for_writing(data, &base, &size);
memory_xor_inplace(base, size, mask_data->base, mask_data->size);
return self;
}
static void
memory_not_inplace(unsigned char * restrict base, size_t size)
{
for (size_t offset = 0; offset < size; offset += 1) {
base[offset] = ~base[offset];
}
}
/*
* call-seq:
* source.not! -> io_buffer
*
* Modify the source buffer in place by applying the binary NOT
* operation to the source.
*
* source = IO::Buffer.for("1234567890").dup # Make a read/write copy.
* # =>
* # #<IO::Buffer 0x000056307a33a450+10 INTERNAL>
* # 0x00000000 31 32 33 34 35 36 37 38 39 30 1234567890
*
* source.not!
* # =>
* # #<IO::Buffer 0x000056307a33a450+10 INTERNAL>
* # 0x00000000 ce cd cc cb ca c9 c8 c7 c6 cf ..........
*/
static VALUE
io_buffer_not_inplace(VALUE self)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
void *base;
size_t size;
io_buffer_get_bytes_for_writing(data, &base, &size);
memory_not_inplace(base, size);
return self;
}
/*
* Document-class: IO::Buffer
*
@ -2211,6 +2603,7 @@ Init_IO_Buffer(void)
rb_eIOBufferAllocationError = rb_define_class_under(rb_cIOBuffer, "AllocationError", rb_eRuntimeError);
rb_eIOBufferAccessError = rb_define_class_under(rb_cIOBuffer, "AccessError", rb_eRuntimeError);
rb_eIOBufferInvalidatedError = rb_define_class_under(rb_cIOBuffer, "InvalidatedError", rb_eRuntimeError);
rb_eIOBufferMaskError = rb_define_class_under(rb_cIOBuffer, "MaskError", rb_eArgError);
rb_define_alloc_func(rb_cIOBuffer, rb_io_buffer_type_allocate);
rb_define_singleton_method(rb_cIOBuffer, "for", rb_io_buffer_type_for, 1);
@ -2233,6 +2626,7 @@ Init_IO_Buffer(void)
// General use:
rb_define_method(rb_cIOBuffer, "initialize", rb_io_buffer_initialize, -1);
rb_define_method(rb_cIOBuffer, "initialize_copy", rb_io_buffer_initialize_copy, 1);
rb_define_method(rb_cIOBuffer, "inspect", rb_io_buffer_inspect, 0);
rb_define_method(rb_cIOBuffer, "hexdump", rb_io_buffer_hexdump, 0);
rb_define_method(rb_cIOBuffer, "to_s", rb_io_buffer_to_s, 0);
@ -2295,6 +2689,17 @@ Init_IO_Buffer(void)
rb_define_method(rb_cIOBuffer, "get_string", io_buffer_get_string, -1);
rb_define_method(rb_cIOBuffer, "set_string", io_buffer_set_string, -1);
// Binary data manipulations:
rb_define_method(rb_cIOBuffer, "&", io_buffer_and, 1);
rb_define_method(rb_cIOBuffer, "|", io_buffer_or, 1);
rb_define_method(rb_cIOBuffer, "^", io_buffer_xor, 1);
rb_define_method(rb_cIOBuffer, "~", io_buffer_not, 0);
rb_define_method(rb_cIOBuffer, "and!", io_buffer_and_inplace, 1);
rb_define_method(rb_cIOBuffer, "or!", io_buffer_or_inplace, 1);
rb_define_method(rb_cIOBuffer, "xor!", io_buffer_xor_inplace, 1);
rb_define_method(rb_cIOBuffer, "not!", io_buffer_not_inplace, 0);
// IO operations:
rb_define_method(rb_cIOBuffer, "read", io_buffer_read, 2);
rb_define_method(rb_cIOBuffer, "pread", io_buffer_pread, 3);

22
test/ruby/test_io_buffer.rb
View File

@ -331,4 +331,26 @@ class TestIOBuffer < Test::Unit::TestCase
ensure
io.close!
end
def test_operators
source = IO::Buffer.for("1234123412")
mask = IO::Buffer.for("133\x00")
result = source & mask
assert_equal (source & mask), IO::Buffer.for("123\x00123\x0012")
assert_equal (source | mask), IO::Buffer.for("1334133413")
assert_equal (source ^ mask), IO::Buffer.for("\x00\x01\x004\x00\x01\x004\x00\x01")
assert_equal ~source, IO::Buffer.for("\xce\xcd\xcc\xcb\xce\xcd\xcc\xcb\xce\xcd")
end
def test_inplace_operators
source = IO::Buffer.for("1234123412")
mask = IO::Buffer.for("133\x00")
result = source & mask
assert_equal source.dup.and!(mask), IO::Buffer.for("123\x00123\x0012")
assert_equal source.dup.or!(mask), IO::Buffer.for("1334133413")
assert_equal source.dup.xor!(mask), IO::Buffer.for("\x00\x01\x004\x00\x01\x004\x00\x01")
assert_equal source.dup.not!, IO::Buffer.for("\xce\xcd\xcc\xcb\xce\xcd\xcc\xcb\xce\xcd")
end
end