C++ extractor improvements (#1803)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Split of NodeTree.
Split out FileUtil.
Split out MacroWriter.

* Rename slang-cpp-extractor-main.cpp -> cpp-extractor-main.cpp

* First pass at extractor unit-tests

* Initial parsing of enum.

* Ability to disable/enable parsing of scope types.

* Initial support for typedef.

* Added operator== != to ArrayVIew.
Added test for splitting to unit tests.

* Improve comment in StringUtil.

* Fix comment.

* Fix typo.

3 files changed, 78 insertions, 0 deletions

diff --git a/source/core/slang-array-view.h b/source/core/slang-array-view.h
index 56c936073..c67a53337 100644
--- a/source/core/slang-array-view.h
+++ b/source/core/slang-array-view.h
@@ -12,6 +12,8 @@ namespace Slang
     class ConstArrayView
     {
     public:
+        typedef ConstArrayView ThisType;
+
         const T* begin() const { return m_buffer; }
         
         const T* end() const { return m_buffer + m_count; }
@@ -70,6 +72,30 @@ namespace Slang
             return -1;
         }
 
+        bool operator==(const ThisType& rhs) const
+        {
+            if (&rhs == this)
+            {
+                return true;
+            }
+            const Index count = getCount();
+            if (count != rhs.getCount())
+            {
+                return false;
+            }
+            const T* thisEle = getBuffer();
+            const T* rhsEle = rhs.getBuffer();
+            for (Index i = 0; i < count; ++i)
+            {
+                if (thisEle[i] != rhsEle[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+        SLANG_FORCE_INLINE bool operator!=(const ThisType& rhs) const { return !(*this == rhs); }
+
         ConstArrayView() :
             m_buffer(nullptr),
             m_count(0)
@@ -111,6 +137,8 @@ namespace Slang
     class ArrayView: public ConstArrayView<T>
     {
     public:
+        typedef ArrayView ThisType;
+
         typedef ConstArrayView<T> Super;
         
         using Super::m_buffer;
@@ -147,6 +175,7 @@ namespace Slang
     {
         return ArrayView<T>(buffer, count);
     }
+
 }
 
 #endif
diff --git a/source/core/slang-string-util.cpp b/source/core/slang-string-util.cpp
index b4c767c87..8108bdc98 100644
--- a/source/core/slang-string-util.cpp
+++ b/source/core/slang-string-util.cpp
@@ -56,6 +56,52 @@ namespace Slang {
     }
 }
 
+/* static */void StringUtil::split(const UnownedStringSlice& in, const UnownedStringSlice& splitSlice, List<UnownedStringSlice>& outSlices)
+{
+    const Index splitLen = splitSlice.getLength();
+
+    if (splitLen == 1)
+    {
+        return split(in, splitSlice[0], outSlices);
+    }
+
+    outSlices.clear();
+
+    SLANG_ASSERT(splitLen > 0);
+    if (splitLen <= 0)
+    {
+        return;
+    }
+
+    const char* start = in.begin();
+    const char* end = in.end();
+
+    const char splitChar = splitSlice[0];
+
+    while (start < end)
+    {
+        // Move cur so it's either at the end or at next splitSlice
+        const char* cur = start;
+        while (cur < end)
+        {
+            if (*cur == splitChar &&
+                (cur + splitLen <= end && UnownedStringSlice(cur, splitLen) == splitSlice))
+            {
+                // We hit a split
+                break;
+            }
+
+            cur++;
+        }
+      
+        // Add to output
+        outSlices.add(UnownedStringSlice(start, cur));
+
+        // Skip the split, if at end we are okay anyway
+        start = cur + splitLen;
+    }
+}
+
 /* static */Index StringUtil::split(const UnownedStringSlice& in, char splitChar, Index maxSlices, UnownedStringSlice* outSlices)
 {
     Index index = 0;
diff --git a/source/core/slang-string-util.h b/source/core/slang-string-util.h
index 2850c3b4f..8031f5c8c 100644
--- a/source/core/slang-string-util.h
+++ b/source/core/slang-string-util.h
@@ -24,6 +24,9 @@ struct StringUtil
         /// Split in, by specified splitChar into slices out
         /// Slices contents will directly address into in, so contents will only stay valid as long as in does.
     static void split(const UnownedStringSlice& in, char splitChar, List<UnownedStringSlice>& slicesOut);
+        /// Split in by the specified splitSlice
+        /// Slices contents will directly address into in, so contents will only stay valid as long as in does.
+    static void split(const UnownedStringSlice& in, const UnownedStringSlice& splitSlice, List<UnownedStringSlice>& slicesOut);
 
         /// Splits in into outSlices, up to maxSlices. May not consume all of in (for example if it runs out of space).
     static Index split(const UnownedStringSlice& in, char splitChar, Index maxSlices, UnownedStringSlice* outSlices);