Further interactive testing strongly suggests that the Write pipe must be closed for the next read pipe to open the same pipe, if two anonymous pipes are created simulataneously by opening both ends they do not point to the same pipe.

but in the process of testing I ended up with a number of hanging pipes and no way to ensure which pipe my opens were opening, thus messing up my system. So I'll say it again don't use anonymous pipes....

I think that the first MODULE does give the expected results:

out1 => "Hello OneHello Two"

Since it looks like your PortablE code is using the DOS library directly.
ie, the first Read() of up to 100 bytes will just empty the current contents of the PIPE.

With a LF included at the end of each Write() it might come out as:

out1 => "Hello One
Hello Two"

To get the best speed, I ended up writing my own proc to DOS.Read() as much as possible, but allow LF delimited reads as well. (taking this opportunity to post Modula-2 code :)

You may be able to use DOS FReadLine() instead.

This, along with large sizes for /[Buffer Size] and /[Max Buffers] in the Open call, will give very fast PIPE transferring of data. os4depot game

(*-----------------------------------------------------------------------------------------------*)
 PROCEDURE ReadToLF(file:PipeFile; VAR Dest:GenStr; maxsize:INTEGER; PutChar:PutCharProc):BOOLEAN;
(*-----------------------------------------------------------------------------------------------*)
 
VAR inx       :INTEGER;
    LFfound   :BOOLEAN;
    ch        :CHAR;
 
BEGIN WITH file^ DO
 
inx := 0;
LFfound := FALSE;
 
LOOP
   IF TstBreak() THEN           (* not very useful currently *)
      pfReadCnt := 0;
      EXIT;
   END;
 
   IF pfNeedRead THEN
      pfReadCnt := ReadBuffered(file);
   END;
 
   IF pfReadCnt = -2 THEN   (* timed out *)
      IF pfRTOExceptOn THEN
         RAISE(PipeIOExceptSrc, ORD(PipeIOTimeOut), "PipeIOTimeOut");
      END;
      EXIT;
 
   ELSIF pfReadCnt > 0 THEN
      WHILE NOT LFfound AND NOT pfNeedRead DO
         ch := pfLineBuffer[pfBufPos];
         INC(pfBufPos);
         IF pfBufPos >= pfReadCnt THEN
            pfNeedRead := TRUE;
         END;
 
         IF ch # LF THEN
            PutChar(ch, Dest, inx, maxsize);
         ELSE
            LFfound := TRUE;
         END;
      END;
      IF LFfound THEN
        EXIT;
      END;
   END;
END;
 
RETURN LFfound;
 
END END ReadToLF;

Using the "PipeFile" type:

TYPE PipeFileRec = RECORD
                      pfFile         :FileHandle(*BPTR*);
                      pfBufPos       :INTEGER;
                      pfReadCnt      :INTEGER;
                      pfRTimMillis   :INTEGER;
                      pfFileName     :Str0.String80;
                      pfLineBuffer   :ARRAY[0..ReadBufSize] OF CHAR;
                      pfNeedRead     :BOOLEAN;
                      pfReadMode     :BOOLEAN;
                      pfRTOExceptOn  :BOOLEAN;  (* if TRUE, a read timeout causes an Exception *)
                      pfRTO          :BOOLEAN;  (* read timed out *)
                    END;

Why do you write to your input file and read from your output file? ;-) Just looks backwards to me.

Also, you open a pipe twice per once access. Once to read, another to write. So this would be a diffenece to the shell script. Have you tried opening only one pipe for both read and write access?

You could also try using one pipe only. But to duplicate the script, you'd need to open a pipe, write to it and close. Twice for each write. And then do the same when reading it back out again.

Also, your E code doesn't send line feeds that I can see, so also try and add one there. I think that may affect the bufferieng of the pipe, if it flushes on a line feed.