fix: fixed several errors that could lead to unexpected results or Ar…

…gon crashing under certain circumstances when using Bytes objects

argon/vm/datatype/bufview.cpp

@@ -42,16 +42,73 @@ void SharedBufferRelease(SharedBuffer *shared) {
 }
 
 bool ViewEnlargeNew(BufferView *view, ArSize count) {
+ SharedBuffer *old = view->shared;
  SharedBuffer *tmp;
 
  if ((tmp = SharedBufferNew(view->length + count)) == nullptr)
  return false;
 
+ // Acquire WriteLock on new SharedBuffer
+ tmp->rwlock.lock();
+
  MemoryCopy(tmp->buffer, view->buffer, view->length);
- view->buffer = tmp->buffer;
 
- SharedBufferRelease(view->shared);
  view->shared = tmp;
+ view->buffer = tmp->buffer;
+
+ // Release WriteLock on SharedBuffer
+ old->rwlock.unlock();
+
+ SharedBufferRelease(old);
+
+ return true;
+}
+
+bool argon::vm::datatype::BufferViewAppendData(BufferView *view, const BufferView *other) {
+ std::unique_lock view_lock(view->lock);
+
+ view->shared->rwlock.lock();
+
+ if (view != other)
+ view->shared->rwlock.lock_shared();
+
+ if (!BufferViewEnlarge(view, other->length)) {
+ view->shared->rwlock.unlock();
+
+ if (view != other)
+ view->shared->rwlock.unlock_shared();
+
+ return false;
+ }
+
+ memory::MemoryCopy(view->buffer + view->length, other->buffer, other->length);
+
+ view->length += other->length;
+
+ if (view != other)
+ view->shared->rwlock.unlock_shared();
+
+ view->shared->rwlock.unlock();
+
+ return true;
+}
+
+bool argon::vm::datatype::BufferViewAppendData(BufferView *view, const unsigned char *buffer, ArSize length) {
+ std::unique_lock view_lock(view->lock);
+
+ view->shared->rwlock.lock();
+
+ if (!BufferViewEnlarge(view, length)) {
+ view->shared->rwlock.unlock();
+
+ return false;
+ }
+
+ memory::MemoryCopy(view->buffer + view->length, buffer, length);
+
+ view->length += length;
+
+ view->shared->rwlock.unlock();
 
  return true;
 }
@@ -94,6 +151,8 @@ bool argon::vm::datatype::BufferViewHoldBuffer(BufferView *view, unsigned char *
  view->shared->buffer = buffer;
  view->shared->capacity = cap;
 
+ new(&view->lock)std::mutex();
+
  view->buffer = buffer;
  view->length = len;
 
@@ -104,33 +163,26 @@ bool argon::vm::datatype::BufferViewInit(BufferView *view, ArSize capacity) {
  if ((view->shared = SharedBufferNew(capacity)) == nullptr)
  return false;
 
+ new(&view->lock)std::mutex();
  view->buffer = view->shared->buffer;
  view->length = 0;
 
  return true;
 }
 
-bool argon::vm::datatype::BufferViewInit(BufferView *view, unsigned char *buffer, ArSize length, ArSize capacity) {
- if ((view->shared = SharedBufferNew(0)) == nullptr)
- return false;
-
- view->shared->buffer = buffer;
- view->shared->capacity = capacity;
-
- view->buffer = buffer;
- view->length = length;
-
- return true;
-}
-
 void argon::vm::datatype::BufferViewDetach(BufferView *view) {
  SharedBufferRelease(view->shared);
+
+ view->lock.~mutex();
  view->buffer = nullptr;
  view->length = 0;
 }
 
 void argon::vm::datatype::BufferViewInit(BufferView *dst, BufferView *src, ArSize start, ArSize length) {
  src->shared->Acquire();
+
+ new(&dst->lock)std::mutex();
+
  dst->shared = src->shared;
  dst->buffer = src->buffer + start;
  dst->length = length;

argon/vm/datatype/bufview.h

@@ -6,6 +6,7 @@
 #define ARGON_VM_DATATYPE_BUFVIEW_H_
 
 #include <atomic>
+#include <shared_mutex>
 
 #include <argon/vm/sync/rsm.h>
 
@@ -20,7 +21,7 @@ namespace argon::vm::datatype {
  unsigned char *buffer;
  ArSize capacity;
 
- bool IsWritable() const {
+ [[nodiscard]] bool IsWritable() const {
  return this->counter == 1;
  }
 
@@ -29,42 +30,32 @@ namespace argon::vm::datatype {
  }
 
  void Acquire() {
+ // It is used to verify that no one has started writing operations!
+ std::shared_lock _(this->rwlock);
+
  this->counter++;
  }
  };
 
  struct BufferView {
+ std::mutex lock;
+
  SharedBuffer *shared;
+
  unsigned char *buffer;
  ArSize length;
+ };
 
- unsigned char *ReadableBufferLock() {
- this->shared->rwlock.lock_shared();
- return this->buffer;
- }
-
- unsigned char *WritableBufferLock() {
- this->shared->rwlock.lock();
- return this->buffer;
- }
-
- void ReadableRelease() {
- this->shared->rwlock.unlock_shared();
- }
+ bool BufferViewAppendData(BufferView *view, const BufferView *other);
 
- void WritableRelease() {
- this->shared->rwlock.unlock();
- }
- };
+ bool BufferViewAppendData(BufferView *view, const unsigned char *buffer, ArSize length);
 
  bool BufferViewEnlarge(BufferView *view, ArSize count);
 
  bool BufferViewHoldBuffer(BufferView *view, unsigned char *buffer, ArSize len, ArSize cap);
 
  bool BufferViewInit(BufferView *view, ArSize capacity);
 
- bool BufferViewInit(BufferView *view, unsigned char *buffer, ArSize length, ArSize capacity);
-
  void BufferViewDetach(BufferView *view);
 
  void BufferViewInit(BufferView *dst, BufferView *src, ArSize start, ArSize length);