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|Action!}}==

CHAR ARRAY line(255)

ReadStream(streamId)

Close(streamId)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Input_loop.png Screenshot from Atari 8-bit computer]

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|APL}}==

{{works with|GNU APL}}

h ← ⊃ (⎕fio['read_text'] 'corpus/sample1.txt')

⍴h

│ │

└─────────────────────────────────────────────────┘

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

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

.include "../affichage.inc"

{{Output}}

<pre>

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|BASIC256}}===

open f, "test.txt"

end while

close f

==={{header|OxygenBasic}}===

uses Console

uses ParseUtil

wend

pause

==={{header|QBasic}}===

{{works with|QBasic}}

{{works with|QuickBasic}}

WHILE NOT EOF(1)

CLOSE #1

==={{header|True BASIC}}===

DO

CLOSE #1

==={{header|Yabasic}}===

f = open(filename$)

close f

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

110 D$ = CHR$(4)

120 PRINT D$"VERIFY"F$

190 POKE 216,0

200 IF PEEK(222) <> 5 THEN RESUME

==={{header|BaCon}}===

'--- some generic header file to give it a real test

PRINT "Enter any file name you want to read ex: /usr/include/X11/X.h"

INCR i

WEND

==={{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|Commodore BASIC}}===

This example should generally work across all Commodore models. It is important to note that when using the reserved variable STATUS (or ST for short) to detect the end of file marker (bit 6), the KERNAL updates this variable based on ''any'' previous I/O operation, including the OPEN command, but makes no indication as to which I/O access the status applies to. Therefore, if using the disk drive, it is best to open the command file number and channel (15) ''before'' opening the actual file on disk, and leave the command channel open while performing the operations to open the file and access it as shown in the example.

10 rem input loop - rosetta code

11 rem open command channel, clear screen, switch to lower case

1110 print:print er;"- ";er$;" track:";tk;"sector:";sc

1120 return

==={{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|uBasic/4tH}}===

Do While Read (a)

Close a

This version tokenizes the line read and prints all individual words.

Do While Read (a) ' get next line

Close a

=={{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;

{

ReaderEnumerator.new(File.assign:"file.txt").forEach(printingLn)

Using loop statement

public program()

}

}

=={{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

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

((1!:1) 3)(1!:2) 4

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|MACRO-10}}==

TITLE Input Loop

END GO

=={{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}}==

Read from stdin until end of data has been reached:

while stdin.readLine(line):

Choose splitting string:

var lines = stdin.readAll()

for line in lines.split("\n"):

Read from a known text file:

for line in i.lines:

discard # process line

Another, shorter, way to do this:

=={{header|NodeJS}}==

#!/usr/bin/env node

const stdin = stdinLineByLine();

stdin.on('line', console.log);

=={{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}}==

try

let line = input_line ic in

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

in

loop []

Or with a higher order function:

let rec loop () =

try f (input_line ic); loop ()

let () =

let ic = open_in Sys.argv.(1) 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:

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">process_line_by_line</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

=={{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|Picat}}==

Reader = open("file.txt"),

while(not at_end_of_stream(Reader))

println(L)

end,

=={{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}}==