FWD » Core Development » Base Language

Only 2 forms are in use in the server project:

OUTPUT TO filename APPEND UNBUFFERED.
OUTPUT TO filename UNBUFFERED.

Sometimes filename is hard coded and sometimes it is specified as VALUE. But that should not affect the UNBUFFERED case. I suspect the APPEND doesn't matter either, but testcases will be needed to prove it.

UNBUFFERED statement is not working properly in p2j. This keyword is properly converted, but worked different.
One example from update(other tests are not working too):

function checkFile returns int (fileName as character, c as character):
   define variable s as memptr no-undo.
   copy-lob from file fileName to s no-convert.
   /* on this line there is no data in file(file is created), but in 4gl all need data is already in file*/
   if (c ne string(s)) then
   do:
      message "ERROR: " string(s) .
      return -1.
   end.

   return 1.
end.

def var res as int.
def var s1 as character no-undo.
def var s2 as character no-undo.

s1 = "10".
s2 = "SoMeTeSt".

define stream rep.
output stream rep to unbuff_file.txt unbuffered.

put stream rep unformatted s1.

res = checkFile("unbuff_file.txt", s1).

if (res eq -1) then message "error1".

put stream rep unformatted s1.
res = checkFile("unbuff_file.txt", s1 + s1).

if (res eq -1) then message "error1".

put stream rep unformatted s2.
res = checkFile("unbuff_file.txt", s1 + s1 + s2).

if (res eq -1) then message "error1".

Also I've not tested input stream with unbuffered property. Do you have idea how I can test it ? I can write some program for example and try to read something.

UNBUFFERED property is allowed in:
INPUT FROM statement (not tested yet)
INPUT THROUGH statement (not tested yet)
INPUT-OUTPUT THROUGH statement (tested)
OUTPUT THROUGH statement (tested)
OUTPUT TO statement (tested)

Also, please add a test for OUTPUT TO "somefile.txt" UNBUFFERED (redirects the unnamed stream from the terminal to a file) and then use DISPLAY to generate formatted output to that file (DISPLAY uses a frame to display "report-like" output in this case).

Tested, works fine and same.

To implement UNBUFFERED, I think that you need to identify the possible places in Stream.java (and possibly in the subclasses) where output occurs and ensure that we flush immediately using the underlying Java stream facilities. There is some trickiness in the redirected terminal case because we hide the buffering in the P2J code, but I think it might be as simple as calling sync() after every output operation.

I've implemented UNBUFFERED option in each low level stream class. Because some of them has each buffer like FileStream. ProcessStream has already flushed data after each write(he used OutWriter and OutStream). I've tested it and it's work properly. TerminalStream has also flushed (sync()) data after each write.

With input operation it was a little bit tricky. There is no any special method flush() for InputStream(I mean java) we can only protect us from buffereing if we will use java unbuffered Readers like FileInputStream, InputStreamReader, FileReader, I've rechecked and retested all input operations and we didn't use any buffered streams.

Perhaps using UNBUFFERED will change how these return (immediate returns instead of blocking) or perhaps it will allow partial reads. You will have to experiment to see if you can find a difference. As with NO-ECHO, you will probably need to run the same test with and without UNBUFFERED (using a logical flag to control the choice at runtime).

Tested 50%. Don't see any difference atm.

1. Please merge the code up to the latest P2J level in bzr (Stream.java is missing changes).
2. In both classes, please place protected methods after public methods and before private methods, as our coding standards dictate.

done

3. If I understood your comments correctly, the ProcessStream and TerminalStream require no changes because in our P2J implementation they are already always unbuffered. Is that right?

Yes, in this classes unbuffered operation is already implemented:
class ProcessStream:
Used IOHelper interface to write or read something. Subclass OutWriter and OutStream call flush() after every write operation. Also InStream and InReader cannot write at all.

class TerminalStream:
This class always call sync.refresh() after each write. There is no flush like in common IO operation, but this method do the same.

4. What about PrinterStream?

I've missed PrinterStream because this class is not Subclass of Stream class. But after looking into code, I've found that this class using ProcessStream class and wrap all other streams into subclasses of IOHelper (which are always using flash())