Check output device is a terminal: Difference between revisions

{{task}}

 

;Task:

=={{header|6502 Assembly}}==

{{works with|Commodore 64}}

AND #%00100000 ;bit 5 clear = text mode, bit 5 set = gfx mode

=={{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}}

stdout is not a tty.

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

 

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

 

: "stdout is not tty");

return 0;

 

{{out}}

stdout is not tty

</pre>

=={{header|C sharp|C#}}==

 

namespace CheckTerminal {

}

}

=={{header|C++}}==

{{trans|C}}

#include <io.h>

#define ISATTY _isatty

 

return 0;

=={{header|COBOL}}==

Works with GnuCOBOL.

 

*> istty, check id fd 0 is a tty

*> Tectonics: cobc -xj istty.cob

 

goback.

 

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

fd 0 tty: +0000000000

fd 2 tty: +0000000000</pre>

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

{{Works with|SBCL}}

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

 

{{Out}}

We use the interface to C library functions <code>isatty()</code> and <code>fileno()</code>. It needs to be compiled to be executed.

 

#include <sys/ioctl.h>

#include <unistd.h>

 

(format T "stdout is~:[ not~;~] a terminal~%" (tty-p))

 

Compilation can be done with the following commands :

$ ./is-tty | cat -

stdout is not a terminal</pre>

=={{header|Crystal}}==

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

=={{header|D}}==

 

extern(C) int isatty(int);

void main() {

writeln("Stdout is tty: ", stdout.fileno.isatty == 1);

 

{{out}}

Stdout is tty: false

</pre>

=={{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|FreeBASIC}}==

Open Cons For Output As #1

' Open Cons abre los flujos de entrada (stdin) o salida (stdout) estándar

Close #1

Sleep

=={{header|Go}}==

Tells a ''terminal'' apart from a ''pipe'' on Linux and Mac, which is probably exactly what you need.

 

 

import (

fmt.Println("Who are you? You're not a terminal")

}

{{out}}

<pre>

Who are you? You're not a terminal.

</pre>

=={{header|Haskell}}==

 

 

-- requires the unix package

(if istty

then "stdout is tty"

{{Out}}

<pre>$ runhaskell istty.hs

stdout is not tty

</pre>

=={{header|J}}==

 

 

Explanation:

 

But, correctness requires us to keep in mind that these will only be heuristics, and will sometimes be incorrect (hopefully not often enough to matter a lot...).

=={{header|Javascript/NodeJS}}==

=={{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|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

import platform.posix.*

else

println("stdout is not a terminal")

 

{{out}}

stdout is a terminal

</pre>

=={{header|Lua}}==

{{works with|Lua|5.1+}}

Using pure Lua, assuming a *NIX-like runtime environment ...

fd = tonumber( fd ) or 1

local ok, exit, signal = os.execute( string.format( "test -t %d", fd ) )

print( "stdin", isTTY( 0 ) )

print( "stdout", isTTY( 1 ) )

 

{{out}}

 

You can accomplish the same results using the luaposix [https://github.com/luaposix/luaposix] library:

 

local function isTTY ( fd )

print( "stdin", isTTY( 0 ) )

print( "stdout", isTTY( 1 ) )

 

The output of this version is identical to the output of the first version.

=={{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|Nim}}==

Using function "isatty" of standard module "terminal" which accepts a File as argument.

As we want to redirect stdout, we write the messages on stderr.

 

 

 

{{out}}

<pre>Command: ./check_output_dev >somefile

Result: stdout is not a terminal</pre>

=={{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|Ol}}==

(define (isatty? fd) (syscall 16 fd 19))

(print (if (isatty? stdout)

"stdout is a tty."

"stdout is not a tty."))

=={{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|Phix}}==

{{out}}

<pre>

stdin:false, stdout:true, stderr:true

</pre>

=={{header|PHP}}==

if(posix_isatty(STDOUT)) {

echo "The output device is a terminal".PHP_EOL;

echo "The output device is NOT a terminal".PHP_EOL;

}

=={{header|Python}}==

Pretty much the same as [[Check input device is a terminal#Python]].

if stdout.isatty():

print 'The output device is a teletype. Or something like a teletype.'

else:

=={{header|Quackery}}==

 

{{trans|Python}}

 

to_stack( 1 if stdout.isatty() else 0)|

python ] is ttyout ( --> b )

[ say "Looks like a teletype." ]

else

 

{{out}}

 

<pre>Looks like a teletype.</pre>

=={{header|Racket}}==

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

=={{header|Raku}}==

(formerly Perl 6)

$ raku -e 'note $*OUT.t' >/dev/null

False</pre>

=={{header|REXX}}==

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

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

 

signal on syntax /*if syntax error, then jump ──► SYNTAX*/

say 'output device:' testSTDIN() /*displays terminal ──or── other */

end /* [↑] can't use a RETURN here. */

 

{{out|output|text=&nbsp; when using the default input:}}

<pre>

output device: 6

</pre>

=={{header|Ruby}}==

p f.isatty # => false

p STDOUT.isatty # => true

=={{header|Rust}}==

 

extern crate libc;

println!("stdout is not tty");

}

=={{header|Scala}}==

{{Works with|Ubuntu|14.04}}

 

object IsATty extends App {

 

println("tty " + apply(true))

=={{header|Standard ML}}==

 

=={{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|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

=={{header|Wren}}==

{{trans|C}}

As there is currently no way to obtain this information via Wren CLI, we instead embed a Wren script in a C application and ask the host program to get it for us.

 

class C {

}

 

<br>

We now embed this Wren script in the following C program, compile and run it.

#include <unistd.h>

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

<pre>

Output device is a terminal = true

 

$ cat tmp

Output device is a terminal = false

 

Output device is a terminal = false

</pre>

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