Section Header
  
  
    + name    := INPUT_STREAM;
  
  
    - comment := "This abstract class is the superclass of all classes \
               \representing an input stream of bytes.";
  
Section Inherit
  
  
    - parent_object:OBJECT := 
  
Section Public
  
  
    - push_back_flag:BOOLEAN;
  
         True if one char is already pushed back.
  
  
    - last_integer:INTEGER;
  
         Last integer read using `read_integer'.
  
  
    - last_string:STRING :=
  
         Access to the unique common buffer to get for example the result
  
         computed by `read_line', `read_word', `newline', etc. This is a once
  
         function (the same common buffer is used for all streams).
    
  
  
    - is_connected:BOOLEAN <-
  
         True when the corresponding stream is connected
  
         to some physical input device.
    
  
    - end_of_input:BOOLEAN <-
  
         Has end-of-input been reached ?
  
         True when the last character has been read.
    
  
  
 To read one character at a time:
  
  
    - read_character <-
  
         Read a character and assign it to `last_character'.
    
  
  
    - last_character:CHARACTER <-
  
         Last character read with `read_character'.
    
  
    - unread_character <-
  
         Un-read the last character read.
    
  
 Skipping separators:
  
  
    - skip_separators <-
  
         Skip all separators (see `is_separator' of class CHARACTER) and
  
         make the first non-separator available in `last_character'. This
  
         non-separator character is pushed back into the stream (see
  
         `unread_character') to be available one more time (the next
  
         `read_character' will consider this non-separator). When
  
         `end_of_input' occurs, this process is automatically stopped.
    
  
    - skip_separators_using separators:STRING <-
  
         Same job as `skip_separators' using the `separators' set.
    
  
    - skip_remainder_of_line <-
  
         Skip all the remainder of the line including the end of
  
         line character itself.
    
  
 To read one number at a time:
  
  
    - read_integer <-
  
         Read an integer according to the Lisaac syntax.
  
         Make result available in `last_integer'.
  
         Heading separators are automatically skipped using
  
         `is_separator' of class CHARACTER.
  
         Trailing separators are not skipped.
    
  
   
  
  
 To read one line or one word at a time:
  
  
    - read_line <-
  
         Read a complete line ended by '\n' or `end_of_input'. Make the
  
         result available in `last_string' common buffer. The end of line
  
         character (usually '\n') is not added in the `last_string' buffer.
    
  
  
    - read_word <-
  
         Read a word using `is_separator' of class CHARACTER. Result is
  
         available in the `last_string' common buffer. Heading separators are
  
         automatically skipped. Trailing separators are not skipped
  
         (`last_character' is left on the first one). If `end_of_input' is
  
         encountered, Result can be the empty string.
    
  
    - newline <-
  
         Consume input until newline ('\n') is found. Corresponding
  
         STRING is stored in `last_string' common buffer.
    
  
    - reach_and_skip keyword:STRING <-
  
         Try to skip enough characters in order to reach the `keyword'
  
         which is skipped too. If the `keyword' is not in the remainder of
  
         this stream, the process is stopped as soon  as `end_of_input'
  
         occurs. As for `skip_separators' the following character of the
  
         `keyword' is available in `last_character' and not yet read.
    
  
 Other features:
  
  
    - read_line_in buffer:STRING <-
  
         Same jobs as `read_line' but storage is directly done in `buffer'.
    
  
    - read_word_using separators:STRING <-
  
         Same jobs as `read_word' using `separators'.
    
  
    - read_tail_in str:STRING <-
  
         Read all remaining character of the file in `str'.