From 154e2d7f4a063703dbdbb0984579be10355bf785 Mon Sep 17 00:00:00 2001
From: Aki <please@ignore.pl>
Date: Fri, 1 Mar 2024 01:41:44 +0100
Subject: Rename inline files to .inl.h

---
 FoundationEx/Dictionary.h     |   2 +-
 FoundationEx/Dictionary.inl   | 246 ------------------------
 FoundationEx/Dictionary.inl.h | 246 ++++++++++++++++++++++++
 FoundationEx/List.h           |   2 +-
 FoundationEx/List.inl         | 432 ------------------------------------------
 FoundationEx/List.inl.h       | 432 ++++++++++++++++++++++++++++++++++++++++++
 StarsEx/Clock.h               |   2 +-
 StarsEx/Clock.inl             |  28 ---
 StarsEx/Clock.inl.h           |  28 +++
 9 files changed, 709 insertions(+), 709 deletions(-)
 delete mode 100644 FoundationEx/Dictionary.inl
 create mode 100644 FoundationEx/Dictionary.inl.h
 delete mode 100644 FoundationEx/List.inl
 create mode 100644 FoundationEx/List.inl.h
 delete mode 100644 StarsEx/Clock.inl
 create mode 100644 StarsEx/Clock.inl.h

diff --git a/FoundationEx/Dictionary.h b/FoundationEx/Dictionary.h
index dae9ca4..bcb30ed 100644
--- a/FoundationEx/Dictionary.h
+++ b/FoundationEx/Dictionary.h
@@ -95,6 +95,6 @@ public:
 
 // +-------------------------------------------------------------------+
 
-#include "Dictionary.inl"
+#include "Dictionary.inl.h"
 #endif  // Dictionary_h
 
diff --git a/FoundationEx/Dictionary.inl b/FoundationEx/Dictionary.inl
deleted file mode 100644
index cd58679..0000000
--- a/FoundationEx/Dictionary.inl
+++ /dev/null
@@ -1,246 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-
-    AUTHOR:       John DiCamillo
-
-
-    OVERVIEW
-    ========
-    Implementation of the Dictionary class
-*/
-
-#ifndef NDEBUG
-#define DICT_CHECK(a, b) if ((a) == 0) throw b;
-#else
-#define DICT_CHECK(a, b)
-#endif
-
-const int CHAINS = 256;
-
-// +-------------------------------------------------------------------+
-
-template <class T> Dictionary<T>::Dictionary()
-   : items(0)
-{ init(); }
-
-template <class T> Dictionary<T>::~Dictionary()
-{ clear(); }
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void Dictionary<T>::init()
-{
-   items = 0;
-   memset(table, 0, CHAINS*sizeof(PTR));
-}
-
-template <class T>
-void Dictionary<T>::clear()
-{
-   for (int i = 0; i < CHAINS; i++) {
-      DictionaryCell<T>* link = table[i];
-
-      while (link) {
-         DictionaryCell<T>* n = link->next;
-         delete link;
-         link = n;
-      }
-   }
-
-   init();
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T& Dictionary<T>::operator[](const Text& key)
-{
-   int idx = key.hash() % CHAINS;
-   DictionaryCell<T>* cell = table[idx];
-
-   if (cell == 0) {  // empty chain
-      items++;
-      cell = new DictionaryCell<T>(key);
-      table[idx] = cell;
-      return cell->value;
-   }
-   else {            // search for key
-      while (cell->next && cell->key != key)
-         cell = cell->next;
-
-      if (cell->key != key) {    // not found in chain
-         items++;
-         cell->next = new DictionaryCell<T>(key);
-         return cell->next->value;
-      }
-      else {         // found: return it!
-         return cell->value;
-      }
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void Dictionary<T>::insert(const Text& key, const T& val)
-{
-   T& value = operator[](key);
-      value = val;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void Dictionary<T>::remove(const Text& key)
-{
-   int idx = key.hash() % CHAINS;
-   DictionaryCell<T>* cell = table[idx];
-
-   if (cell == 0) {  // empty chain
-      return;
-   }
-   else {            // search for key
-      while (cell->next && cell->key != key)
-         cell = cell->next;
-
-      if (cell->key != key) {    // not found in chain
-         return;
-      }
-      else {         // found: remove it!
-         if (table[idx] == cell) {
-            table[idx] = cell->next;
-            delete cell;
-         }
-         else {
-            DictionaryCell<T>* p = table[idx];
-            while (p->next != cell)
-               p = p->next;
-            p->next = cell->next;
-            delete cell;
-         }
-      }
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-int Dictionary<T>::contains(const Text& key) const
-{
-   int idx = key.hash() % CHAINS;
-   DictionaryCell<T>* cell = table[idx];
-
-   if (cell != 0) {
-      while (cell->next && cell->key != key)
-         cell = cell->next;
-
-      if (cell->key == key)
-         return 1;
-   }
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T Dictionary<T>::find(const Text& key, T defval) const
-{
-   int idx = key.hash() % CHAINS;
-   DictionaryCell<T>* cell = table[idx];
-
-   if (cell != 0) {
-      while (cell->next && cell->key != key)
-         cell = cell->next;
-
-      if (cell->key == key)
-         return cell->value;
-   }
-
-   return defval;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T> DictionaryIter<T>::DictionaryIter(Dictionary<T>& d)
-   : dict(&d), chain(0), here(0)
-{ }
-
-template <class T> DictionaryIter<T>::~DictionaryIter()
-{ }
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void DictionaryIter<T>::reset()
-{
-   chain = 0;
-   here  = 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-Text DictionaryIter<T>::key() const
-{
-   return here->key;
-}
-
-template <class T>
-T DictionaryIter<T>::value() const
-{
-   return here->value;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-int DictionaryIter<T>::operator++()
-{
-   forth();
-   int more = chain < CHAINS;
-   return more;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void DictionaryIter<T>::forth()
-{
-   if (here) {
-      here = here->next;
-      if (!here) // off the end of this chain
-         chain++;
-   }
-
-   if (!here) {
-      while (!dict->table[chain] && chain < CHAINS)
-         chain++;
-
-      if (chain < CHAINS)
-         here = dict->table[chain];
-      else
-         here = 0;
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void DictionaryIter<T>::attach(Dictionary<T>& d)
-{
-   dict = &d;
-   reset();
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-Dictionary<T>& DictionaryIter<T>::container()
-{
-   return *dict;
-}
-
diff --git a/FoundationEx/Dictionary.inl.h b/FoundationEx/Dictionary.inl.h
new file mode 100644
index 0000000..cd58679
--- /dev/null
+++ b/FoundationEx/Dictionary.inl.h
@@ -0,0 +1,246 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+
+    AUTHOR:       John DiCamillo
+
+
+    OVERVIEW
+    ========
+    Implementation of the Dictionary class
+*/
+
+#ifndef NDEBUG
+#define DICT_CHECK(a, b) if ((a) == 0) throw b;
+#else
+#define DICT_CHECK(a, b)
+#endif
+
+const int CHAINS = 256;
+
+// +-------------------------------------------------------------------+
+
+template <class T> Dictionary<T>::Dictionary()
+   : items(0)
+{ init(); }
+
+template <class T> Dictionary<T>::~Dictionary()
+{ clear(); }
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void Dictionary<T>::init()
+{
+   items = 0;
+   memset(table, 0, CHAINS*sizeof(PTR));
+}
+
+template <class T>
+void Dictionary<T>::clear()
+{
+   for (int i = 0; i < CHAINS; i++) {
+      DictionaryCell<T>* link = table[i];
+
+      while (link) {
+         DictionaryCell<T>* n = link->next;
+         delete link;
+         link = n;
+      }
+   }
+
+   init();
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T& Dictionary<T>::operator[](const Text& key)
+{
+   int idx = key.hash() % CHAINS;
+   DictionaryCell<T>* cell = table[idx];
+
+   if (cell == 0) {  // empty chain
+      items++;
+      cell = new DictionaryCell<T>(key);
+      table[idx] = cell;
+      return cell->value;
+   }
+   else {            // search for key
+      while (cell->next && cell->key != key)
+         cell = cell->next;
+
+      if (cell->key != key) {    // not found in chain
+         items++;
+         cell->next = new DictionaryCell<T>(key);
+         return cell->next->value;
+      }
+      else {         // found: return it!
+         return cell->value;
+      }
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void Dictionary<T>::insert(const Text& key, const T& val)
+{
+   T& value = operator[](key);
+      value = val;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void Dictionary<T>::remove(const Text& key)
+{
+   int idx = key.hash() % CHAINS;
+   DictionaryCell<T>* cell = table[idx];
+
+   if (cell == 0) {  // empty chain
+      return;
+   }
+   else {            // search for key
+      while (cell->next && cell->key != key)
+         cell = cell->next;
+
+      if (cell->key != key) {    // not found in chain
+         return;
+      }
+      else {         // found: remove it!
+         if (table[idx] == cell) {
+            table[idx] = cell->next;
+            delete cell;
+         }
+         else {
+            DictionaryCell<T>* p = table[idx];
+            while (p->next != cell)
+               p = p->next;
+            p->next = cell->next;
+            delete cell;
+         }
+      }
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+int Dictionary<T>::contains(const Text& key) const
+{
+   int idx = key.hash() % CHAINS;
+   DictionaryCell<T>* cell = table[idx];
+
+   if (cell != 0) {
+      while (cell->next && cell->key != key)
+         cell = cell->next;
+
+      if (cell->key == key)
+         return 1;
+   }
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T Dictionary<T>::find(const Text& key, T defval) const
+{
+   int idx = key.hash() % CHAINS;
+   DictionaryCell<T>* cell = table[idx];
+
+   if (cell != 0) {
+      while (cell->next && cell->key != key)
+         cell = cell->next;
+
+      if (cell->key == key)
+         return cell->value;
+   }
+
+   return defval;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T> DictionaryIter<T>::DictionaryIter(Dictionary<T>& d)
+   : dict(&d), chain(0), here(0)
+{ }
+
+template <class T> DictionaryIter<T>::~DictionaryIter()
+{ }
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void DictionaryIter<T>::reset()
+{
+   chain = 0;
+   here  = 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+Text DictionaryIter<T>::key() const
+{
+   return here->key;
+}
+
+template <class T>
+T DictionaryIter<T>::value() const
+{
+   return here->value;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+int DictionaryIter<T>::operator++()
+{
+   forth();
+   int more = chain < CHAINS;
+   return more;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void DictionaryIter<T>::forth()
+{
+   if (here) {
+      here = here->next;
+      if (!here) // off the end of this chain
+         chain++;
+   }
+
+   if (!here) {
+      while (!dict->table[chain] && chain < CHAINS)
+         chain++;
+
+      if (chain < CHAINS)
+         here = dict->table[chain];
+      else
+         here = 0;
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void DictionaryIter<T>::attach(Dictionary<T>& d)
+{
+   dict = &d;
+   reset();
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+Dictionary<T>& DictionaryIter<T>::container()
+{
+   return *dict;
+}
+
diff --git a/FoundationEx/List.h b/FoundationEx/List.h
index 12fc635..54dfcb1 100644
--- a/FoundationEx/List.h
+++ b/FoundationEx/List.h
@@ -101,6 +101,6 @@ private:
    int      step;
 };
 
-#include "List.inl"
+#include "List.inl.h"
 #endif  // List_h
 
diff --git a/FoundationEx/List.inl b/FoundationEx/List.inl
deleted file mode 100644
index 9ccb796..0000000
--- a/FoundationEx/List.inl
+++ /dev/null
@@ -1,432 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-
-    AUTHOR:       John DiCamillo
-
-
-    OVERVIEW
-    ========
-    Implementation of the List class template
-*/
-
-#include <stdlib.h>
-
-#include "Utils.h"
-
-
-template <class T>
-List<T>::List(const List<T>& l)
-  : items(l.items), extent(l.extent)
-{
-   array = new PTR[extent];
-   for (int i = 0; i < extent; i++)
-      array[i] = l.array[i];
-}
-
-template <class T>
-void List<T>::clear()
-{
-   delete [] array;
-   items       = 0;
-   extent  = 0;
-   array       = 0;
-}
-
-template <class T>
-void List<T>::destroy()
-{
-   if (items) {
-      items = 0;  // prevent dangerous re-entrancy
-
-      for (int i = 0; i < extent; i++)
-         delete array[i];
-
-      delete [] array;
-      items       = 0;
-      extent  = 0;
-      array       = 0;
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-bool List<T>::check(int& index) const
-{
-   if (index < 0) {
-      Print("Bounds error in List(%08p) T=%s index=%d min=0\n", this, T::TYPENAME(), index);
-      index = 0;
-   }
-
-   else if (index >= items) {
-      Print("Bounds error in List(%08p) T=%s index=%d max=%d\n", this, T::TYPENAME(), index, items-1);
-      index = items-1;
-   }
-
-   return (index >= 0 && index < items);
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T*& List<T>::operator[](int index)
-{
-   if (check(index))
-      return array[index];
-
-   if (!array || !extent)
-      resize(1);
-
-   return array[0];
-}
-
-template <class T>
-T* List<T>::operator[](int index) const
-{
-   if (check(index))
-      return array[index];
-   return 0;
-}
-
-template <class T>
-T*& List<T>::at(int index)
-{
-   if (check(index))
-      return array[index];
-
-   if (!array || !extent)
-      resize(1);
-
-   return array[0];
-}
-
-template <class T>
-T* List<T>::at(int index) const
-{
-   if (check(index))
-      return array[index];
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void List<T>::resize(int newsize)
-{
-   if (newsize > extent) {
-      extent = 16 * (newsize/16 + 1);
-      T** v = new PTR[extent];
-      int i;
-      for (i = 0; i < items; i++)
-         v[i] = array[i];
-
-      for (; i < extent; i++)
-         v[i] = 0;
-
-      delete [] array;
-      array = v;
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void List<T>::append(const T* item)
-{
-   if (item) {
-      if (items+1 > extent) resize(items+1);
-      array[items++] = (T*)item;
-   }
-}
-
-template <class T>
-void List<T>::append(List<T>& list)
-{
-   if (&list != this && list.items > 0) {
-      int need = items + list.items;
-      if (need > extent) resize(need);
-
-      for (int i = 0; i < list.items; i++)
-         array[items++] = list.array[i];
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void List<T>::insert(const T* item, int index)
-{
-   if (item && index >= 0 && index <= items) {
-      if (items+1 > extent) resize(items+1);
-
-      // slide right:
-      for (int i = items; i > index; i--)
-         array[i] = array[i-1];
-
-      array[index] = (T*)item;
-      items++;
-   }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void List<T>::insertSort(const T* item)
-{
-    if (item) {
-        int i;
-        for (i = 0; i < items; i++) {
-            if (*item < *array[i])
-                break;
-        }
-
-        insert(item, i);
-    }
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T* List<T>::remove(const T* val)
-{
-   if (items == 0 || val == 0)
-      return 0;
-
-   for (int i = 0; i < items; i++) {
-      if (array[i] == val) {
-         return removeIndex(i);
-      }
-   }
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T* List<T>::removeIndex(int index)
-{
-   if (!check(index))
-      return 0;
-
-   T* tmp = array[index];
-   array[index] = 0;
-
-   // slide left:
-   for (int i = index; i < items-1; i++)
-      array[i] = array[i+1];
-
-   // blank out the hole we just created:
-   array[items-1] = 0;
-
-   items--;
-   return tmp;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-bool List<T>::contains(const T* val) const
-{
-   if (val) {
-      if (index(val) != -1)
-          return true;
-   }
-
-   return false;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-int List<T>::count(const T* val) const
-{
-   int c = 0;
-
-   if (val) {
-      for (int i = 0; i < items; i++) {
-         if (array[i] && ((*array[i])==(*val)))
-            c++;
-      }
-   }
-
-   return c;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-int List<T>::index(const T* val) const
-{
-   if (val) {
-      for (int i = 0; i < items; i++) {
-         if (array[i] && ((*array[i])==(*val)))
-            return i;
-      }
-   }
-
-   return -1;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T* List<T>::find(const T* val) const
-{
-   if (val) {
-      for (int i = 0; i < items; i++) {
-         if (array[i] && ((*array[i])==(*val)))
-            return array[i];
-      }
-   }
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void List<T>::swap(T** a, int i, int j)
-{
-   if (i >= 0 && i < items && j >= 0 && j < items && i != j) {
-      T* t = a[i];
-      a[i] = a[j];
-      a[j] = t;
-   }
-}
-
-template <class T>
-void List<T>::qsort(T** a, int lo0, int hi0)
-{
-   int lo = lo0;
-   int hi = hi0;
-
-   // zero or one element list, nothing to do:
-   if (lo >= hi) {
-      return;
-   }
-
-   // two element list, swap if needed:
-   else if (lo == hi-1) {
-      if (*a[hi] < *a[lo]) {
-         swap(a, lo, hi);
-      }
-      return;
-   }
-
-   // pick a pivot, and move it out of the way:
-   int mid   = (lo+hi)/2;
-   T*  pivot = a[mid];
-   a[mid]    = a[hi];
-   a[hi]     = pivot;
-
-   while (lo < hi) {
-      while ((*a[lo] <= *pivot) && lo < hi) lo++;
-      while ((*pivot <= *a[hi]) && lo < hi) hi--;
-
-      if (lo < hi) {
-         swap(a, lo, hi);
-      }
-   }
-
-   // Put the pivot into its final location:
-   a[hi0] = a[hi];
-   a[hi] = pivot;
-
-    qsort(a, lo0, lo-1);
-    qsort(a, hi+1, hi0);
-}
-
-template <class T>
-void List<T>::sort()
-{
-   if (items < 2)
-      return;
-
-   qsort(array, 0, items-1);
-}
-
-template <class T>
-void List<T>::shuffle()
-{
-   if (items < 3)
-      return;
-
-   for (int s = 0; s < 5; s++) {
-      for (int i = 0; i < items; i++) {
-         int j = (rand()>>4) % items;
-         swap(array, i, j);
-      }
-   }
-}
-
-// +===================================================================+
-
-template <class T>
-T* ListIter<T>::value()
-{
-   if (list && step >= 0 && step < list->items)
-      return list->array[step];
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T* ListIter<T>::removeItem()
-{
-   if (list && step >= 0 && step < list->items)
-      return list->removeIndex(step--);
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-T* ListIter<T>::next()
-{
-   if (list && step >= -1 && step < list->items-1)
-      return list->array[++step];
-
-   return 0;
-}
-
-template <class T>
-T* ListIter<T>::prev()
-{
-   if (list && step > 0 && step < list->items)
-      return list->array[--step];
-
-   return 0;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-void ListIter<T>::attach(List<T>& l)
-{
-   list = &l;
-   step = -1;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-int ListIter<T>::size()
-{
-   if (!list) return 0;
-   return list->items;
-}
-
-// +-------------------------------------------------------------------+
-
-template <class T>
-List<T>& ListIter<T>::container()
-{
-   return *list;
-}
-
diff --git a/FoundationEx/List.inl.h b/FoundationEx/List.inl.h
new file mode 100644
index 0000000..9ccb796
--- /dev/null
+++ b/FoundationEx/List.inl.h
@@ -0,0 +1,432 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+
+    AUTHOR:       John DiCamillo
+
+
+    OVERVIEW
+    ========
+    Implementation of the List class template
+*/
+
+#include <stdlib.h>
+
+#include "Utils.h"
+
+
+template <class T>
+List<T>::List(const List<T>& l)
+  : items(l.items), extent(l.extent)
+{
+   array = new PTR[extent];
+   for (int i = 0; i < extent; i++)
+      array[i] = l.array[i];
+}
+
+template <class T>
+void List<T>::clear()
+{
+   delete [] array;
+   items       = 0;
+   extent  = 0;
+   array       = 0;
+}
+
+template <class T>
+void List<T>::destroy()
+{
+   if (items) {
+      items = 0;  // prevent dangerous re-entrancy
+
+      for (int i = 0; i < extent; i++)
+         delete array[i];
+
+      delete [] array;
+      items       = 0;
+      extent  = 0;
+      array       = 0;
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+bool List<T>::check(int& index) const
+{
+   if (index < 0) {
+      Print("Bounds error in List(%08p) T=%s index=%d min=0\n", this, T::TYPENAME(), index);
+      index = 0;
+   }
+
+   else if (index >= items) {
+      Print("Bounds error in List(%08p) T=%s index=%d max=%d\n", this, T::TYPENAME(), index, items-1);
+      index = items-1;
+   }
+
+   return (index >= 0 && index < items);
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T*& List<T>::operator[](int index)
+{
+   if (check(index))
+      return array[index];
+
+   if (!array || !extent)
+      resize(1);
+
+   return array[0];
+}
+
+template <class T>
+T* List<T>::operator[](int index) const
+{
+   if (check(index))
+      return array[index];
+   return 0;
+}
+
+template <class T>
+T*& List<T>::at(int index)
+{
+   if (check(index))
+      return array[index];
+
+   if (!array || !extent)
+      resize(1);
+
+   return array[0];
+}
+
+template <class T>
+T* List<T>::at(int index) const
+{
+   if (check(index))
+      return array[index];
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void List<T>::resize(int newsize)
+{
+   if (newsize > extent) {
+      extent = 16 * (newsize/16 + 1);
+      T** v = new PTR[extent];
+      int i;
+      for (i = 0; i < items; i++)
+         v[i] = array[i];
+
+      for (; i < extent; i++)
+         v[i] = 0;
+
+      delete [] array;
+      array = v;
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void List<T>::append(const T* item)
+{
+   if (item) {
+      if (items+1 > extent) resize(items+1);
+      array[items++] = (T*)item;
+   }
+}
+
+template <class T>
+void List<T>::append(List<T>& list)
+{
+   if (&list != this && list.items > 0) {
+      int need = items + list.items;
+      if (need > extent) resize(need);
+
+      for (int i = 0; i < list.items; i++)
+         array[items++] = list.array[i];
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void List<T>::insert(const T* item, int index)
+{
+   if (item && index >= 0 && index <= items) {
+      if (items+1 > extent) resize(items+1);
+
+      // slide right:
+      for (int i = items; i > index; i--)
+         array[i] = array[i-1];
+
+      array[index] = (T*)item;
+      items++;
+   }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void List<T>::insertSort(const T* item)
+{
+    if (item) {
+        int i;
+        for (i = 0; i < items; i++) {
+            if (*item < *array[i])
+                break;
+        }
+
+        insert(item, i);
+    }
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T* List<T>::remove(const T* val)
+{
+   if (items == 0 || val == 0)
+      return 0;
+
+   for (int i = 0; i < items; i++) {
+      if (array[i] == val) {
+         return removeIndex(i);
+      }
+   }
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T* List<T>::removeIndex(int index)
+{
+   if (!check(index))
+      return 0;
+
+   T* tmp = array[index];
+   array[index] = 0;
+
+   // slide left:
+   for (int i = index; i < items-1; i++)
+      array[i] = array[i+1];
+
+   // blank out the hole we just created:
+   array[items-1] = 0;
+
+   items--;
+   return tmp;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+bool List<T>::contains(const T* val) const
+{
+   if (val) {
+      if (index(val) != -1)
+          return true;
+   }
+
+   return false;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+int List<T>::count(const T* val) const
+{
+   int c = 0;
+
+   if (val) {
+      for (int i = 0; i < items; i++) {
+         if (array[i] && ((*array[i])==(*val)))
+            c++;
+      }
+   }
+
+   return c;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+int List<T>::index(const T* val) const
+{
+   if (val) {
+      for (int i = 0; i < items; i++) {
+         if (array[i] && ((*array[i])==(*val)))
+            return i;
+      }
+   }
+
+   return -1;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T* List<T>::find(const T* val) const
+{
+   if (val) {
+      for (int i = 0; i < items; i++) {
+         if (array[i] && ((*array[i])==(*val)))
+            return array[i];
+      }
+   }
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void List<T>::swap(T** a, int i, int j)
+{
+   if (i >= 0 && i < items && j >= 0 && j < items && i != j) {
+      T* t = a[i];
+      a[i] = a[j];
+      a[j] = t;
+   }
+}
+
+template <class T>
+void List<T>::qsort(T** a, int lo0, int hi0)
+{
+   int lo = lo0;
+   int hi = hi0;
+
+   // zero or one element list, nothing to do:
+   if (lo >= hi) {
+      return;
+   }
+
+   // two element list, swap if needed:
+   else if (lo == hi-1) {
+      if (*a[hi] < *a[lo]) {
+         swap(a, lo, hi);
+      }
+      return;
+   }
+
+   // pick a pivot, and move it out of the way:
+   int mid   = (lo+hi)/2;
+   T*  pivot = a[mid];
+   a[mid]    = a[hi];
+   a[hi]     = pivot;
+
+   while (lo < hi) {
+      while ((*a[lo] <= *pivot) && lo < hi) lo++;
+      while ((*pivot <= *a[hi]) && lo < hi) hi--;
+
+      if (lo < hi) {
+         swap(a, lo, hi);
+      }
+   }
+
+   // Put the pivot into its final location:
+   a[hi0] = a[hi];
+   a[hi] = pivot;
+
+    qsort(a, lo0, lo-1);
+    qsort(a, hi+1, hi0);
+}
+
+template <class T>
+void List<T>::sort()
+{
+   if (items < 2)
+      return;
+
+   qsort(array, 0, items-1);
+}
+
+template <class T>
+void List<T>::shuffle()
+{
+   if (items < 3)
+      return;
+
+   for (int s = 0; s < 5; s++) {
+      for (int i = 0; i < items; i++) {
+         int j = (rand()>>4) % items;
+         swap(array, i, j);
+      }
+   }
+}
+
+// +===================================================================+
+
+template <class T>
+T* ListIter<T>::value()
+{
+   if (list && step >= 0 && step < list->items)
+      return list->array[step];
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T* ListIter<T>::removeItem()
+{
+   if (list && step >= 0 && step < list->items)
+      return list->removeIndex(step--);
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+T* ListIter<T>::next()
+{
+   if (list && step >= -1 && step < list->items-1)
+      return list->array[++step];
+
+   return 0;
+}
+
+template <class T>
+T* ListIter<T>::prev()
+{
+   if (list && step > 0 && step < list->items)
+      return list->array[--step];
+
+   return 0;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+void ListIter<T>::attach(List<T>& l)
+{
+   list = &l;
+   step = -1;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+int ListIter<T>::size()
+{
+   if (!list) return 0;
+   return list->items;
+}
+
+// +-------------------------------------------------------------------+
+
+template <class T>
+List<T>& ListIter<T>::container()
+{
+   return *list;
+}
+
diff --git a/StarsEx/Clock.h b/StarsEx/Clock.h
index 39e08ac..238616d 100644
--- a/StarsEx/Clock.h
+++ b/StarsEx/Clock.h
@@ -50,6 +50,6 @@ private:
 };
 
 
-#include "Clock.inl"
+#include "Clock.inl.h"
 
 #endif  // Clock_h
diff --git a/StarsEx/Clock.inl b/StarsEx/Clock.inl
deleted file mode 100644
index 42a2693..0000000
--- a/StarsEx/Clock.inl
+++ /dev/null
@@ -1,28 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-*/
-
-#include "Clock.h"
-
-#include <chrono>
-#include <ratio>
-
-
-template <typename R>
-R
-Clock::GameTime() const
-{
-    using target_duration = std::chrono::duration<R, std::milli>;
-    return std::chrono::duration_cast<target_duration>(m_game_elapsed).count();
-}
-
-
-template <typename R>
-R
-Clock::RealTime() const
-{
-    using target_duration = std::chrono::duration<R, std::milli>;
-    return std::chrono::duration_cast<target_duration>(m_real_elapsed).count();
-}
diff --git a/StarsEx/Clock.inl.h b/StarsEx/Clock.inl.h
new file mode 100644
index 0000000..42a2693
--- /dev/null
+++ b/StarsEx/Clock.inl.h
@@ -0,0 +1,28 @@
+/*  Starshatter: The Open Source Project
+    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
+    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
+    Copyright (c) 1997-2006, Destroyer Studios LLC.
+*/
+
+#include "Clock.h"
+
+#include <chrono>
+#include <ratio>
+
+
+template <typename R>
+R
+Clock::GameTime() const
+{
+    using target_duration = std::chrono::duration<R, std::milli>;
+    return std::chrono::duration_cast<target_duration>(m_game_elapsed).count();
+}
+
+
+template <typename R>
+R
+Clock::RealTime() const
+{
+    using target_duration = std::chrono::duration<R, std::milli>;
+    return std::chrono::duration_cast<target_duration>(m_real_elapsed).count();
+}
-- 
cgit v1.1