Copy stdin to stdout

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.

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. <lang AWK>awk "//"</lang>

C

include <stdio.h>

int main(){

 char c;
 while ( (c=getchar()) != EOF ){
   putchar(c);
 }
 return 0;

} </lang>

C++

<lang cpp>#include <iostream>

include <iterator>

int main() {

   using namespace std;
   noskipws(cin);
   copy(
       istream_iterator<char>(cin),
       istream_iterator<char>(),
       ostream_iterator<char>(cout)
   );
   return 0;

}</lang>

Shorter and quicker alternative: <lang cpp>#include <iostream>

int main() {

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

}</lang>

D

<lang d>import std.stdio;

void main() {

   foreach (line; stdin.byLine) {
       writeln(line);
   }

}</lang>

Delphi

→ See Pascal

F#

<lang fsharp> let copy()=let n,g=stdin,stdout

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

copy() </lang>

Factor

<lang factor>USING: io kernel ;

[ read1 dup ] [ write1 ] while drop</lang>

Forth

Works with: gforth version 0.7.3

<lang forth>stdin slurp-fid type bye</lang>

Frink

The special string "-" indicates reading from stdin. <lang frink>print[read["-"]]</lang>

Go

<lang go>package main

import (

   "bufio"
   "io"
   "os"

)

func main() {

   r := bufio.NewReader(os.Stdin)
   w := bufio.NewWriter(os.Stdout)
   for {
       b, err := r.ReadByte()       
       if err == io.EOF {
           return
       }
       w.WriteByte(b)
       w.Flush()
   }

}</lang>

Haskell

<lang Haskell>main = interact id </lang>

Java

Copies until no more input. <lang java> import java.util.Scanner;

public class CopyStdinToStdout {

   public static void main(String[] args) {
       try (Scanner scanner = new Scanner(System.in);) {
           String s;
           while ( (s = scanner.nextLine()).compareTo("") != 0 ) {
               System.out.println(s);
           }
       }
   }

} </lang>

Output:

Output interleaved. Stdin and Stdout are same window.

Line 1.
Line 1.
Line 2.
Line 2.

Julia

<lang Julia>while !eof(stdin)

   write(stdout, read(stdin, UInt8))

end</lang>

Kotlin

<lang scala>fun main() {

   var c: Int
   do {
       c = System.`in`.read()
       System.out.write(c)
   } while (c >= 0)

}</lang>

Latitude

<lang latitude>while { $stdin eof? not. } do {

 $stdout putln: $stdin readln.

}.</lang>

Lua

lua -e 'for x in io.lines() do print(x) end'

Mercury

- module stdin_to_stdout.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

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

- implementation.

- import_module char.

- import_module list.

- import_module string.

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

main(!IO) :-

   io.read_line_as_string(Result, !IO),
   (
       Result = ok(Line),
       io.write_string(Line, !IO),
       main(!IO)
   ;
       Result = eof
   ;
       Result = error(Error),
       io.error_message(Error, Message),
       io.input_stream_name(StreamName, !IO),
       io.progname("stdin_to_stdout", ProgName, !IO),
       io.write_strings([
           ProgName, ": ",
           "error reading from `", StreamName, "': \n\t",
           Message, "\n"
       ], !IO)
   ).

%-----------------------------------------------------------------------------% </lang>

Nim

<lang nim>stdout.write readAll(stdin)</lang>

OCaml

<lang ocaml>try

 while true do
   output_char stdout (input_char stdin)
 done

with End_of_file -> ()</lang>

Pascal

<lang pascal>program writeInput(input, output); var buffer: char; begin while not EOF() do begin read(buffer); // shorthand for read(input, buffer) write(buffer); // shorthand for write(output, buffer) end; end.</lang>

Perl

Phix

<lang Phix>while true do

   integer ch = wait_key()
   if ch=#1B then exit end if
   puts(1,ch)

end while</lang>

PicoLisp

Prolog

<lang Prolog> %File: stdin_to_stdout.pl

- initialization(main).

main :- repeat, get_char(X), put_char(X), X == end_of_file, fail. </lang>

Invocation at the command line (with Swi-prolog): <lang sh> swipl stdin_to_stdout.pl </lang>

Python

python -c 'import sys; sys.stdout.write(sys.stdin.read())'

R

Rscript -e 'cat(readLines(file("stdin")))'

Racket

<lang racket>#lang racket

(let loop ()

 (match (read-char)
   [(? eof-object?) (void)]
   [c (display c)
      (loop)]))</lang>

Raku

(formerly Perl 6) 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.

<lang perl6>raku -pe'.lines'</lang>

When invoked from a file: Lines are auto-chomped, so need to re-add newlines (hence .say rather than .print) <lang perl6>.say for lines</lang>

REXX

In the REXX language, the STDIN (default input stream) is normally the console, and the STDOUT (default output stream) is normally the console. So for REXX, this task equates to copying data from the console to itself. <lang rexx>/*REXX pgm copies data from STDIN──►STDOUT (default input stream──►default output stream*/

 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   "    */
 end   /*while*/                                /*stick a fork in it,  we're all done. */</lang>

Ring

<lang ring> ? "give input: " give str ? "output: " + str </lang>

Output:

give input:
Ring Programming Language
output: Ring Programming Language

Rust

<lang Rust>use std::io;

fn main() {

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

}</lang>

Scheme

<lang scheme> (do ((c (read-char) (read-char)))

   ((eof-object? c) 'done)
 (display c))

</lang>

sed

Seed7

<lang seed7>$ include "seed7_05.s7i";

 include "fileutil.s7i";

const proc: main is func

 begin
   copyFile(IN, OUT);
 end func;</lang>

Smalltalk

Works with: Smalltalk/X

<lang smalltalk>"using Stream class's bulk copy method:" Stdin copyToEndInto:Stdout.

"line wise" [Stdin atEnd] whileFalse:[ Stdout nextPutLine:(Stdin nextLine) ].

"character wise" [Stdin atEnd] whileFalse:[ Stdout nextPut:(Stdin next) ].

"no EOF test, but handle EOF Exception" [

   [ Stdout nextPut:(Stdin next) ] loop.

] on: StreamError do:[]</lang>

Symsyn

<lang Symsyn> Loop [] []

    go Loop

</lang>

Wren

In the following script, stdin and stdout are both assumed to be connected to a terminal.

Bytes are read from stdin and written to stdout until the return key is pressed. <lang ecmascript>import "io" for Stdin, Stdout

Stdin.isRaw = true // prevents echoing to the terminal while (true) {

   var byte = Stdin.readByte()         // read a byte from stdin
   if (byte == 13) break               // break when enter key pressed
   System.write(String.fromByte(byte)) // write the byte (in string form) to stdout
   Stdout.flush()                      // flush output

} System.print() Stdin.isRaw = false</lang>

zkl

<lang zkl>zkl --eval "File.stdout.write(File.stdin.read())"</lang>