Copy stdin to stdout: Difference between revisions

 

Create an executable file that copies stdin to stdout, or else a script that does so through the invocation of an interpreter at the command line.

 

=={{header|Ada}}==

 

 

procedure Copy_Stdin_To_Stdout is

Put (C);

end loop;

 

=={{header|Aime}}==

data b;

f.stdin;

while (f.b_line(b) ^ -1) {

o_(b, "\n");

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

BOOL at eof := FALSE;

# set the EOF handler for stand in to a procedure that sets "at eof" to true #

# copy stand in to stand out #

WHILE STRING line; read( ( line, newline ) ); NOT at eof DO write( ( line, newline ) ) OD

 

=={{header|AWK}}==

Using the awk interpreter, the following command uses the pattern // (which matches anything) with the default action (which is to print the current line) and so copy lines from stdin to stdut.

 

=={{header|C}}==

#include <stdio.h>

 

return 0;

}

 

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

#include <iterator>

 

);

return 0;

 

Shorter and quicker alternative:

 

int main() {

std::cout << std::cin.rdbuf();

 

=={{header|D}}==

 

void main() {

writeln(line);

}

 

=={{header|Delphi}}==

''→ See [[#Pascal|Pascal]]''

 

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

let copy()=let n,g=stdin,stdout

let rec fN()=match n.ReadLine() with "EOF"->g.Write "" |i->g.WriteLine i; fN()

fN()

copy()

 

=={{header|Factor}}==

 

 

=={{header|Forth}}==

{{works with|gforth|0.7.3}}

 

=={{header|Frink}}==

 

=={{header|Go}}==

 

import (

w.Flush()

}

 

=={{header|Haskell}}==

 

=={{header|Java}}==

Copies until no more input.

import java.util.Scanner;

 

 

}

{{out}}

Output interleaved. Stdin and Stdout are same window.

 

</pre>

 

=={{header|Julia}}==

write(stdout, read(stdin, UInt8))

 

=={{header|Kotlin}}==

var c: Int

do {

System.out.write(c)

} while (c >= 0)

 

=={{header|Latitude}}==

$stdout putln: $stdin readln.

 

=={{header|Lua}}==

 

=={{header|Mercury}}==

 

:- module stdin_to_stdout.

 

%-----------------------------------------------------------------------------%

 

=={{header|Nim}}==

 

 

=={{header|OCaml}}==

 

while true do

output_char stdout (input_char stdin)

done

 

=={{header|Pascal}}==

var

buffer: char;

write(buffer); // shorthand for write(output, buffer)

end;

 

=={{header|Perl}}==

perl -pe ''

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

 

=={{header|Prolog}}==

%File: stdin_to_stdout.pl

:- initialization(main).

X == end_of_file,

fail.

 

Invocation at the command line (with Swi-prolog):

swipl stdin_to_stdout.pl

 

=={{header|Python}}==

 

=={{header|Racket}}==

 

(let loop ()

[(? eof-object?) (void)]

[c (display c)

 

=={{header|Raku}}==

When invoked at a command line: Slightly less magical than Perl / sed. The p flag means automatically print each line of output to STDOUT. The e flag means execute what follows inside quotes. ".lines" reads lines from the assigned pipe (file handle), STDIN by default.

 

 

When invoked from a file: Lines are auto-chomped, so need to re-add newlines (hence .say rather than .print)

 

=={{header|REXX}}==

normally the console. &nbsp; So for REXX, this task equates to copying data

from the console to itself.

 

do while chars()\==0 /*repeat loop until no more characters.*/

call charin , x /*read a char from the input stream. */

call charout , x /*write " " " " output " */

 

=={{header|Ring}}==

? "give input: " give str

? "output: " + str

{{out}}

<pre>

</pre>

 

=={{header|Rust}}==

 

fn main() {

io::copy(&mut io::stdin().lock(), &mut io::stdout().lock());

 

=={{header|Scheme}}==

 

(do ((c (read-char) (read-char)))

((eof-object? c) 'done)

(display c))

 

=={{header|sed}}==

 

sed -e ''

 

=={{header|Seed7}}==

 

include "fileutil.s7i";

 

begin

copyFile(IN, OUT);

 

=={{header|Symsyn}}==

Loop [] []

go Loop

 

=={{header|Wren}}==

 

Bytes are read from stdin and written to stdout until the return key is pressed.

 

Stdin.isRaw = true // prevents echoing to the terminal

}

System.print()

 

=={{header|zkl}}==