From 6a7c870337236f9273c03bd5173f56375262f847 Mon Sep 17 00:00:00 2001 From: Pavankumar07s Date: Fri, 8 Nov 2024 21:37:30 +0530 Subject: [PATCH] feat:Make use of coloured output --- include/termcolor/termcolor.hpp | 940 ++++++++++++++++++++++++++++++++ src/CMakeLists.txt | 4 +- src/main.cc | 131 +++-- src/messages.cc | 19 + src/messages.h | 14 + 5 files changed, 1072 insertions(+), 36 deletions(-) create mode 100644 include/termcolor/termcolor.hpp create mode 100644 src/messages.cc create mode 100644 src/messages.h diff --git a/include/termcolor/termcolor.hpp b/include/termcolor/termcolor.hpp new file mode 100644 index 00000000..0c0f8311 --- /dev/null +++ b/include/termcolor/termcolor.hpp @@ -0,0 +1,940 @@ +//! +//! termcolor +//! ~~~~~~~~~ +//! +//! termcolor is a header-only c++ library for printing colored messages +//! to the terminal. Written just for fun with a help of the Force. +//! +//! :copyright: (c) 2013 by Ihor Kalnytskyi +//! :license: BSD, see LICENSE for details +//! + +#ifndef TERMCOLOR_HPP_ +#define TERMCOLOR_HPP_ + +#include +#include + +// Detect target's platform and set some macros in order to wrap platform +// specific code this library depends on. +#if defined(_WIN32) || defined(_WIN64) +# define TERMCOLOR_TARGET_WINDOWS +#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)) +# define TERMCOLOR_TARGET_POSIX +#endif + +// If implementation has not been explicitly set, try to choose one based on +// target platform. +#if !defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) && !defined(TERMCOLOR_USE_WINDOWS_API) && !defined(TERMCOLOR_USE_NOOP) +# if defined(TERMCOLOR_TARGET_POSIX) +# define TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES +# define TERMCOLOR_AUTODETECTED_IMPLEMENTATION +# elif defined(TERMCOLOR_TARGET_WINDOWS) +# define TERMCOLOR_USE_WINDOWS_API +# define TERMCOLOR_AUTODETECTED_IMPLEMENTATION +# endif +#endif + +// These headers provide isatty()/fileno() functions, which are used for +// testing whether a standard stream refers to the terminal. +#if defined(TERMCOLOR_TARGET_POSIX) +# include +#elif defined(TERMCOLOR_TARGET_WINDOWS) +# include +# include +#endif + + +namespace termcolor +{ + // Forward declaration of the `_internal` namespace. + // All comments are below. + namespace _internal + { + inline int colorize_index(); + inline FILE* get_standard_stream(const std::ostream& stream); + inline FILE* get_standard_stream(const std::wostream& stream); + template + bool is_colorized(std::basic_ostream& stream); + template + bool is_atty(const std::basic_ostream& stream); + + #if defined(TERMCOLOR_TARGET_WINDOWS) + template + void win_change_attributes(std::basic_ostream& stream, int foreground, int background = -1); + #endif + } + + template + std::basic_ostream& colorize(std::basic_ostream& stream) + { + stream.iword(_internal::colorize_index()) = 1L; + return stream; + } + + template + std::basic_ostream& nocolorize(std::basic_ostream& stream) + { + stream.iword(_internal::colorize_index()) = 0L; + return stream; + } + + template + std::basic_ostream& reset(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[00m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, -1); + #endif + } + return stream; + } + + template + std::basic_ostream& bold(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[1m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& dark(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[2m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& italic(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[3m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& underline(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[4m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, COMMON_LVB_UNDERSCORE); + #endif + } + return stream; + } + + template + std::basic_ostream& blink(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[5m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& reverse(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[7m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& concealed(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[8m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& crossed(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[9m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& color(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[38;5;" << +code << "m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& on_color(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[48;5;" << +code << "m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& color(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[38;2;" << +r << ";" << +g << ";" << +b << "m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& on_color(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[48;2;" << +r << ";" << +g << ";" << +b << "m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + #endif + } + return stream; + } + + template + std::basic_ostream& grey(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[30m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + 0 // grey (black) + ); + #endif + } + return stream; + } + + template + std::basic_ostream& red(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[31m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& green(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[32m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_GREEN + ); + #endif + } + return stream; + } + + template + std::basic_ostream& yellow(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[33m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_GREEN | FOREGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& blue(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[34m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE + ); + #endif + } + return stream; + } + + template + std::basic_ostream& magenta(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[35m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& cyan(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[36m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_GREEN + ); + #endif + } + return stream; + } + + template + std::basic_ostream& white(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[37m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED + ); + #endif + } + return stream; + } + + + template + std::basic_ostream& bright_grey(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[90m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + 0 | FOREGROUND_INTENSITY // grey (black) + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_red(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[91m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_RED | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_green(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[92m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_GREEN | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_yellow(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[93m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_blue(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[94m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_magenta(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[95m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_cyan(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[96m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& bright_white(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[97m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, + FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY + ); + #endif + } + return stream; + } + + + template + std::basic_ostream& on_grey(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[40m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + 0 // grey (black) + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_red(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[41m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_green(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[42m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_yellow(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[43m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_blue(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[44m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_BLUE + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_magenta(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[45m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_BLUE | BACKGROUND_RED + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_cyan(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[46m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_BLUE + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_white(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[47m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED + ); + #endif + } + + return stream; + } + + + template + std::basic_ostream& on_bright_grey(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[100m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + 0 | BACKGROUND_INTENSITY // grey (black) + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_red(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[101m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_RED | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_green(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[102m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_yellow(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[103m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_blue(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[104m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_BLUE | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_magenta(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[105m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_cyan(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[106m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY + ); + #endif + } + return stream; + } + + template + std::basic_ostream& on_bright_white(std::basic_ostream& stream) + { + if (_internal::is_colorized(stream)) + { + #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) + stream << "\033[107m"; + #elif defined(TERMCOLOR_USE_WINDOWS_API) + _internal::win_change_attributes(stream, -1, + BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY + ); + #endif + } + + return stream; + } + + + + //! Since C++ hasn't a way to hide something in the header from + //! the outer access, I have to introduce this namespace which + //! is used for internal purpose and should't be access from + //! the user code. + namespace _internal + { + // An index to be used to access a private storage of I/O streams. See + // colorize / nocolorize I/O manipulators for details. Due to the fact + // that static variables ain't shared between translation units, inline + // function with local static variable is used to do the trick and share + // the variable value between translation units. + inline int colorize_index() + { + static int colorize_index = std::ios_base::xalloc(); + return colorize_index; + } + + //! Since C++ hasn't a true way to extract stream handler + //! from the a given `std::ostream` object, I have to write + //! this kind of hack. + inline + FILE* get_standard_stream(const std::ostream& stream) + { + if (&stream == &std::cout) + return stdout; + else if (&stream == &std::cerr || &stream == &std::clog) + return stderr; + + return nullptr; + } + + //! Since C++ hasn't a true way to extract stream handler + //! from the a given `std::wostream` object, I have to write + //! this kind of hack. + inline + FILE* get_standard_stream(const std::wostream& stream) + { + if (&stream == &std::wcout) + return stdout; + else if (&stream == &std::wcerr || &stream == &std::wclog) + return stderr; + + return nullptr; + } + + // Say whether a given stream should be colorized or not. It's always + // true for ATTY streams and may be true for streams marked with + // colorize flag. + template + bool is_colorized(std::basic_ostream& stream) + { + return is_atty(stream) || static_cast(stream.iword(colorize_index())); + } + + //! Test whether a given `std::ostream` object refers to + //! a terminal. + template + bool is_atty(const std::basic_ostream& stream) + { + FILE* std_stream = get_standard_stream(stream); + + // Unfortunately, fileno() ends with segmentation fault + // if invalid file descriptor is passed. So we need to + // handle this case gracefully and assume it's not a tty + // if standard stream is not detected, and 0 is returned. + if (!std_stream) + return false; + + #if defined(TERMCOLOR_TARGET_POSIX) + return ::isatty(fileno(std_stream)); + #elif defined(TERMCOLOR_TARGET_WINDOWS) + return ::_isatty(_fileno(std_stream)); + #else + return false; + #endif + } + + #if defined(TERMCOLOR_TARGET_WINDOWS) + + //! same hack as used in get_standard_stream function, but for Windows with `std::ostream` + inline HANDLE get_terminal_handle(std::ostream& stream) + { + if (&stream == &std::cout) + return GetStdHandle(STD_OUTPUT_HANDLE); + else if (&stream == &std::cerr || &stream == &std::clog) + return GetStdHandle(STD_ERROR_HANDLE); + return nullptr; + } + + //! same hack as used in get_standard_stream function, but for Windows with `std::wostream` + inline HANDLE get_terminal_handle(std::wostream& stream) + { + if (&stream == &std::wcout) + return GetStdHandle(STD_OUTPUT_HANDLE); + else if (&stream == &std::wcerr || &stream == &std::wclog) + return GetStdHandle(STD_ERROR_HANDLE); + return nullptr; + } + + //! Change Windows Terminal colors attribute. If some + //! parameter is `-1` then attribute won't changed. + template + void win_change_attributes(std::basic_ostream& stream, int foreground, int background) + { + // yeah, i know.. it's ugly, it's windows. + static WORD defaultAttributes = 0; + + // Windows doesn't have ANSI escape sequences and so we use special + // API to change Terminal output color. That means we can't + // manipulate colors by means of "std::stringstream" and hence + // should do nothing in this case. + if (!_internal::is_atty(stream)) + return; + + // get terminal handle + HANDLE hTerminal = INVALID_HANDLE_VALUE; + hTerminal = get_terminal_handle(stream); + + // save default terminal attributes if it unsaved + if (!defaultAttributes) + { + CONSOLE_SCREEN_BUFFER_INFO info; + if (!GetConsoleScreenBufferInfo(hTerminal, &info)) + return; + defaultAttributes = info.wAttributes; + } + + // restore all default settings + if (foreground == -1 && background == -1) + { + SetConsoleTextAttribute(hTerminal, defaultAttributes); + return; + } + + // get current settings + CONSOLE_SCREEN_BUFFER_INFO info; + if (!GetConsoleScreenBufferInfo(hTerminal, &info)) + return; + + if (foreground != -1) + { + info.wAttributes &= ~(info.wAttributes & 0x0F); + info.wAttributes |= static_cast(foreground); + } + + if (background != -1) + { + info.wAttributes &= ~(info.wAttributes & 0xF0); + info.wAttributes |= static_cast(background); + } + + SetConsoleTextAttribute(hTerminal, info.wAttributes); + } + #endif // TERMCOLOR_TARGET_WINDOWS + + } // namespace _internal + +} // namespace termcolor + + +#undef TERMCOLOR_TARGET_POSIX +#undef TERMCOLOR_TARGET_WINDOWS + +#if defined(TERMCOLOR_AUTODETECTED_IMPLEMENTATION) +# undef TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES +# undef TERMCOLOR_USE_WINDOWS_API +#endif + +#endif // TERMCOLOR_HPP_ diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 40550a2f..2d07a0dc 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,5 +1,5 @@ add_executable(jsonschema_cli - main.cc configure.h.in command.h + main.cc configure.h.in command.h messages.h utils.h utils.cc command_fmt.cc command_frame.cc @@ -12,7 +12,7 @@ add_executable(jsonschema_cli command_identify.cc command_canonicalize.cc command_encode.cc - command_decode.cc) + command_decode.cc messages.cc) noa_add_default_options(PRIVATE jsonschema_cli) set_target_properties(jsonschema_cli PROPERTIES OUTPUT_NAME jsonschema) diff --git a/src/main.cc b/src/main.cc index e75e5e0e..8cbdf84f 100644 --- a/src/main.cc +++ b/src/main.cc @@ -8,9 +8,16 @@ #include // std::string #include // std::string_view #include // std::vector +#ifdef _WIN32 +#include +#define isatty _isatty +#else +#include +#endif #include "command.h" #include "configure.h" +#include "messages.h" constexpr std::string_view USAGE_DETAILS{R"EOF( Global Options: @@ -85,101 +92,157 @@ Global Options: For more documentation, visit https://github.com/sourcemeta/jsonschema )EOF"}; +// Initialize color usage +bool use_colors = true; auto jsonschema_main(const std::string &program, const std::string &command, - const std::span &arguments) -> int { - if (command == "fmt") { + const std::span &arguments) -> int +{ + if (command == "fmt") + { return sourcemeta::jsonschema::cli::fmt(arguments); - } else if (command == "frame") { + } + else if (command == "frame") + { return sourcemeta::jsonschema::cli::frame(arguments); - } else if (command == "bundle") { + } + else if (command == "bundle") + { return sourcemeta::jsonschema::cli::bundle(arguments); - } else if (command == "compile") { + } + else if (command == "compile") + { return sourcemeta::jsonschema::cli::compile(arguments); - } else if (command == "lint") { + } + else if (command == "lint") + { return sourcemeta::jsonschema::cli::lint(arguments); - } else if (command == "validate") { + } + else if (command == "validate") + { return sourcemeta::jsonschema::cli::validate(arguments); - } else if (command == "metaschema") { + } + else if (command == "metaschema") + { return sourcemeta::jsonschema::cli::metaschema(arguments); - } else if (command == "test") { + } + else if (command == "test") + { return sourcemeta::jsonschema::cli::test(arguments); - } else if (command == "identify") { + } + else if (command == "identify") + { return sourcemeta::jsonschema::cli::identify(arguments); - } else if (command == "canonicalize") { + } + else if (command == "canonicalize") + { return sourcemeta::jsonschema::cli::canonicalize(arguments); - } else if (command == "encode") { + } + else if (command == "encode") + { return sourcemeta::jsonschema::cli::encode(arguments); - } else if (command == "decode") { + } + else if (command == "decode") + { return sourcemeta::jsonschema::cli::decode(arguments); - } else { - std::cout << "JSON Schema CLI - v" - << sourcemeta::jsonschema::cli::PROJECT_VERSION << "\n"; - std::cout << "Usage: " << std::filesystem::path{program}.filename().string() - << " [arguments...]\n"; - std::cout << USAGE_DETAILS; + } + else + { + print_success(std::string("JSON Schema CLI - v") + std::string(sourcemeta::jsonschema::cli::PROJECT_VERSION)); + + print_success("Usage: " + std::filesystem::path{program}.filename().string() + " [arguments...]"); + + print_success(std::string(USAGE_DETAILS)); + return EXIT_SUCCESS; } } -auto main(int argc, char *argv[]) noexcept -> int { - try { +auto main(int argc, char *argv[]) noexcept -> int +{ + try + { const std::string program{argv[0]}; const std::string command{argc > 1 ? argv[1] : "help"}; const std::vector arguments{argv + std::min(2, argc), argv + argc}; return jsonschema_main(program, command, arguments); - } catch (const sourcemeta::jsontoolkit::SchemaReferenceError &error) { + } + catch (const sourcemeta::jsontoolkit::SchemaReferenceError &error) + { std::cerr << "error: " << error.what() << "\n " << error.id() << "\n at schema location \""; sourcemeta::jsontoolkit::stringify(error.location(), std::cerr); std::cerr << "\"\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::SchemaResolutionError &error) { + } + catch (const sourcemeta::jsontoolkit::SchemaResolutionError &error) + { std::cerr << "error: " << error.what() << "\n at " << error.id() << "\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::SchemaError &error) { + } + catch (const sourcemeta::jsontoolkit::SchemaError &error) + { std::cerr << "error: " << error.what() << "\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::SchemaVocabularyError &error) { + } + catch (const sourcemeta::jsontoolkit::SchemaVocabularyError &error) + { std::cerr << "error: " << error.what() << "\n " << error.uri() << "\n\nTo request support for it, please open an issue " "at\nhttps://github.com/sourcemeta/jsonschema\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::URIParseError &error) { + } + catch (const sourcemeta::jsontoolkit::URIParseError &error) + { std::cerr << "error: " << error.what() << " at column " << error.column() << "\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::FileParseError &error) { + } + catch (const sourcemeta::jsontoolkit::FileParseError &error) + { std::cerr << "error: " << error.what() << " at line " << error.line() << " and column " << error.column() << "\n " << std::filesystem::weakly_canonical(error.path()).string() << "\n"; return EXIT_FAILURE; - } catch (const sourcemeta::jsontoolkit::ParseError &error) { + } + catch (const sourcemeta::jsontoolkit::ParseError &error) + { std::cerr << "error: " << error.what() << " at line " << error.line() << " and column " << error.column() << "\n"; return EXIT_FAILURE; - } catch (const std::filesystem::filesystem_error &error) { + } + catch (const std::filesystem::filesystem_error &error) + { // See https://en.cppreference.com/w/cpp/error/errc - if (error.code() == std::errc::no_such_file_or_directory) { + if (error.code() == std::errc::no_such_file_or_directory) + { std::cerr << "error: " << error.code().message() << "\n " << std::filesystem::weakly_canonical(error.path1()).string() << "\n"; - } else if (error.code() == std::errc::is_a_directory) { + } + else if (error.code() == std::errc::is_a_directory) + { std::cerr << "error: The input was supposed to be a file but it is a " "directory\n " << std::filesystem::weakly_canonical(error.path1()).string() << "\n"; - } else { + } + else + { std::cerr << "error: " << error.what() << "\n"; } return EXIT_FAILURE; - } catch (const std::runtime_error &error) { + } + catch (const std::runtime_error &error) + { std::cerr << "error: " << error.what() << "\n"; return EXIT_FAILURE; - } catch (const std::exception &error) { + } + catch (const std::exception &error) + { std::cerr << "unexpected error: " << error.what() << "\nPlease report it at " << "https://github.com/sourcemeta/jsonschema\n"; diff --git a/src/messages.cc b/src/messages.cc new file mode 100644 index 00000000..c9178ea1 --- /dev/null +++ b/src/messages.cc @@ -0,0 +1,19 @@ +#include "messages.h" + +// Define print functions with color control + +void print_error(const std::string &message) { + if (use_colors) { + std::cerr << termcolor::red << "error: " << message << termcolor::reset << "\n"; + } else { + std::cerr << "error: " << message << "\n"; + } +} + +void print_success(const std::string &message) { + if (use_colors) { + std::cout << termcolor::green << message << termcolor::reset << "\n"; + } else { + std::cout << message << "\n"; + } +} diff --git a/src/messages.h b/src/messages.h new file mode 100644 index 00000000..47d5921b --- /dev/null +++ b/src/messages.h @@ -0,0 +1,14 @@ +#ifndef MESSAGES_H +#define MESSAGES_H + +#include +#include +#include "../include/termcolor/termcolor.hpp" + +// Declare color control as an external variable +extern bool use_colors; + +void print_error(const std::string &message); +void print_success(const std::string &message); + +#endif // MESSAGES_H