Check input device is a terminal: Difference between revisions
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes)) |
||
Line 1:
[[Category:Hardware]]▼
[[Category:Initialization]]▼
{{task}}
Line 8 ⟶ 11:
* [[Check output device is a terminal]]
<br><br>
=={{header|Ada}}==
{{works with|GNAT}}
We use the interface to C library functions <code>isatty()</code> and <code>fileno()</code>.
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Interfaces.C_Streams; use Interfaces.C_Streams;
Line 33 ⟶ 35:
stdin is not a tty.
</pre>
=={{header|BaCon}}==
<syntaxhighlight lang="freebasic">terminal = isatty(0)
PRINT terminal</syntaxhighlight>
Line 48 ⟶ 49:
prompt$ ./istty <<<"testing"
0</pre>
=={{header|C}}==
Use <code>isatty()</code> on file descriptor to determine if it's a TTY. To get the file descriptor from a <code>FILE*</code> pointer, use <code>fileno</code>:
<syntaxhighlight lang="c">#include <unistd.h> //for isatty()
#include <stdio.h> //for fileno()
Line 70:
stdin is not tty
</pre>
=={{header|COBOL}}==
Works with GnuCOBOL.
<syntaxhighlight lang="cobol"> *>
*> istty, check id fd 0 is a tty
*> Tectonics: cobc -xj istty.cob
Line 121 ⟶ 120:
fd 0 tty: +0000000000
fd 2 tty: +0000000000</pre>
=={{header|Common Lisp}}==
{{Works with|SBCL}}
<syntaxhighlight lang="lisp">(with-open-stream (s *standard-input*)
(format T "stdin is~:[ not~;~] a terminal~%"
(interactive-stream-p s)))</syntaxhighlight>
Line 135 ⟶ 133:
$ echo "" | sbcl --script rc.lisp
stdin is not a terminal</pre>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">File.new("testfile").tty? #=> false
File.new("/dev/tty").tty? #=> true
STDIN.tty? #=> true</syntaxhighlight>
=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio;
extern(C) int isatty(int);
Line 157 ⟶ 153:
C:\test < in.txt
Input doesn't come from tty.</pre>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
Open Cons For Input As #1
' Open Cons abre los flujos de entrada (stdin) o salida (stdout) estándar
Line 173 ⟶ 167:
Sleep
</syntaxhighlight>
=={{header|Go}}==
{{libheader|Go sub-repositories}}
<syntaxhighlight lang="go">package main
import (
Line 199 ⟶ 191:
Who are you? You're not a terminal.
</pre>
=={{header|Haskell}}==
Example uses [https://hackage.haskell.org/package/unix <tt>unix</tt>] package:
<syntaxhighlight lang="haskell">module Main (main) where
import System.Posix.IO (stdInput)
Line 215 ⟶ 206:
then "stdin is TTY"
else "stdin is not TTY"</syntaxhighlight>
=={{header|Jsish}}==
<syntaxhighlight lang="javascript">/* Check input device is a terminal, in Jsish */
;Interp.conf().subOpts.istty;
Line 234 ⟶ 224:
prompt$ jsish --U checkInputDevice.jsi
Interp.conf().subOpts.istty ==> false</pre>
=={{header|Julia}}==
<syntaxhighlight lang=
if isa(STDIN, Base.TTY)
println("This program sees STDIN as a TTY.")
Line 248 ⟶ 237:
This program sees STDIN as a TTY.
</pre>
=={{header|Kotlin}}==
{{Works with|Ubuntu|14.04}}
<syntaxhighlight lang="scala">// Kotlin Native version 0.5
import platform.posix.*
Line 267 ⟶ 255:
stdin is a terminal
</pre>
=={{header|Nemerle}}==
There is no explicit way (ie <tt>isatty()</tt>)to do this; however, if we ''assume'' that standard input ''is'' a terminal, we can check if the input stream has been redirected (presumably to something other than a terminal).
<syntaxhighlight lang=
=={{header|Nim}}==
Using function "isatty" of standard module "terminal" which accepts a File as argument.
<syntaxhighlight lang=
echo if stdin.isatty: "stdin is a terminal" else: "stdin is not a terminal"</syntaxhighlight>
Line 285 ⟶ 271:
<pre>Command: ./check_input_dev <somefile
Result: stdin is not a terminal</pre>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let () =
print_endline (
if Unix.isatty Unix.stdin
Line 302 ⟶ 287:
Input doesn't come from tty.
</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (isatty? fd) (syscall 16 fd 19))
(print (if (isatty? stdin)
Line 310 ⟶ 294:
"Input doesn't come from tty."))
</syntaxhighlight>
=={{header|Perl}}==
<syntaxhighlight lang="perl">use strict;
use warnings;
use 5.010;
Line 326 ⟶ 309:
$ true | perl istty.pl
Input doesn't come from tty.
=={{header|Phix}}==
<!--<syntaxhighlight lang=
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no input redirection in a browser!)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"stdin:%t, stdout:%t, stderr:%t\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">isatty</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">),</span><span style="color: #000000;">isatty</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span><span style="color: #000000;">isatty</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)})</span>
Line 339 ⟶ 321:
stdin:false, stdout:true, stderr:true
</pre>
=={{header|Pike}}==
<syntaxhighlight lang="pike">void main()
{
if(Stdio.Terminfo.is_tty())
Line 354 ⟶ 335:
$ echo | ./istty.pike
Input doesn't come from tty.</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">from sys import stdin
if stdin.isatty():
print("Input comes from tty.")
Line 366 ⟶ 346:
$ true | python istty.py
Input doesn't come from tty.
=={{header|Quackery}}==
{{trans|Python}}
<syntaxhighlight lang=
to_stack( 1 if stdin.isatty() else 0)|
python ] is ttyin ( --> b )
Line 383 ⟶ 362:
<pre>Looks like a teletype.</pre>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
(terminal-port? (current-input-port))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>say $*IN.t ?? "Input comes from tty." !! "Input doesn't come from tty.";</syntaxhighlight>
$ raku istty.raku
Line 398 ⟶ 375:
$ true | raku istty.raku
Input doesn't come from tty.
=={{header|REXX}}==
<syntaxhighlight lang="rexx">/*REXX program determines if input comes from terminal or standard input*/
if queued() then say 'input comes from the terminal.'
Line 407 ⟶ 383:
/*stick a fork in it, we're done.*/
</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Check input device is a terminal
Line 431 ⟶ 406:
input redirected
</pre>
=={{header|Ruby}}==
Example from the docs.
<syntaxhighlight lang="ruby">File.new("testfile").isatty #=> false
File.new("/dev/tty").isatty #=> true</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="rust">/* Uses C library interface */
extern crate libc;
Line 450 ⟶ 423:
}
}</syntaxhighlight>
=={{header|Scala}}==
{{Works with|Ubuntu|14.04}}
<syntaxhighlight lang="scala">import org.fusesource.jansi.internal.CLibrary._
object IsATty extends App {
Line 474 ⟶ 446:
println("tty " + apply(true))
}</syntaxhighlight>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">val stdinRefersToTerminal : bool = Posix.ProcEnv.isatty Posix.FileSys.stdin</syntaxhighlight>
=={{header|Tcl}}==
Tcl automatically detects whether <tt>stdin</tt> is coming from a terminal (or a socket) and sets up the channel to have the correct type. One of the configuration options of a terminal channel is <tt>-mode</tt> (used to configure baud rates on a real serial terminal) so we simply detect whether the option is present.
<syntaxhighlight lang="tcl">if {[catch {fconfigure stdin -mode}]} {
puts "Input doesn't come from tty."
} else {
Line 492 ⟶ 462:
Input doesn't come from tty.
</pre>
=={{header|UNIX Shell}}==
<syntaxhighlight lang="sh">#!/bin/sh
if [ -t 0 ]
Line 502 ⟶ 471:
echo "Input is NOT a terminal"
fi</syntaxhighlight>
=={{header|Wren}}==
<syntaxhighlight lang="ecmascript">import "io" for Stdin
System.print("Input device is a terminal? %(Stdin.isTerminal ? "Yes" : "No")")</syntaxhighlight>
Line 512 ⟶ 480:
Input device is a terminal? Yes
</pre>
=={{header|zkl}}==
On Unix, check to see if stdin's st_mode is a character device.
<syntaxhighlight lang="zkl">const S_IFCHR=0x2000;
fcn S_ISCHR(f){ f.info()[4].bitAnd(S_IFCHR).toBool() }
S_ISCHR(File.stdin).println();</syntaxhighlight>
Line 527 ⟶ 494:
False
</pre>
{{omit from|Clojure}}
{{omit from|GUISS}}▼
{{omit from|Java|See bug JDK-4099017}}
▲{{omit from|GUISS}}
{{omit from|Processing}}
{{omit from|TI-83 BASIC|Input device is always either a terminal or created by the program}}
{{omit from|ZX Spectrum Basic}}
▲[[Category:Terminal control]]
▲[[Category:Hardware]]
▲[[Category:Initialization]]
|
Revision as of 22:54, 30 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Demonstrate how to check whether the input device is a terminal or not.
- Related task
Ada
We use the interface to C library functions isatty()
and fileno()
.
with Ada.Text_IO; use Ada.Text_IO;
with Interfaces.C_Streams; use Interfaces.C_Streams;
procedure Test_tty is
begin
if Isatty(Fileno(Stdin)) = 0 then
Put_Line(Standard_Error, "stdin is not a tty.");
else
Put_Line(Standard_Error, "stdin is a tty.");
end if;
end Test_tty;
- Output:
$ ./test_tty stdin is a tty. $ ./test_tty < /dev/null stdin is not a tty.
BaCon
terminal = isatty(0)
PRINT terminal
- Output:
prompt$ bacon -q istty.bac Converting 'istty.bac'... done, 4 lines were processed in 0.002 seconds. Compiling 'istty.bac'... cc -c istty.bac.c cc -o istty istty.bac.o -lm Done, program 'istty' ready. prompt$ ./istty 1 prompt$ ./istty <<<"testing" 0
C
Use isatty()
on file descriptor to determine if it's a TTY. To get the file descriptor from a FILE*
pointer, use fileno
:
#include <unistd.h> //for isatty()
#include <stdio.h> //for fileno()
int main(void)
{
puts(isatty(fileno(stdin))
? "stdin is tty"
: "stdin is not tty");
return 0;
}
- Output:
$ ./a.out stdin is tty $ ./a.out < /dev/zero stdin is not tty $ echo "" | ./a.out stdin is not tty
COBOL
Works with GnuCOBOL.
*>
*> istty, check id fd 0 is a tty
*> Tectonics: cobc -xj istty.cob
*> echo "test" | ./istty
*>
identification division.
program-id. istty.
data division.
working-storage section.
01 rc usage binary-long.
procedure division.
sample-main.
call "isatty" using by value 0 returning rc
display "fd 0 tty: " rc
call "isatty" using by value 1 returning rc
display "fd 1 tty: " rc upon syserr
call "isatty" using by value 2 returning rc
display "fd 2 tty: " rc
goback.
end program istty.
DISPLAY for fd 1 is directed to SYSERR to get some output during the various trials.
- Output:
prompt$ cobc -xj istty.cob fd 0 tty: +0000000001 fd 1 tty: +0000000001 fd 2 tty: +0000000001 prompt$ echo "test" | ./istty fd 0 tty: +0000000000 fd 1 tty: +0000000001 fd 2 tty: +0000000001 prompt$ echo "test" | ./istty >/dev/null fd 1 tty: +0000000000 prompt$ echo "test" | ./istty 2>/dev/tty fd 0 tty: +0000000000 fd 1 tty: +0000000001 fd 2 tty: +0000000001 prompt$ echo "test" | ./istty 2>/dev/null fd 0 tty: +0000000000 fd 2 tty: +0000000000
Common Lisp
(with-open-stream (s *standard-input*)
(format T "stdin is~:[ not~;~] a terminal~%"
(interactive-stream-p s)))
- Output:
$ sbcl --script rc.lisp stdin is a terminal $ sbcl --script rc.lisp < /dev/zero stdin is not a terminal $ echo "" | sbcl --script rc.lisp stdin is not a terminal
Crystal
File.new("testfile").tty? #=> false
File.new("/dev/tty").tty? #=> true
STDIN.tty? #=> true
D
import std.stdio;
extern(C) int isatty(int);
void main() {
if (isatty(0))
writeln("Input comes from tty.");
else
writeln("Input doesn't come from tty.");
}
- Output:
C:\test Input comes from tty. C:\test < in.txt Input doesn't come from tty.
FreeBASIC
Open Cons For Input As #1
' Open Cons abre los flujos de entrada (stdin) o salida (stdout) estándar
' de la consola para leer o escribir.
If Err Then
Print "Input doesn't come from tt."
Else
Print "Input comes from tty."
End If
Close #1
Sleep
Go
package main
import (
"golang.org/x/crypto/ssh/terminal"
"fmt"
"os"
)
func main() {
if terminal.IsTerminal(int(os.Stdin.Fd())) {
fmt.Println("Hello terminal")
} else {
fmt.Println("Who are you? You're not a terminal.")
}
}
- Output:
> hello Hello terminal > hello </dev/null Who are you? You're not a terminal.
Haskell
Example uses unix package:
module Main (main) where
import System.Posix.IO (stdInput)
import System.Posix.Terminal (queryTerminal)
main :: IO ()
main = do
isTTY <- queryTerminal stdInput
putStrLn $ if isTTY
then "stdin is TTY"
else "stdin is not TTY"
Jsish
/* Check input device is a terminal, in Jsish */
;Interp.conf().subOpts.istty;
/*
=!EXPECTSTART!=
Interp.conf().subOpts.istty ==> false
=!EXPECTEND!=
*/
- Output:
prompt$ jsish Jsish interactive: see 'help [cmd]' or 'history'. \ cancels > input. ctrl-c aborts running script. jsi> Interp.conf().subOpts.istty; true jsi> prompt$ jsish --U checkInputDevice.jsi Interp.conf().subOpts.istty ==> false
Julia
if isa(STDIN, Base.TTY)
println("This program sees STDIN as a TTY.")
else
println("This program does not see STDIN as a TTY.")
end
- Output:
This program sees STDIN as a TTY.
Kotlin
// Kotlin Native version 0.5
import platform.posix.*
fun main(args: Array<String>) {
if (isatty(STDIN_FILENO) != 0)
println("stdin is a terminal")
else
println("stdin is not a terminal")
}
- Output:
stdin is a terminal
Nemerle
There is no explicit way (ie isatty())to do this; however, if we assume that standard input is a terminal, we can check if the input stream has been redirected (presumably to something other than a terminal).
def isTerm = System.Console.IsInputRedirected;
Nim
Using function "isatty" of standard module "terminal" which accepts a File as argument.
import terminal
echo if stdin.isatty: "stdin is a terminal" else: "stdin is not a terminal"
- Output:
Command: ./check_input_dev Result: stdin is a terminal
Command: ./check_input_dev <somefile Result: stdin is not a terminal
OCaml
let () =
print_endline (
if Unix.isatty Unix.stdin
then "Input comes from tty."
else "Input doesn't come from tty."
)
Testing in interpreted mode:
$ ocaml unix.cma istty.ml Input comes from tty. $ echo "foo" | ocaml unix.cma istty.ml Input doesn't come from tty.
Ol
(define (isatty? fd) (syscall 16 fd 19))
(print (if (isatty? stdin)
"Input comes from tty."
"Input doesn't come from tty."))
Perl
use strict;
use warnings;
use 5.010;
if (-t) {
say "Input comes from tty.";
}
else {
say "Input doesn't come from tty.";
}
$ perl istty.pl Input comes from tty. $ true | perl istty.pl Input doesn't come from tty.
Phix
without js -- (no input redirection in a browser!) printf(1,"stdin:%t, stdout:%t, stderr:%t\n",{isatty(0),isatty(1),isatty(2)})
- Output:
C:\Program Files (x86)\Phix>p test stdin:true, stdout:true, stderr:true C:\Program Files (x86)\Phix>echo hello | p test stdin:false, stdout:true, stderr:true
Pike
void main()
{
if(Stdio.Terminfo.is_tty())
write("Input comes from tty.\n");
else
write("Input doesn't come from tty.\n");
}
- Output:
$ ./istty.pike Input comes from tty. $ echo | ./istty.pike Input doesn't come from tty.
Python
from sys import stdin
if stdin.isatty():
print("Input comes from tty.")
else:
print("Input doesn't come from tty.")
$ python istty.py Input comes from tty. $ true | python istty.py Input doesn't come from tty.
Quackery
[ $ |from sys import stdin
to_stack( 1 if stdin.isatty() else 0)|
python ] is ttyin ( --> b )
ttyin if
[ say "Looks like a teletype." ]
else
[ say "Not a teletype." ]
- Output:
Looks like a teletype.
Racket
(terminal-port? (current-input-port))
Raku
(formerly Perl 6)
say $*IN.t ?? "Input comes from tty." !! "Input doesn't come from tty.";
$ raku istty.raku Input comes from tty. $ true | raku istty.raku Input doesn't come from tty.
REXX
/*REXX program determines if input comes from terminal or standard input*/
if queued() then say 'input comes from the terminal.'
else say 'input comes from the (stacked) terminal queue.'
/*stick a fork in it, we're done.*/
Ring
# Project : Check input device is a terminal
load "stdlib.ring"
if isWindows()
write("mycmd.bat","
@echo off
timeout 1 2>nul >nul
if errorlevel 1 (
echo input redirected
) else (
echo input is console
)
")
see SystemCmd("mycmd.bat")
ok
Output:
input redirected
Ruby
Example from the docs.
File.new("testfile").isatty #=> false
File.new("/dev/tty").isatty #=> true
Rust
/* Uses C library interface */
extern crate libc;
fn main() {
let istty = unsafe { libc::isatty(libc::STDIN_FILENO as i32) } != 0;
if istty {
println!("stdout is tty");
} else {
println!("stdout is not tty");
}
}
Scala
import org.fusesource.jansi.internal.CLibrary._
object IsATty extends App {
var enabled = true
def apply(enabled: Boolean): Boolean = {
// We must be on some unix variant..
try {
enabled && isatty(STDIN_FILENO) == 1
}
catch {
case ignore: Throwable =>
ignore.printStackTrace()
false
}
}
println("tty " + apply(true))
}
Standard ML
val stdinRefersToTerminal : bool = Posix.ProcEnv.isatty Posix.FileSys.stdin
Tcl
Tcl automatically detects whether stdin is coming from a terminal (or a socket) and sets up the channel to have the correct type. One of the configuration options of a terminal channel is -mode (used to configure baud rates on a real serial terminal) so we simply detect whether the option is present.
if {[catch {fconfigure stdin -mode}]} {
puts "Input doesn't come from tty."
} else {
puts "Input comes from tty."
}
Demonstrating:
$ tclsh8.5 istty.tcl Input comes from tty. $ tclsh8.5 istty.tcl </dev/null Input doesn't come from tty.
UNIX Shell
#!/bin/sh
if [ -t 0 ]
then
echo "Input is a terminal"
else
echo "Input is NOT a terminal"
fi
Wren
import "io" for Stdin
System.print("Input device is a terminal? %(Stdin.isTerminal ? "Yes" : "No")")
- Output:
Input device is a terminal? Yes
zkl
On Unix, check to see if stdin's st_mode is a character device.
const S_IFCHR=0x2000;
fcn S_ISCHR(f){ f.info()[4].bitAnd(S_IFCHR).toBool() }
S_ISCHR(File.stdin).println();
- Output:
$ zkl bbb # from the command line True $ zkl bbb < bbb.zkl False $ cat bbb.zkl | zkl bbb False
- Terminal control
- Hardware
- Initialization
- Programming Tasks
- Solutions by Programming Task
- Ada
- BaCon
- C
- COBOL
- Common Lisp
- Crystal
- D
- FreeBASIC
- Go
- Go sub-repositories
- Haskell
- Jsish
- Julia
- Kotlin
- Nemerle
- Nim
- OCaml
- Ol
- Perl
- Phix
- Pike
- Python
- Quackery
- Racket
- Raku
- REXX
- Ring
- Ruby
- Rust
- Scala
- Standard ML
- Tcl
- UNIX Shell
- Wren
- Zkl
- Clojure/Omit
- GUISS/Omit
- Java/Omit
- Processing/Omit
- TI-83 BASIC/Omit
- ZX Spectrum Basic/Omit