Interprocess communication via pipes (#2009)

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

* Use 'Process' to communicate with an command line tool.

* Remove slang-win-stream

* Tidy up windows ProcessUtil.

* First version of BufferedReadStream.

* Windows working IPC for steams.

* Test proxy count option.

* Split Process/ProcessUtil. Process is platform dependant. ProcessUtil are functions that are platform independent.

* First implementation of Unix Process interface.

* Unix process compiles on cygwin.

* Fix typo in unix process.

* Separate unix pipe stream error of invalid access, from pipe availability.

* Fix in standard line extraction.

* Make fd non blocking.

* Fix issues with Windows Process streams.

* Added UnixPipe.

* Some fixes around UnixPipeStream.

* Make a unix stream closed explicit.

* Hack to debug linux process/stream.

* Revert to old linux pipe handling.

* Pass executable path for unit tests.
Split out CommandLine into own source.

* Small improvements in process/command line.

* Check process behavior with crash.

* Make stderr and stdout unbuffered for crash testing.

* Only turn disable buffering in crash test.

* Disable crash test on CI.

* Fix crash on clang/linux.

* Enable crash test.
Remove _appendBuffer as can use StreamUtil functionality.

1 files changed, 54 insertions, 0 deletions

diff --git a/source/core/slang-string-util.cpp b/source/core/slang-string-util.cpp
index b2886c413..5282f01a6 100644
--- a/source/core/slang-string-util.cpp
+++ b/source/core/slang-string-util.cpp
@@ -350,6 +350,60 @@ ComPtr<ISlangBlob> StringUtil::createStringBlob(const String& string)
     return (fromChar == toChar || string.indexOf(fromChar) == Index(-1)) ? string : calcCharReplaced(string.getUnownedSlice(), fromChar, toChar);
 }
 
+/* static */void StringUtil::appendStandardLines(const UnownedStringSlice& text, StringBuilder& out)
+{
+    const char* cur = text.begin();
+    const char* start = cur;
+    const char* const end = text.end();
+
+    while (cur < end)
+    {
+        const char c = *cur;
+        switch (c)
+        {
+            case '\n':
+            {
+                ++cur;
+                if (cur < end && *cur == '\r')
+                {
+                    // If we have following \r, we should append with \n
+                    // Append (including \n) 
+                    out.append(start, cur);
+                    // Skip the \r
+                    start = ++cur;
+                }
+                else
+                {
+                    // If not, we don't need to append because just \n is 'standard', and everything remaining
+                    // is appended at the end
+                }
+                break;
+            }
+            case '\r':
+            {
+                out.append(start, cur);
+                out.appendChar('\n');
+
+                ++cur;
+                // If next is \n, we want to skip that
+                cur += Index(cur < end && *cur == '\n');
+                start = cur;
+                break;
+            }
+            default:
+            {
+                cur++;
+                break;
+            }
+        }
+    }
+
+    if (start < end)
+    {
+        out.append(start, end);
+    }
+}
+
 /* static */bool StringUtil::extractLine(UnownedStringSlice& ioText, UnownedStringSlice& outLine)
 {
     char const*const begin = ioText.begin();