Input of Strings and Characters, EOL and EOF

Output of Strings

         with Ada.Text_IO; use Ada.Text_IO;

         procedure io is
         begin
    
            put("Hello");
            put_line("There");
            put_line("Hi Mom!");
            new_line(2);

            put_line("ITEC 320" & " is FUN" & "!");

            set_col(3);
            put_line("I like Ada!");
        
         end io;
    OUTPUT:
    HelloThere
    Hi Mom!


    ITEC 320 is FUN!
      I like Ada!

Input a String

get(s) always tries to read s'length characters
but, get(s) ignores newlines!

        -- Demonstrates input of a string

        with Ada.Text_IO; use Ada.Text_IO;
        procedure doStrings1 is
           s: String(1 .. 2);           
           t: String(1 .. 3);          
        begin
           put("Enter 5 characters and press return: ");
           -- input exactly 2 characters
           get(s);
           put_line("first 2: " & s);

           -- input exactly 3 characters
           get(t);
           put_line("next 3: " & t);
           new_line;

           put("Enter 5 characters on several lines: ");

           -- input exactly 2 characters, spread over several lines
           get(s);
           put_line("first 2: " & s);

           -- input exactly 3 characters, spread over several lines
           get(t);
           put_line("next 3: " & t);
        end doStrings1;

        SAMPLE RUN:
        Enter 5 characters and press return: abc d
        first 2: ab
        next 3: c d

        Enter 5 characters on several lines:a
        b
        first 2: ab
        c
        d
        e
        next 3: cde

Get_Line

What if the length of the input is not known?

Use Ada.Text_IO.Get_Line(s, len)
- inputs one line of input (but no more than s'length characters)
- len will contain the number of characters that were read
- s(1..len) will contain the characters
Example:

        with Ada.Text_IO; use Ada.Text_IO;
        with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
        procedure doStrings2 is
           s: String(1 .. 80);           
           len: Natural;

        begin
           put("Enter fewer than 80 characters: ");

           get_line(s, len);

           put("len = ");
           put(len, 0); 
           new_line;

           put_Line("You entered |" & s(1 .. len)  & "|");

           put_Line("All of s: |" & s & "|");
        end doStrings2;

SAMPLE RUN:
Enter fewer than 80 characters: cde
len = 3
You entered |cde|
All of s |cde$ряѕх `Ё|

Get_line(s, l) fills s until it reaches the end of either s or the line.
Any unfilled locations in s have their previous contents!!
You must make sure you use a slice of s: s(1 .. len)

More on Get_Line

The newline at the end of the line is NOT read into s

If the end of the line is encountered, then get_line automatically calls skip_line

If the line has exactly the number of characters in the string, skip_line is NOT called and must be called explicitly.

Notice that the put_line outputs a slice of the string. What would happen if the whole string were output?

 
        with Ada.Text_IO; use Ada.Text_IO;
        procedure doStrings4 is
           s: String(1 .. 4);           
           len: Natural;

        begin
           for i in 1 .. 6 loop
              get_line(s, len);
              put_line(s(1 .. len));  -- Slice

              if len = 4 then
                 skip_line;
              end if;

           end loop;
        end doStrings4;

SAMPLE RUN:
abcdefg
abcd
pqrstuv
pqrs
1234
1234
mno
mno
abcd
abcd
abcde
abcd

End_Of_File

How to test for end of file: Ada.Text_IO.End_Of_File

Example - sum up an unknown number of integers:

 
        -- Illustrates use of End_Of_File and integer get
        with Ada.Text_IO; use Ada.Text_IO;
        with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

        procedure eof4 is
           i: Integer;
           s: Integer := 0;

        begin
           while (not End_Of_File) loop
              get(i);
              s := s + i;
           end loop;

           put(s);
           new_line;
        end eof4;

Application of End_Of_File - Echo input

        -- Echoes input.
        -- Reads and writes one character at a time
        with Ada.Text_IO; use Ada.Text_IO;

        procedure eofloop3a is
           c: Character;
        begin
           while (not End_Of_File) loop
              get(c);
              put(c);
           end loop;
        end eofloop3b;

Echo input - Improved version

        -- Echoes input.
        -- Reads and writes one character at a time
        with Ada.Text_IO; use Ada.Text_IO;

        procedure eofloop3b is
           c: Character;
        begin
           while (not End_Of_File) loop

              get(c);
              put(c);

              -- Move output to new line as needed
              if End_Of_Line then
                  new_line;          
              end if;

           end loop;
        end eofloop3b;

Get_Immediate

Get_Immediate can be used for unbuffered character input

Get_Immediate reads a character without waiting for a newline

        -- Echoes input, using get_immediate.
        with Ada.Text_IO; use Ada.Text_IO;

        procedure eofloop4 is
           c: Character;
        begin
           loop
              get_immediate(c);
              put(c);
              exit when c = 'x';
           end loop;
        end eofloop4;

Look_Ahead

Ada.Text_IO.look_ahead allows the user to view the next character in the input without consuming that character (ie without moving the input pointer)

        with Ada.Characters.Handling; use Ada.Characters.Handling;

        with Ada.Text_IO; use Ada.Text_IO;
        with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

        procedure lookahead is
           c: Character;
           i: Integer;
           line: String(1 .. 80);
           len: Natural;
           EOL: Boolean;
        begin
           put("Enter a number or a string: ");

           look_ahead(c, EOL);

           put_line("The first character in the input: " & c);
           put_line("At end of line: " & Boolean'Image(EOL));
           new_line;

           if Ada.Characters.Handling.is_digit(c) then
              get(i);
              put("You entered this number: ");
              put(i);
              new_line;

           else
              get_line(line, len);
              put("You entered this string: ");
              put_line(line(1 .. len));
           end if;

        end lookahead;

SAMPLE RUN 1
Enter a number or a string: 123
The first character in the input: 1
At end of line: FALSE

You entered this number:         123

SAMPLE RUN 2
Enter a number or a string: abcde
The first character in the input: a
At end of line: FALSE

You entered this string: abcde

SAMPLE RUN 3
Enter a number or a string: 
The first character in the input: 
At end of line: TRUE
 
EOL is true.  You must have just hit enter

Multiple calls to look ahead without intervening calls to get will all return the same value for C

Second parameter returns whether or not input is currently at the end of line

Value of C is unchanged if EOL is true

You can't look several characters ahead

Lookahead can be done at any point of the input

End_Of_File - Echo input using get_line

Get_line can also be used to echo input, but there are some subtleties when the length of the input line is not less then the length of the string being used for input

        -- Echoes its input.
        -- Demonstrates using multiple get_lines to input lines that are
        -- longer than 4 characters 
        with Ada.Text_IO; use Ada.Text_IO;
        procedure eofLoop2 is
           maxLength: Positive := 4;
           s: String(1 .. maxLength);           
           length: Natural;

        begin
           while (not End_Of_File) loop

              get_line(s, length);
              put(s(1 .. length));

              if length < maxLength then
                 new_line;
              elsif length = maxLength and End_Of_Line then
                 skip_line;
                 new_line;
              end if;

           end loop;
        end eofLoop2;

SAMPLE RUN: 
abc
abc
abcdef
abcdef
ghijklkm
ghijklkm
a
a
^D

Running Programs Interactively vs Using Redirection

A program that reads from standard input can be run interactively or from a file using redirection

Example: running eofloop3 (from above) interactively:

>eofloop3
line
line
another line
another line
^D

In interactive programs on unix systems, entering ^D on a line by itself will cause end of file to return true. Enter ^D by holding down control and D at the same time.

In interactive programs on Windows systems, entering ^Z <Enter> on a line by itself will cause end of file to return true. Enter this by holding down control and Z at the same time, and then pressing the Enter/Return key.

To cause program eofloop3 to read from the file foo, use redirection:

>cat foo
line 1
line 2

>eofloop3 < foo
line 1
line 2

Another use for redirection is to capture output:

>eofloop3 < foo > goo

>cat goo
line 1
line 2

Note that the output redirection above only works if the file goo does not exist. If the output file exists, you can replace it with a new version using an exclamation point (ie !, aka bang) as follows:

>cat moo
line A
line B

>eofloop3 < moo >! goo

>cat goo
line A
line B

Skip_Line

Skip_Line causes remainder of current input line to be ignored by later calls to get

        -- Demonstrates how skip_line moves to next line, 
        -- and ignores the rest of a line

        with Ada.Text_IO; use Ada.Text_IO;
        procedure doStrings1 is
           s: String(1 .. 2);
           t: String(1 .. 3);

        begin
           put("Enter 2 or more characters and press return: ");
           get(s);
           put_line("first 2: " & s);
           new_line;

           skip_line;

           put("Enter 3 or more characters and press return: ");
           get(t);
           put_line("next 3: " & t);
        end doStrings1;
SAMPLE RUN:
Enter 2 or more characters and press return: abcde
first 2: ab

Enter 3 or more characters and press return: PQRST
next 3: PQR

Character, Get/Put Loop, End_Of_Line

        -- Demonstrates how end_of_line tests for end of line
        -- and how skip_line moves to next line
        with Ada.Text_IO; use Ada.Text_IO;
        procedure doStrings2 is
           c: Character;
           s: String(1 .. 80);           
           length: Natural;

        begin
           put("Enter some text and press enter: ");
           while (not Ada.Text_IO.End_Of_Line) loop
              get(c);
              put(c);
           end loop;

           skip_line;  -- move to next line of input
                       --   since we use get_line next

           new_line;

           put("Enter another line: ");

           get_line(s, length);

           put_Line(s);
        end doStrings2;

SAMPLE RUN:
Enter some text and press enter: ab
ab
Enter another line: def
def

Summary of input routines

Use these declarations:

 
   i: integer;
   c: character;
   s: String(1..80);

Integer: get(i) will skip whitespace (including newlines) until it finds a digit, plus, or minus. It will input the following integer, convert it, and store it in i.

Character: get(c) will input the next character (ie the character that the input pointer currently points to) and advance the input pointer. At the end of a line get will find the next character by skipping the newline and getting the first character on the next line.

String: get(s) will input the next 80 characters (actually it will input the number of characters specified as the length in the declaration - 80 in this case), skipping over any newlines that are encountered.

String: get_line(s, len) will input up to 80 characters (actually up to the number of characters specified as the length to be in the declaration), up to the end of the line (but not including the newline character). The number of characters that were input is returned in len.
If the line has fewer than 80 characters, then the input marker moves to the next line and the next input will read from that next line. If the line has 80 or more characters, then the input marker remains on the current line.

An important WARNING on input from a file

Remember: get (of either a character or an integer) skips newlines

However, characters inserted at the end of a line differ by OS:

Windows: newline and linefeed
Unix: newline only

Consequence: A get command compiled under unix can treat end of line in data files created under unix differently from data files created under windows.

A get command compiled under unix that works correctly on data files created under unix may not work on data files created under windows.

Bottom line: Create any data file on the same system that you used to compile a program that reads that file.

A final word on EOF in interactive programs

In interactive programs, get causes an End_Error if it reads the end of file character (ie control D or control Z).

In interactive programs, an end of file test samples the input to see if it is the EOF character.

In interactive programs, the end of file character is not sticky.

This means that if a program executes 2 EOF tests, then for both of them to be true, then two EOF characters must be entered.

In a program that executes 2 EOF tests, it is possible to execute a regular get between them.

This is weird and should be avoided if at all possible.

When reading from files, EOF is sticky since the file has an actual end of file character (or since the length of the file is known and the operating system can determine when EOF is reached.

When reading from files, get causes an End_Error if it does a read when the input pointer is at the end of the file.