View source for Check input device is a terminal

[[Category:Terminal control]]
[[Category:Hardware]]
[[Category:Initialization]]
{{task}} 

;Task:
Demonstrate how to check whether the input device is a terminal or not.


;Related task:
* &nbsp; [[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;

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;</syntaxhighlight>

{{out}}

<pre>
$ ./test_tty 
stdin is a tty.
$ ./test_tty < /dev/null
stdin is not a tty.
</pre>

=={{header|BASIC}}==
==={{header|BaCon}}===
<syntaxhighlight lang="freebasic">terminal = isatty(0)
PRINT terminal</syntaxhighlight>

{{out}}
<pre>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</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 
' 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
</syntaxhighlight>


=={{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()

int main(void)
{
	puts(isatty(fileno(stdin))
		? "stdin is tty"
		: "stdin is not tty");
	return 0;
}</syntaxhighlight>
{{out}}
<pre>
$ ./a.out
stdin is tty
$ ./a.out < /dev/zero
stdin is not tty
$ echo "" | ./a.out
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
      *>            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.</syntaxhighlight>

DISPLAY for fd 1 is directed to SYSERR to get some output during the various trials.

{{out}}
<pre>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</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>

{{Out}}
<pre>$ 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</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);

void main() {
    if (isatty(0))
        writeln("Input comes from tty.");
    else
        writeln("Input doesn't come from tty.");
}</syntaxhighlight>
{{out}}
<pre>C:\test
Input comes from tty.
C:\test < in.txt
Input doesn't come from tty.</pre>


=={{header|Forth}}==
{{works with|gforth|0.7.3}}
In Gforth, the word "source-id" is used to determine the program source.

If you got a program file "source.f":
<syntaxhighlight lang="Forth">
: ?tty source-id if ." not " then ." from terminal" ; ?tty bye
</syntaxhighlight>
Then,
<syntaxhighlight lang="bash">gforth source.f</syntaxhighlight> in the shell will display:
{{out}}<pre>not from terminal</pre>
Then,
<syntaxhighlight lang="bash">gforth -e ': ?tty source-id if ." not " then ." from terminal" ; ?tty bye'</syntaxhighlight> will display:
{{out}}<pre>not from terminal</pre>

At Gforth prompt,
<syntaxhighlight lang="bash">: ?tty source-id if ." not " then ." from terminal" ; ?tty bye</syntaxhighlight> will display:
{{out}}<pre>from terminal</pre>


=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"

BeginCCode
  if (isatty(fileno(stdin)))
  NSLog( @"stdin is connected to a terminal" );
  else
  NSLog( @"stdin is NOT connected to a terminal" );
EndC

HandleEvents
</syntaxhighlight>
{{output}}
<pre>
stdin is NOT connected to a terminal
</pre>


=={{header|Go}}==
{{libheader|Go sub-repositories}}
<syntaxhighlight 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.")
    }
}</syntaxhighlight>
{{out}}
<pre>
> hello
Hello terminal
> hello </dev/null
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)
import           System.Posix.Terminal (queryTerminal)
 
main :: IO ()
main = do
    isTTY <- queryTerminal stdInput
    putStrLn $ if isTTY
                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;

/*
=!EXPECTSTART!=
Interp.conf().subOpts.istty ==> false
=!EXPECTEND!=
*/</syntaxhighlight>

{{out}}
<pre>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</pre>
=={{header|Julia}}==
<syntaxhighlight 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
</syntaxhighlight>

{{out}}
<pre>
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.*

fun main(args: Array<String>) {
    if (isatty(STDIN_FILENO) != 0)
        println("stdin is a terminal")
    else
        println("stdin is not a terminal") 
}
</syntaxhighlight>

{{out}}
<pre>
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="nemerle">def isTerm = System.Console.IsInputRedirected;</syntaxhighlight>
=={{header|Nim}}==
Using function "isatty" of standard module "terminal" which accepts a File as argument.

<syntaxhighlight lang="nim">import terminal

echo if stdin.isatty: "stdin is a terminal" else: "stdin is not a terminal"</syntaxhighlight>

{{out}}
<pre>Command: ./check_input_dev
Result: stdin is a terminal</pre>

<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
    then "Input comes from tty."
    else "Input doesn't come from tty."
  )</syntaxhighlight>

Testing in interpreted mode:

<pre>$ ocaml unix.cma istty.ml
Input comes from tty.
$ echo "foo" | ocaml unix.cma istty.ml
Input doesn't come from tty.
</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (isatty? fd) (syscall 16 fd 19))
(print (if (isatty? stdin)
   "Input comes from tty."
   "Input doesn't come from tty."))
</syntaxhighlight>
=={{header|Perl}}==
<syntaxhighlight lang="perl">use strict;
use warnings;
use 5.010;
if (-t) {
    say "Input comes from tty.";
}
else {
    say "Input doesn't come from tty.";
}</syntaxhighlight>

 $ perl istty.pl
 Input comes from tty.
 $ true | perl istty.pl
 Input doesn't come from tty.
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
 <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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
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
</pre>
=={{header|Pike}}==
<syntaxhighlight lang="pike">void main()
{
    if(Stdio.Terminfo.is_tty())
	write("Input comes from tty.\n");
    else
        write("Input doesn't come from tty.\n");
}</syntaxhighlight>

{{out}}
<pre>$ ./istty.pike
Input comes from tty.
$ 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.")
else:
    print("Input doesn't come from tty.")</syntaxhighlight>

 $ python istty.py
 Input comes from tty.
 $ true | python istty.py
 Input doesn't come from tty.
=={{header|Quackery}}==

{{trans|Python}}

<syntaxhighlight lang="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." ]</syntaxhighlight>

{{out}}

<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
 Input comes from tty.
 $ 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.'
             else say 'input comes from the (stacked) terminal queue.'

                                       /*stick a fork in it, we're done.*/
</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight 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
</syntaxhighlight>
Output:
<pre>
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;

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");
    }
}</syntaxhighlight>
=={{header|Scala}}==
{{Works with|Ubuntu|14.04}}
<syntaxhighlight 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))
}</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 {
    puts "Input comes from tty."
}</syntaxhighlight>
Demonstrating:
<pre>
$ tclsh8.5 istty.tcl 
Input comes from tty.
$ tclsh8.5 istty.tcl </dev/null
Input doesn't come from tty.
</pre>
=={{header|UNIX Shell}}==
<syntaxhighlight lang="sh">#!/bin/sh

if [ -t 0 ]
then echo "Input is a terminal"
else echo "Input is NOT a terminal"
fi</syntaxhighlight>

=={{header|Wren}}==
<syntaxhighlight lang="wren">import "io" for Stdin

System.print("Input device is a terminal? %(Stdin.isTerminal ? "Yes" : "No")")</syntaxhighlight>

{{out}}
<pre>
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>
{{out}}
<pre>
$ zkl bbb  # from the command line
True
$ zkl bbb < bbb.zkl
False
$ cat bbb.zkl | zkl bbb
False
</pre>
{{omit from|Clojure}}
{{omit from|GUISS}}
{{omit from|Java|See bug JDK-4099017}}
{{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}}