1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename IMMUTABLE to READONLY.

Browse Source
This commit is contained in:
Samuel Williams 2021-12-20 23:06:21 +13:00
parent 9fbf94ff04
commit 617687df09
Notes: git 2021-12-21 08:26:07 +09:00 
Merged: https://github.com/ruby/ruby/pull/5303
4 changed files with 55 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/ruby/io/buffer.h
View File

@ -44,7 +44,7 @@ enum rb_io_buffer_flags {
RB_IO_BUFFER_PRIVATE = 64, RB_IO_BUFFER_PRIVATE = 64,
// The buffer is read-only and cannot be modified. // The buffer is read-only and cannot be modified.
RB_IO_BUFFER_IMMUTABLE = 128 RB_IO_BUFFER_READONLY = 128
}; };
enum rb_io_buffer_endian { enum rb_io_buffer_endian {
@ -71,8 +71,10 @@ VALUE rb_io_buffer_lock(VALUE self);
VALUE rb_io_buffer_unlock(VALUE self); VALUE rb_io_buffer_unlock(VALUE self);
VALUE rb_io_buffer_free(VALUE self); VALUE rb_io_buffer_free(VALUE self);
void rb_io_buffer_get_mutable(VALUE self, void **base, size_t *size); int rb_io_buffer_readonly_p(VALUE self);
void rb_io_buffer_get_immutable(VALUE self, const void **base, size_t *size);
void rb_io_buffer_get(VALUE self, void **base, size_t *size);
void rb_io_buffer_get_readonly(VALUE self, const void **base, size_t *size);
VALUE rb_io_buffer_transfer(VALUE self); VALUE rb_io_buffer_transfer(VALUE self);
void rb_io_buffer_resize(VALUE self, size_t size); void rb_io_buffer_resize(VALUE self, size_t size);

70
io_buffer.c
View File

@ -69,8 +69,8 @@ io_buffer_map_file(struct rb_io_buffer *data, int descriptor, size_t size, off_t
DWORD protect = PAGE_READONLY, access = FILE_MAP_READ; DWORD protect = PAGE_READONLY, access = FILE_MAP_READ;
if (flags & RB_IO_BUFFER_IMMUTABLE) { if (flags & RB_IO_BUFFER_READONLY) {
data->flags |= RB_IO_BUFFER_IMMUTABLE; data->flags |= RB_IO_BUFFER_READONLY;
} }
else { else {
protect = PAGE_READWRITE; protect = PAGE_READWRITE;
@ -99,8 +99,8 @@ io_buffer_map_file(struct rb_io_buffer *data, int descriptor, size_t size, off_t
#else #else
int protect = PROT_READ, access = 0; int protect = PROT_READ, access = 0;
if (flags & RB_IO_BUFFER_IMMUTABLE) { if (flags & RB_IO_BUFFER_READONLY) {
data->flags |= RB_IO_BUFFER_IMMUTABLE; data->flags |= RB_IO_BUFFER_READONLY;
} }
else { else {
protect |= PROT_WRITE; protect |= PROT_WRITE;
@ -292,7 +292,7 @@ rb_io_buffer_type_for(VALUE klass, VALUE string)
enum rb_io_buffer_flags flags = RB_IO_BUFFER_EXTERNAL; enum rb_io_buffer_flags flags = RB_IO_BUFFER_EXTERNAL;
if (RB_OBJ_FROZEN(string)) if (RB_OBJ_FROZEN(string))
flags |= RB_IO_BUFFER_IMMUTABLE; flags |= RB_IO_BUFFER_READONLY;
io_buffer_initialize(data, RSTRING_PTR(string), RSTRING_LEN(string), flags, string); io_buffer_initialize(data, RSTRING_PTR(string), RSTRING_LEN(string), flags, string);
@ -364,7 +364,7 @@ io_buffer_map(int argc, VALUE *argv, VALUE klass)
offset = NUM2OFFT(argv[2]); offset = NUM2OFFT(argv[2]);
} }
enum rb_io_buffer_flags flags = RB_IO_BUFFER_IMMUTABLE; enum rb_io_buffer_flags flags = RB_IO_BUFFER_READONLY;
if (argc >= 4) { if (argc >= 4) {
flags = RB_NUM2UINT(argv[3]); flags = RB_NUM2UINT(argv[3]);
} }
@ -426,7 +426,7 @@ io_buffer_validate_slice(VALUE source, void *base, size_t size)
RSTRING_GETMEM(source, source_base, source_size); RSTRING_GETMEM(source, source_base, source_size);
} }
else { else {
rb_io_buffer_get_immutable(source, &source_base, &source_size); rb_io_buffer_get_readonly(source, &source_base, &source_size);
} }
// Source is invalid: // Source is invalid:
@ -484,8 +484,8 @@ rb_io_buffer_to_s(VALUE self)
rb_str_cat2(result, " LOCKED"); rb_str_cat2(result, " LOCKED");
} }
if (data->flags & RB_IO_BUFFER_IMMUTABLE) { if (data->flags & RB_IO_BUFFER_READONLY) {
rb_str_cat2(result, " IMMUTABLE"); rb_str_cat2(result, " READONLY");
} }
if (data->source != Qnil) { if (data->source != Qnil) {
@ -571,6 +571,15 @@ rb_io_buffer_null_p(VALUE self)
return data->base ? Qfalse : Qtrue; return data->base ? Qfalse : Qtrue;
} }
static VALUE
rb_io_buffer_empty_p(VALUE self)
{
struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
return data->size ? Qtrue : Qfalse;
}
static VALUE static VALUE
rb_io_buffer_external_p(VALUE self) rb_io_buffer_external_p(VALUE self)
{ {
@ -607,13 +616,19 @@ rb_io_buffer_locked_p(VALUE self)
return data->flags & RB_IO_BUFFER_LOCKED ? Qtrue : Qfalse; return data->flags & RB_IO_BUFFER_LOCKED ? Qtrue : Qfalse;
} }
static VALUE int
rb_io_buffer_immutable_p(VALUE self) rb_io_buffer_readonly_p(VALUE self)
{ {
struct rb_io_buffer *data = NULL; struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data); TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
return data->flags & RB_IO_BUFFER_IMMUTABLE ? Qtrue : Qfalse; return data->flags & RB_IO_BUFFER_READONLY;
}
static VALUE
io_buffer_readonly_p(VALUE self)
{
return rb_io_buffer_readonly_p(self) ? Qtrue : Qfalse;
} }
VALUE VALUE
@ -717,10 +732,10 @@ rb_io_buffer_slice(VALUE self, VALUE _offset, VALUE _length)
} }
static void static void
io_buffer_get_mutable(struct rb_io_buffer *data, void **base, size_t *size) io_buffer_get(struct rb_io_buffer *data, void **base, size_t *size)
{ {
if (data->flags & RB_IO_BUFFER_IMMUTABLE) { if (data->flags & RB_IO_BUFFER_READONLY) {
rb_raise(rb_eIOBufferMutationError, "Buffer is immutable!"); rb_raise(rb_eIOBufferMutationError, "Buffer is not writable!");
} }
if (!io_buffer_validate(data)) { if (!io_buffer_validate(data)) {
@ -738,16 +753,16 @@ io_buffer_get_mutable(struct rb_io_buffer *data, void **base, size_t *size)
} }
void void
rb_io_buffer_get_mutable(VALUE self, void **base, size_t *size) rb_io_buffer_get(VALUE self, void **base, size_t *size)
{ {
struct rb_io_buffer *data = NULL; struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data); TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
io_buffer_get_mutable(data, base, size); io_buffer_get(data, base, size);
} }
void void
rb_io_buffer_get_immutable(VALUE self, const void **base, size_t *size) rb_io_buffer_get_readonly(VALUE self, const void **base, size_t *size)
{ {
struct rb_io_buffer *data = NULL; struct rb_io_buffer *data = NULL;
TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data); TypedData_Get_Struct(self, struct rb_io_buffer, &rb_io_buffer_type, data);
@ -881,8 +896,8 @@ rb_io_buffer_compare(VALUE self, VALUE other)
const void *ptr1, *ptr2; const void *ptr1, *ptr2;
size_t size1, size2; size_t size1, size2;
rb_io_buffer_get_immutable(self, &ptr1, &size1); rb_io_buffer_get_readonly(self, &ptr1, &size1);
rb_io_buffer_get_immutable(other, &ptr2, &size2); rb_io_buffer_get_readonly(other, &ptr2, &size2);
if (size1 < size2) { if (size1 < size2) {
return RB_INT2NUM(-1); return RB_INT2NUM(-1);
@ -1035,7 +1050,7 @@ io_buffer_get_value(VALUE self, VALUE type, VALUE _offset)
size_t size; size_t size;
size_t offset = NUM2SIZET(_offset); size_t offset = NUM2SIZET(_offset);
rb_io_buffer_get_immutable(self, &base, &size); rb_io_buffer_get_readonly(self, &base, &size);
return rb_io_buffer_get_value(base, size, RB_SYM2ID(type), offset); return rb_io_buffer_get_value(base, size, RB_SYM2ID(type), offset);
} }
@ -1078,7 +1093,7 @@ io_buffer_set_value(VALUE self, VALUE type, VALUE _offset, VALUE value)
size_t size; size_t size;
size_t offset = NUM2SIZET(_offset); size_t offset = NUM2SIZET(_offset);
rb_io_buffer_get_mutable(self, &base, &size); rb_io_buffer_get(self, &base, &size);
rb_io_buffer_set_value(base, size, RB_SYM2ID(type), offset, value); rb_io_buffer_set_value(base, size, RB_SYM2ID(type), offset, value);
@ -1090,7 +1105,7 @@ io_buffer_memcpy(struct rb_io_buffer *data, size_t offset, const void *source_ba
{ {
void *base; void *base;
size_t size; size_t size;
io_buffer_get_mutable(data, &base, &size); io_buffer_get(data, &base, &size);
rb_io_buffer_validate(data, offset, length); rb_io_buffer_validate(data, offset, length);
@ -1153,7 +1168,7 @@ io_buffer_copy(int argc, VALUE *argv, VALUE self)
const void *source_base; const void *source_base;
size_t source_size; size_t source_size;
rb_io_buffer_get_immutable(source, &source_base, &source_size); rb_io_buffer_get_readonly(source, &source_base, &source_size);
return io_buffer_copy_from(data, source_base, source_size, argc-1, argv+1); return io_buffer_copy_from(data, source_base, source_size, argc-1, argv+1);
} }
@ -1213,7 +1228,7 @@ rb_io_buffer_clear(VALUE self, uint8_t value, size_t offset, size_t length)
void *base; void *base;
size_t size; size_t size;
rb_io_buffer_get_mutable(self, &base, &size); rb_io_buffer_get(self, &base, &size);
if (offset + length > size) { if (offset + length > size) {
rb_raise(rb_eArgError, "The given offset + length out of bounds!"); rb_raise(rb_eArgError, "The given offset + length out of bounds!");
@ -1319,7 +1334,7 @@ Init_IO_Buffer(void)
rb_define_const(rb_cIOBuffer, "MAPPED", RB_INT2NUM(RB_IO_BUFFER_MAPPED)); rb_define_const(rb_cIOBuffer, "MAPPED", RB_INT2NUM(RB_IO_BUFFER_MAPPED));
rb_define_const(rb_cIOBuffer, "LOCKED", RB_INT2NUM(RB_IO_BUFFER_LOCKED)); rb_define_const(rb_cIOBuffer, "LOCKED", RB_INT2NUM(RB_IO_BUFFER_LOCKED));
rb_define_const(rb_cIOBuffer, "PRIVATE", RB_INT2NUM(RB_IO_BUFFER_PRIVATE)); rb_define_const(rb_cIOBuffer, "PRIVATE", RB_INT2NUM(RB_IO_BUFFER_PRIVATE));
rb_define_const(rb_cIOBuffer, "IMMUTABLE", RB_INT2NUM(RB_IO_BUFFER_IMMUTABLE)); rb_define_const(rb_cIOBuffer, "READONLY", RB_INT2NUM(RB_IO_BUFFER_READONLY));
// Endian: // Endian:
rb_define_const(rb_cIOBuffer, "LITTLE_ENDIAN", RB_INT2NUM(RB_IO_BUFFER_LITTLE_ENDIAN)); rb_define_const(rb_cIOBuffer, "LITTLE_ENDIAN", RB_INT2NUM(RB_IO_BUFFER_LITTLE_ENDIAN));
@ -1328,11 +1343,12 @@ Init_IO_Buffer(void)
rb_define_const(rb_cIOBuffer, "NETWORK_ENDIAN", RB_INT2NUM(RB_IO_BUFFER_NETWORK_ENDIAN)); rb_define_const(rb_cIOBuffer, "NETWORK_ENDIAN", RB_INT2NUM(RB_IO_BUFFER_NETWORK_ENDIAN));
rb_define_method(rb_cIOBuffer, "null?", rb_io_buffer_null_p, 0); rb_define_method(rb_cIOBuffer, "null?", rb_io_buffer_null_p, 0);
rb_define_method(rb_cIOBuffer, "empty?", rb_io_buffer_empty_p, 0);
rb_define_method(rb_cIOBuffer, "external?", rb_io_buffer_external_p, 0); rb_define_method(rb_cIOBuffer, "external?", rb_io_buffer_external_p, 0);
rb_define_method(rb_cIOBuffer, "internal?", rb_io_buffer_internal_p, 0); rb_define_method(rb_cIOBuffer, "internal?", rb_io_buffer_internal_p, 0);
rb_define_method(rb_cIOBuffer, "mapped?", rb_io_buffer_mapped_p, 0); rb_define_method(rb_cIOBuffer, "mapped?", rb_io_buffer_mapped_p, 0);
rb_define_method(rb_cIOBuffer, "locked?", rb_io_buffer_locked_p, 0); rb_define_method(rb_cIOBuffer, "locked?", rb_io_buffer_locked_p, 0);
rb_define_method(rb_cIOBuffer, "immutable?", rb_io_buffer_immutable_p, 0); rb_define_method(rb_cIOBuffer, "readonly?", io_buffer_readonly_p, 0);
// Locking to prevent changes while using pointer: // Locking to prevent changes while using pointer:
// rb_define_method(rb_cIOBuffer, "lock", rb_io_buffer_lock, 0); // rb_define_method(rb_cIOBuffer, "lock", rb_io_buffer_lock, 0);

2
scheduler.c
View File

@ -264,7 +264,7 @@ rb_fiber_scheduler_io_read_memory(VALUE scheduler, VALUE io, void *base, size_t
VALUE VALUE
rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size, size_t length) rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size, size_t length)
{ {
VALUE buffer = rb_io_buffer_new((void*)base, size, RB_IO_BUFFER_LOCKED|RB_IO_BUFFER_IMMUTABLE); VALUE buffer = rb_io_buffer_new((void*)base, size, RB_IO_BUFFER_LOCKED|RB_IO_BUFFER_READONLY);
VALUE result = rb_fiber_scheduler_io_write(scheduler, io, buffer, length); VALUE result = rb_fiber_scheduler_io_write(scheduler, io, buffer, length);

12
test/ruby/test_io_buffer.rb
View File

@ -25,7 +25,7 @@ class TestIOBuffer < Test::Unit::TestCase
assert_equal 32, IO::Buffer::LOCKED assert_equal 32, IO::Buffer::LOCKED
assert_equal 64, IO::Buffer::PRIVATE assert_equal 64, IO::Buffer::PRIVATE
assert_equal 128, IO::Buffer::IMMUTABLE assert_equal 128, IO::Buffer::READONLY
end end
def test_endian def test_endian
@ -56,9 +56,9 @@ class TestIOBuffer < Test::Unit::TestCase
assert buffer.mapped? assert buffer.mapped?
end end
def test_new_immutable def test_new_readonly
buffer = IO::Buffer.new(128, IO::Buffer::INTERNAL|IO::Buffer::IMMUTABLE) buffer = IO::Buffer.new(128, IO::Buffer::INTERNAL|IO::Buffer::READONLY)
assert buffer.immutable? assert buffer.readonly?
assert_raise IO::Buffer::MutationError do assert_raise IO::Buffer::MutationError do
buffer.set_string("") buffer.set_string("")
@ -86,7 +86,7 @@ class TestIOBuffer < Test::Unit::TestCase
def test_string_mapped def test_string_mapped
string = "Hello World" string = "Hello World"
buffer = IO::Buffer.for(string) buffer = IO::Buffer.for(string)
refute buffer.immutable? refute buffer.readonly?
# Cannot modify string as it's locked by the buffer: # Cannot modify string as it's locked by the buffer:
assert_raise RuntimeError do assert_raise RuntimeError do
@ -107,7 +107,7 @@ class TestIOBuffer < Test::Unit::TestCase
string = "Hello World".freeze string = "Hello World".freeze
buffer = IO::Buffer.for(string) buffer = IO::Buffer.for(string)
assert buffer.immutable? assert buffer.readonly?
end end
def test_non_string def test_non_string