Check output device is a terminal: Difference between revisions

Line 1:

⚫

[[Category:Hardware]]

⚫

[[Category:Terminal control]]

⚫

[[Category:Initialization]]

⚫

[[Category:Hardware]]

⚫

[[Category:Terminal control]]

⚫

[[Category:Initialization]]

⚫

{{omit from|TI-83 BASIC|Output device is always either a terminal or created by the program}}

;Task:

Line 14:

Line 15:

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

<syntaxhighlight lang=6502asm>LDA $D011 ;screen control register 1

<syntaxhighlight lang="6502asm">LDA $D011 ;screen control register 1

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

BEQ isTerminal</syntaxhighlight>

=={{header|Ada}}==

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;

<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;

with Interfaces.C_Streams; use Interfaces.C_Streams;

Line 42:

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

<syntaxhighlight lang=c>#include <unistd.h> // for isatty()

<syntaxhighlight lang="c">#include <unistd.h> // for isatty()

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

Line 71:

Line 70:

stdout is not tty

</pre>

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

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

namespace CheckTerminal {

Line 82:

Line 80:

}

}</syntaxhighlight>

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

<syntaxhighlight lang=cpp>#if _WIN32

<syntaxhighlight lang="cpp">#if _WIN32

#include <io.h>

#define ISATTY _isatty

Line 106:

Line 103:

return 0;

}</syntaxhighlight>

=={{header|COBOL}}==

Works with GnuCOBOL.

*> istty, check id fd 0 is a tty

*> Tectonics: cobc -xj istty.cob

Line 157:

Line 153:

fd 0 tty: +0000000000

fd 2 tty: +0000000000</pre>

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

<syntaxhighlight lang=lisp>(with-open-stream (s *standard-output*)

<syntaxhighlight lang="lisp">(with-open-stream (s *standard-output*)

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

(interactive-stream-p s)))</syntaxhighlight>

Line 176:

Line 171:

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

<syntaxhighlight lang=lisp>(ffi:clines "

<syntaxhighlight lang="lisp">(ffi:clines "

#include <sys/ioctl.h>

#include <unistd.h>

Line 206:

Line 201:

$ ./is-tty | cat -

stdout is not a terminal</pre>

=={{header|Crystal}}==

<syntaxhighlight lang=ruby>File.new("testfile").tty? #=> false

<syntaxhighlight lang="ruby">File.new("testfile").tty? #=> false

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

STDOUT.tty? #=> true</syntaxhighlight>

=={{header|D}}==

<syntaxhighlight lang=D>import std.stdio;

<syntaxhighlight lang="d">import std.stdio;

extern(C) int isatty(int);

Line 228:

Line 221:

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

Line 238:

Line 230:

1

</syntaxhighlight>

=={{header|FreeBASIC}}==

Open Cons For Output As #1

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

Line 254:

Line 244:

Sleep

</syntaxhighlight>

=={{header|Go}}==

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

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import (

Line 280:

Line 268:

Who are you? You're not a terminal.

</pre>

=={{header|Haskell}}==

<syntaxhighlight lang=haskell>module Main where

<syntaxhighlight lang="haskell">module Main where

-- requires the unix package

Line 303:

Line 290:

stdout is not tty

</pre>

=={{header|J}}==

Explanation:

Line 319:

Line 305:

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

<syntaxhighlight lang=js>node -p -e "Boolean(process.stdout.isTTY)"

<syntaxhighlight lang="js">node -p -e "Boolean(process.stdout.isTTY)"

true</syntaxhighlight>

=={{header|Julia}}==

if isa(STDOUT, Base.TTY)

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

Line 337:

Line 321:

This program sees STDOUT as a TTY.

</pre>

=={{header|Kotlin}}==

<syntaxhighlight lang=scala>// Kotlin Native version 0.5

<syntaxhighlight lang="scala">// Kotlin Native version 0.5

import platform.posix.*

Line 355:

Line 338:

stdout is a terminal

</pre>

=={{header|Lua}}==

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

<syntaxhighlight lang=~~Lua~~>local function isTTY ( fd )

<syntaxhighlight lang="lua">local function isTTY ( fd )

fd = tonumber( fd ) or 1

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

Line 393:

Line 375:

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

<syntaxhighlight lang=lua>local unistd = require( "posix.unistd" )

<syntaxhighlight lang="lua">local unistd = require( "posix.unistd" )

local function isTTY ( fd )

Line 406:

Line 388:

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).

<syntaxhighlight lang=~~Nemerle~~>def isTerm = System.Console.IsOutputRedirected;</syntaxhighlight>

<syntaxhighlight lang="nemerle">def isTerm = System.Console.IsOutputRedirected;</syntaxhighlight>

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

<syntaxhighlight lang=~~Nim~~>import terminal

<syntaxhighlight lang="nim">import terminal

stderr.write if stdout.isatty: "stdout is a terminal\n" else: "stdout is not a terminal\n"</syntaxhighlight>

Line 425:

Line 405:

<pre>Command: ./check_output_dev >somefile

Result: stdout is not a terminal</pre>

=={{header|OCaml}}==

<syntaxhighlight lang=ocaml>let () =

<syntaxhighlight lang="ocaml">let () =

print_endline (

if Unix.isatty Unix.stdout

Line 447:

Line 426:

Output doesn't go to tty.

</pre>

=={{header|Ol}}==

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

(print (if (isatty? stdout)

Line 455:

Line 433:

"stdout is not a tty."))

</syntaxhighlight>

=={{header|Perl}}==

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

<syntaxhighlight lang=bash>$ perl -e "warn -t STDOUT ? 'Terminal' : 'Other'"

<syntaxhighlight lang="bash">$ perl -e "warn -t STDOUT ? 'Terminal' : 'Other'"

Terminal

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

Other

</syntaxhighlight>

=={{header|Phix}}==

without js -- (no input or output redirection in a browser!)

printf(1,"stdin:%t, stdout:%t, stderr:%t\n",{isatty(0),isatty(1),isatty(2)})

Line 484:

Line 460:

stdin:false, stdout:true, stderr:true

</pre>

=={{header|PHP}}==

if(posix_isatty(STDOUT)) {

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

Line 493:

Line 468:

}

</syntaxhighlight>

=={{header|Python}}==

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

<syntaxhighlight lang=python>from sys import stdout

<syntaxhighlight lang="python">from sys import stdout

if stdout.isatty():

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

else:

print 'The output device isn\'t like a teletype.'</syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang=~~Quackery~~> [ $ |from sys import stdout

<syntaxhighlight lang="quackery"> [ $ |from sys import stdout

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

python ] is ttyout ( --> b )

Line 518:

Line 491:

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

=={{header|Racket}}==

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

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Line 532:

Line 503:

$ 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}}

Line 555:

Line 525:

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

<syntaxhighlight lang=rexx>/*REXX program determines if the STDIN is a terminal device or other. */

<syntaxhighlight lang="rexx">/*REXX program determines if the STDIN is a terminal device or other. */

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

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

Line 589:

Line 559:

output device: 6

</pre>

=={{header|Ruby}}==

<syntaxhighlight lang=rust>f = File.open("test.txt")

<syntaxhighlight lang="rust">f = File.open("test.txt")

p f.isatty # => false

p STDOUT.isatty # => true

</syntaxhighlight>

=={{header|Rust}}==

<syntaxhighlight lang=rust>/* Uses C library interface */

<syntaxhighlight lang="rust">/* Uses C library interface */

extern crate libc;

Line 609:

Line 577:

}

}</syntaxhighlight>

=={{header|Scala}}==

<syntaxhighlight lang=scala>import org.fusesource.jansi.internal.CLibrary._

<syntaxhighlight lang="scala">import org.fusesource.jansi.internal.CLibrary._

object IsATty extends App {

Line 633:

Line 600:

println("tty " + apply(true))

}</syntaxhighlight>

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

<syntaxhighlight lang=sml>val stdoutRefersToTerminal : bool = Posix.ProcEnv.isatty Posix.FileSys.stdout</syntaxhighlight>

<syntaxhighlight lang="sml">val stdoutRefersToTerminal : bool = Posix.ProcEnv.isatty Posix.FileSys.stdout</syntaxhighlight>

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

<syntaxhighlight lang=tcl>set toTTY [dict exists [fconfigure stdout] -mode]

<syntaxhighlight lang="tcl">set toTTY [dict exists [fconfigure stdout] -mode]

puts [expr {$toTTY ? "Output goes to tty" : "Output doesn't go to tty"}]</syntaxhighlight>

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.

Line 650:

Line 615:

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

<syntaxhighlight lang=tcl>set toTTY [expr {![catch {fconfigure stdout -mode}]}]</syntaxhighlight>

<syntaxhighlight lang="tcl">set toTTY [expr {![catch {fconfigure stdout -mode}]}]</syntaxhighlight>

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

<syntaxhighlight lang=sh>#!/bin/sh

<syntaxhighlight lang="sh">#!/bin/sh

if [ -t 1 ]

Line 661:

Line 625:

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

fi</syntaxhighlight>

=={{header|Visual Basic .NET}}==

<syntaxhighlight lang=vbnet>Module Module1

<syntaxhighlight lang="vbnet">Module Module1

Sub Main()

Line 671:

Line 634:

End Module</syntaxhighlight>

=={{header|Wren}}==

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.

<syntaxhighlight lang=ecmascript>/* check_output_device_is_terminal.wren */

<syntaxhighlight lang="ecmascript">/* check_output_device_is_terminal.wren */

class C {

Line 684:

Line 646:

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

<syntaxhighlight lang=c>#include <stdlib.h>

<syntaxhighlight lang="c">#include <stdlib.h>

#include <unistd.h>

#include <stdio.h>

Line 779:

Line 741:

Output device is a terminal = false

</pre>

=={{header|zkl}}==

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

<syntaxhighlight lang=zkl>const S_IFCHR=0x2000;

<syntaxhighlight lang="zkl">const S_IFCHR=0x2000;

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

S_ISCHR(File.stdout).println();</syntaxhighlight>

Line 795:

Line 756:

False

</pre>

⚫

{{omit from|TI-83 BASIC|Output device is always either a terminal or created by the program}}