allow constructing some arrays from ranges

gets a little weird with strings, though.

Author: Bike

include/clasp/core/array.h

@@ -479,6 +479,14 @@ template <typename MyLeafType, typename ValueType, typename MyParentType> class
   template_SimpleVector(size_t length, value_type initialElement = value_type(), bool initialElementSupplied = false,
                         size_t initialContentsSize = 0, const value_type* initialContents = NULL)
       : Base(), _Data(length, initialElement, initialElementSupplied, initialContentsSize, initialContents){};
+  template_SimpleVector(size_t length, const value_type& initialElement)
+    : Base(), _Data(length, initialElement) {};
+  template <std::ranges::sized_range R>
+  template_SimpleVector(R&& initialContents)
+    : Base(), _Data(initialContents) {};
+  template <std::input_iterator I, std::sized_sentinel_for<I> S>
+  template_SimpleVector(I first, S last)
+    : Base(), _Data(first, last) {};
 
 public:
   static void never_invoke_allocator() { gctools::GCAbstractAllocator<template_SimpleVector>::never_invoke_allocator(); };

include/clasp/core/array_int8.h

@@ -34,13 +34,21 @@ class SimpleVector_byte8_t_O : public specialized_SimpleVector_byte8_t {
   SimpleVector_byte8_t_O(size_t length, value_type initialElement = value_type(), bool initialElementSupplied = false,
                          size_t initialContentsSize = 0, const value_type* initialContents = NULL)
       : TemplatedBase(length, initialElement, initialElementSupplied, initialContentsSize, initialContents){};
+  template <std::ranges::sized_range R>
+  SimpleVector_byte8_t_O(size_t length, R&& initialContents)
+    : TemplatedBase(initialContents) { (void)length; };
+
   static smart_ptr_type make(size_t length, value_type initialElement = value_type(), bool initialElementSupplied = false,
                              size_t initialContentsSize = 0, const value_type* initialContents = NULL,
                              bool static_vector_p = false) {
     auto bs = gctools::GC<my_type>::allocate_container<gctools::RuntimeStage>(
         static_vector_p, length, initialElement, initialElementSupplied, initialContentsSize, initialContents);
     return bs;
   }
+  template <std::ranges::sized_range R>
+  static smart_ptr_type make(R&& initialContents) {
+    return gctools::GC<my_type>::allocate_container<gctools::RuntimeStage>(false, std::ranges::ssize(initialContents), initialContents);
+  }
 
 public:
   virtual T_sp element_type() const override { return ext::_sym_byte8; };

include/clasp/core/array_t.h

@@ -33,19 +33,21 @@ class SimpleVector_O : public specialized_SimpleVector {
   SimpleVector_O(size_t length, value_type initialElement = default_initial_element(), bool initialElementSupplied = true,
                  size_t initialContentsSize = 0, const value_type* initialContents = NULL)
       : TemplatedBase(length, initialElement, initialElementSupplied, initialContentsSize, initialContents){};
+  template <std::ranges::sized_range R>
+  // the length arg is necessary even though it's unused, because it's
+  // passed by the allocate_container machinery.
+  // the length was computed by make below from the range anyway.
+  SimpleVector_O(size_t length, R&& initialContents)
+    : TemplatedBase(initialContents) { (void)length; };
   static SimpleVector_sp make(size_t length, T_sp initialElement = nil<T_O>(), bool initialElementSupplied = true,
                               size_t initialContentsSize = 0, const T_sp* initialContents = NULL, bool static_vector_p = false) {
     auto bs = gctools::GC<SimpleVector_O>::allocate_container<gctools::RuntimeStage>(
         static_vector_p, length, initialElement, initialElementSupplied, initialContentsSize, initialContents);
     return bs;
   }
-  // Used in one place in lisp.cc. FIXME: Maybe remove?
-  static SimpleVector_sp make(const gc::Vec0<T_sp>& objs) {
-    size_t len = objs.size();
-    if (len == 0)
-      return make(0);
-    else
-      return make(len, nil<T_O>(), true, len, &(objs[0]));
+  template <std::ranges::sized_range R>
+  static SimpleVector_sp make(R&& initialContents) {
+    return gctools::GC<SimpleVector_O>::allocate_container<gctools::RuntimeStage>(false, std::ranges::ssize(initialContents), initialContents);
   }
 
 public:

include/clasp/gctools/gcarray.h

@@ -77,6 +77,20 @@ template <class T> class __attribute__((__packed__)) GCArray_moveable : public G
     }
 #endif
   }
+  GCArray_moveable(int64_t size, const T& initialElement)
+    : _MaybeSignedLength(size) {
+    std::fill(_Data, _Data + size, initialElement);
+  }
+  template <std::ranges::sized_range R>
+  GCArray_moveable(R&& initialContents)
+    : _MaybeSignedLength(std::ranges::size(initialContents)) {
+    std::ranges::copy(initialContents, _Data);
+  }
+  template <std::input_iterator I, std::sized_sentinel_for<I> S>
+  GCArray_moveable(I first, S last)
+    : _MaybeSignedLength(last - first) {
+    std::ranges::copy(first, last, _Data);
+  }
 
 public:
   inline uint64_t size() const { return this->length(); };

src/core/primitives.cc

@@ -1891,16 +1891,10 @@ CL_DEFUN SimpleVector_byte8_t_sp core__base_string_to_octets(T_sp tarray) {
   }
   if (gc::IsA<SimpleBaseString_sp>(tarray)) {
     SimpleBaseString_sp sarray = gc::As_unsafe<SimpleBaseString_sp>(tarray);
-    SimpleVector_byte8_t_sp result = SimpleVector_byte8_t_O::make(sarray->length(), 0, false, sarray->length(), &(*sarray)[0]);
-    return result;
+    return SimpleVector_byte8_t_O::make(sarray);
   } else if (gc::IsA<Str8Ns_sp>(tarray)) {
     Str8Ns_sp sarray = gc::As_unsafe<Str8Ns_sp>(tarray);
-    AbstractSimpleVector_sp basesv;
-    size_t start, end;
-    sarray->asAbstractSimpleVectorRange(basesv, start, end);
-    SimpleBaseString_sp sbs = gc::As_unsafe<SimpleBaseString_sp>(basesv);
-    SimpleVector_byte8_t_sp result = SimpleVector_byte8_t_O::make((end - start), 0, false, (end - start), &(*sbs)[start]);
-    return result;
+    return SimpleVector_byte8_t_O::make(sarray);
   }
   SIMPLE_ERROR("Don't get here");
 }
@@ -1909,23 +1903,10 @@ DOCGROUP(clasp);
 CL_DEFUN SimpleVector_byte8_t_sp core__character_string_that_fits_in_base_string_to_octets(T_sp tarray) {
   if (gc::IsA<SimpleCharacterString_sp>(tarray)) {
     SimpleCharacterString_sp sarray = gc::As_unsafe<SimpleCharacterString_sp>(tarray);
-    SimpleVector_byte8_t_sp result = SimpleVector_byte8_t_O::make(sarray->length(), 0, false);
-    for (int i = 0; i < sarray->length(); ++i) {
-      int c = sarray[i];
-      result[i] = c;
-    }
-    return result;
+    return SimpleVector_byte8_t_O::make(sarray);
   } else if (gc::IsA<StrWNs_sp>(tarray)) {
     StrWNs_sp sarray = gc::As_unsafe<StrWNs_sp>(tarray);
-    AbstractSimpleVector_sp basesv;
-    size_t start, end;
-    sarray->asAbstractSimpleVectorRange(basesv, start, end);
-    SimpleVector_byte8_t_sp result = SimpleVector_byte8_t_O::make((end - start), 0, false);
-    for (int i = 0; i < sarray->length(); ++i) {
-      int c = sarray[i];
-      result[i] = c;
-    }
-    return result;
+    return SimpleVector_byte8_t_O::make(sarray);
   }
   SIMPLE_ERROR("Handle Don't get here");
 }

src/llvmo/llvmoExpose.cc

@@ -627,8 +627,7 @@ CL_DEFMETHOD core::T_sp TargetMachine_O::emitModule(core::T_sp stream, core::T_s
 
   if (stream == kw::_sym_simple_vector_byte8) {
     SYMBOL_EXPORT_SC_(KeywordPkg, simple_vector_byte8);
-    core::SimpleVector_byte8_t_sp vector_byte8 = core::SimpleVector_byte8_t_O::make(
-        stringOutput.size(), 0, false, stringOutput.size(), (const unsigned char*)stringOutput.data());
+    core::SimpleVector_byte8_t_sp vector_byte8 = core::SimpleVector_byte8_t_O::make(stringOutput);
     if (dwo_stream.notnilp()) {
       SIMPLE_ERROR("dwo_stream must be nil");
     }