Copy stdin to stdout: Difference between revisions

=={{header|8086 Assembly}}==

 

WRITE: equ 40h

BUFSZ: equ 4000h ; Buffer size

done: ret

section .bss

 

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

CHAR c

 

UNTIL c=27 ;repeat until Esc key is pressed

OD

{{out}}

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

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

 

let start() be

if c = endstreamch then finish

wrch(c)

 

=={{header|Brainf***}}==

 

=={{header|C}}==

#include <stdio.h>

 

return 0;

}

 

{{works with|.NET Framework|4.0 or later}}

using System;

 

}

}

 

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

#include <iterator>

 

);

return 0;

 

Shorter and quicker alternative:

 

int main() {

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

 

=={{header|CLU}}==

pi: stream := stream$primary_input()

po: stream := stream$primary_output()

return

end

 

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

The following program opens channels to devices chosen by the user, then uses the GET# and PRINT# I/O statements instead of the standard GET and PRINT (for typical keyboard/screen interaction.) When keyboard and/or screen are chosen, BASIC ignores the extra filename and file type parameters normally used for other devices. Peripheral devices (tape, disk drive) use STATUS register to flag end of file, however the keyboard does not. When using the keyboard, the program terminates on a CTRL-Z.

 

11 print "0:Keyboard 1:Tape 2:RS-232 3:Screen"

12 print "4-7:printers/plotters"

50 if (d1=0 and a$=chr$(26)) or (d1>0 and st>0) then close 5:close 2:end

60 print#2,a$;

 

{{output}}

 

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

Then concatenates the characters into a string|#

(format t

(concatenate 'string

(loop for x = (read-char *query-io*) until (or (char= x #\Sub) (char= x #\Eot)) collecting x)))

 

=={{header|Crystal}}==

puts line

 

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

#include "crt/stdio.bi" 'provides the C functions getchar and putchar

dim as ubyte char

char = getchar()

if char = FIN then exit do else putchar(char)

 

=={{header|Frink}}==

The special string "-" indicates reading from stdin.

 

=={{header|Go}}==

 

import (

w.Flush()

}

 

=={{header|Groovy}}==

static void main(args) {

try (def reader = System.in.newReader()) {

}

}

 

=={{header|Haskell}}==

 

=={{header|Java}}==

Copies until no more input.

import java.util.Scanner;

 

 

}

{{out}}

Output interleaved. Stdin and Stdout are same window.

Line 2.

 

</pre>

 

=={{header|jq}}==

 

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

(bytestream->port (port->bytestream stdin) stdout)

 

=={{header|Pascal}}==

var

buffer: char;

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

end;

 

=={{header|Perl}}==

perl -pe ''

 

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span>

<span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

 

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

For Scala 2's compiler <code>scalac</code>, a containing object is required:

 

io.Source.fromInputStream(System.in).getLines().foreach(println)

 

If it's being run directly by <code>scala</code>, it can be shortened to one line, and run directly in the shell:

 

 

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

{{Works with|Smalltalk/X}}

Stdin copyToEndInto:Stdout.

 

[

[ Stdout nextPut:(Stdin next) ] loop.

 

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

case TextIO.input TextIO.stdIn of

"" => ()

| tx => copyLoop (TextIO.output (TextIO.stdOut, tx))

 

 

=={{header|Symsyn}}==

Loop [] []

go Loop

 

=={{header|Tcl}}==

 

chan copy stdin stdout

 

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