Check input device is a terminal: Difference between revisions
Thundergnat (talk | contribs) Rename Perl 6 -> Raku, alphabetize, minor clean-up |
SqrtNegInf (talk | contribs) m →{{header|Raku}}: Fix code: Perl 6 --> Raku |
||
Line 259: | Line 259: | ||
<lang perl6>say $*IN.t ?? "Input comes from tty." !! "Input doesn't come from tty.";</lang> |
<lang perl6>say $*IN.t ?? "Input comes from tty." !! "Input doesn't come from tty.";</lang> |
||
$ |
$ raku istty.raku |
||
Input comes from tty. |
Input comes from tty. |
||
$ true | |
$ true | raku istty.raku |
||
Input doesn't come from tty. |
Input doesn't come from tty. |
||
Revision as of 14:18, 18 March 2020
- 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()
.
<lang ada>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;</lang>
- Output:
$ ./test_tty stdin is a tty. $ ./test_tty < /dev/null stdin is not a tty.
C
Use isatty()
on file descriptor to determine if it's a TTY. To get the file descriptor from a FILE*
pointer, use fileno
:
<lang c>#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; }</lang>
- Output:
$ ./a.out stdin is tty $ ./a.out < /dev/zero stdin is not tty $ echo "" | ./a.out stdin is not tty
Common Lisp
<lang lisp>(with-open-stream (s *standard-input*)
(format T "stdin is~:[ not~;~] a terminal~%" (interactive-stream-p s)))</lang>
- 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
<lang ruby>File.new("testfile").tty? #=> false File.new("/dev/tty").tty? #=> true STDIN.tty? #=> true</lang>
D
<lang 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.");
}</lang>
- Output:
C:\test Input comes from tty. C:\test < in.txt Input doesn't come from tty.
Go
<lang 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.") }
}</lang>
- Output:
> hello Hello terminal > hello </dev/null Who are you? You're not a terminal.
Haskell
Example uses unix package:
<lang haskell>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"</lang>
Jsish
<lang javascript>/* Check input device is a terminal, in Jsish */
- Interp.conf().subOpts.istty;
/*
!EXPECTSTART!
Interp.conf().subOpts.istty ==> false
!EXPECTEND!
- /</lang>
- 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
<lang 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 </lang>
- Output:
This program sees STDIN as a TTY.
Kotlin
<lang scala>// 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")
} </lang>
- 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). <lang Nemerle>def isTerm = System.Console.IsInputRedirected;</lang>
OCaml
<lang ocaml>let () =
print_endline ( if Unix.isatty Unix.stdin then "Input comes from tty." else "Input doesn't come from tty." )</lang>
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.
Perl
<lang perl>use strict; use warnings; use 5.010; if (-t) {
say "Input comes from tty.";
} else {
say "Input doesn't come from tty.";
}</lang>
$ perl istty.pl Input comes from tty. $ true | perl istty.pl Input doesn't come from tty.
Pike
<lang pike>void main() {
if(Stdio.Terminfo.is_tty())
write("Input comes from tty.\n");
else write("Input doesn't come from tty.\n");
}</lang>
- Output:
$ ./istty.pike Input comes from tty. $ echo | ./istty.pike Input doesn't come from tty.
Python
<lang python>from sys import stdin if stdin.isatty():
print("Input comes from tty.")
else:
print("Input doesn't come from tty.")</lang>
$ python istty.py Input comes from tty. $ true | python istty.py Input doesn't come from tty.
Racket
<lang racket> (terminal-port? (current-input-port)) </lang>
Raku
(formerly Perl 6)
<lang perl6>say $*IN.t ?? "Input comes from tty." !! "Input doesn't come from tty.";</lang>
$ raku istty.raku Input comes from tty. $ true | raku istty.raku Input doesn't come from tty.
REXX
<lang 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.*/
</lang>
Ring
<lang 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 </lang> Output:
input redirected
Ruby
Example from the docs. <lang ruby>File.new("testfile").isatty #=> false File.new("/dev/tty").isatty #=> true</lang>
Rust
<lang 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"); }
}</lang>
Scala
<lang 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))
}</lang>
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. <lang tcl>if {[catch {fconfigure stdin -mode}]} {
puts "Input doesn't come from tty."
} else {
puts "Input comes from tty."
}</lang> Demonstrating:
$ tclsh8.5 istty.tcl Input comes from tty. $ tclsh8.5 istty.tcl </dev/null Input doesn't come from tty.
UNIX Shell
<lang sh>#!/bin/sh
if [ -t 0 ] then
echo "Input is a terminal"
else
echo "Input is NOT a terminal"
fi</lang>
zkl
On Unix, check to see if stdin's st_mode is a character device. <lang zkl>const S_IFCHR=0x2000; fcn S_ISCHR(f){ f.info()[4].bitAnd(S_IFCHR).toBool() } S_ISCHR(File.stdin).println();</lang>
- Output:
$ zkl bbb # from the command line True $ zkl bbb < bbb.zkl False $ cat bbb.zkl | zkl bbb False