File input/output: Difference between revisions

 

 

=={{header|ACL2}}==

 

(defun read-channel (channel limit state)

(mv-let (contents state)

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

 

=={{header|Ada}}==

 

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;

 

0644);

 

 

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

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

140 PRINT D$"VERIFY"I$

 

 

 

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

or

or

 

There may be other techniques too.

 

 

=={{header|Befunge}}==

{{works with|CCBI|2.1}}

 

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

It then writes the content in text mode (i.e. minus trailing spaces) to "output.txt" (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}}==

===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");

 

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

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

 

(This version holds the entire contents in memory.)

=={{header|Eiffel}}==

 

APPLICATION

 

output_file: PLAIN_TEXT_FILE

 

 

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

w/o create-file throw r>

begin

pad swap 3 pick write-file throw

repeat

 

\ Invoke it like this:

 

 

Also, abort" can be used instead of throw if desired.

 

=={{header|Fortran}}==

{{works with|Fortran|2003}}

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

integer :: err

 

open(out, file="output.txt", status="new", action="write", access="stream", iostat=err)

open(in, file="input.txt", status="old", action="read", access="stream", iostat=err)

err = 0

read(unit=in, iostat=err) c

end do

close(in)

end if

 

 

=={{header|Frink}}==

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

w = new Writer["output.txt"]

w.print[contents]

w.close[]

 

=={{header|GAP}}==

local f, g, line;

f := InputTextFile(src);

CloseStream(f);

CloseStream(g);

 

=={{header|GML}}==

file = file_text_open_read("input.txt");

str = "";

{

str += file_text_read_string(file);

{

file_text_readln(file);

}

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|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|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>:

 

 

=={{header|Java}}==

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

 

=={{header|Julia}}==

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")

close(outfile)

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

 

=={{header|K}}==

 

=={{header|LabVIEW}}==

{{VI snippet}}<br/>

[[File:LabVIEW File IO.png]]

 

=={{header|Lang5}}==

: set-file '> swap open ;

: >>contents slurp puts ;

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

 

 

 

 

 

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

outFile = createFile "output.txt"

while not EOF inFile do

)

close inFile

 

=={{header|Mercury}}==

:- interface.

 

io.stderr_stream(Stderr, !IO),

io.write_string(Stderr, io.error_message(Error), !IO),

 

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

 

{{works with|mIRC}}

.write myfilename.txt Goodbye Mike!

.echo -a Myfilename.txt contains: $read(myfilename.txt,1)

 

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

 

IMPORT IO, Rd, Wr;

Rd.Close(infile);

Wr.Close(outfile);

 

The code <code><*FATAL ANY*></code> is a pragma that tells the program to die if any exceptions (such as read/write errors) occur.

 

=={{header|NetRexx}}==

{{works with|Java|7}}

Takes advantage of some of the new path and file handling features of [[Java|Java's]] <tt>java.nio</tt> library.

options replace format comments java crossref symbols nobinary

 

 

return

 

Copying the file directly (without buffer):

 

Buffer for the entire file:

 

Line by line:

i = open("input.txt")

o = open("output.txt", fmWrite)

 

for line in i.lines:

 

i.close()

 

With a fixed sized buffer:

 

var

 

i.close()

 

Using memory mapping:

 

var

 

i.close()

 

=={{header|Objeck}}==

 

bundle Default {

}

}

 

=={{header|Object Pascal}}==

For a more object oriented style one can use a TFilestream:

 

classes;

begin

Free;

end;

 

=={{header|OCaml}}==

By line:

let ic = open_in "input.txt" in

let oc = open_out "output.txt" in

close_in ic;

close_out oc;

 

By character:

let ic = open_in "input.txt" in

let oc = open_out "output.txt" in

close_in ic;

close_out oc;

 

(Notice that ic and oc, of type ''in_channel'' and ''out_channel'', are buffered)

 

=={{header|Octave}}==

in = fopen("input.txt", "r", "native");

out = fopen("output.txt", "w","native");

fclose(out);

end

 

=={{header|OpenEdge/Progress}}==

 

=={{header|Oz}}==

class TextFile from Open.file Open.text end

 

{CopyAll In Out}

{Out close}

 

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

 

=={{header|Pascal}}==

 

{{works with|Perl|5.8.8}}

 

open my $fh_in, '<', 'input.txt' or die "could not open <input.txt> for reading: $!";

 

close $fh_in;

 

Perl has also a powerful mechanism in conjunction with opening files called IO disciplines. It allows you to automatically apply chainable transformations on the input and output. Mangling newlines, gzip (de)compression and character encoding are the most used examples.

 

 

 

 

 

=={{header|PHP}}==

 

{{works with|PHP|4}}

 

if (!$in = fopen('input.txt', 'r')) {

fclose($out);

fclose($in);

{{works with|PHP|5}}

if ($contents = file_get_contents('input.txt')) {

if (!file_put_contents('output.txt', $contents)) {

echo('Could not open input file.');

}

 

=={{header|PicoLisp}}==

===Using a variable===

===Skipping intermediate variable===

(out "output.txt"

 

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

declare in file, out file;

 

put file (out) edit (line) (A);

end;

 

=={{header|Pop11}}==

Char by char copy:

 

lvars o_stream = discout('output.txt');

lvars c;

while (i_stream() ->> c) /= termin do

o_stream(c);

 

Low level block copy:

 

lvars o_file = syscreate('output.txt', 1, true);

lvars buff = inits(4096);

while (sysread(i_file, buff, length(buff)) ->> i) > 0 do

syswrite(o_file, buff, i);

 

=={{header|PowerShell}}==

Read the input file then pipe it's contents to output file.

Assumes that the files are in the same folder that the script is executing in.

 

Using an alternate cmdlet to write the file

 

=={{header|Python}}==

The following use of the standard libraries shutil.copyfile is to be preferred. (Current source code ensures that failure to open files raises appropriate exceptions, a restricted buffer is used to copy the files using binary mode, and any used file descriptors are always closed).

 

 

However the following example shows how one would do file I/O of other sorts:

 

outfile = open('output.txt', 'w')

for line in infile:

outfile.write(line)

outfile.close()

 

This does no error checking. A more robust program would wrap each open with exception handling blocks:

 

try:

infile = open('input.txt', 'r')

finally:

infile.close()

 

In Python 2.6 (or 2.5 if we use ''from __future__ import with_statement'') we can more simply write:

 

try:

with open('input.txt') as infile:

except IOError:

print >> sys.stderr, "Some I/O Error occurred"

 

The files will automatically be closed on exit of their ''with:'' blocks. (Thus even if an I/O error occurred while reading the middle of the input file we are assured that the ''.close()'' method will have been called on each of the two files.

 

=={{header|R}}==

If files are textual we can use <tt>readLines</tt> ("-1" means "read until the end")

 

dest <- file("output.txt", "w")

 

fc <- readLines(src, -1)

writeLines(fc, dest)

 

If the files are not textual but "generic":

 

dest <- file("output.txt", "wb")

 

writeBin(v, dest)

}

 

Another simpler way is to use <tt>file.copy</tt>

 

 

=={{header|Racket}}==

(define file-content

(with-input-from-file "input.txt"

(with-output-to-file "output.txt"

(lambda ()

 

 

 

 

 

 

=={{header|Raven}}==

 

=={{header|REBOL}}==

 

; No line translations:

; Save a web page:

write/binary %output.html read http://rosettacode.org

 

=={{header|Retro}}==

 

=={{header|REXX}}==

 

===version 1===

 

===version 2===

Note that this version is limited to files less than one million bytes (and/or possibly virtual memory).

* 03.09.2012 Walter Pachl (without erase string would be appended)

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

'erase' ofid /* avoid appending */

s=charin(ifid,,1000000) /* read the input file */

 

=={{header|Ruby}}==

In general, open both files in binary mode.

 

 

If 'input.txt' is a text file, we may forget binary mode. If no pathname begins with a pipe '|', then we may use ''IO::read'' and ''Kernel#open''. (The pipe is a problem, because <code>IO.read('| uname')</code> or <code>open('| sh', 'w')</code> would open a subprocess and not a file.)

 

# Only if pipe '|' is not first character of path!

str = IO.read('input.txt')

 

To copy a file block by block, use FileUtils from the standard library.

 

 

fileLen = LOF(#in) 'Length Of File

fileData$ = input$(#in, fileLen) 'read entire file

close #out

end

open "output.txt" for output as #out

fileLen = LOF(#in) 'Length Of File

close #in

close #out

 

=={{header|Rust}}==

 

fn main() {

 

}

 

 

=={{header|Scala}}==

{{libheader|Scala}}

 

object FileIO extends App {

}

}

 

=={{header|Scheme}}==

(define in-file (open-input-file "input.txt"))

(define out-file (open-output-file "output.txt"))

(close-input-port in-file)

(close-output-port out-file)

 

=={{header|Seed7}}==

can be used to copy a source file to a destination.

 

include "osfiles.s7i";

 

begin

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

 

=={{header|Slate}}==

(File newNamed: 'output.txt' &mode: File CreateWrite) sessionDo: [| :out |

 

=={{header|Smalltalk}}==

in := FileStream open: 'input.txt' mode: FileStream read.

out := FileStream open: 'output.txt' mode: FileStream write.

whileFalse: [

out nextPut: (in next)

 

=={{header|SNOBOL4}}==

input(.input,5,,'input.txt')

output(.output,6,,'output.txt')

while output = input :s(while)

 

 

=={{header|Standard ML}}==

{{works with|SML/NJ|110.59}}

let

val instream = TextIO.openIn from

in

true

 

=={{header|Tcl}}==

{{works with|tixwish}}

{{works with|tclkit}}

set out [open "output.txt" w]

# Obviously, arbitrary transformations could be added to the data at this point

puts -nonewline $out [read $in]

close $in

For larger files, it is better to use the <tt>fcopy</tt> command, though in general this restricts what operations can be performed rather more (only encoding and end-of-line translations are possible — or more general byte-level transformations with the generic filter mechanism provided in Tcl 8.6 — none of which are shown here):

set out [open "output.txt" w]

fcopy $in $out

close $in

Or the minimal version if we don't need any processing of the data at all:

===Other key file I/O operations===

;Writing a line to a file<nowiki>:</nowiki>

set myfile [open "README.TXT" w]

#write something to the file

puts $myfile "This is line 1, so hello world...."

#close the file

;Reading a line from a file<nowiki>:</nowiki>

set myfile [open "README.TXT" r]

#read something from the file

puts $mydata

#close the file

 

=={{header|Toka}}==

This is one method, which works with any type of file:

 

{

value| source dest size buffer |

[ source file.close dest file.close ] is close-files

[ prepare [ read-source write-dest close-files ] ifTrue ]

 

And a much simpler way for plain text files, making use of file.slurp:

 

swap file.slurp dup 0 <>

[ >r "W" file.open dup r> string.getLength file.write drop file.close ] ifTrue

 

And a test:

 

 

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

* Caveat: output.txt will end with a newline, whether or not input.txt ended with one.

 

while IFS= read -r a; do

printf '%s\n' "$a"

 

Another way, using the 'cat' program

 

 

Yet another way, using the 'cp' utility

 

=={{header|Ursala}}==

Returning a copy of the input file with a new name causes it to be

written as a new file.

 

#executable ('parameterized','')

 

 

 

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

An edit buffer is normally used as "string variable" in Vedit.

To read a file into edit buffer, simply open the file. The file contents can then be modified if required before saving into a new file.

File_Save_As("output.txt", NOMSG)

 

=={{header|Wart}}==

with outfile "output.txt"

whilet line (read_line)

 

=={{header|XPL0}}==

Usage: fileio <input.txt >output.txt

 

int I, C;

char IntermediateVariable;

ChOut(0, C);

until C = $1A; \EOF

 

=={{header|zkl}}==

 

 

{{omit from|HTML}}

{{omit from|Order}}