output.h - mozsearch

// Copyright (c) 2019 nyorain

// Distributed under the Boost Software License, Version 1.0.

// See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt

#ifndef INC_DLG_OUTPUT_H_

#define INC_DLG_OUTPUT_H_

#include <dlg/dlg.h>

#include <stdio.h>

#ifdef __cplusplus

extern "C" {

#endif

// Text style

enum dlg_text_style {

	dlg_text_style_reset     = 0,

	dlg_text_style_bold      = 1,

	dlg_text_style_dim       = 2,

	dlg_text_style_italic    = 3,

	dlg_text_style_underline = 4,

	dlg_text_style_blink     = 5,

	dlg_text_style_rblink    = 6,

	dlg_text_style_reversed  = 7,

	dlg_text_style_conceal   = 8,

	dlg_text_style_crossed   = 9,

	dlg_text_style_none,

};

// Text color

enum dlg_color {

	dlg_color_black = 0,

	dlg_color_red,

	dlg_color_green,

	dlg_color_yellow,

	dlg_color_blue,

	dlg_color_magenta,

	dlg_color_cyan,

	dlg_color_gray,

	dlg_color_reset = 9,

	dlg_color_black2 = 60,

	dlg_color_red2,

	dlg_color_green2,

	dlg_color_yellow2,

	dlg_color_blue2,

	dlg_color_magenta2,

	dlg_color_cyan2,

	dlg_color_gray2,

	dlg_color_none = 69,

};

struct dlg_style {

	enum dlg_text_style style;

	enum dlg_color fg;

	enum dlg_color bg;

};

// Like fprintf but fixes utf-8 output to console on windows.

// On non-windows sytems just uses the corresponding standard library

// functions. On windows, if dlg was compiled with the win_console option,

// will first try to output it in a way that allows the default console

// to display utf-8. If that fails, will fall back to the standard

// library functions.

DLG_API int dlg_fprintf(FILE* stream, const char* format, ...) DLG_PRINTF_ATTRIB(2, 3);

DLG_API int dlg_vfprintf(FILE* stream, const char* format, va_list list);

// Like dlg_printf, but also applies the given style to this output.

// The style will always be applied (using escape sequences), independent of the given stream.

// On windows escape sequences don't work out of the box, see dlg_win_init_ansi().

DLG_API int dlg_styled_fprintf(FILE* stream, struct dlg_style style,

	const char* format, ...) DLG_PRINTF_ATTRIB(3, 4);

// Features to output from the generic output handler.

// Some features might have only an effect in the specializations.

enum dlg_output_feature {

	dlg_output_tags = 1, // output tags list

	dlg_output_time = 2, // output time of log call (hour:minute:second)

	dlg_output_style = 4, // whether to use the supplied styles

	dlg_output_func = 8, // output function

	dlg_output_file_line = 16, // output file:line,

	dlg_output_newline = 32, // output a newline at the end

	dlg_output_threadsafe = 64, // locks stream before printing

	dlg_output_time_msecs = 128 // output micro seconds (ms on windows)

};

// The default level-dependent output styles. The array values represent the styles

// to be used for the associated level (i.e. [0] for trace level).

DLG_API extern const struct dlg_style dlg_default_output_styles[6];

// Generic output function. Used by the default output handler and might be useful

// for custom output handlers (that don't want to manually format the output).

// Will call the given output func with the given data (and format + args to print)

// for everything it has to print in printf format.

// See also the *_stream and *_buf specializations for common usage.

// The given output function must not be NULL.

typedef void(*dlg_generic_output_handler)(void* data, const char* format, ...);

DLG_API void dlg_generic_output(dlg_generic_output_handler output, void* data,

		unsigned int features, const struct dlg_origin* origin, const char* string,

		const struct dlg_style styles[6]);

// Generic output function, using a format string instead of feature flags.

// Use following conversion characters:

// %h - output the time in H:M:S format

// %m - output the time in milliseconds

// %t - output the full list of tags, comma separated

// %f - output the function name noted in the origin

// %o - output the file:line of the origin

// %s - print the appropriate style escape sequence.

// %r - print the escape sequence to reset the style.

// %c - The content of the log/assert

// %% - print the '%' character

// Only the above specified conversion characters are valid, the rest are

// written as it is.

DLG_API void dlg_generic_outputf(dlg_generic_output_handler output, void* data,

		const char* format_string, const struct dlg_origin* origin,

		const char* string, const struct dlg_style styles[6]);

// Generic output function. Used by the default output handler and might be useful

// for custom output handlers (that don't want to manually format the output).

// If stream is NULL uses stdout.

// Automatically uses dlg_fprintf to assure correct utf-8 even on windows consoles.

// Locks the stream (i.e. assures threadsafe access) when the associated feature

// is passed (note that stdout/stderr might still mix from multiple threads).

DLG_API void dlg_generic_output_stream(FILE* stream, unsigned int features,

	const struct dlg_origin* origin, const char* string,

	const struct dlg_style styles[6]);

DLG_API void dlg_generic_outputf_stream(FILE* stream, const char* format_string,

	const struct dlg_origin* origin, const char* string,

	const struct dlg_style styles[6], bool lock_stream);

// Generic output function (see dlg_generic_output) that uses a buffer instead of

// a stream. buf must at least point to *size bytes. Will set *size to the number

// of bytes written (capped to the given size), if buf == NULL will set *size

// to the needed size. The size parameter must not be NULL.

DLG_API void dlg_generic_output_buf(char* buf, size_t* size, unsigned int features,

	const struct dlg_origin* origin, const char* string,

	const struct dlg_style styles[6]);

DLG_API void dlg_generic_outputf_buf(char* buf, size_t* size, const char* format_string,

	const struct dlg_origin* origin, const char* string,

	const struct dlg_style styles[6]);

// Returns if the given stream is a tty. Useful for custom output handlers

// e.g. to determine whether to use color.

// NOTE: Due to windows limitations currently returns false for wsl ttys.

DLG_API bool dlg_is_tty(FILE* stream);

// Returns the null-terminated escape sequence for the given style into buf.

// Undefined behvaiour if any member of style has a value outside its enum range (will

// probably result in a buffer overflow or garbage being printed).

// If all member of style are 'none' will simply nullterminate the first buf char.

DLG_API void dlg_escape_sequence(struct dlg_style style, char buf[12]);

// The reset style escape sequence.

DLG_API extern const char* const dlg_reset_sequence;

// Just returns true without other effect on non-windows systems or if dlg

// was compiled without the win_console option.

// On windows tries to set the console mode to ansi to make escape sequences work.

// This works only on newer windows 10 versions. Returns false on error.

// Only the first call to it will have an effect, following calls just return the result.

// The function is threadsafe. Automatically called by the default output handler.

// This will only be able to set the mode for the stdout and stderr consoles, so

// other streams to consoles will still not work.

DLG_API bool dlg_win_init_ansi(void);

#ifdef __cplusplus

} // extern "C"

#endif

#endif // header guard