descarga - ¿Cómo obtener salida coloreada con cmake?

cmake vs make

Question

Quiero tener la función de mensaje en CMakeLists.txt que genere texto coloreado. Tal vez la secuencia de escape. Por ejemplo

message("/x1b[31m;This text must be in red")

No funciona yo obtengo

Error de sintaxis en el código cmake en

/home/taurus/cmakecolor/CMakeLists.txt:1

al analizar la cadena

/x1b[31m;This text must be in red

Secuencia de escape no válida / x

Answer 1

Para extender la respuesta correcta de @ grim, puede hacer las cosas un poco más cómodas configurando variables para manejar los distintos colores:

if(NOT WIN32)
  string(ASCII 27 Esc)
  set(ColourReset "${Esc}[m")
  set(ColourBold  "${Esc}[1m")
  set(Red         "${Esc}[31m")
  set(Green       "${Esc}[32m")
  set(Yellow      "${Esc}[33m")
  set(Blue        "${Esc}[34m")
  set(Magenta     "${Esc}[35m")
  set(Cyan        "${Esc}[36m")
  set(White       "${Esc}[37m")
  set(BoldRed     "${Esc}[1;31m")
  set(BoldGreen   "${Esc}[1;32m")
  set(BoldYellow  "${Esc}[1;33m")
  set(BoldBlue    "${Esc}[1;34m")
  set(BoldMagenta "${Esc}[1;35m")
  set(BoldCyan    "${Esc}[1;36m")
  set(BoldWhite   "${Esc}[1;37m")
endif()

message("This is normal")
message("${Red}This is Red${ColourReset}")
message("${Green}This is Green${ColourReset}")
message("${Yellow}This is Yellow${ColourReset}")
message("${Blue}This is Blue${ColourReset}")
message("${Magenta}This is Magenta${ColourReset}")
message("${Cyan}This is Cyan${ColourReset}")
message("${White}This is White${ColourReset}")
message("${BoldRed}This is BoldRed${ColourReset}")
message("${BoldGreen}This is BoldGreen${ColourReset}")
message("${BoldYellow}This is BoldYellow${ColourReset}")
message("${BoldBlue}This is BoldBlue${ColourReset}")
message("${BoldMagenta}This is BoldMagenta${ColourReset}")
message("${BoldCyan}This is BoldCyan${ColourReset}")
message("${BoldWhite}This is BoldWhite/n/n${ColourReset}")

Si realmente desea empujar el bote, puede reemplazar la función de message incorporada con la suya propia, que colorea la salida según el tipo de mensaje:

function(message)
  list(GET ARGV 0 MessageType)
  if(MessageType STREQUAL FATAL_ERROR OR MessageType STREQUAL SEND_ERROR)
    list(REMOVE_AT ARGV 0)
    _message(${MessageType} "${BoldRed}${ARGV}${ColourReset}")
  elseif(MessageType STREQUAL WARNING)
    list(REMOVE_AT ARGV 0)
    _message(${MessageType} "${BoldYellow}${ARGV}${ColourReset}")
  elseif(MessageType STREQUAL AUTHOR_WARNING)
    list(REMOVE_AT ARGV 0)
    _message(${MessageType} "${BoldCyan}${ARGV}${ColourReset}")
  elseif(MessageType STREQUAL STATUS)
    list(REMOVE_AT ARGV 0)
    _message(${MessageType} "${Green}${ARGV}${ColourReset}")
  else()
    _message("${ARGV}")
  endif()
endfunction()

message("No colour at all.")
message(STATUS "/"Colour/" is spelled correctly.")
message(AUTHOR_WARNING "/"Color/" is misspelled.")
message(WARNING "Final warning: spell /"color/" correctly.")
message(SEND_ERROR "Game over.  It''s /"colour/", not /"color/".")
message(FATAL_ERROR "And there''s no /"z/" in /"colourise/" either.")

No puedo decir que recomiendo anular la función de message incorporada de esta manera, pero dicho esto, tampoco he encontrado ningún problema importante al hacer esto.

Answer 2

Si bien es tedioso, puedes definir una variable que contenga un carácter de escape y usarla en las cadenas de mensajes.

string(ASCII 27 ESCAPE)
message("${ESCAPE}[34mblue${ESCAPE}[0m")

Answer 3

Una solución más simple es probablemente usar la capacidad incorporada de CMake para emitir salidas en color, es decir, estos comandos

Colores diferentes

cmake -E cmake_echo_color --normal hello
cmake -E cmake_echo_color --black hello
cmake -E cmake_echo_color --red hello
cmake -E cmake_echo_color --green hello
cmake -E cmake_echo_color --yellow hello
cmake -E cmake_echo_color --blue hello
cmake -E cmake_echo_color --magenta hello
cmake -E cmake_echo_color --cyan hello
cmake -E cmake_echo_color --white hello

Texto en negrita

cmake -E cmake_echo_color --red --bold hello

Ninguna nueva linea

cmake -E cmake_echo_color --red --no-newline hello

Desde CMake puedes usar el execute_process() para invocar ${CMAKE_COMMAND} . Podrías escribir una función conveniente para hacer esto.

ACTUALIZACIÓN: usando cmake_echo_color con execute_process()

Como señalado por @ sjm324 corriendo

execute_process(COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --red --bold hello)

No funciona. Mirando la implementación https://github.com/Kitware/CMake/blob/10371cd6dcfc1bf601fa3e715734dbe66199e2e4/Source/kwsys/Terminal.c#L160

mi conjetura es que la salida estándar no está conectada al terminal y, por lo tanto, cuando CMake llama internamente a isatty() esto falla.

Tengo dos hacks que solucionan esto, pero realmente si te importa esto, deberías contactar a los desarrolladores de CMake para una solución menos frágil.

HACK 1: establece CLICOLOR_FORCE=1 variable de entorno.

execute_process(COMMAND 
  ${CMAKE_COMMAND} -E env CLICOLOR_FORCE=1
    ${CMAKE_COMMAND} -E cmake_echo_color --red --bold hello
)

Esto no es una gran idea Si registra la salida de su compilación en un archivo, tendrá secuencias de escape porque las obliga a emitirse siempre.

HACK 2: configura OUTPUT_FILE para que sea el TTY

No hagas esto HACK 1 es probablemente más portátil.

execute_process(COMMAND
  /usr/bin/tty
  OUTPUT_VARIABLE TTY_NAME
OUTPUT_STRIP_TRAILING_WHITESPACE)

execute_process(COMMAND
  ${CMAKE_COMMAND} -E cmake_echo_color --red --bold hello
  OUTPUT_FILE ${TTY_NAME})