File input/output: Difference between revisions

=={{header|11l}}==

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program readwrtFile64.s */

.include "../includeARM64.inc"

=={{header|ACL2}}==

(defun read-channel (channel limit state)

(mv-let (contents state)

(read-from-file in (expt 2 40) state)

=={{header|Action!}}==

The attached result has been obtained under DOS 2.5.

{{libheader|Action! Tool Kit}}

PROC Dir(CHAR ARRAY filter)

PrintF("Dir ""%S""%E",filter)

Dir(filter)

{{out}}

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

Assuming everything is fine and no error handling is required, this solution is sufficient:

procedure Read_And_Write_File_Line_By_Line is

Close (Output);

end if;

Expanded with proper error handling and reporting it reads:

procedure Read_And_Write_File_Line_By_Line is

Close (Output);

end if;

===Character by character===

The following example reads and writes each file one character at a time. (You should of course add error reporting as in the example above.)

procedure Read_And_Write_File_Character_By_Character is

Close (Output);

end if;

===Using Ada.Text_IO.Text_Streams===

The following solution uses stream I/O. Any file of Ada.Text_IO can be used to obtain a corresponding stream. Reading and writing streams is more efficient than reading text files directly, because it skips formatting.

with Ada.Text_IO.Text_Streams; use Ada.Text_IO.Text_Streams;

Close (Output);

end if;

=={{header|Aime}}==

text s;

o.text(s);

o.byte('\n');

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

{{works 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]}}

# note: algol68toc-1.18 - can compile, but not run v1 #

INT errno;

test:(

copy file v2("input.txt","output.txt")

=={{header|AppleScript}}==

set filedata to read file src

set outfile to open for access dst with write permission

end copyFile

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

pop {r2,lr}

bx lr

=={{header|Arturo}}==

write "output.txt" source

=={{header|AutoHotkey}}==

Method 1: the input file can be processed line by line.

Method 2: the input file can be read at once if it is less than 1 GB.

Method 3: the file can be copied without I/O.

Binary I/O is possible with [http://www.autohotkey.com/forum/topic4604.html&highlight=binread this] library from Laszlo.

(This does not handle properly binary files)

while ( (getline <"input.txt") > 0 ) {

print >"output.txt"

}

=={{header|Babel}}==

{ "input.txt" >>> -- File is now on stack

foo set -- File is now in 'foo'

The spirit of Babel is to manipulate things on the stack whenever feasible. In this example,

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

OPEN "OUTPUT.TXT" FOR OUTPUT AS #2

DO UNTIL EOF(1)

CLOSE #1

CLOSE #2

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

This is only meant to copy a sequential text file. It is very unlikely that this works copying a random access text file.

110 O$ = "OUTPUT.TXT"

120 M$ = CHR$(13)

300 IF NOT EOF THEN RESUME

310 PRINT M$D$"CLOSE"

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

text$ = LOAD$("input.txt")

SAVE text$ TO "output.txt"

==={{header|BASIC256}}===

open 2, "output.txt"

while not eof(1)

end while

close 1

==={{header|Commodore BASIC}}===

20 print "read seq file input.txt and write to seq file output.txt"

30 open 4,8,4,"input.txt,seq,read"

110 close 4

120 close 8

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

110 OPEN #1:"output.txt"

120 OPEN #2:"input.txt" ACCESS OUTPUT

210 CLOSE #1

220 CLOSE #2

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

OPEN "OUTPUT.TXT" FOR OUTPUT AS #2

DO UNTIL EOF(1)

CLOSE #1

CLOSE #2

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

OPEN #2: NAME "output.txt", CREATE NEWOLD

ERASE #2

CLOSE #1

CLOSE #2

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

open "output.txt" for writing as #2

while not eof(1)

wend

close #1

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

or

or

There may be other techniques too.

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

[[BBC BASIC for Windows]] has a file copy command:

Alternatively the copy can be done explicitly:

outfile% = OPENOUT("output.txt")

WHILE NOT EOF#infile%

ENDWHILE

CLOSE #infile%

=={{header|BCPL}}==

LET start() BE $(

endwrite()

$)

=={{header|Befunge}}==

{{works with|CCBI|2.1}}

This linear program tries to open "input.txt" as text file (or aborts).

=={{header|Bracmat}}==

=={{header|C}}==

int main(int argc, char **argv) {

fclose(in);

return 0;

A couple of remarks on the preceding example:

{{works with|POSIX}}

#include <fcntl.h>

#include <sys/types.h>

copy_file("infile", "outfile");

return 0;

{

int ret = 0;

if (bi != (void*)-1) munmap(bi, st.st_size);

return ret;

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

The long way:

using (var reader = new StreamReader("input.txt"))

var text = reader.ReadToEnd();

writer.Write(text);

The short way:

var text = File.ReadAllText("input.txt");

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

{{works with|g++|3.4.2}}

#include <fstream>

#include <string>

}

return 0;

Simpler version:

#include <fstream>

#include <cstdlib>

return EXIT_SUCCESS;

Using istream- and ostream- iterators:

# include <fstream>

std::istreambuf_iterator<char>(),

std::ostreambuf_iterator<char>(ofile));

Even simpler way:

int main()

std::ofstream output("output.txt");

output << input.rdbuf();

=={{header|Clean}}==

Define a function that copies the content from one file to another.

copyFile fromPath toPath world

# toFile = fwrites buffer toFile

| size buffer < bufferSize = (fromFile, toFile) // we're done

Apply this function to the world to copy a file.

=={{header|Clojure}}==

(use 'clojure.java.io)

(copy (file "input.txt") (file "output.txt"))

;; simple file writing

(spit "filename.txt" "your content here")

;; simple file reading

(slurp "filename.txt")

=={{header|COBOL}}==

Flags used for Micro Focus COBOL:

$set ans85 flag"ans85" flagas"s" sequential"line"

program-id. copyfile.

environment division.

end-read

.

===Implementation===

{{works with|OpenCOBOL}}

PROGRAM-ID. file-io.

CLOSE in-file, out-file

===Built-in Subroutines===

{{works with|OpenCOBOL}}

{{works with|Visual COBOL}}

=={{header|ColdFusion}}==

<cffile action="read" file="#expandPath('input.txt')#" variable="inputContents">

<cffile action="write" file="#expandPath('output.txt')#" output="#inputContents#">

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

By lines:

(with-open-file (out #p"output.txt" :direction :output)

(loop for line = (read-line in nil 'foo)

until (eq line 'foo)

By arbitrary blocks and for possibly-binary files:

(with-open-file (in #p"input.txt" :direction :input

for size = (read-sequence buffer in)

while (plusp size)

If you're on an odd platform which actually stores text/binary/... type information for files and your CL implementation will use this information, then <tt>in</tt> should be opened with <tt>:element-type :default</tt>.

{{libheader|Phobos}}

{{works with|D|2}}

void main() {

copy("input.txt", "output.txt");

very plainly, with an intermediate variable:

void main() {

import std.file;

std.file.write("output.txt", data);

}

via an intermediate buffer variable:

int main() {

return 0;

{{libheader|Tango}}

Copy the content from one file to another (exceptions are handled by Tango):

void main()

to.copy(from).close;

from.close;

Or a shorter example without explicitly closing the output file:

void main()

auto to = new File("output.txt", File.WriteCreate);

to.copy(new File("input.txt")).close;

=={{header|DBL}}==

; File Input and output examples for DBL version 4 by Dario B.

;

QUIT, CLOSE 1

{{out}}

<pre>00001Alan Turing London

=={{header|DCL}}==

$ open /write output output.txt

$ loop:

$ done:

$ close input

=={{header|Delphi}}==

'''- Text File I/O -'''

f : TextFile ;

s : string ;

ReadLn(F,S);

CloseFile(

This is perhaps one of the most powerful I/O functions built into Pascal. This will allow you to open and read a file of ANY type, regardless of structure, size or content. Note the usage of Reset(). This is using the optional size parameter that instructs the record size of file I/O. This could have been called with SizeOf(Buff) as the optional parameter but that would have limited flexibility. Calling it with a size of ONE byte allows you to adjust the buffer size on the fly, as conditions warrant. Also note the use of the BytesRead parameter. When included in the BlockRead() function it will return the number of bytes actually read. If this is not included, then if your directive to read n bytes is greater then the size of the file, the EOF will be encountered unexpectedly and EIOError will be raised.

f : File ;

buff : array[1.1024] of byte ;

Blockread(f,Buff,SizeOf(Buff),BytesRead);

CloseFile(f);

'''- Typed File I/O -'''

Typed file I/O is very useful when reading and writing structures. An Address List is quiet easy to write when using this type of I/O. The same file procedures are used with some subtle differences. Bite below in the blockread and blockwrite procedures that the bytes to read or write are 1. Also note that the reset procedure is not called with a buffer size. When performing '''Typed File I/O''' the size of the type definition is the buffer size. In the BlockRead() and BlockWrite() procedures I elected to read '''one record'''. Had I declared a very large buffer of type tAddressBook of say 500 records, I could have set bytes to read as SizeOf(Buffer) thereby reading a minimum of 500 records.

tAddressBook = Record

BlockWrite(f,v,1,bytes);

CloseFile(f);

=={{header|DIBOL-11}}==

START ;Simple File Input and Output

END

=={{header|E}}==

{{works with|E-on-Java}}

(This version holds the entire contents in memory.)

=={{header|Eiffel}}==

APPLICATION

output_file: PLAIN_TEXT_FILE

=={{header|Elena}}==

ELENA 4.x :

public program()

File.assign("output.txt").saveContent(text);

=={{header|Elixir}}==

Read in the whole file and write the contents to a new file.

def copy(path,new_path) do

case File.read(path) do

end

'''Built in function:'''

=={{header|Emacs Lisp}}==

(insert-file-contents "input.txt")

(buffer-string)))

(with-temp-file "output.txt"

(insert input))

=={{header|Erlang}}==

-module( file_io ).

{ok, Contents} = file:read_file( "input.txt" ),

ok = file:write_file( "output.txt", Contents ).

=={{header|Euphoria}}==

===Read the entire file and then write it===

{{works with|Euphoria|4.0.0}}

===Line-by-line reading and writing===

{{works with|Euphoria|any}}

object line

close(out)

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

Using an intermediate variable for the input file content is not ideomatic in functional programming. Nevertheless...

let copyFile fromTextFileName toTextFileName =

copyFile "input.txt" "output.txt"

0

=={{header|Factor}}==

Holds entire file content in memory:

A bit longer, but only holds a small amount of data in memory. If opening the file for writing fails, we want to clean up the file that's open for reading:

"input.txt" binary <file-reader> &dispose

"output.txt" binary <file-writer> stream-copy

] with-destructors

Possibly cheating:

=={{header|Forth}}==

Forth traditionally has not had any file handling capabilities, preferring instead to operate on a disk image block by block. Most modern Forth systems however run under an existing operating system and provide methods for disk access.

: copy-file ( a1 n1 a2 n2 -- )

r/o open-file throw >r

\ Invoke it like this:

Note the use of "2 pick" to get the input file handle and "3 pick" to get the output file handle. Local or global variables could have been used, but in this implementation simple stack manipulation was chosen. Also, only maxstring bytes are copied at a time, and the global "pad" memory area is used to hold the data. For faster copies, allocating a larger buffer could be advantageous.

A good practice is to ask the user the file name he wants to create like in this short example

pad swap accept pad swap ;

cr ." Enter file name : " 20 INPUT$ w/o create-file throw Value fd-out

s\" \n" fd-out write-file

close-output

=={{header|Fortran}}==

It uses the <tt>access="stream"</tt> which is defined in Fortran 2003 standard and should allow to "copy" also binary data easily.

integer, parameter :: out = 123, in = 124

end if

=={{header|FreeBASIC}}==

/'

Close #2

{{out}}

=={{header|Frink}}==

contents = read["file:input.txt"]

w = new Writer["output.txt"]

w.print[contents]

w.close[]

=={{header|Gambas}}==

Dim sOutput As String = "Hello "

Dim sInput As String = File.Load(User.Home &/ "input.txt") 'Has the word 'World!' stored

Print "'output.txt' contains - " & sOutput

Output:

<pre>

=={{header|GAP}}==

local f, g, line;

f := InputTextFile(src);

CloseStream(f);

CloseStream(g);

=={{header|GML}}==

file = file_text_open_read("input.txt");

str = "";

file = file_text_open_write("output.txt");

file_text_write_string(file,str);

=={{header|Go}}==

import (

fmt.Println(err)

}

Alternative solution is not a one-liner, but is one of "secondary interest" that copies data from one file to another without an intermediate variable.

import (

log.Fatal(err)

}

=={{header|Groovy}}==

Using File

Using Ant

Buffered

new File('input.txt').withReader( r -> w << r }

=={{header|GUISS}}==

=={{header|Haskell}}==

Note: this doesn't keep the file in memory. Buffering is provided by lazy evaluation.

=={{header|hexiscript}}==

let out openout "output.txt"

while !(catch (let c read char in))

write c out

endwhile

=={{header|HicEst}}==

Copy via system call:

Read and write line by line

OPEN(FIle=output)

DO i = 1, 1E300 ! "infinite" loop, exited on end-of-file error

WRITE(FIle=output, ERror=23) buffer ! on error branch to label 23 (not shown)

ENDDO

Read and write in 1 block

OPEN(FIle=output, SEQuential, UNFormatted, ERror=32) ! on error branch to label 32 (not shown)

ALLOCATE(c, len)

READ(FIle=input, CLoSe=1) c

=={{header|i}}==

file = load("input.txt")

open("output.txt").write(file)

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

Icon and Unicon I/O by default is line driven. This can be changed with options in open and by the use of reads() and writes().

in := open(f := "input.txt","r") | stop("Unable to open ",f)

out := open(f := "output.txt","w") | stop("Unable to open ",f)

while write(out,read(in))

=={{header|IDL}}==

openw,unit1,'output.txt,/get

openr,unit2,'input.txt',/get

writeu,unit1,buff

; that's all

=={{header|Io}}==

outf := File with("output.txt") openForUpdating

inf close

outf close

=={{header|J}}==

Or using the system library <tt>files</tt>:

Note that J will read as many characters from the file as the system reports, for the size of the file. So if the system reports that the file is empty when it is not, J will return an empty result when using this file reading mechanism. (This can happen for "files" which really represent a connection to something else. When this happens, it's usually better to dedicate a [[Execute_a_system_command#J|separate process]] to reading the file.)

Simple version; Files ''may'' be closed automatically by OS, on some systems.

public class FileIODemo {

}

}

This version closes both files after without OS intervention.

public class FileIODemo2 {

}

}

{{works with|Java|1.4}}

'''Package''' [[nio]]

import java.nio.channels.*;

}

}

This version is more in line with the other languages' implementations: it assumes simple text files, and doesn't worry too much about errors (just throws them out to the caller, the console in this case). It's shorter and simpler and shows that simple programs can be simple to write, in Java as well.

public class Test {

public static void main (String[] args) throws IOException {

bw.close();

}

{{works with|Java|7+}}

public class Copy{

public static void main(String[] args) throws Exception{

Files.copy(in, out, StandardCopyOption.REPLACE_EXISTING);

}

=={{header|JavaScript}}==

{{works with|JScript}}

var ForReading = 1, ForWriting = 2;

var f_in = fso.OpenTextFile('input.txt', ForReading);

f_in.Close();

{{works with|Node.js}}

var fs = require('fs');

require('util').pump(fs.createReadStream('input.txt', {flags:'r'}), fs.createWriteStream('output.txt', {flags:'w+'}));

=={{header|jq}}==

If the input file consists of ordinary lines of text, then the lines can be copied verbatim, one by one, as follows:

jq -M '. as $line | $line' input.txt > output.txt

Note that the variable, $line, is included in the above programs solely to satisfy the task requirements. In practice, the jq program in both cases would normally be just: `.`

=={{header|Julia}}==

Here we read the content of file1 into the variable mystring. Then we write the content of string to file2.

Note however that Julia has a `cp` function to copy the content of a file to another file.

We can also open and close the file handles manually.

outfile = open("file2", "w")

write(outfile, read(infile, String))

close(outfile)

Here is a one-liner that guarantees that the file handle is closed

even if something goes wrong during the read/write phase.

=={{header|K}}==

=={{header|Kotlin}}==

import java.io.File

val text = File("input.txt").readText()

File("output.txt").writeText(text)

=={{header|LabVIEW}}==

=={{header|Lang5}}==

: set-file '> swap open ;

: >>contents slurp puts ;

swap set-file 'fdst set fdst fout >>contents fdst close ;

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

open "input.txt" for input as #f1

close #f2

=={{header|Lingo}}==

-- Returns file as ByteArray

-- @param {string} tFile

fp.closeFile()

return true

=={{header|Lisaac}}==

+ name := FILE_IO;

};

};

=={{header|Logo}}==

{{works with|UCB Logo}}

openread :from

openwrite :to

end

=={{header|Lua}}==

inFile = io.open("input.txt", "r")

data = inFile:read("*all") -- may be abbreviated to "*a";

-- Oneliner version:

io.open("output.txt", "w"):write(io.open("input.txt", "r"):read("*a"))

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

We can edit thousands of lines. Document is a double linked list.

Module FileInputOutput {

Edit "Input.txt"

}

FileInputOutput

===Using Buffer Object===

A buffer expose real pointer (address), so here M(0) is the address of first byte, and Len(m) is the size of buffer in bytes. This buffer is not for code, but for data (no execution allowed).

Module Using_Buffer {

M=buffer("Input.txt")

}

Using_Buffer

=={{header|Maple}}==

inout:=proc(filename)

local f;

FileTools[Text][WriteFile]("output.txt",f);

end proc;

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

If[FileExistsQ["output.txt"], DeleteFile["output.txt"], Print["No output yet"] ];

=={{header|MAXScript}}==

outFile = createFile "output.txt"

while not EOF inFile do

)

close inFile

=={{header|Mercury}}==

:- interface.