NAME

sio - standard input/output module

STANDARD INPUT/OUTPUT MODULE

The Standard Input/Outputmodule is an orginal implementation that provides objects for i/o operations. Although input and output files are the standard objects that one might expect, the module facilities for directory access, path manipulation and i/o event management. At the heart of this module is the concept of stream associated with the transcoding object which enable the passage between one coding system to another. It is also this module which provides the stream selector object.

Input and output streams
The afnix-siomodule is based on facilities provided by two base classes, namely, the InputStreamstream and the OutputStreamstream. Both classes have associated predicates with the name input-stream-pand output-stream-p. The base class associated is the Streamclass those sole purpose is to define the stream coding mode.

Stream base class
The Streamclass is the base class for the InputStreamand OutputStreamclasses. The Streamclass is used to define the stream coding mode that affects how characters are read or written. When a stream operates in byte mode, each character is assumed to be encoded in one byte. In that case, the input stream methods readand getuare equivalent and no transformation is performed when writing characters. This behavior is the default stream behavior. For certain stream, like terminal, this behavior is changed depending on the current localization settings. For instance, if the current locale is operating with an UTF-8codeset, the Terminalstream coding mode is automatically adjusted to reflect this situation. Since the US-ASCIIcodeset is predominant and the default steam coding mode is the byte mode, there should be no conflict during the read and write operations.

Stream transcoding
The Streamclass provides the support for the transcoding of different codesets. All ISO-8859codesets are supported. Since the engine operates internally with Unicode characters, the transcoding operation takes care of changing a character in one particular codeset into its equivalent Unicode representation. This operation is done for an input stream that operates in byte mode. For an output stream, the opposite operation is done. An internal Unicode characters representation is therefore mapped into a particular codeset. Note that only the codeset characters can be mapped.

The set-encoding-modecan be used to set the stream encoding codeset. The method operates either by enumeration or string. The get-encoding-modereturns the stream encoding mode. There are some time good reasons to force a stream encoding mode. For example, a file encoded in UTF-8 that is read will require this call since the default stream mode is to work in byte mode. It should be noted that there is a difference between the enumeration and the string encoding mode. The enumeration mode defines whether the stream operates in byte or UTF-8 mode. When the stream operates in byte mode, it is also necessary to define the transcoding mode with the set-transcoding-modemethod. For simplicity, the string version of the set-encoding-modetakes care of setting both the stream mode and the transcoding mode. It is also worth to note that internally, the Streamclass is derived from the Transcoderclass.

Input stream
The InputStreambase class has several method for reading and testing for byte availability. Moreover, the class provides a push-back buffer. Reading bytes is in the form of three methods. The readmethod without argument returns the next available byte or the end-of-streameos. With an integer argument, the readmethod returns a Bufferwith at most the number of requested bytes. The readlnmethod returns the next available line. When it is necessary to read characters instead of bytes, the getuis more appropriate since it returns an Unicode character.

Output stream
The OutputStreambase class provides the base methods to write to an output stream. The writemethod takes literal objects which are automatically converted to string representation and then written to the output stream. Note that for the case of a Bufferobject, it is the buffer itself that take a stream argument and not the opposite.

The valid-p predicate
The input stream provides a general mechanism to test and read for bytes. The base method is the valid-ppredicate that returns trueif a byte can be read from the stream. It is important to understand its behavior which depends on the stream type. Without argument, the valid-ppredicate checks for an available byte from the input stream. This predicate will block if no byte is available. On the other end, for a bounded stream like an input file, the method will not block at the end of file. With one integer argument, the valid-ppredicate will timeout after the specified time specified in milliseconds. This second behavior is particularly useful with unbound stream like socket stream.

The eos-p predicate
The eos-ppredicate does not take argument. The predicate behaves like not (valid-p 0). However, there are more subtle behaviors. For an input file, the predicate will return trueif and only if a byte cannot be read. If a byte has been pushed-back and the end-of-streammarker is reached, the method will return false. For an input terminal, the method returns true if the user and entered the end-of-streambyte. Once again, the method reacts to the contents of the push-back buffer. For certain input stream, like a tcp socket, the method will return true when no byte can be read, that is here, the connection has been closed. For an udp socket, the method will return truewhen all datagram bytes have be read.

The read method
The readmethod is sometimes disturbing. Nevertheless, the method is a blocking one and will return a byte when completed. The noticeable exception is the returned byte when an end-of-streammarker has been reached. The method returns the ctrl-dbyte. Since a binary file might contains valid byte like ctrl-dit is necessary to use the valid-por eos-ppredicate to check for a file reading completion. This remark apply also to bounded streams like a tcp socket. For some type of streams like a udp socket, the method will block when all datagram bytes have been consumed and no more datagram has arrived. With this kind of stream, there is no end-of-streamcondition and therefore care should be taken to properly assert the stream content. This last remark is especially true for the readlnmethod. The method will return when the end-of-streammarker is reached, even if a newline byte has not been read. With an udp socket, such behavior will not happen.

Buffer read mode
The readmethod with an integer argument, returns a buffer with at least the number of bytes specified as an argument. This method is particularly useful when the contents has a precise size. The method returns a Bufferobject which can later be used to read, or transform bytes. Multi-byte conversion to number should use such approach. The readmethod does not necessarily returns the number of requested bytes. Once the buffer is returned, the lengthmethod can be used to check the buffer size. Note also the existence of the to-stringmethod which returns a string representation of the buffer.

# try to read 256 bytes
const buf (is:read 256)
# get the buffer size
println (buf:length)
# get a string representation
println (buf:to-string)

File stream
The afnix-siomodule provides two classes for file access. The InputFileclass open a file for input. The OutputFileclass opens a file for output. The InputFileclass is derived from the InputStreambase class. The OutputFileclass is derived from the OutputStreamclass. By default an output file is created if it does not exist. If the file already exist, the file is truncated to 0. Another constructor for the output file gives more control about this behavior. It takes two boolean flags that defines the truncate and append mode.

# load the module
interp:library "afnix-sio"
# create an input file by name
const if (afnix:sio:InputFile "orig.txt")
# create an output file by name
const of (afnix:sio:OutputFile "copy.txt")

Stream information
Both InputFileand OutputFilesupports the get-namemethod which returns the file name.

println (if:get-name)
println (of:get-name)

Predicates are also available for these classes. The input-file-preturns true for an input file object.The output-file-preturns true for an output file object.

afnix:sio:input-stream-p  if
afnix:sio:output-stream-p of
afnix:sio:input-file-p    if
afnix:sio:output-file-p   of

Reading and writing
The readmethod reads a byte on an input stream. The writemethod writes one or more literal arguments on the output stream. The writelnmethod writes one or more literal arguments followed by a newline byte on the output stream. The newlinemethod write a newline byte on the output stream. The eos-ppredicate returns true for an input stream, if the stream is at the end. The valid-ppredicate returns true if an input stream is in a valid state. With these methods, copying a file is a simple operation.

# load the module and open the files
interp:library "afnix-sio"
const if (afnix:sio:InputFile "orig.txt")
const of (afnix:sio:OutputFile "copy.txt")
# loop in the input file and write
while (if:valid-p) (of:write (if:read))

The use of the readlnmethod can be more effective. The example below is a simple cat program which take the file name an argument.

# cat a file on the output terminal
# usage: axi 0601.als file
# get the io module
interp:library "afnix-sio"
# cat a file
const cat (name) {


  const f (afnix:sio:InputFile name)


  while (f:valid-p) (println (f:readln))


  f:close
}
# get the file
if (== 0 (interp:argv:length)) {


  errorln "usage: axi 0601.als file"
} {


  cat (interp:argv:get 0)
}

Multiplexing
I/O multiplexing is the ability to manipulate several streams at the same time and process one at a time. Although the use of threads reduce the needs for i/o multiplexing, there is still situations where they are needed. In other words, I/O multiplexing is identical to the valid-ppredicate, except that it works with several stream objects.

Selector object
I/O multiplexing is accomplished with the Selectorclass. The constructor takes 0 or several stream arguments. The class manages automatically to differentiate between InputStreamstream and OutputStreamstreams. Once the class is constructed, it is possible to get the first stream ready for reading or writing or all of them. We assume in the following example that isand osare respectively an input and an output stream.

# create a selector
const slt (afnix:sio:Selector is)
# at this stage the selector has one stream
# the add method can add more streams
slt:add os

The addmethod adds a new stream to the selector. The stream must be either an InputStreamand OutputStreamstream or an exception is raised. If the stream is both an input and an output stream, the preference is given to the input stream. If this preference is not acceptable, the input-addor the output-addmethods might be preferable. The input-lengthmethod returns the number of input streams in this selector. The output-lengthmethod returns the number of output streams in this selector. The input-getmethod returns the selector input stream by index. The output-getmethod returns the selector output stream by index.

Waiting for i/o event
The waitand wait-allmethods can be used to detect a status change in the selector. Without argument both methods will block indefinitely until one stream change. With one integer argument, both method blocks until one stream change or the integer argument timeout expires. The timeout is expressed in milliseconds. Note that 0 indicates an immediate return. The waitmethod returns the first stream which is ready either for reading or writing depending whether it is an input or output stream. The wait-allmethod returns a vector with all streams that have changed their status. The waitmethod returns nilif the no stream have changed. Similarly, the wait-allmethod returns an empty vector.

# wait for a status change
const is (slt:wait)
# is is ready for reading - make sure it is an input one
if (afnix:sio:input-stream-p is) (is:read)

A call to the waitmethod will always returns the first input stream.

Marking mode
When used with several input streams in a multi-threaded context, the selector behavior can becomes quite complicated. For this reason, the selector can be configured to operate in marking mode. In such mode, the selector can be marked as ready by a thread independently of the bounded streams. This is a useful mechanism which can be used to cancel a select loop. The markmethod is designed to mark the selector while the marked-ppredicate returns true if the stream has been marked.

Terminal streams
Terminal streams are another kind of streams available in the standard i/o module. The InputTerm, OutputTermand ErrorTermclasses are low level classes used to read or write from or to the standard streams. The basic methods to read or write are the same as the file streams. Reading from the input terminal is not a good idea, since the class does not provide any formatting capability. One may prefer to use the Terminalclass. The use of the output terminal or error terminal streams is convenient when the interpreter standard streams have been changed but one still need to print to the terminal.

Terminal class
The Terminalclass combines an input stream and an output stream with some line editing capabilities. When the class is created, the constructed attempts to detect if the input and output streams are bounded to a terminal (i.e tty). If the line editing capabilities can be loaded (i.e non canonical mode), the terminal is initialized for line editing. Arrows, backspace, delete and other control sequences are available when using the read-linemethod. The standard methods like reador readlndo not use the line editing features. When using a terminal, the prompt can be set to whatever the user wishes with the methods set-primary-promptor set-secondary-prompt. A secondary prompt is displayed when the read-linemethod is called with the boolean argument false.

const term (Terminal)
term:set-primary-prompt "demo:"
const line (term:read-line)
errorln line

Using the error terminal
The ErrorTermclass is the most frequently used class for printing data on the standard error stream. The reserved keywords erroror errorlnare available to write on the interpreter error stream. If the interpreter error stream has been changed, the use of the ErrorTermwill provide the facility required to print directly on the terminal. The catprogram can be rewritten to do exactly this.

# cat a file on the error terminal
# get the io module
interp:library "afnix-sio"
# cat a file
const cat (name es) {


  const f (afnix:sio:InputFile name)


  while (f:valid-p) (es:writeln (f:readln))


  f:close
}

Directory
The Directoryclass provides a facility to manipulate directories. A directory object is created either by name or without argument by considering the current working directory. Once the directory object is created, it is possible to retrieve its contents, create new directory or remove empty one.

Reading a directory
A Directoryobject is created either by name or without argument. With no argument, the current directory is opened. When the current directory is opened, its full name is computed internally and can be retrieved with the get-namemethod.

# print the current directory
const pwd (afnix:sio:Directory)
println   (pwd:get-name)

Once the directory object is opened, it is possible to list its contents. The get-listmethod returns the full contents of the directory object. The get-filesmethod returns a list of files in this directory. The get-subdirsmethod returns a list of sub directories in this directory.

# print a list of files
const pwd (afnix:sio:Directory)
const lsf (d:get-files)
for (name) (lsf) (println name)

Creating and removing directories
The mkdirand rmdirmethods can be used to create or remove a directory. Both methods take a string argument and construct a full path name from the directory name and the argument. This approach has the advantage of being file system independent. If the directory already exists, the mkdirmethods succeeds. The rmdirmethod requires the directory to be empty.

const tmp (afnix:sio:Directory (


    afnix:sio:absolute-path "tmp"))
const exp (tmp:mkdir "examples")
const lsf (exp:get-files)
println   (lsf:length)
tmp:rmdir "examples"

The function absolute-pathconstructs an absolute path name from the argument list. If relative path needs to be constructed, the function relative-pathmight be used instead.

Logtee
The Logteeclass is a message logger facility associated with an output stream. When a message is added to the logger object, the message is also sent to the output stream, depending on the controlling flags. The name "logtee" comes from the contraction of "logger" and "tee". One particularity of the class is that without a stream, the class behaves like a regular logger.

Creating a logger
The Logteedefault constructor creates a standard logger object without an output stream. The instance can also be created by size or with an output stream or both. A third method can also attach an information string.

# create a logger with the interpreter stream
const log (Logtee (interp:get-output-stream))
assert true (logger-p log)

Adding messages
The process of adding messages is similar to the regular logger. The only difference is that the message is placed on the output stream if a control flag is set and the message level is less or equal the report level. In the other word, the control flag controls the message display -- the tee operation -- while the report level filters some of the messages.

log:add 2 "a level 2 message"

The set-teemethod sets the control flag. The set-report-levelmethod sets the report level. Note that the set-report-leveland its associated get-report-levelmethod is part of the base Loggerclass.

Path name
The Pathnameclass is a base class designed to ease the manipulation of system path. It is particularly useful when it come to manipulate directory component.

Creating a path name
A path name is created either by file name or by file and directory name. In the first case, only the file name is used. In the second case, the full path name is characterized.

# create a new path name
const path (afnix:sio:Pathname "axi")

Adding a directory path
The best way to add a directory path is to use the absolute-pathor the relative-pathfunctions.

# adding a directory path
const name (afnix:sio:absolute-path "usr" "bin")
path:set-directory-name name

Getting the path information
The path information can be obtained individually or globally. The get-file-nameand get-directory-namemethods return respectively the file and directory name. The get-rootmethod returns the root component of the directory name. The get-fullmethod returns the full path name.

STANDARD INPUT/OUTPUT REFERENCE

Transcoder
The Transcoderclass is a codeset transcoder class. The class is responsible to map a byte character in a given codeset into its associated Unicode character. It should be noted that not all characters can be transcoded.

Predicate

Inheritance

Constants

Constructors

Methods

Stream
The Streamclass is a base class for the standard streams. The class is automatically constructed by a derived class and provides the common methods for all streams.

Predicate

Inheritance

Constants

Methods

InputStream
The InputStreamclass is a base class for the standard i/o module. The class is automatically constructed by a derived class and provides the common methods for all input streams. The input stream is associated with a timeout value which is used for read operation. By default, timeout is infinite, meaning that any read without data will be a blocking one.

Predicate

Inheritance

Methods

InputFile
The InputFileclass provide the facility for an input file stream. An input file instance is created with a file name. If the file does not exist or cannot be opened, an exception is raised. The InputFileclass is derived from the InputStreamclass.

Predicate

Inheritance

Constructors

Methods

InputMapped
The InputMappedclass is an input stream class that provides the facility for reading a mapped input stream. The input stream is mapped at construction given a file name, a size and a file offset. An anonymous mapped input stream can also be designed with a buffer object. Finally, without any information an always valid null input stream is constructed.

Predicate

Inheritance

Constructors

Methods

InputString
The InputStringclass provide the facility for an input string stream. The class is initialized or set with a string and then behaves like a stream. This class is very useful to handle generic stream method without knowing what kind of stream is behind it.

Predicate

Inheritance

Constructors

Methods

InputTerm
The InputTermclass provide the facility for an input terminal stream. The input terminal reads byte from the standard input stream. No line editing facility is provided with this class This is a low level class, and normally, the Terminalclass should be used instead.

Predicate

Inheritance

Constructors

Methods

OutputStream
The OutputStreamclass is a base class for the standard i/o module. The class is automatically constructed by a derived class and provide the common methods for all output streams.

Predicate

Inheritance

Methods

OutputFile
The OutputFileclass provide the facility for an output file stream. An output file instance is created with a file name. If the file does not exist, it is created. If the file cannot be created, an exception is raised. Once the file is created, it is possible to write literals. The class is derived from the OutputStreamclass. By default an output file is created if it does not exist. If the file already exist, the file is truncated to 0. Another constructor for the output file gives more control about this behavior. It takes two boolean flags that defines the truncate and append mode. The t-flagis the truncate flag. The a-flagis the append flag.

Predicate

Inheritance

Constructors

Methods

OutputString
The OutputStringclass provide the facility for an output string stream. The class is initially empty and acts as a buffer which accumulate the write method bytes. The to-stringmethod can be used to retrieve the buffer content.

Predicate

Inheritance

Constructors

Methods

OutputBuffer
The OutputBufferclass provide the facility for an output byte stream. The class is initially empty and acts as a buffer which accumulate the write method bytes. The to-stringmethod can be used to retrieve the buffer content as a string. The formatmethod can be used to retrieve the buffer content as an octet string. content.

Predicate

Inheritance

Constructors

Methods

OutputTerm
The OutputTermclass provide the facility for an output terminal. The output terminal is defined as the standard output stream. If the standard error stream needs to be used, the ErrorTermclass is more appropriate.

Predicate

Inheritance

Constructors

Terminal
The Terminalclass provides the facility for an i/o terminal with line editing capability. The class combines the InputTermand OutputTermmethods.

Predicate

Inheritance

Constructors

Methods

Intercom
The Intercomclass is the interpreter communication class. The class operates with two streams. One output stream is used to send serialized data while the input stream is used to deserialize data. The sendmethod can be used to send the data, while the recvcan be used to receive them.

Predicate

Inheritance

Constructors

Methods

InputOutput
The InputOutputclass implements an input-output stream with a buffer which holds character during the processing of transit between the output stream to the input stream. The theory of operation goes as follow. The internal buffer is filled with characters with the help of the output stream. The characters are consumed from the buffer with the help of the input stream (read method). If the buffer becomes empty the eos-ppredicate returns true, the valid-ppredicate false and the readmethod will return the eoscharacter. The InputOutput buffer can also be initialized with a buffer. This provides a nice mechanism to use a buffer like an input stream. The i/o operations implemented by this class are non-blocking. As a consequence, it is not possible to suspend a thread with this class and have it awaken when some characters are available in the input stream.

Predicate

Inheritance

Constructors

Methods

Selector
The Selectorclass provides some facilities to perform i/o multiplexing. The constructor takes 0 or several stream arguments.The class manages automatically the differentiation between the InputStreamand the OutputStreamobjects. Once the class is constructed, it is possible to get the first stream ready for reading or writing or all of them. It is also possible to add more steams after construction with the addmethod. When a call to the waitmethod succeeds, the method returns the first available stream. If the waitallmethod is called, the method returns a vector with all ready steams. The selector can be configured to operate in marking mode. In such mode, the selector can be marked as ready by a thread independently of the bounded streams. This is a useful mechanism which can be used to cancel a select loop. The markmethod is designed to mark the selector while the marked-ppredicate returns true if the stream has been marked.

Predicate

Inheritance

Constructors

Methods

Logtee
The Logteeclass provides the facility of a logger object associated with an output stream. When a message is added, the message is written to the output stream depending on an internal flag. By default the tee mode is false and can be activated with the set-teemethod.

Predicate

Inheritance

Constructors

Methods

Pathname
The Pathnameclass is a base class designed to manipulate system i/o paths. The class operates with a directory name and a file name. Both names are kept separated to ease the path manipulation. The path components can be extracted individually. However, it shall be noted that the first component has a special treatment to process the root directory name.

Predicate

Inheritance

Constructors

Methods

Pathlist
The Pathlistclass is a base class designed to ease the manipulation of a file search path. The class acts like a list of search paths and various facilities are provided to find a valid path for a given name. The path list can be manipulated like any other list.

Predicate

Inheritance

Constructors

Methods

Functions

Directory
The Directoryclass provides some facilities to access a directory. By default, a directory object is constructed to represent the current directory. With one argument, the object is constructed from the directory name. Once the object is constructed, it is possible to retrieve its content.

Predicate

Inheritance

Constructors

Methods

Logtee
The Logteeclass is a message logger facility associated with an output stream. When a message is added to the logger object, the message is also sent to the output stream, depending on the controlling flags. The name "logtee" comes from the contraction of "logger" and "tee". One particularity of the class is that without a stream, the class behaves like a regular logger.

Predicate

Inheritance

Constructors

Methods

NamedFifo
The NameFifoclass is a string vector designed to operate as a stream fifo object. The class provides the facility to read or write the fifo content from a stream. The stream can be created by name for writing, in which case the named fifo operates as a backup object.

Predicate

Inheritance

Constructors

Methods

FileInfo
The FileInfois a file information class that holds the primary information related to a file, such like its size or its modification time. The file information is set at construction but can be updated with the help of the updatemethod.

Predicate

Inheritance

Constructors

Methods