Read a file line by line: Difference between revisions

=={{header|360 Assembly}}==

This program uses OS QSAM I/O macros (OPEN,CLOSE,GET,PUT,DCB).

READFILE CSECT

SAVE (14,12) save registers on entry

PG DS CL80 buffer

YREGS

 

=={{header|8th}}==

"path/to/file" f:open ( . cr ) f:eachline f:close

 

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program readfile64.s */

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

.include "../includeARM64.inc"

 

=={{header|Ada}}==

{{works with|Ada 2005}}

line_by_line.adb:

 

procedure Line_By_Line is

Close (File);

end Line_By_Line;

 

{{Out}}

 

=={{header|Aime}}==

text s;

 

o_text(s);

o_byte('\n');

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.5 algol68g-2.3.5].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

FILE foobar;

printf(($g(0)": "$, count, line fmt, line))

OD;

{{out}}

<pre style="height:15ex;overflow:scroll">

</pre>

 

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program readfile.s */

iMagicNumber: .int 0xCCCCCCCD

 

 

=={{header|Astro}}==

print line

 

=={{header|AutoHotkey}}==

 

 

FileSelectFile, File, 1, %A_ScriptDir%, Select the (text) file to read, Documents (*.txt) ; Could of course be set to support other filetypes

FileDelete, Output.txt ; Makes sure output is clear before writing

FileAppend, %Text%, Output.txt ; Writes the result to Output.txt

 

=={{header|AWK}}==

 

'''One-liner:'''

 

'''Shorter:'''<br>

so this is the shortest possible awk-program

(not counting the [[Empty program]]):

 

'''Longer:'''<br>

Reading several files, with some processing:

BEGIN { print "# Reading..." }

FNR==1 { f++; print "# File #" f, ":", FILENAME }

{ print } # same as "print $0"

END { print "# Done with", f, "file(s), with a total of", NR, "lines." }

Note:

* The variables c and f are initialized automatically to 0

 

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

filename$ = "readlines.bac"

OPEN filename$ FOR READING AS fh

WEND

PRINT lines, " lines in ", filename$

 

{{out}}

 

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

110 OPEN #1:NAME$ ACCESS INPUT

120 COPY FROM #1 TO #0

 

==={{header|Locomotive Basic}}===

20 WHILE NOT EOF

30 LINE INPUT#9,i$

40 PRINT i$

 

==={{header|ZX Spectrum Basic}}===

The tape recorder interface does not support fragmented reads, because tape recorder start and stop is not atomic, (and a leadin is required for tape input).

In the following example, we read a file line by line from a file on microdrive 1.

 

20 OPEN #4;"m";1;"MYFILE": REM stream 4 is the first available for general purpose

30 INPUT #4; LINE a$: REM a$ will hold our line from the file

50 REM to gracefully exit when the file is read. (omitted from this example)

60 REM to prevent an error at end of file, place a handler here

 

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

This takes account on the blank lines, because FOR ignores blank lines when reading a file.

rem delayed expansion must be disabled before the FOR command.

setlocal disabledelayedexpansion

echo(!var!

endlocal

 

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

{{works with|BBC BASIC for Windows}}

This method is appropriate if the lines are terminated by a single CR or LF:

IF file%=0 ERROR 100, "File could not be opened"

WHILE NOT EOF#file%

a$ = GET$#file%

ENDWHILE

This method is appropriate if the lines are terminated by a CRLF pair:

IF file%=0 ERROR 100, "File could not be opened"

WHILE NOT EOF#file%

IF ASCa$=10 a$ = MID$(a$,2)

ENDWHILE

 

=={{header|Bracmat}}==

<code>fil</code> is a relatively low level Bracmat function for manipulating files. Depending on the parameters it opens, closes, reads, writes a file or reads or sets the file position.

& fil$(,STR,\n) { first argument empty: same as before (i.e. "test.txt") }

{ if \n were replaced by e.g. "\n\t " we would read word-wise instead }

)

& (fil$(,SET,-1)|); { Setting file position before start closes file, and fails.

 

=={{header|Brat}}==

 

file.each_line "foobar.txt" { line |

p line

 

=={{header|C}}==

 

#include <conio.h>

 

return 0;

 

===with getline===

 

#include <stdio.h>

fclose(stream);

exit(EXIT_SUCCESS);

 

=== Using mmap() ===

Implementation using mmap syscall. Works on Linux 2.6.* and on *BSDs. Line reading routine takes a callback function, each line is passed into callback as begin and end pointer. Let OS handle your memory pages, we don't need no stinking mallocs.

#include <sys/types.h>

#include <sys/stat.h>

 

int read_lines(const char * fname, int (*call_back)(const char*, const char*))

return read_lines("test.ps", print_line) ? 0 : 1;

}

 

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

'File.ReadLines' reads the lines of a file which could easily be stepped through.

A full code may look like;

using System.IO;

using System.Text;

}

}

 

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

{{works with|C++03 to C++17 }}

#include <string>

#include <iostream>

infile.close( ) ;

return 0 ;

 

====using std::getline====

</pre>

 

#include <fstream>

#include <iostream>

}

std::cout << "finished" << std::endl;

 

{{out}}

{{libheader|U++}}

 

 

using namespace Upp;

while(in && !in.IsEof())

Cout().PutLine(in.GetLine());

 

=={{header|Clojure}}==

 

(with-open [r (clojure.java.io/reader "some-file.txt")]

(doseq [l (line-seq r)]

(println l)))

 

=={{header|COBOL}}==

PROGRAM-ID. read-file-line-by-line.

 

 

GOBACK

 

=={{header|CoffeeScript}}==

{{works_with|node.js}}

# This module shows two ways to read a file line-by-line in node.js.

fs = require 'fs'

console.log "DONE ASYNC!"

reader.next_line callbacks.process_line, callbacks.all_done

 

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

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

 

=={{header|D}}==

import std.stdio;

 

foreach (line; "read_a_file_line_by_line.d".File.byLine)

line.writeln;

The File is managed by reference count, and it gets closed when it gets out of scope or it changes. The 'line' is a char[] (with newline), so if you need a string you have to idup it.

 

=={{header|DCL}}==

$ loop:

$ read /end_of_file = done input line

$ goto loop

$ done:

 

=={{header|Delphi}}==

procedure ReadFileByLine;

var

CloseFile(TextFile);

end;

The example file (above) '''"c:\test.txt"''' is assigned to the text file variable '''"TextFile"''' is opened and any line is read in a loop into the string variable '''"TextLine"'''.

 

procedure ReadFileByLine;

var

ShowMessage(TextLines[i]);

end;

 

Above uses the powerful utility classs type [http://www.delphibasics.co.uk/RTL.asp?Name=TStringList TStringList] from Classes Unit

 

See also GNU LGPL (Delphi replacement) [http://www.lazarus.freepascal.org/ Lazarus IDE FreePascal] and specifically [http://wiki.lazarus.freepascal.org/TString_List-TString_Tutorial Lazarus FreePascal Equivalent for TStringList]

 

=={{header|Elena}}==

import extensions;

import extensions'routines;

public program()

{

 

=={{header|Elixir}}==

Two Slightly different solutions in the FileReader namespace

defmodule FileReader do

# Create a File.Stream and inspect each line

end

end

 

=={{header|Erlang}}==

read_a_file_line_by_line:into_list/1 is used by [[Read_a_specific_line_from_a_file]]. If this task is updated keep backwards compatibility, or change [[Read_a_specific_line_from_a_file]], too.

-module( read_a_file_line_by_line ).

 

into_list( {error, _Error}, _IO, Acc ) -> lists:reverse( Acc );

into_list( Line, IO, Acc ) -> into_list( io:get_line(IO, ''), IO, [Line | Acc] ).

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM LETTURA

 

CLOSE(1) ! chiude il file

END PROGRAM

From ERRE manual: use an EXCEPTION to trap a "file not found" error. If you change INPUT(LINE statement with a GET you can read the file one character at time.

 

=={{header|Euphoria}}==

constant filename = cmd[2]

constant fn = open(filename,"r")

i += 1

end while

 

{{out}}

Wednesday

</pre>

eui readfile.ex "File.txt"

 

{{out}}

=={{header|F_Sharp|F#}}==

Using DotNet's [http://msdn.microsoft.com/en-us/library/dd383503.aspx System.IO.File.ReadLines] iterator:

 

[<EntryPoint>]

let main argv =

File.ReadLines(argv.[0]) |> Seq.iter (printfn "%s")

 

=={{header|Factor}}==

 

 

=={{header|Fantom}}==

Reads each line from the file "data.txt".

 

class Main

{

}

}

 

=={{header|Forth}}==

 

 

: third ( A b c -- A b c A )

>r over r> swap ;

 

 

=={{header|Fortran}}==

 

In the absence of such error reception, ugly messages are presented as the prog. is cancelled, and the most common such error is to name a missing file. So, an INQUIRE statement to check first. This too should have an ERR and IOSTAT blather (the file name might be malformed) but enough is enough. The assignment direction for such codes as EXIST and IOSTAT is ''left'' to right rather than the usual right to left (as in FILE = FNAME), but rather than remember this, it is easiest to take advantage of Fortran's (complete) absence of reserved words and define a logical variable EXIST so that the statement is EXIST = EXIST, and the compiler and the programmer can go their own ways.

INTEGER ENUFF !A value has to be specified beforehand,.

PARAMETER (ENUFF = 2468) !Provide some provenance.

20 CLOSE (IN) !All done.

END !That's all.

With F90 and later it is possible to use an ALLOCATE statement to prepare a variable of a size determined at run time, so that one could for each record use the <code>Q</code> format code (or a new feature of the READ statement) to ascertain the size of the record about to be read, free the storage for the old ALINE and allocate a new sized ALINE, then read that record into ALINE. This avoids worrying about the record overflowing (or underflowing) ALINE, at the cost of hammering at the memory allocation process.

 

 

=={{header|FreeBASIC}}==

 

Open "input.txt" For Input As #1

Print

Print "Press any key to quit"

 

=={{header|Frink}}==

The <CODE>lines</CODE> function can also take an optional second string argument indicating the encoding of the file, and can read from any supported URL type (HTTP, FTP, etc.) or a <CODE>java.io.InputStream</CODE>.

for line = lines["file:yourfile.txt"]

println[line]

 

=={{header|Gambas}}==

Dim hFile As File

Dim sLine As String

Wend

 

 

=={{header|GAP}}==

local file, line, count;

file := InputTextFile(name);

# With [http://www.ibiblio.org/pub/docs/misc/amnesty.txt amnesty.txt]

ReadByLines("amnesty.txt");

 

=={{header|Genie}}==

/*

Read file line by line, in Genie

lines++

stdout.printf("%04d %s\n", lines, line)

 

{{out}}

Scanning stops unrecoverably at EOF, the first I/O error, or a token too large to fit in the buffer. When a scan stops, the reader may have advanced arbitrarily far past the last token. Programs that need more control over error handling or large tokens, or must run sequential scans on a reader, should use bufio.Reader instead.

 

 

import (

}

}

 

;ReadLine

This function allows files to be rapidly scanned for desired data while minimizing memory allocations. It also handles /r/n line endings and allows unreasonably long lines to be handled as error conditions.

 

import (

fmt.Println(string(line))

}

;ReadString

In comparison, ReadString is a little quick and dirty, but is often good enough.

 

import (

}

}

 

=={{header|Groovy}}==

println "processing line $lineNumber: $line"

 

 

Thanks to laziness, there's no difference between reading the file all at once and reading it line by line.

 

file <- readFile "linebyline.hs"

mapM_ putStrLn (lines file)

 

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

Line oriented I/O is basic. This program reads lines from "input.txt" into the variable line, but does nothing with it.

 

f := open("input.txt","r") | stop("cannot open file ",fn)

while line := read(f)

close(f)

 

=={{header|J}}==

This implementation does nothing special when dealing with multi-gigabyte lines. If you encounter an excessively large line and if do not have enough physical memory, your system will experience heavy memory pressure. If you also do not have enough virtual memory to hold a line you will get an out of memory exception.

 

 

NB. configuration parameter

lines=: }.lines

r

 

next__example''

this is line 1

next__example''

 

=={{header|Java}}==

import java.io.FileReader;

 

}

}

{{works with|Java|7+}}

In Java 7, the try with resources block handles multiple readers and writers without nested try blocks. The loop in the main method would look like this:

try (FileReader fr = new FileReader(filename);BufferedReader br = new BufferedReader(fr)){

String line;

x.printStackTrace();

}

<code>fr</code> and <code>br</code> are automatically closed when the program exits the try block (it also checks for nulls before closing and throws closing exceptions out of the block).

 

A more under-the-hood method in Java 7 would be to use the <code>Files</code> class (line numbers can be inferred from indices in the returned <code>List</code>):

import java.nio.file.Paths;

import java.nio.charset.Charset;

}catch(IOException | SecurityException e){

//problem with the file

 

=={{header|JavaScript}}==

 

var readFile = function(path) {

};

 

 

=={{header|jq}}==

When invoked with the -R option, jq will read each line as a JSON string. For example:

0

0.8414709848078965

0.1411200080598672

-0.7568024953079282

 

To perform any kind of reduction operation while reading the lines one-by-one, one would normally use

`input` or `inputs`. For example, to compute the maximum of the above sin values:

 

 

=={{header|Jsish}}==

var f = new Channel('read-by-line.jsi');

var line;

 

while (line = f.gets()) puts(line);

{{out}}

<pre>prompt$ jsish read-by-line.jsi

 

=={{header|Julia}}==

for line in eachline(f)

println("read line: ", line)

end

 

=={{header|Kotlin}}==

 

import java.io.File

fun main(args: Array<String>) {

File("input.txt").forEachLine { println(it) }

 

=={{header|Lasso}}==

handle => {#f->close}

#f->forEachLine => {^

#1

'<br>' // note this simply inserts an HTML line break between each line.

 

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

if file$="" then end

open file$ for input as #f

print t$

wend

Mac

if file$="" then end

open file$ for input as #f

print t$

wend

Unix

if file$="" then end

open file$ for input as #f

print t$

wend

 

=={{header|Lingo}}==

The following code works fine for text files using 'CRLF' or 'CR only' as line end characters, but unfortunately not for the *nix default 'LF only' (note: Lingo's implementation Director does not run on Linux. It was originally created for ancient Mac OS systems, and later also ported to Windows):

fp.openFile(_movie.path & "input.txt", 1)

fileSize = fp.getLength()

if fp.getPosition()>=fileSize then exit repeat

end repeat

 

=={{header|LiveCode}}==

local tFile, tLines, startRead

put "/usr/share/dict/words" into tFile

close file tFile

put tLines

 

=={{header|Logo}}==

* 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|Lua}}==

fp = io.open( filename, "r" )

 

 

fp:close()

===Simpler version===

The following achieves the same result as the example above, including implicitly closing the file at the end of the loop.

for line in io.lines("input.txt") do

print(line)

end

 

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

Documents have Load.Doc statement to load text file. Here we see how we make indexes, and then reopen for input, and move to index, and then load a line.

 

Module checkit {

\\ prepare a file

}

checkit

 

=={{header|Maple}}==

while (true) do

input := readline(path):

if input = 0 then break; end if:

#The line is stored in input

 

If[strm=!=$Failed,

While[line=!=EndOfFile,

(*Do something*)

]];

 

=={{header|MATLAB}} / {{header|Octave}}==

The function fgetl() read lines from file:

 

fid = fopen('foobar.txt','r');

if (fid < 0)

end;

fclose(fid)

 

=={{header|Maxima}}==

 

readfile(name) := block(

close(f),

v

 

=={{header|Mercury}}==

Basic version.

:- interface.

 

ReadLineResult = error(Error),

error(io.error_message(Error))

 

Version using a stream fold.

 

:- interface.

 

process_line(line(Line), !LineCount, !IO) :-

!:LineCount = !.LineCount + 1,

 

=={{header|Neko}}==

Need to define a growing buffer to handle streaming unknown sizes, 2 to the 29 max, for this one.

 

Read a file line by line, in Neko

<doc><pre>Tectonics:

} catch a break;

}

 

{{out}}

=={{header|NetRexx}}==

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

options replace format comments java crossref symbols nobinary

 

 

return fileLines

 

=== Using Java <tt>Reader</tt> ===

options replace format comments java crossref symbols nobinary

 

 

return fileLines

 

=={{header|NewLISP}}==

(set 'in-file (open "filename" "read"))

(while (read-line in-file)

(write-line))

 

=={{header|Nim}}==

 

=={{header|Objeck}}==

bundle Default {

class ReadFile {

}

}

 

=={{header|Objective-C}}==

 

To read an entire file into a string, you can:

NSError *error = nil;

NSString *words = [[NSString alloc] initWithContentsOfFile:path

encoding:NSUTF8StringEncoding error:&error];

 

Use the UTF-8 encoder on ASCII.

Now to get the individual lines, break down the string:

 

 

=={{header|OCaml}}==

 

let ic = open_in "input.txt" in

try

done

with End_of_file ->

 

But if we want to write a functional loading function we should remember that the <code>try/with</code> couple breaks the [[tail recursion]]. So we should externalise it outside of the loop in another function:

 

try Some (input_line ic)

with End_of_file -> None

let lines = read_lines ic in

close_in ic;

 

we use it like this:

 

let lines = lines_of_file "unixdict.txt" in

 

 

 

 

 

 

=={{header|PARI/GP}}==

 

Thus the usual way of interacting with files in more than the simple way allowed by <code>read</code> is done by PARI with the usual [[#C|C]] commands:

if (!f) {

pari_err(openfiler, "input", name);

while(fgets(line, MAX_LINELEN, f) != NULL) {

// ...

 

=={{header|Pascal}}==

{{Works with|Free Pascal}}

Works for text files. "testin.txt" must exist in directory of program and you must have read/write access. No IO-Checks.

program ReadFileByLine;

var

Close(InputFile);

Close(OutputFile)

 

=={{header|Perl}}==

For the simple case of iterating over the lines of a file you can do:

|| die "Could not open file: $!";

while (<$fh>)

process($_);

}

File encoding can be specified like:

The angle bracket operator <code>< ></code> reads a filehandle line by line. (The angle bracket operator can also be used to open and read from files that match a specific pattern, by putting the pattern in the brackets.)

 

Without specifying the variable that each line should be put into, it automatically puts it into <code>$_</code>, which is also conveniently the default argument for many Perl functions. If you wanted to use your own variable, you can do something like this:

|| die "Could not open file: $!";

while (my $line = <$fh>)

process($line);

}

 

The special use of the angle bracket operator with nothing inside, will read from all files whose names were specified on the command line:

chomp;

process($_);

 

As noted in <code>perlop.pod</code> under "I/O Operators", <code>&lt;&gt;</code> opens with the 2-arg <code>open()</code> and so can read from a piped command. This can be convenient but is also very much insecure--a user could supply a file with the name like

 

 

or any other arbitrary command, which will be executed when perl attempts to open a pipe for it. As such, this feature is best reserved for one-liners and is bad practice to use in production code. The same is true for the open(FILEHANDLE, EXPR) form of open as opposed to open(FILEHANDLE, MODE, EXPR). (See <code>perlfunc.pod</code> on the <code>open()</code> function.)

 

The readline function can be used instead of < >:

while (readline $fh)

{ ... }

while (my $line = readline $fh)

{ ... }

The readline function is the internal function used to implement < >, but can be used directly and is useful for conveying programmer intent in certain situations.

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

 

true

while

 

=={{header|PHP}}==

$file = fopen(__FILE__, 'r'); // read current file

while ($line = fgets($file)) {

$line = rtrim($line); // removes linebreaks and spaces at end

echo strrev($line) . "\n"; // reverse line and upload it

 

$file = fopen('test.txt', 'r'); // OPEN FILE WITH READ ACCESS

while (!feof($file)) {

$line = rtrim(fgets($file)); // REMOVE TRAILING WHITESPACE AND GET LINE

if($line != NULL) echo("$line\n"); // IF THE LINE ISN'T NULL, ECHO THE LINE

 

=={{header|PicoLisp}}==

(while (line)

 

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

read: procedure options (main);

declare line character (500) varying;

end;

end read;

 

=={{header|PowerShell}}==

try {

do {

$reader.Close()

}

 

=={{header|PureBasic}}==

 

If ReadFile(0, FileName$) ; use ReadFile instead of OpenFile to include read-only files

Wend

CloseFile(0)

 

=={{header|Python}}==

For the simple case of iterating over the lines of a file you can do:

for line in f:

The with statement ensures the correct closing of the file after it is processed, and iterating over the file object <code>f</code>, adjusts what is considered line separator character(s) so the code will work on multiple operating systems such as Windows, Mac, and Solaris without change.<br>

Any exceptional conditions seen when processing the file will raise an exception. Leaving the while loop because of an exception will also cause the file to be correctly closed on the way.

 

Python also has the [http://docs.python.org/library/fileinput.html fileinput module]. This can process multiple files parsed from the command line and can be set to modify files 'in-place'.

for line in fileinput.input():

process(line)

 

=={{header|R}}==

 

while(length(line <- readLines(conn, 1)) > 0) {

cat(line, "\n")

 

=={{header|Racket}}==

(let ((line (read-line file 'any)))

(unless (eof-object? line)

(newline)

(read-next-line-iter file))))

 

(for ([line (in-lines in)])

(displayln line))

 

=={{header|Raku}}==

(formerly Perl 6)

The lines method is lazy so the following code does indeed read the file line by line, and not all at once.

{

.say

 

In order to be more explicit about the file being read on line at a time, one can write:

while my $line = $f.get {

say $line;

 

=={{header|RapidQ}}==

$Include "Rapidq.inc"

dim file as qfilestream

 

input "Press enter to exit: ";a$

 

=={{header|REXX}}==

<br>beginning of the file needs to be re-established so the reading can start from the beginning of the file.

<br><br>The &nbsp; '''lineout''' &nbsp; BIF closes the file (in most REXX interpreters); &nbsp; this is done for general housekeeping.

parse arg fID . /*obtain optional argument from the CL.*/

if fID=='' then exit 8 /*Was no fileID specified? Then quit. */

say /*stick a fork in it, we're all done. */

say center(' file ' fID " has " #-1 ' records.', 79, '═') /*show rec count. */

 

=== deluxe version ===

<br>It can also just show the last line.

<br>If appropriate, the program will show the total number of lines in the file.

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 123456.TXT </tt>}}

<pre>

 

=== ARexx version ===

filename='file.txt'

contents=''

ELSE EXIT 20

CALL Close filehandle

 

=={{header|Ring}}==

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

r = ""

end

fclose(fp)

 

=={{header|Ruby}}==

# Do something with line.

puts line

 

 

IO.foreach "| grep afs3 /etc/services" do |line|

puts line

 

''Caution!'' IO.foreach and File.foreach take a portname.

The block form of File.open automatically closes the file after running the block.

 

File.open(filename) do |file|

file.each {|line| puts line}

 

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

while not(eof(#f))

line input #f, a$

wend

close #f

 

=={{header|Rust}}==

use std::fs::File;

 

println!("{}", line.unwrap());

}

 

{{out}}

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

;(use-modules (ice-9 rdelim))

 

(do ((line (read-line file) (read-line file))) ((eof-object? line))

(display line)

 

=={{header|Sed}}==

Through a .sed file:

p

 

or through a one-liner in bash:

sed p filename

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("LINE: " <& line);

end while;

 

The function [http://seed7.sourceforge.net/libraries/file.htm#hasNext%28in_file%29 hasNext]

 

=={{header|SenseTalk}}==

open file myFile

 

end repeat

 

 

=={{header|Sidef}}==

''FileHandle.each{}'' is lazy, allowing us to do this:

 

Same thing explicitly:

while (fh.readline(\var line)) {

 

=={{header|Smalltalk}}==

{{works with|Pharo}}

(StandardFileStream oldFileNamed: 'test.txt') contents lines do: [ :each | Transcript show: each. ]

 

{{works with|Smalltalk/X}}

alternatively:

s := 'foobar.txt' asFilename readStream.

[ s atEnd ] whileFalse:[

s nextLine printCR.

].

alternatively:

 

=={{header|SNOBOL4}}==

Accessing the variable fails (does not succeed) when the end of file is reached.

 

rdloop output = infile :s(rdloop)

 

=={{header|Sparkling}}==

if f != nil {

var line;

 

fclose(f);

 

=={{header|SPL}}==

> !#.eof(f)

#.output(#.readline(f))

 

=={{header|Tcl}}==

while {[gets $f line] >= 0} {

# This loops over every line

puts ">>$line<<"

}

 

=={{header|TorqueScript}}==

Read a file line by line:

 

//Create a file object

 

 

%f.delete();

 

=={{header|Turing}}==

For a named file:

open : f, "rosetta.txt", get

loop

put line

end loop

 

For a command line argument file (e.g. program.x rosetta.txt):

exit when eof (1)

var line: string

get : 1, line:*

put line

 

For standard input (e.g., program.x < rosetta.txt):

exit when eof

var line : string

get line:*

put line

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

 

ENDLOOP

ENDACCESS q

or:

LOOP line=datei

PRINT line

ENDLOOP

 

 

Taken from C++ U++ section

 

 

using namespace Upp;

while(in && !in.IsEof())

Cout().PutLine(in.GetLine());

 

 

{{works with|Almquist Shell}}

 

# This loop is inside a pipeline; many shells will

# run this loop inside a subshell.

while IFS= read -r line ; do

printf '%s\n' "$line"

 

{{works with|Almquist Shell}}

 

# the old standard input (fd 1) and input.txt (fd 3).

exec 3<input.txt

printf '%s\n' "$line"

done

 

{{works with|Bourne Shell}}

 

# It requires extra code to restore the original value of IFS.

exec 3<input.txt

done

IFS=$oldifs

 

=={{header|Ursa}}==

Reads the file "filename.txt" and outputs it to the console line by line.

f.open "filename.txt"

while (f.hasline)

out (in string f) endl console

 

=={{header|Vala}}==

Reads and prints out file line by line:

public static void main(){

var file = FileStream.open("foo.txt", "r");

}

}

 

=={{header|VBA}}==

Sub Main()

Dim fInput As String, fOutput As String 'File names

Close #1

Close #2

 

=={{header|VBScript}}==

FilePath = "<SPECIFY FILE PATH HERE>"

Set objFSO = CreateObject("Scripting.FileSystemObject")

objFile.Close

Set objFSO = Nothing

 

=={{header|Vedit macro language}}==

This example reads the source code of this macro,

copies it line by line into a new buffer and adds line numbers.

#10 = Buf_Num // edit buffer for input file

#11 = Buf_Free // edit buffer for output

}

Buf_Close(NOMSG) // close the input file

 

{{out}}

===Simple version===

{{works with|Visual Basic|VB6 Standard}}

Sub Main()

Dim fInput As String, fOutput As String 'File names

InputError:

MsgBox "File: " & fInput & " not found"

 

===Complex version===

'

' (c) Copyright 1993 - 2011 Mark Hobley

Public Function btrim$(arg$)

btrim$ = LTrim$(RTrim$(arg$))

 

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

 

' Loop through the lines of a file.

oReader.Close()

 

 

=={{header|Wart}}==

 

=={{header|Wren}}==

 

var lines = [] // store lines read

}

 

 

=={{header|XPL0}}==

File is redirected on command line i.e: <file.txt

[repeat repeat C:= ChIn(1); \repeat until end-of-line

ChOut(0, C);

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

until C = \EOF\ $1A; \repeat until end-of-file

 

=={{header|zkl}}==

So many ways, here are a few

[0..],File("foo.zkl","r"))

-->

0: var R; n:=GarbageMan.gcCount;

1: ref := GarbageMan.WeakRef(String("the","quick brown fox"));