gnu make - determine if stdout is terminal - linux

Question

Trying to do:
help:
#echo "you must $(call red_text,clean)"
where red_text is defined as
red_text = $(shell tput setaf 1; echo -n "$1"; tput sgr0)
This prints "you must clean", where word "clean" is printed in red.
The problem is when the output of make is piped (e.g. to less).
In this case I should not use colors, but rather print the $1.
I need to update red_text to handle the case. For that I thought I can use something like $(shell [ -t 1 ] ..) but the problem is that the stdout of $(shell) is never a terminal.
How can I change red to handle the case when stdout is not to a terminal?

Answer 1

As you pointed out, there is no way to test from $(shell ...) whether the output is a standard terminal or a pipe / file. There are however a few things we can do, each with their own pros/cons.
Detect TTY in a custom make script
We simply write a simple shell script that intercepts the call to the native make, detects the TTY, and defines a variable appropriately. The main advantages of this solution:
simplicity,
works for echo, $(info ...) and alike, $(shell ...) commands,
no modification required in the recipes,
no extra process spawned at each echo, which on some platform can be quite slow (eg. Cygwin).
ifdef IS_TTY
# DO NOT ADD TRAILING COMMENTS OR THIS WILL FAIL BECAUSE OF TRAILING SPACES
ESC := $(shell printf '\e')
R := $(ESC)[31m
Z := $(ESC)[0;0m
endif
$(info [info ] $Rred$Z black)
$(shell echo >&2 "[shell ] $Rred$Z black")
if_fancy:
#echo "[recipe] $Rred$Z black"
Example of custom make script to add in path (eg. /usr/local/bin/make):
#! /bin/bash
[ -t 1 ] && IS_TTY=1 || IS_TTY=0
exec /usr/bin/make IS_TTY=$IS_TTY "$#"
This method provides the expected output in all these cases
make # Colored
make >&2 # Colored
make | cat # NOT colored
make >tmp && cat tmp # NOT colored
Detect in recipe and call the Makefile recursively
In some cases, it might not be possible to intercept the call to make or replace it with a custom script. In this solution, we fix that limitation by detecting the TTY in a first pass, and then calling the same Makefile recursively with the appropriate variable set.
ifndef IS_TTY
.SILENT:
%:
#[ -t 1 ] && IS_TTY=1 || IS_TTY=0; $(MAKE) IS_TTY=$$IS_TTY "$#"
xyz:
#[ -t 1 ] && IS_TTY=1 || IS_TTY=0; $(MAKE) IS_TTY=$$IS_TTY
else
ifeq ($(IS_TTY),1)
# DO NOT ADD TRAILING COMMENTS OR THIS WILL FAIL BECAUSE OF TRAILING SPACES
ESC := $(shell printf '\e')
R := $(ESC)[31m
Z := $(ESC)[0;0m
endif
$(info [info ] $Rred$Z black)
$(shell echo >&2 "[shell ] $Rred$Z black")
recursive:
#echo "[recipe] $Rred$Z black"
endif
The disadvantage of this method is that it adds quite some garbage in the Makefile. Dealing with recursion may be tricky. In the example above, I only applied some basic recursive mechanism that should work when make is called with or without a target, and which should also propagate variables. Extending this would be the subject of another question ;-)
Strip the escape sequences at each echo
We test at each echo command whether the output is a TTY, and we strip the escape sequences if not so (using https://superuser.com/questions/380772/removing-ansi-color-codes-from-text-stream). To reduce the spam on the line, we use a make variable $(STRIPESC). The solution is quite simple, but it only works for echo command, and spawns an extra process at each echo. It also requires to edit every recipe with an echo.
# DO NOT ADD TRAILING COMMENTS OR THIS WILL FAIL BECAUSE OF TRAILING SPACES
ESC := $(shell printf '\e')
R := $(ESC)[31m
Z := $(ESC)[0;0m
STRIPESC:=( [ -t 1 ] && cat || sed 's/\x1b\[[0-9;]*m//g' )
# $(info ...) not supported
# $(shell echo >&2 ...) not supported
if_tty:
#echo "[recipe] $Rred$Z black" | $(STRIPESC)
Use an external echo command to strip escape sequences
This is similar to the solution above except that the syntax is a bit more lightweight. The pros/cons are the same. Also, in the example below, I generate the external echo in the makefile itself. In a standard build, you would provide this command as an external tool in some standard path.
# DO NOT ADD TRAILING COMMENTS OR THIS WILL FAIL BECAUSE OF TRAILING SPACES
ESC := $(shell printf '\e')
R := $(ESC)[31m
Z := $(ESC)[0;0m
$(shell echo "#! /bin/bash" > echotty)
$(shell echo '[ -t 1 ] && echo "$$#" || echo "$$#" | sed "s/\x1b\[[0-9;]*m//g"' >> echotty)
$(shell chmod a+x echotty)
# $(info ...)
# $(shell echo >&2 ...)
.PHONY: echotty
echotty:
#./echotty "[recipe] $Rred$Z black"

Answer 2

#fuujuhi already provided a good answer if you care about reliability, but all of his solutions are quite complex. If you need a quick 'n dirty solution, I found this to work quite reliably (although it depends on the implementation of make):
red_text = $(shell [ -c /proc/$$PPID/fd/1 ] && (tput setaf 1; echo -n "$1"; tput sgr0) || echo -n "$1")
Just be aware that it may still detect a tty if you pipe into a character device like /dev/null. This may not be an issue for color output, but in other cases it could be.

Answer 3

if test -t 1
then
echo terminal
else
echo file
fi

Answer 4

In the spirit of Perfection is reached not when there is nothing more to add, but when there is nothing left to take away (Antoine de Saint Exupery), solve the problem by not using color in the first place! Really. It sucks has inherent problems. You make assumptions about terminals that will be wrong for some poor user some fine day. You run into this interactive terminal issue. You spend time solving a problem that could be better spent programming cool functionality instead of eye candy. You please the wrong group of people, namely, the chromatically addicted, and disregard the chromatically challenged, like red/green blind users (of which there are more than you and I estimate).