Copy stdin to stdout: Difference between revisions
→{{header|Binary Lambda Calculus}}
Not a robot (talk | contribs) (Add BCPL) |
|||
(22 intermediate revisions by 17 users not shown) | |||
Line 5:
=={{header|8086 Assembly}}==
<
WRITE: equ 40h
BUFSZ: equ 4000h ; Buffer size
Line 26:
done: ret
section .bss
buffer: resb BUFSZ</
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
CHAR c
DO
c=GetD(7)
Put(c)
UNTIL c=27 ;repeat until Esc key is pressed
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Copy_stdin_to_stdout.png Screenshot from Atari 8-bit computer]
<pre>
COPY STDIN TO STDOUT
</pre>
=={{header|Ada}}==
<
procedure Copy_Stdin_To_Stdout is
Line 40 ⟶ 56:
Put (C);
end loop;
end Copy_Stdin_To_Stdout;</
=={{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 #
Line 59 ⟶ 75:
# copy stand in to stand out #
WHILE STRING line; read( ( line, newline ) ); NOT at eof DO write( ( line, newline ) ) OD
END</
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic">0 GET C$ : PRINT C$; : GOTO</syntaxhighlight>
=={{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
Line 72 ⟶ 90:
if c = endstreamch then finish
wrch(c)
$) repeat</
=={{header|Brainf***}}==
<syntaxhighlight lang="brainf***">,[.,]</syntaxhighlight>
=={{header|Binary Lambda Calculus}}==
As explained on https://www.ioccc.org/2012/tromp/hint.html, `cat' is the 4-bit program
<pre>0010</pre>
in bit-wise BLC, or any one of the 16 characters in the ASCII range from space to slash
<pre> !"#$%&'()*+,-./</pre>
in byte-wise BLC.
=={{header|C}}==
<syntaxhighlight lang="c">
#include <stdio.h>
Line 85 ⟶ 118:
return 0;
}
</syntaxhighlight>
=={{header|C sharp|C#}}==
{{works with|.NET Framework|4.0 or later}}
<syntaxhighlight lang="csharp">
using System;
class Program
{
static void Main(string[] args)
{
Console.OpenStandardInput().CopyTo(Console.OpenStandardOutput());
}
}
</syntaxhighlight>
=={{header|C++}}==
<
#include <iterator>
Line 100 ⟶ 147:
);
return 0;
}</
Shorter and quicker alternative:
<
int main() {
std::cout << std::cin.rdbuf();
}</
=={{header|CLU}}==
<syntaxhighlight lang="clu">start_up = proc ()
pi: stream := stream$primary_input()
po: stream := stream$primary_output()
while true do
stream$putc(po, stream$getc(pi))
end except when end_of_file:
return
end
end start_up</syntaxhighlight>
=={{header|Commodore BASIC}}==
Line 146 ⟶ 205:
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"
Line 160 ⟶ 219:
50 if (d1=0 and a$=chr$(26)) or (d1>0 and st>0) then close 5:close 2:end
60 print#2,a$;
70 goto 40</
{{output}}
Line 215 ⟶ 274:
█
</pre>
=={{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)))
</syntaxhighlight>
=={{header|Crystal}}==
<
puts line
end</
=={{header|D}}==
<
void main() {
Line 237 ⟶ 295:
writeln(line);
}
}</
=={{header|Dart}}==
<syntaxhighlight lang="dart">import 'dart:io';
void main() {
var line = stdin.readLineSync();
stdout.write(line);
}</syntaxhighlight>
=={{header|Delphi}}==
''→ See [[#Pascal|Pascal]]''
=={{header|Draco}}==
<syntaxhighlight lang="draco">\util.g
proc nonrec main() void:
char c;
while
/* I/O is line-oriented, so first read characters
* from the current line while that is possible */
while read(c) do write(c) od;
case ioerror()
/* Then once it fails, if the line is empty,
* try to go to the next line. */
incase CH_MISSING:
readln();
writeln();
true
/* If it failed for another reason (which will be
* EOF here), stop. */
default:
false
esac
do od
corp</syntaxhighlight>
=={{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()
</syntaxhighlight>
=={{header|Factor}}==
<
[ read1 dup ] [ write1 ] while drop</
=={{header|Forth}}==
{{works with|gforth|0.7.3}}
<syntaxhighlight lang
=={{header|FreeBASIC}}==
<
#include "crt/stdio.bi" 'provides the C functions getchar and putchar
dim as ubyte char
Line 266 ⟶ 356:
char = getchar()
if char = FIN then exit do else putchar(char)
loop</
=={{header|Frink}}==
The special string "-" indicates reading from stdin.
<
=={{header|Go}}==
<
import (
Line 292 ⟶ 382:
w.Flush()
}
}</
===io.Copy===
<syntaxhighlight lang="go">
package main
import (
"io"
"os"
)
func main() {
io.Copy(os.Stdout, os.Stdin)
}
</syntaxhighlight>
=={{header|Groovy}}==
<syntaxhighlight lang="groovy">class StdInToStdOut {
static void main(args) {
try (def reader = System.in.newReader()) {
def line
while ((line = reader.readLine()) != null) {
println line
}
}
}
}</syntaxhighlight>
=={{header|Haskell}}==
<
=={{header|Java}}==
Copies until no more input.
<
import java.util.Scanner;
Line 314 ⟶ 430:
}
</syntaxhighlight>
{{out}}
Output interleaved. Stdin and Stdout are same window.
Line 323 ⟶ 439:
Line 2.
</pre>
=={{header|JavaScript}}==
JavaScript in the browser does not have a stdin or stdout, but using Node.js we have:
<syntaxhighlight lang="javascript">process.stdin.resume();
process.stdin.pipe(process.stdout);</syntaxhighlight>
<syntaxhighlight lang="bash">node index.js < index.js</syntaxhighlight>
{{out}}
<pre>
process.stdin.resume();
process.stdin.pipe(process.stdout);
</pre>
=={{header|jq}}==
<syntaxhighlight lang
=={{header|Julia}}==
<
write(stdout, read(stdin, UInt8))
end</
=={{header|Kotlin}}==
<
var c: Int
do {
Line 340 ⟶ 468:
System.out.write(c)
} while (c >= 0)
}</
=={{header|Latitude}}==
<
$stdout putln: $stdin readln.
}.</
=={{header|Lua}}==
Line 351 ⟶ 479:
=={{header|Mercury}}==
<syntaxhighlight lang="mercury">
:- module stdin_to_stdout.
Line 394 ⟶ 522:
%-----------------------------------------------------------------------------%
</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang
=={{header|OCaml}}==
<
while true do
output_char stdout (input_char stdin)
done
with End_of_file -> ()</
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(bytestream->port (port->bytestream stdin) stdout)
</syntaxhighlight>
=={{header|Pascal}}==
<
var
buffer: char;
Line 418 ⟶ 551:
write(buffer); // shorthand for write(output, buffer)
end;
end.</
=={{header|Perl}}==
<
perl -pe ''
</syntaxhighlight>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<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: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">wait_key</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #000000;">#1B</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</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>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
<syntaxhighlight lang
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
%File: stdin_to_stdout.pl
:- initialization(main).
Line 445 ⟶ 581:
X == end_of_file,
fail.
</syntaxhighlight>
Invocation at the command line (with Swi-prolog):
<syntaxhighlight lang="sh">
swipl stdin_to_stdout.pl
</syntaxhighlight>
=={{header|Python}}==
Line 459 ⟶ 595:
=={{header|Racket}}==
<
(let loop ()
Line 465 ⟶ 601:
[(? eof-object?) (void)]
[c (display c)
(loop)]))</
=={{header|Raku}}==
Line 471 ⟶ 607:
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.
<syntaxhighlight lang="raku"
When invoked from a file: Lines are auto-chomped, so need to re-add newlines (hence .say rather than .print)
<syntaxhighlight lang="raku"
=={{header|REXX}}==
Line 482 ⟶ 618:
normally the console. 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 " */
end /*while*/ /*stick a fork in it, we're all done. */</
=={{header|Ring}}==
<
? "give input: " give str
? "output: " + str
</syntaxhighlight>
{{out}}
<pre>
Line 501 ⟶ 637:
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">
$stdout << $stdin.gets
</syntaxhighlight>
=={{header|Rust}}==
<
fn main() {
io::copy(&mut io::stdin().lock(), &mut io::stdout().lock());
}</
=={{header|Scala}}==
Line 512 ⟶ 652:
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))
</syntaxhighlight>
=={{header|sed}}==
<syntaxhighlight lang="sh">
sed -e ''
</syntaxhighlight>
=={{header|Seed7}}==
<
include "fileutil.s7i";
Line 542 ⟶ 682:
begin
copyFile(IN, OUT);
end func;</
=={{header|Smalltalk}}==
{{Works with|Smalltalk/X}}
<
Stdin copyToEndInto:Stdout.
Line 558 ⟶ 698:
[
[ Stdout nextPut:(Stdin next) ] loop.
] on: StreamError do:[]</
=={{header|Standard ML}}==
<
case TextIO.input TextIO.stdIn of
"" => ()
| tx => copyLoop (TextIO.output (TextIO.stdOut, tx))
val () = copyLoop ()</
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
Loop [] []
go Loop
</syntaxhighlight>
=={{header|Tcl}}==
<
chan copy stdin stdout
# fcopy stdin stdout for older versions</
=={{header|VBScript}}==
VBScript can't get single chars from stdin, so we have to implement it line to line. Ctrl-Z+Enter stops.
<syntaxhighlight lang="vb">
do
s=wscript.stdin.readline
wscript.stdout.writeline s
loop until asc(left(s,1))=26
</syntaxhighlight>
=={{header|Wren}}==
Line 584 ⟶ 733:
Bytes are read from stdin and written to stdout until the return key is pressed.
<
Stdin.isRaw = true // prevents echoing to the terminal
Line 594 ⟶ 743:
}
System.print()
Stdin.isRaw = false</
=={{header|XPL0}}==
Device 1 is stdin without echoing a character to the screen. Device 0 (or 1) is
stdout, which displays the character on the monitor. This program can
list a file to the screen like this: stdio <file.txt
<syntaxhighlight lang="xpl0">int C;
loop [C:= ChIn(1);
if C = $1A \EOF\ then quit;
ChOut(0, C);
]</syntaxhighlight>
=={{header|zkl}}==
<
|