Input loop: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program inputLoop64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|Ada}}==

This example reads in a text stream from standard input line by line

and writes the output to standard output.

 

procedure Read_Stream is

end if;

end loop;

 

=={{header|Aime}}==

read_stream(file f)

{

# the read line available as -s-

}

 

=={{header|ALGOL 68}}==

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

PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end );

on logical file end(stand in, raise logical file end);

except logical file end:

SKIP

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

PROC raise logical file end = (REF FILE f) BOOL: ( except logical file end );

on logical file end(stand in, raise logical file end);

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.

 

=={{header|ALGOL W}}==

string(80) line;

% allow the program to continue after reaching end-of-file %

read( line )

end

 

=={{header|AmigaE}}==

 

PROC consume_input(fh)

Close(fh)

ENDIF

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

 

</pre>

 

=={{header|AutoHotkey}}==

This example reads the text of a source file line by line

and writes the output to a destination file.

{

FileAppend, %A_LoopReadLine%`n

 

=={{header|AWK}}==

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

 

 

or, more idiomatic:

 

 

=={{header|BASIC}}==

 

==={{header|Applesoft BASIC}}===

110 D$ = CHR$(4)

120 PRINT D$"VERIFY"F$

190 POKE 216,0

200 IF PEEK(222) <> 5 THEN RESUME

 

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

This specifically relates to console input (stdin).

STD_OUTPUT_HANDLE = -11

SYS "GetStdHandle", STD_INPUT_HANDLE TO @hfile%(1)

INPUT A$

PRINT A$

 

==={{header|IS-BASIC}}===

110 TEXT 80

120 INPUT PROMPT "File name: ":F$

220 PRINT EXSTRING$(EXTYPE)

230 END

 

Alternate solution:

110 INPUT PROMPT "File name: ":F$

120 WHEN EXCEPTION USE IOERROR

180 PRINT EXSTRING$(EXTYPE)

190 CLOSE #1

 

=={{header|Batch File}}==

for /f %%i in (file.txt) do if %%i@ neq @ echo %%i

 

=={{header|Bracmat}}==

This example first creates a test file with three lines. It then opens the file in read mode, sets the string of break characters and then reads the file token by token, where tokens are delimeted by break characters. Finally, the file position is set to an invalid value, which closes the file.

a three line

text","test.txt",NEW)

)

& (fil$(,SET,-1)|out$"file closed")

{{out}}

<pre>breakchar:SP, word 1:This

Reads arbitrarily long line each time and return a null-terminated string.

Caller is responsible for freeing the string.

#include <stdio.h>

 

}

return 0;

 

=={{header|C sharp|C#}}==

 

using System.IO;

 

}

}

 

=={{header|C++}}==

The following functions send the words resp. lines

to a generic output iterator.

#include <istream>

#include <string>

}

 

 

An alternate way to read words or lines is to use istream iterators:

 

template<class OutIt>

void read_words(std::istream& is, OutIt dest)

dest);

}

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

{{works with|Visual COBOL}}

PROGRAM-ID. input-loop.

CLOSE in-stream

.

 

=={{header|Common Lisp}}==

(with-open-file (stream (make-pathname :name filename) :direction :input)

(loop for line = (read-line stream nil nil)

while line

 

=={{header|D}}==

import std.stdio;

 

line.writeln;

}

 

{{libheader|Tango}}

import tango.text.stream.LineIterator;

 

// do something with each line

}

{{libheader|Tango}}

import tango.text.stream.SimpleIterator;

 

// do something with each word

}

 

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

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

lReader.Free;

end;

 

=={{header|Déjà Vu}}==

!print( "Read a line: " !decode!utf-8 swap )

drop

 

=={{header|EasyLang}}==

 

l$ = input

until error = 1

print l$

 

=={{header|Eiffel}}==

{{works with|Eiffel Studio|6.6}}

 

note

description : "{

 

end

 

=={{header|Elena}}==

 

Using ReaderEnumerator

import system'io;

import extensions'routines;

public program()

{

Using loop statement

public program()

{

{

while (reader.Available)

}

}

 

=={{header|Elixir}}==

def input_loop(stream) do

case IO.read(stream, :line) do

 

path = hd(System.argv)

 

=={{header|Erlang}}==

-module(read_files).

-export([main/0]).

Lines = string:tokens(binary_to_list(Read("read_files.erl")), "\n"),

lists:foreach(fun (Y) -> io:format("~s~n", [Y]) end, lists:zipwith(fun(X,_)->X end, Lines, lists:seq(1, length(Lines)))).

 

=={{header|ERRE}}==

=={{header|Euphoria}}==

Process text stream line-by-line:

object line

while 1 do

-- process the line

end while

 

=={{header|F Sharp|F#}}==

Using a sequence expression:

let lines_of_file file =

seq { use stream = System.IO.File.OpenRead file

while not reader.EndOfStream do

yield reader.ReadLine() }

The file is reopened every time the sequence is traversed and lines are read on-demand so this can handle arbitrarily-large files.

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

An input stream can be from a string or from a file. The method <code>eachLine</code> will divide the stream by linebreaks. The method <code>readStrToken</code> takes two arguments: a maximum size to read, and a function to decide when to stop reading - by default, it stops when it finds a white space.

 

class Main

{

}

}

 

=={{header|Forth}}==

{{works with|GNU Forth}}

: read-lines

begin stdin pad max-line read-line throw

while pad swap \ addr len is the line of data, excluding newline

2drop

 

=={{header|Fortran}}==

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

 

 

implicit none

end if

 

 

=={{header|FreeBASIC}}==

 

Dim line_ As String ' line is a keyword

Print

Print "Press any key to quit"

 

=={{header|Frink}}==

println[line]

 

=={{header|FutureBasic}}==

Note: This code goes beyond simply specifying the file to open. It includes a dialog window that allows the user to select a text file to read. The entire contents of the file are read in at once, rather than line by line.

 

local fn ReadTextFile

end fn

 

fn ReadTextFile

 

=={{header|gnuplot}}==

The following gnuplot script echoes standard input

to standard output line-by-line until the end of the stream.

It makes use of the ability of gnuplot to spawn shell commands.

In that sense it might be considered cheating.

=={{header|Go}}==

The following reads a line at a time from stdin.

 

import (

_ = s

}

Or, using <code>bufio.Scanner</code> you can read

line at a time,

byte or Unicode code point at a time,

or by any custom "split function".

 

import (

log.Fatal(err)

}

 

=={{header|Groovy}}==

Solution:

System.in.eachLine { line, i ->

lineMap[i] = line

}

 

{{out|Test}}

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.

 

 

readLines :: Handle -> IO [String]

readWords h = do

s <- hGetContents h

 

=={{header|HicEst}}==

 

OPEN(FIle=name, OLD, LENgth=bytes, IOStat=errorcode, ERror=9)

ENDDO

 

 

=={{header|i}}==

loop {

read()

}

}

 

=={{header|Icon}} and {{header|Unicon}}==

# call either words or lines depending on what you want to do.

procedure main()

local line

while line := read() do line ? every write(str2toks())

{{libheader|Icon Programming Library}}

See [http://www.cs.arizona.edu/icon/library/src/procs/str2toks.icn str2toks]

=={{header|J}}==

Script "read-input-until-eof.ijs":

NB. read input until EOF

Example:

> abc

> def

def

ghi

 

=={{header|Java}}==

Some people prefer <tt>Scanner</tt> or <tt>BufferedReader</tt>, so a way with each is presented.

import java.util.Scanner;

 

}

}

Or

import java.io.IOException;

import java.io.InputStreamReader;

}

}

 

=={{header|JavaScript}}==

 

As above, this operates on standard input

var i = 0;

 

// do something with line

WScript.echo(++i + ": " + line);

 

=={{header|jq}}==

.

 

 

 

Other options, e.g. to emit JSON in compact form, also exist.

 

=={{header|Jsish}}==

 

var line;

while (line = console.input()) { cs += line.length; ls += 1; }

 

 

{{out}}

We create a text stream and read the lines from the stream one by one, printing them on screen.

Note that the lines end by a newline, except the last one. The ending newlines are part of the strings returned by the function readline. Once the end of the stream is reached, readline returns an empty string.

 

while !eof(stream)

line = readline(stream)

println(line)

{{Out}}

<pre>1

 

=={{header|Kotlin}}==

 

import java.util.*

words.add(input)

}

Sample input/output:

{{out}}

 

=={{header|Lang5}}==

: ==>contents

'< swap open 'fh set fh fin read-lines fh close ;

 

 

=={{header|Lasso}}==

local(

myfile = file('//path/to/file.txt'),

}

 

 

Result:

 

=={{header|Liberty BASIC}}==

filedialog "Open","*.txt",file$

if file$="" then end

wend

close #f

 

=={{header|LIL}}==

From the canread.lil sample that ships with LIL.

 

# canread test (note that canread is not available in LIL/FPLIL itself

# but provided by the command line interfaces in main.c/lil.pas)

inc count

}

 

{{out}}

* readword - returns a line as a single word, or an empty list if it reached the end of file

* readrawline - returns a line as a single word, with no characters escaped

 

=={{header|LSL}}==

 

To test it yourself; rez a box on the ground, add the following as a New Script, create a notecard named "Input_Loop_Data_Source.txt", and put what ever data you want in it (in this case I just put a copy of the source code.)

default {

integer iNotecardLine = 0;

}

}

{{out}}

<pre>Reading 'Input_Loop_Data_Source.txt'

 

=={{header|Lua}}==

str = io.read()

while str do

table.insert(lines,str)

str = io.read()

 

=== Via generic for loop ===

Reads line-by-line via an iterator (from stdin). Substitute <code>io.lines()</code> with <code>io.open(filename, "r"):lines()</code> to read from a file.

 

 

for line in io.lines() do

table.insert(lines, line) -- add the line to the list of lines

 

=={{header|M2000 Interpreter}}==

Document A$={1st Line

2nd line

\\ List of current variables (in any scope, public only)

List

 

=={{header|Maple}}==

readinput:=proc(filename)

local line,file;

end do;

end proc;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

While[a != EndOfFile, Read[stream, Word]];

 

=={{header|MAXScript}}==

this function will read a file line by line.

(

local in_file = openfile FileName

)

close in_file

 

=={{header|Mercury}}==

:- module input_loop.

:- interface.

io.set_exit_status(1, !IO)

).

 

=={{header|mIRC Scripting Language}}==

while (%n <= $lines(input.txt)) {

write output.txt $read(input.txt,%n)

inc %n

 

=={{header|ML/I}}==

The very nature of ML/I is that its default behaviour

is to copy from input to output until it reaches end of file.

 

=={{header|Modula-2}}==

 

VAR n : CARDINAL;

IF n <= HIGH (str) THEN str [n-1] := 0C END;

lastCh := ch

 

=={{header|Modula-3}}==

 

IMPORT Rd, Wr, Stdio;

Wr.PutText(Stdio.stdout, buf);

END;

 

=={{header|NetRexx}}==

=== Using NetRexx <tt>ASK</tt> Special Variable ===

options replace format comments java crossref symbols nobinary

 

 

return

 

=== Using Java <tt>Scanner</tt> ===

options replace format comments java crossref symbols nobinary

 

 

return

 

=={{header|Nim}}==

for line in i.lines:

discard # process line

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE InputLoop;

IMPORT

END

END InputLoop.

Execute: InputLoop &lt; Inputloop.Mod<br/>

Output:

 

=={{header|Objeck}}==

use IO;

 

}

}

 

=={{header|OCaml}}==

line :: read_lines ic

with End_of_file ->

 

The version above will work for small files, but it is not tail-recursive. <br />

Below will be more scalable:

 

try Some (input_line ic)

with End_of_file -> None

let read_lines ic =

let rec loop acc =

| Some line -> loop (line :: acc)

in

loop []

 

Or with a higher order function:

 

let rec loop () =

with End_of_file -> ()

in

 

 

=={{header|Oforth}}==

Reads a file line by line and write each line on standard output :

 

 

=={{header|Oz}}==

%% Text: an instance of Open.text (a mixin class)

fun {ReadAll Text}

[] Line then Line|{ReadAll Text}

end

 

=={{header|Pascal}}==

 

var

closefile(f);

 

 

=={{header|Perl}}==

The angle brackets operator ( <tt><...></tt> ) reads one line at a time from a filehandle in scalar context:

while (my $line = <FH>) {

chomp $line; # removes trailing newline

# process $line

}

 

Or you can get a list of all lines when you use it in list context:

 

Or a simpler program for lines of files entered as command line arguments or standard input:

# $_ contains a line

 

Invoking perl with the -p or -n option implies the above loop, executing its code once per input line, with the line stored in $_. -p will print $_ automatically at the end of each iteration, -n will not.

{{trans|Euphoria}}

Process text stream line-by-line:

 

=={{header|PHP}}==

if ($fh) {

while (!feof($fh)) {

}

fclose($fh);

 

Or you can get an array of all the lines in the file:

 

Or you can get the entire file as a string:

 

=={{header|PicoLisp}}==

This reads all lines in a file, and returns them as a list of lists

(make

(until (eof)

 

=={{header|PL/I}}==

 

open file (in) title ('/TEXT.DAT,type(text),recsize(200)' );

get file(in) edit (line) (L);

put skip list (line);

 

=={{header|PowerShell}}==

ForEach-Object {

$_

or

 

=={{header|PureBasic}}==

File objects can be read bytewise, characterwise (ASCII or UNICODE), floatwise, doublewise, integerwise, linewise ...

; file based line wise

If ReadFile(0, "Text.txt")

CloseFile(1)

EndIf

 

=={{header|Python}}==

To create a Python3 input loop use python's `input()` function.

 

x = input("What is your age? ")

 

Python file objects can be iterated like lists:

 

try:

for line in my_file:

pass # process line, includes newline

finally:

 

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

 

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

for line in f:

 

You can also get lines manually from a file:

This does not mix well with the iteration, however.

 

 

When you want to read from stdin, or (multiple) filenames are given on the command line:

for line in fileinput.input():

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

 

=={{header|R}}==

Note that read.csv and read.table provide alternatives for files with 'dataset' style contents.

 

=={{header|Racket}}==

 

The following prints input lines from standard input to standard output:

#lang racket

(copy-port (current-input-port) (current-output-port))

 

=={{header|Raku}}==

'''Line-by-line''' <small>''(line endings are automatically stripped)''</small>

 

...

...

...

...

 

'''Word-by-word'''

...

*From standard input or a pipe, accordingly.

 

=={{header|REBOL}}==

Title: "Basic Input Loop"

URL: http://rosettacode.org/wiki/Basic_input_loop

f: next f ; Advance to next line.

]

 

=={{header|REXX}}==

{{works with|oorexx and Regina}}

Reading line by line from the standard input using <tt>linein</tt> and <tt>lines</tt> did not work.

call charout ,charin(stdin)

 

===version 1b===

{{works with|oorexx and Regina}}

Apparently only lines() does not work

input=linein(stdin)

Call lineout ,input

 

===version 2===

{{works with|ARexx}}

do until eof(stdin)

l = readln(stdin)

say l

 

===version 3===

 

Therefore, the following two REXX programs use the presence of a null line to indicate e-o-f.

do until _==''

parse pull _

 

===version 4===

do until _==''

_= linein()

 

=={{header|Ring}}==

fp = fopen("C:\Ring\ReadMe.txt","r")

 

fclose(fp)

 

 

=={{header|Ruby}}==

Ruby input streams are IO objects. One can use IO#each or IO#each_line to iterate lines from a stream.

 

stream.each do |line|

# process line

 

IO objects are also Enumerable (like Array or Range), and have methods like Enumerable#map, which call IO#each to loop through lines from a stream.

 

 

''To open a new stream for reading, see [[Read a file line by line#Ruby]].''

 

=={{header|Run BASIC}}==

while not(eof(#f))

line input #f, a$

print a$

wend

 

=={{header|Rust}}==

use std::fs::File;

 

}

Ok(())

 

=={{header|Scala}}==

{{libheader|Scala}}

{{works with|Scala|2.10.3}}

 

=={{header|sed}}==

 

=={{header|Seed7}}==

const proc: main is func

writeln("LINE: " <& line);

end while;

 

=={{header|Sidef}}==

To read from the standard input, you can use '''STDIN''' as your '''fh'''.

file.open_r(\var fh, \var err) || die "#{file}: #{err}"

 

say word

}

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

f := FileStream open: 'afile.txt' mode: FileStream read.

 

=={{header|SNOBOL4}}==

 

=={{header|Sparkling}}==

while (line = getline()) != nil {

print(line);

 

=={{header|Tcl}}==

while {[gets $fh line] != -1} {

# process $line

}

For “small” files, it is often more common to do this:

set data [read $fh]

close $fh

foreach line [split $data \n] {

# process line

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

file="a.txt"

ENDLOOP

ENDACCESS source

 

=={{header|UNIX Shell}}==

When there is something to do with the input, here is a loop:

# examine or do something to the text in the "line" variable

echo "$line"

The following echoes standard input to standard output line-by-line until the end of the stream.

Since <code>cat</code> defaults to reading from standard input and writing to standard output, this can be further simplified to the following.

 

=={{header|UnixPipes}}==

 

read by lines:

read by words:

 

=={{header|Ursa}}==

f.open "filename.txt"

while (f.hasnext)

out (in string f) endl console

 

=={{header|Vala}}==

string? s;

while((s = stdin.read_line()) != null) {

}

return 0;

 

=={{header|VBA}}==

Dim filesystem As Object, stream As Object, line As String

Set filesystem = CreateObject("Scripting.FileSystemObject")

Loop

stream.Close

 

=={{header|VBScript}}==

filepath = "SPECIFY PATH TO TEXT FILE HERE"

 

objInFile.Close

Set objFSO = Nothing

 

=={{header|Visual Basic .NET}}==

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

 

Dim line = stream.ReadLine

Do Until line Is Nothing

line = stream.ReadLine

Loop

 

=={{header|x86 Assembly}}==

 

'''GAS, 64 bit (Linux)''': Compiled with <code>gcc -nostdlib</code>. Memory maps the file and outputs one line at a time. Try <code>./a.out file</code>, <code>./a.out < file</code>, or <code>./a.out <<< "Heredoc"</code>. It's a little like cat, but less functional.

#define SYS_OPEN $2

#define SYS_CLOSE $3

filesize: // 8 bytes.

.quad 0

 

=={{header|XPL0}}==

Text stream is a file redirected on command line i.e: <file.txt

[repeat \read file

repeat \read line

until C < $20; \CR, LF, or EOF

until C = \EOF\ $1A;

 

=={{header|zkl}}==

Word by word isn't explicitly supported.

If an object is stream-able, it supports methods like foreach, pump, apply, reduce, etc.

List(1,2,3).readln() // here, a "line" is a list element

Utils.Helpers.zipWith(False, // enumerate a file