VM: Refactor strings.cpp/hpp to Factor style

diff --git a/vm/strings.cpp b/vm/strings.cpp
index ef93d8c503ab29e6db94892064b39bff7725f0d2..f73ae0802a080d8b5a6939fdf81ffbbc6d4d777c 100644 (file)
--- a/vm/strings.cpp
+++ b/vm/strings.cpp
@@ -1,126 +1,114 @@
 #include "master.hpp"
 
-namespace factor
-{
+namespace factor {
 
 /* Allocates memory */
-string *factor_vm::allot_string_internal(cell capacity)
-{
-       string *str = allot<string>(string_size(capacity));
+string* factor_vm::allot_string_internal(cell capacity) {
+  string* str = allot<string>(string_size(capacity));
 
-       str->length = tag_fixnum(capacity);
-       str->hashcode = false_object;
-       str->aux = false_object;
+  str->length = tag_fixnum(capacity);
+  str->hashcode = false_object;
+  str->aux = false_object;
 
-       return str;
+  return str;
 }
 
 /* Allocates memory */
-void factor_vm::fill_string(string *str_, cell start, cell capacity, cell fill)
-{
-       data_root<string> str(str_,this);
-
-       if(fill <= 0x7f)
-               memset(&str->data()[start],(u8)fill,capacity - start);
-       else
-       {
-               byte_array *aux;
-               if(to_boolean(str->aux))
-                       aux = untag<byte_array>(str->aux);
-               else
-               {
-                       aux = allot_uninitialized_array<byte_array>(untag_fixnum(str->length) * 2);
-                       str->aux = tag<byte_array>(aux);
-                       write_barrier(&str->aux);
-               }
-
-               u8 lo_fill = (u8)((fill & 0x7f) | 0x80);
-               u16 hi_fill = (u16)((fill >> 7) ^ 0x1);
-               memset(&str->data()[start],lo_fill,capacity - start);
-               memset_2(&aux->data<u16>()[start],hi_fill,(capacity - start) * sizeof(u16));
-       }
+void factor_vm::fill_string(string* str_, cell start, cell capacity,
+                            cell fill) {
+  data_root<string> str(str_, this);
+
+  if (fill <= 0x7f)
+    memset(&str->data()[start], (u8) fill, capacity - start);
+  else {
+    byte_array* aux;
+    if (to_boolean(str->aux))
+      aux = untag<byte_array>(str->aux);
+    else {
+      aux =
+          allot_uninitialized_array<byte_array>(untag_fixnum(str->length) * 2);
+      str->aux = tag<byte_array>(aux);
+      write_barrier(&str->aux);
+    }
+
+    u8 lo_fill = (u8)((fill & 0x7f) | 0x80);
+    u16 hi_fill = (u16)((fill >> 7) ^ 0x1);
+    memset(&str->data()[start], lo_fill, capacity - start);
+    memset_2(&aux->data<u16>()[start], hi_fill,
+             (capacity - start) * sizeof(u16));
+  }
 }
 
 /* Allocates memory */
-string *factor_vm::allot_string(cell capacity, cell fill)
-{
-       data_root<string> str(allot_string_internal(capacity),this);
-       fill_string(str.untagged(),0,capacity,fill);
-       return str.untagged();
+string* factor_vm::allot_string(cell capacity, cell fill) {
+  data_root<string> str(allot_string_internal(capacity), this);
+  fill_string(str.untagged(), 0, capacity, fill);
+  return str.untagged();
 }
 
 /* Allocates memory */
-void factor_vm::primitive_string()
-{
-       cell initial = to_cell(ctx->pop());
-       cell length = unbox_array_size();
-       ctx->push(tag<string>(allot_string(length,initial)));
+void factor_vm::primitive_string() {
+  cell initial = to_cell(ctx->pop());
+  cell length = unbox_array_size();
+  ctx->push(tag<string>(allot_string(length, initial)));
 }
 
-bool factor_vm::reallot_string_in_place_p(string *str, cell capacity)
-{
-       return nursery.contains_p(str)
-               && (!to_boolean(str->aux) || nursery.contains_p(untag<byte_array>(str->aux)))
-               && capacity <= string_capacity(str);
+bool factor_vm::reallot_string_in_place_p(string* str, cell capacity) {
+  return nursery.contains_p(str) &&
+         (!to_boolean(str->aux) ||
+          nursery.contains_p(untag<byte_array>(str->aux))) &&
+         capacity <= string_capacity(str);
 }
 
 /* Allocates memory */
-string* factor_vm::reallot_string(string *str_, cell capacity)
-{
-       data_root<string> str(str_,this);
-
-       if(reallot_string_in_place_p(str.untagged(),capacity))
-       {
-               str->length = tag_fixnum(capacity);
-
-               if(to_boolean(str->aux))
-               {
-                       byte_array *aux = untag<byte_array>(str->aux);
-                       aux->capacity = tag_fixnum(capacity * 2);
-               }
-
-               return str.untagged();
-       }
-       else
-       {
-               cell to_copy = string_capacity(str.untagged());
-               if(capacity < to_copy)
-                       to_copy = capacity;
-
-               data_root<string> new_str(allot_string_internal(capacity),this);
-
-               memcpy(new_str->data(),str->data(),to_copy);
-
-               if(to_boolean(str->aux))
-               {
-                       byte_array *new_aux = allot_uninitialized_array<byte_array>(capacity * 2);
-                       new_str->aux = tag<byte_array>(new_aux);
-                       write_barrier(&new_str->aux);
-
-                       byte_array *aux = untag<byte_array>(str->aux);
-                       memcpy(new_aux->data<u16>(),aux->data<u16>(),to_copy * sizeof(u16));
-               }
-
-               fill_string(new_str.untagged(),to_copy,capacity,'\0');
-               return new_str.untagged();
-       }
+string* factor_vm::reallot_string(string* str_, cell capacity) {
+  data_root<string> str(str_, this);
+
+  if (reallot_string_in_place_p(str.untagged(), capacity)) {
+    str->length = tag_fixnum(capacity);
+
+    if (to_boolean(str->aux)) {
+      byte_array* aux = untag<byte_array>(str->aux);
+      aux->capacity = tag_fixnum(capacity * 2);
+    }
+
+    return str.untagged();
+  } else {
+    cell to_copy = string_capacity(str.untagged());
+    if (capacity < to_copy)
+      to_copy = capacity;
+
+    data_root<string> new_str(allot_string_internal(capacity), this);
+
+    memcpy(new_str->data(), str->data(), to_copy);
+
+    if (to_boolean(str->aux)) {
+      byte_array* new_aux = allot_uninitialized_array<byte_array>(capacity * 2);
+      new_str->aux = tag<byte_array>(new_aux);
+      write_barrier(&new_str->aux);
+
+      byte_array* aux = untag<byte_array>(str->aux);
+      memcpy(new_aux->data<u16>(), aux->data<u16>(), to_copy * sizeof(u16));
+    }
+
+    fill_string(new_str.untagged(), to_copy, capacity, '\0');
+    return new_str.untagged();
+  }
 }
 
 /* Allocates memory */
-void factor_vm::primitive_resize_string()
-{
-       data_root<string> str(ctx->pop(),this);
-       str.untag_check(this);
-       cell capacity = unbox_array_size();
-       ctx->push(tag<string>(reallot_string(str.untagged(),capacity)));
+void factor_vm::primitive_resize_string() {
+  data_root<string> str(ctx->pop(), this);
+  str.untag_check(this);
+  cell capacity = unbox_array_size();
+  ctx->push(tag<string>(reallot_string(str.untagged(), capacity)));
 }
 
-void factor_vm::primitive_set_string_nth_fast()
-{
-       string *str = untag<string>(ctx->pop());
-       cell index = untag_fixnum(ctx->pop());
-       cell value = untag_fixnum(ctx->pop());
-       str->data()[index] = (u8)value;
+void factor_vm::primitive_set_string_nth_fast() {
+  string* str = untag<string>(ctx->pop());
+  cell index = untag_fixnum(ctx->pop());
+  cell value = untag_fixnum(ctx->pop());
+  str->data()[index] = (u8) value;
 }
 
 }

diff --git a/vm/strings.hpp b/vm/strings.hpp
index 54ff981d99af99fda5ebdccb3ea58fdc5ab36ca1..af9813329ddb344e5152486a54f17a38b72041a5 100644 (file)
--- a/vm/strings.hpp
+++ b/vm/strings.hpp
@@ -1,14 +1,9 @@
-namespace factor
-{
+namespace factor {
 
-inline static cell string_capacity(const string *str)
-{
-       return untag_fixnum(str->length);
+inline static cell string_capacity(const string* str) {
+  return untag_fixnum(str->length);
 }
 
-inline static cell string_size(cell size)
-{
-       return sizeof(string) + size;
-}
+inline static cell string_size(cell size) { return sizeof(string) + size; }
 
 }