/* output_buffer.c PUBLIC DOMAIN 2016 */ /* part of lsr */ /* I, Tom Vajzovic, am the author of this software and its documentation. I permanently abandon all intellectual property rights in them, including copyright, trademarks, design rights, database right, patents, and the right to be identified as the author. I am fairly certain that the software does what the documentation says it does, but I do not guarantee that it does, or that it does what you think it should. I do not guarantee that it will not have undesirable side effects. You are free to use, modify and distribute this software as you please, but you do so at your own risk. If you do not pass on this warning then you may be responsible for any problems encountered by those who obtain the software through you. */ #define _GNU_SOURCE #include #include #include #include #include #include "output_buffer.h" #define DEFAULT_MODE (WHITE | ON_BLACK) static struct { char buffer[4096]; size_t count; unsigned char mode_ever_buffered; unsigned char mode_ever_requested; unsigned char mode_buffered; unsigned char mode_requested; } state; static void write_bytes (const char *buffer, size_t count) {{{ while (count > 0) { ssize_t written = write (STDOUT_FILENO, buffer, count); if (written == 0) { errno = EAGAIN; written = -1; } if (written < 0) { dprintf (STDERR_FILENO, "%s: stdout: %m\n", program_invocation_short_name); exit (EXIT_FAILURE); } if ((size_t)written >= count) { count = 0; } else { buffer += (size_t)written; count -= (size_t)written; } } }}} static void buffer_bytes (const char *buffer, size_t count) {{{ size_t state_count = state.count; if (state_count == 0) { if (count < sizeof state.buffer) { memcpy (state.buffer, buffer, count); state.count = count; } else { write_bytes (buffer, count); } } else { size_t total_count = (state_count + count); if (total_count < sizeof state.buffer) { memcpy (&state.buffer[state_count], buffer, count); state.count = total_count; } else { if (total_count < (2 * sizeof state.buffer)) { size_t remaining_space = ((sizeof state.buffer) - state_count); memcpy (&state.buffer[state_count], buffer, remaining_space); write_bytes (state.buffer, sizeof state.buffer); size_t remaining_count = (count - remaining_space); memcpy (state.buffer, &buffer[remaining_space], remaining_count); state.count = remaining_count; } else { write_bytes (state.buffer, state_count); write_bytes (buffer, count); state.count = 0; } } } }}} static void buffer_mode (void) {{{ unsigned int mode = DEFAULT_MODE; unsigned int set_bg = 1; unsigned int set_fg = 1; unsigned int set_inverse = 1; unsigned int set_weight = 1; if (state.mode_ever_requested) { mode = state.mode_requested; } if (state.mode_ever_buffered) { unsigned int mode_buffered = state.mode_buffered; set_bg = ((mode & ON_WHITE) != (mode_buffered & ON_WHITE)); set_fg = ((mode & WHITE) != (mode_buffered & WHITE)); set_inverse = ((mode & INVERSE) != (mode_buffered & INVERSE)); set_weight = ((mode & BOLD) != (mode_buffered & BOLD)); } state.mode_ever_buffered = 1; state.mode_buffered = mode; if (set_bg || set_fg || set_inverse || set_weight) { buffer_bytes ("\e[", 2); } if (set_bg) { switch (mode & ON_WHITE) { case ON_BLACK : buffer_bytes ("40", 2); break; case ON_RED : buffer_bytes ("41", 2); break; case ON_GREEN : buffer_bytes ("42", 2); break; case ON_YELLOW : buffer_bytes ("43", 2); break; case ON_BLUE : buffer_bytes ("44", 2); break; case ON_MAGENTA : buffer_bytes ("45", 2); break; case ON_CYAN : buffer_bytes ("46", 2); break; case ON_WHITE : buffer_bytes ("47", 2); break; } } if (set_fg) { if (set_bg) { buffer_bytes (";", 1); } switch (mode & WHITE) { case BLACK : buffer_bytes ("30", 2); break; case RED : buffer_bytes ("31", 2); break; case GREEN : buffer_bytes ("32", 2); break; case YELLOW : buffer_bytes ("33", 2); break; case BLUE : buffer_bytes ("34", 2); break; case MAGENTA : buffer_bytes ("35", 2); break; case CYAN : buffer_bytes ("36", 2); break; case WHITE : buffer_bytes ("37", 2); break; } } if (set_inverse) { if (set_bg || set_fg) { buffer_bytes (";", 1); } if (mode & INVERSE) { buffer_bytes ("7", 1); } else { buffer_bytes ("27", 2); } } if (set_weight) { if (set_bg || set_fg || set_inverse) { buffer_bytes (";", 1); } if (mode & BOLD) { buffer_bytes ("1", 1); } else { buffer_bytes ("22", 2); } } if (set_bg || set_fg || set_inverse || set_weight) { buffer_bytes ("m", 1); } }}} void output_mode (unsigned int mode) {{{ state.mode_ever_requested = 1; state.mode_requested = mode; }}} void output (const char *buffer, size_t count) {{{ if (count > 0) { buffer_mode (); buffer_bytes (buffer, count); } }}} void output_flush (void) {{{ output_mode (DEFAULT_MODE); buffer_mode (); write_bytes (state.buffer, state.count); state.count = 0; }}}