Input loop

Input loop
You are encouraged to solve this task according to the task description, using any language you may know.

Read from a text stream either word-by-word or line-by-line until the stream runs out of data. The stream will have an unknown amount of data on it.

Ada

This example reads in a text stream from standard input line by line and writes the output to standard output. <lang ada> with Ada.Text_Io; use Ada.Text_Io;

procedure Read_Stream is

  Line : String(1..10);
  Length : Natural;

begin

  while not End_Of_File loop
     Get_Line(Line, Length); -- read up to 10 characters at a time
     Put(Line(1..Length));
     -- The current line of input data may be longer than the string receiving the data.
     -- If so, the current input file column number will be greater than 0
     -- and the extra data will be unread until the next iteration.
     -- If not, we have read past an end of line marker and col will be 1
     if Col(Current_Input) = 1 then
        New_Line;
     end if;
  end loop;

end Read_Stream; </lang>

ALGOL 68

For file consisting of just one page - a typical linux/unix file:

main:(
  PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end );
  on logical file end(stand in, raise logical file end);
  DO
    print(read string);
    read(new line);
    print(new line)
  OD;
  except logical file end: 
    SKIP
)

For multi page files, each page is seekable with PROC set = (REF FILE file, INT page, line, char)VOID: ~. This allows rudimentary random access where each new page is effectively a new record.

main:(
  PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end );
  on logical file end(stand in, raise logical file end);
  DO
    PROC raise page end = (REF FILE f) BOOL: ( except page end );
    on page end(stand in, raise page end);
    DO
      print(read string);
      read(new line);
      print(new line)
    OD;
    except page end: 
      read(new page);
      print(new page)
  OD;
  except logical file end: 
    SKIP
)

The boolean functions physical file ended(f), logical file ended(f), page ended(f) and line ended(f) are also available to indicate the end of a file, page and line.

AWK

This just reads lines from stdin and prints them until EOF is read.

{ print $0 }

or, more idiomatic:

1

C

<lang c>#include <stdio.h>

1. define MAX_LEN 20

/* line by line: */ /* This may not read the whole line; just up to MAX_LEN characters at a time. */ void process_lines(FILE *stream) {

 char line[MAX_LEN + 1];
 while (fgets(line, MAX_LEN + 1, stream) != NULL) {
   /* process the string here */
   /* the string includes the line return, if it reached the end of line */
 }

}

/* word by word */ /* This may not read the whole word; just up to MAX_LEN characters at a time. */

1. define Str(x) #x
2. define Xstr(x) Str(x)

void process_words(FILE *stream) {

 char word[MAX_LEN + 1];
 while (fscanf(stream, "%" Xstr(MAX_LEN) "s", word) == 1) {
   /* process the string here */
 }

} </lang>

C++

The following functions store the words resp. lines in a vector. Of course, instead arbitrary processing of the words could be done. <lang cpp>#include <istream>

1. include <string>
2. include <vector>

// word by word void read_words(std::istream& is, std::vector<std::string>& words) {

 std::string word;
 while (is >> word)
 {
   // store the word in the vector
   words.push_back(word);
 }

}

// line by line: void read_lines(std::istream& is, std::vector<std::string>& lines) {

 std::string line;
 while (std::getline(is, line))
 {
   // store the line in the vector
   lines.push_back(line);
 }</lang>

An alternate way to read all words into a vector is to use iterators:

<lang cpp>#include <istream>

1. include <string>
2. include <iterator>
3. include <algorithm>
4. include <vector>

void read_words(std::istream& is, std::vector<std::string>& words) {

 std::copy(std::istream_iterator<std::string>(is), std::istream_iterator<std::string>(),
           std::back_inserter(words));

}</lang>

For arbitrary processing, replace std::copy with std::for_each or std::transform calling an appropriate function (or function object).

C#

<lang csharp>using System; using System.IO;

class Program {

   static void Main(string[] args)
   {
       StreamReader b = new StreamReader("file.txt"); //or any other Stream

       string line = b.ReadLine();

       while (line != null)
       {
           Console.WriteLine(line);
           line = b.ReadLine();
       }
   }

}</lang>

D

Library: Tango

<lang d>import tango.io.Console; import tango.text.stream.LineIterator;

void main (char[][] args) {

   foreach (line; new LineIterator!(char)(Cin.input)) {
       // do something with each line
   }

}</lang>

Library: Tango

<lang d>import tango.io.Console; import tango.text.stream.SimpleIterator;

void main (char[][] args) {

   foreach (word; new SimpleIterator!(char)(" ", Cin.input)) {
       // do something with each word
   }

}</lang>

Note that foreach variables 'line' and 'word' are transient slices. If you need to retain them for later use, you should .dup them.

Forth

Works with: GNU Forth

4096 constant max-line
: read-lines
  begin  stdin pad max-line read-line throw
  while  pad swap   \ addr len is the line of data, excluding newline
         2drop
  repeat ;

Fortran

Works with: Fortran version 90 and later

The code read line-by-line, but the maximum length of the line is limited (by a parameter)

<lang fortran>program BasicInputLoop

 implicit none

 integer, parameter        :: in = 50, &
                              linelen = 1000
 integer                   :: ecode
 character(len=linelen)    :: l

 open(in, file="afile.txt", action="read", status="old", iostat=ecode)
 if ( ecode == 0 ) then
    do
       read(in, fmt="(A)", iostat=ecode) l
       if ( ecode /= 0 ) exit
       write(*,*) trim(l)
    end do
    close(in)
 end if

end program BasicInputLoop</lang>

Haskell

The whole contents of a file can be read lazily. The standard functions lines and words convert that lazily into the lists of lines resp. words. Usually, one wouldn't use extra routines for that, but just use readFile and then put 'lines' or words somewhere in the next processing step.

import System.IO

readLines :: Handle -> IO [String]
readLines h = do
  s <- hGetContents h
  return $ lines s

readWords :: Handle -> IO [String]
readWords h = do
  s <- hGetContents h
  return $ words s

Icon

link str2toks
# call either words or lines depending on what you want to do.
procedure main()
   words()
end

procedure lines()
   while write(read())
end

procedure words()
   local line
   while line := read() do line ? every write(str2toks())
end

Java

Some people prefer Scanner or BufferedReader, so a way with each is presented. <lang java>import java.util.Scanner; ... Scanner in = new Scanner(System.in);//stdin //new Scanner(new FileInputStream(filename)) for a file //new Scanner(socket.getInputStream()) for a network stream while(in.hasNext()){ String input = in.next(); //in.nextLine() for line-by-line //process the input here }</lang> Or <lang java>import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; ... try{ BufferedReader inp = new BufferedReader(new InputStreamReader(System.in));//stdin //new BufferedReader(new FileReader(filename)) for a file //new BufferedReader(new InputStreamReader(socket.getInputStream())) for a network stream while(inp.ready()){ String input = inp.readLine();//line-by-line only //in.read() for character-by-character //process the input here } } catch (IOException e) { //There was an input error }</lang>

MAXScript

this function will read a file line by line. <lang MAXScript> fn ReadAFile FileName = ( local in_file = openfile FileName while not eof in_file do ( --Do stuff in here-- print (readline in_file) ) close in_file ) </lang>

OCaml

<lang ocaml>let rec read_lines ic =

 try let line = input_line ic in
   line :: read_lines ic
 with End_of_file ->
   []</lang>

The version above will work for small files, but it is not tail-recursive.
Below will be more scalable:

<lang ocaml>let read_line ic =

 try Some (input_line ic)
 with End_of_file -> None

let read_lines ic =

 let rec loop acc =
   match read_line ic with
   | Some line -> loop (line :: acc)
   | None -> List.rev acc
 in
 loop []

</lang>

Or with a higher order function:

<lang ocaml>let read_lines f ic =

 let rec loop () =
   try f(input_line ic); loop()
   with End_of_file -> ()
 in
 loop()

read_lines print_endline (open_in Sys.argv.(1)) </lang>

Pascal

<lang pascal> { for stdio }

var

s : string ;

begin

 repeat

   readln(s);

 until s = "" ;

{ for a file }

var

f : text ;
s : string ;

begin

 assignfile(f,'foo');
 reset(f);
 
 while not eof(f) do
   readln(f,s);

 closefile(f);

end;</lang>

Perl

The angle brackets operator ( <...> ) reads one line at a time from a filehandle in scalar context: <lang perl>open FH, "< $filename" or die "can't open file: $!"; while (my $line = <FH>) {

   chomp $line; # removes trailing newline
   # process $line

} close FH or die "can't close file: $!";</lang>

Or you can get a list of all lines when you use it in list context: <lang perl>@lines = <FH>;</lang>

PHP

<lang php>$fh = fopen($filename, 'r'); if ($fh) {

   while (!feof($fh)) {
       $line = rtrim(fgets($fh)); # removes trailing newline
       # process $line
   }
   fclose($fh);

}</lang>

Or you can get an array of all the lines in the file: <lang php>$lines = file($filename);</lang>

Or you can get the entire file as a string: <lang php>$contents = file_get_contents($filename);</lang>

Python

Python file objects can be iterated like lists:

<lang python>my_file = open(filename, 'r') try:

   for line in my_file:
       pass # process line, includes newline

finally:

   my_file.close()</lang>

One can open a new stream for read and have it automatically close when done, with a new "with" statement: <lang python>from __future__ import with_statement

with open(filename, 'r') as f:

   for line in f:
       pass # process line, includes newline</lang>

You can also get lines manually from a file: <lang python>line = my_file.readline() # returns a line from the file lines = my_file.readlines() # returns a list of the rest of the lines from the file</lang> This does not mix well with the iteration, however.

When (multiple) filenames are given on the command line: <lang python>import fileinput for line in fileinput.input():

   pass # process line, includes newline</lang>

The fileinput module can also do inplace file editing, follow line counts, and the name of the current file being read etc.

Ruby

Ruby input streams are Enumerable objects like Arrays, so one can use the standard #each:

<lang ruby>stream.each do |line|

 # process line

end</lang>

One can open a new stream for read and have it automatically close when done:

<lang ruby>File.open(filename, "r") do |stream|

 stream.each do |line|
   # process line
 end

end</lang>

Smalltalk

<lang smalltalk>|f| f := FileStream open: 'afile.txt' mode: FileStream read. [ f atEnd ] whileFalse: [ (f nextLine) displayNl ] .</lang>

Tcl

<lang php>set fh [open $filename] while {[gets $fh line] != -1} {

   # process $line

} close $fh</lang>

UnixPipes

the pipe 'yes XXX' produces a sequence

read by lines

yes 'A B C D ' | while read x ; do echo -$x- ; done

read by words

yes 'A B C D ' | while read -d\  a ; do echo -$a- ; done

Visual Basic .NET

This reads a stream line by line, outputing each line to the screen.

   Sub Consume(ByVal stream As IO.StreamReader)
       Dim line = stream.ReadLine
       Do Until line Is Nothing
           Console.WriteLine(line)
           line = stream.ReadLine
       Loop
   End Sub