Check output device is a terminal: Difference between revisions

 

 

 

=={{header|Ada}}==

{{works with|GNAT}}

We use the interface to C library functions <code>isatty()</code> and <code>fileno()</code>.

 

with Interfaces.C_Streams; use Interfaces.C_Streams;

 

Put_Line(Standard_Error, "stdout is a tty.");

end if;

 

{{out}}

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>:

 

#include <stdio.h> // for fileno()

 

: "stdout is not tty");

return 0;

 

{{out}}

stdout is not tty

</pre>

 

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

{{Works with|SBCL}}

(format T "stdout is~:[ not~;~] a terminal~%"

 

{{Out}}

stdout is not a terminal</pre>

 

=={{header|Crystal}}==

File.new("/dev/tty").tty? #=> true

 

=={{header|Factor}}==

You have to know 1 is the correct file descriptor number:

IN: scratchpad USE: unix.ffi

IN: scratchpad 1 isatty

--- Data stack:

1

 

=={{header|Go}}==

 

import (

"os"

"fmt"

)

 

func main() {

fmt.Println("Hello terminal")

} else {

}

{{out}}

<pre>

Hello terminal

> hello | cat

</pre>

 

 

=={{header|Julia}}==

if isa(STDOUT, Base.TTY)

println("This program sees STDOUT as a TTY.")

println("This program does not see STDOUT as a TTY.")

end

 

{{out}}

This program sees STDOUT as a TTY.

</pre>

 

=={{header|Nemerle}}==

There is no explicit way (ie <tt>isatty()</tt>)to do this; however, if we ''assume'' that standard out ''is'' a terminal, we can check if the output stream has been redirected (presumably to something other than a terminal).

 

=={{header|OCaml}}==

 

print_endline (

if Unix.isatty Unix.stdout

then "Output goes to tty."

else "Output doesn't go to tty."

 

Testing in interpreted mode:

Output doesn't go to tty.

</pre>

=={{header|Perl}}==

The -t function on a filehandle tells you whether it's a terminal.

 

Terminal

$ perl -e "warn -t STDOUT ? 'Terminal' : 'Other'" > x.tmp

Other

 

 

=={{header|Racket}}==

(terminal-port? (current-output-port))

=={{header|REXX}}==

{{works with|PC/REXX under DOS or in a DOS window under MS Windows}}

{{works with|Personal REXX under DOS or in a DOS window under MS Windows}}

{{works with|Regina in a DOS window under MS Windows}}

Programming note: &nbsp; The comment about the REXX statements have to be on one line isn't quite true,

<br>but because the REXX special variable '''SIGL''' is defined where it's executed, it makes coding simpler.

:::* &nbsp; a '''CALL''' statement is used

:::* &nbsp; a ''function'' is invoked

:::* &nbsp; a '''SIGNAL''' statement is used

Method used: &nbsp; since REXX has no direct way of determining if the STDIN is a terminal or not, the REXX code (below)

<br><br>Note that under VM/CMS, this can be accomplished with a (host) command within REXX and then examining the results.

<br>On IBM mainframes, a user can have STDIN defined, but the terminal can be ''disconnected''.

 

<pre>

output device: terminal

</pre>

 

=={{header|Ruby}}==

p f.isatty # => false

p STDOUT.isatty # => true

=={{header|Rust}}==

 

fn main() {

let istty = unsafe { libc::isatty(libc::STDOUT_FILENO as i32) } != 0;

} else {

}

 

=={{header|Tcl}}==

To detect whether output is going to a terminal in Tcl, you check whether the <code>stdout</code> channel looks like a serial line (as those are indistinguishable from terminals). The simplest way of doing that is to see whether you can read the <tt>-mode</tt> or <code>-xchar</code> channel options, which are only present on serial channels:

At the system call level, when Tcl is setting up the channels that correspond to the underlying <tt>stdout</tt> (and <tt>stdin</tt> and <tt>stderr</tt>) file descriptors, it checks whether the channels are network sockets (with <code>getsockname()</code>) or serial lines (with <code>isatty()</code>). This allows Tcl scripts to find out information about their calling environment (e.g., when they are run from <tt>inetd</tt>) with minimal code.

{{out|Demonstrating}}

===Channel type discovery with older Tcl versions===

Before Tcl 8.4, this discovery process is impossible; <code>stdout</code> always looks like it is going to a file. With 8.4, you can discover the channel type but you need slightly different (and less efficient, due to the thrown error in the non-tty case) code to do it.

=={{header|UNIX Shell}}==

 

if [ -t 1 ]

else

echo "Output is NOT a terminal" >/dev/tty

 

=={{header|zkl}}==

On Unix, check to see if stdout's st_mode is a character device.

fcn S_ISCHR(f){ f.info()[4].bitAnd(S_IFCHR).toBool() }

{{out}}

<pre>

False

</pre>