#define LF 0x01
#define CR 0x02
-#define SKIP_LINE_ENDINGS(flags) (((flags) & CR) && ((flags) & LF) ? 2 : 1)
+#define SKIP_LINE_ENDINGS(flags) ((flags) == (CR|LF) ? 2 : 1)
#define VALID_FILE_TYPE(mode) (S_ISREG (mode) || S_ISLNK (mode) || S_ISFIFO (mode))
#define ABORT_TRACE() \
fprintf (stderr, "Aborting in source file %s, line %u\n", __FILE__, __LINE__); \
- abort (); \
+ abort ();
#define CHECK_COLORS_RANDOM(color1, color2) \
streq (color_names[color1]->name, "random") \
&& (streq (color_names[color2]->name, "none") \
- || streq (color_names[color2]->name, "default")) \
+ || streq (color_names[color2]->name, "default"))
#define ALLOC_COMPLETE_PART_LINE 8
# define COLOR_SEP_CHAR '/'
#endif
-#define DEBUG_FILE "debug.txt"
+#if DEBUG
+# define DEBUG_FILE "debug.txt"
+#endif
+
+#define MAX_ATTRIBUTE_CHARS (6 * 2)
-#define MAX_ATTRIBUTE_CHARS (5 * 2)
+#define PROGRAM_NAME "colorize"
-#define VERSION "0.60"
+#define VERSION "0.63"
typedef enum { false, true } bool;
char unit;
};
-enum fmts {
+enum {
FMT_GENERIC,
FMT_STRING,
FMT_QUOTE,
enum { GENERIC, FOREGROUND = 0, BACKGROUND };
static const struct {
- struct color const *entries;
+ const struct color *entries;
unsigned int count;
const char *desc;
} tables[] = {
OPT_CLEAN,
OPT_CLEAN_ALL,
OPT_EXCLUDE_RANDOM,
+ OPT_OMIT_COLOR_EMPTY,
OPT_HELP,
OPT_VERSION
};
static int opt_type;
static const struct option long_opts[] = {
- { "attr", required_argument, &opt_type, OPT_ATTR },
- { "clean", no_argument, &opt_type, OPT_CLEAN },
- { "clean-all", no_argument, &opt_type, OPT_CLEAN_ALL },
- { "exclude-random", required_argument, &opt_type, OPT_EXCLUDE_RANDOM },
- { "help", no_argument, &opt_type, OPT_HELP },
- { "version", no_argument, &opt_type, OPT_VERSION },
- { NULL, 0, NULL, 0 },
+ { "attr", required_argument, &opt_type, OPT_ATTR },
+ { "clean", no_argument, &opt_type, OPT_CLEAN },
+ { "clean-all", no_argument, &opt_type, OPT_CLEAN_ALL },
+ { "exclude-random", required_argument, &opt_type, OPT_EXCLUDE_RANDOM },
+ { "omit-color-empty", no_argument, &opt_type, OPT_OMIT_COLOR_EMPTY },
+ { "help", no_argument, &opt_type, OPT_HELP },
+ { "version", no_argument, &opt_type, OPT_VERSION },
+ { NULL, 0, NULL, 0 },
+};
+
+enum attr_type {
+ ATTR_BOLD = 0x01,
+ ATTR_UNDERSCORE = 0x02,
+ ATTR_BLINK = 0x04,
+ ATTR_REVERSE = 0x08,
+ ATTR_CONCEALED = 0x10
+};
+struct attr {
+ const char *name;
+ unsigned int val;
+ enum attr_type type;
};
static FILE *stream;
static bool clean;
static bool clean_all;
+static bool omit_color_empty;
static char attr[MAX_ATTRIBUTE_CHARS + 1];
static char *exclude;
static void process_opts (int, char **);
static void process_opt_attr (const char *);
-static void write_attr (unsigned int);
+static void write_attr (const struct attr *, unsigned int *);
static void print_hint (void);
static void print_help (void);
static void print_version (void);
static void save_char (char, char **, size_t *, size_t *);
static void find_color_entries (struct color_name **, const struct color **);
static void find_color_entry (const struct color_name *, unsigned int, const struct color **);
-static void print_line (const char *, const struct color **, const char * const, unsigned int);
+static void print_line (const char *, const struct color **, const char * const, unsigned int, bool);
static void print_clean (const char *);
static bool is_esc (const char *);
static const char *get_end_of_esc (const char *);
#define PRINT_HELP_EXIT() \
print_help (); \
- exit (EXIT_SUCCESS); \
+ exit (EXIT_SUCCESS);
#define PRINT_VERSION_EXIT() \
print_version (); \
- exit (EXIT_SUCCESS); \
+ exit (EXIT_SUCCESS);
extern char *optarg;
vfprintf_fail (formats[FMT_GENERIC], "--exclude-random switch must be provided a plain color");
break;
}
+ case OPT_OMIT_COLOR_EMPTY:
+ omit_color_empty = true;
+ break;
case OPT_HELP:
PRINT_HELP_EXIT ();
case OPT_VERSION:
static void
process_opt_attr (const char *p)
{
+ /* If attributes are added to this "list", also increase MAX_ATTRIBUTE_CHARS! */
+ const struct attr attrs[] = {
+ { "bold", 1, ATTR_BOLD },
+ { "underscore", 4, ATTR_UNDERSCORE },
+ { "blink", 5, ATTR_BLINK },
+ { "reverse", 7, ATTR_REVERSE },
+ { "concealed", 8, ATTR_CONCEALED },
+ };
+ unsigned int attr_types = 0;
+
while (*p)
{
const char *s;
vfprintf_fail (formats[FMT_GENERIC], "--attr switch must have strings separated by ,");
else
{
- /* If attributes are added to this "list", also increase MAX_ATTRIBUTE_CHARS! */
- if (p - s == 4 && strneq (s, "bold", 4))
- write_attr (1);
- else if (p - s == 10 && strneq (s, "underscore", 10))
- write_attr (4);
- else if (p - s == 5 && strneq (s, "blink", 5))
- write_attr (5);
- else if (p - s == 7 && strneq (s, "reverse", 7))
- write_attr (7);
- else if (p - s == 9 && strneq (s, "concealed", 9))
- write_attr (8);
- else
- vfprintf_fail (formats[FMT_GENERIC], "--attr switch must be provided valid attribute names");
+ bool valid_attr = false;
+ unsigned int i;
+ for (i = 0; i < sizeof (attrs) / sizeof (struct attr); i++)
+ {
+ const size_t name_len = strlen (attrs[i].name);
+ if ((size_t)(p - s) == name_len && strneq (s, attrs[i].name, name_len))
+ {
+ write_attr (&attrs[i], &attr_types);
+ valid_attr = true;
+ break;
+ }
+ }
+ if (!valid_attr)
+ {
+ char *attr_invalid = xmalloc ((p - s) + 1);
+ STACK_VAR (attr_invalid);
+ strncpy (attr_invalid, s, p - s);
+ attr_invalid[p - s] = '\0';
+ vfprintf_fail ("--attr switch attribute '%s' is not valid", attr_invalid);
+ RELEASE_VAR (attr_invalid); /* never reached */
+ }
}
if (*p)
p++;
}
static void
-write_attr (unsigned int val)
+write_attr (const struct attr *attr_i, unsigned int *attr_types)
{
+ const unsigned int val = attr_i->val;
+ const enum attr_type attr_type = attr_i->type;
+ const char *attr_name = attr_i->name;
+
+ if (*attr_types & attr_type)
+ vfprintf_fail ("--attr switch has attribute '%s' twice or more", attr_name);
snprintf (attr + strlen (attr), 3, "%u;", val);
+ *attr_types |= attr_type;
}
static void
static void
print_help (void)
{
- struct short_opt {
+ struct opt_data {
const char *name;
const char *short_opt;
+ const char *arg;
};
- const struct short_opt short_opts[] = {
- { "help", "h" },
- { "version", "V" },
+ const struct opt_data opts_data[] = {
+ { "attr", NULL, "=ATTR1,ATTR2,..." },
+ { "exclude-random", NULL, "=COLOR" },
+ { "help", "h", NULL },
+ { "version", "V", NULL },
};
const struct option *opt = long_opts;
unsigned int i;
printf ("\n\tOptions\n");
for (; opt->name; opt++)
{
- const char *short_opt = NULL;
+ const struct opt_data *opt_data = NULL;
unsigned int i;
- for (i = 0; i < sizeof (short_opts) / sizeof (struct short_opt); i++)
+ for (i = 0; i < sizeof (opts_data) / sizeof (struct opt_data); i++)
+ if (streq (opt->name, opts_data[i].name))
+ {
+ opt_data = &opts_data[i];
+ break;
+ }
+ if (opt_data)
{
- if (streq (opt->name, short_opts[i].name))
- {
- short_opt = short_opts[i].short_opt;
- break;
- }
+ if (opt_data->short_opt)
+ printf ("\t\t-%s, --%s\n", opt_data->short_opt, opt->name);
+ else
+ printf ("\t\t --%s%s\n", opt->name, opt_data->arg);
}
- if (short_opt)
- printf ("\t\t-%s, --%s\n", short_opt, opt->name);
else
printf ("\t\t --%s\n", opt->name);
}
#endif
const char *version_prefix, *version_string;
const char *c_flags, *ld_flags, *cpp_flags;
+ const char *const desc_flags_unknown = "unknown";
struct bytes_size bytes_size;
bool debug;
#ifdef CFLAGS
c_flags = to_str (CFLAGS);
#else
- c_flags = "unknown";
+ c_flags = desc_flags_unknown;
#endif
#ifdef LDFLAGS
ld_flags = to_str (LDFLAGS);
#else
- ld_flags = "unknown";
+ ld_flags = desc_flags_unknown;
#endif
#ifdef CPPFLAGS
cpp_flags = to_str (CPPFLAGS);
#else
- cpp_flags = "unknown";
+ cpp_flags = desc_flags_unknown;
#endif
#if DEBUG
debug = true;
#endif
version_prefix = version ? "" : "v";
version_string = version ? version : VERSION;
- printf ("colorize %s%s (compiled at %s, %s)\n", version_prefix, version_string, __DATE__, __TIME__);
+ printf ("%s %s%s (compiled at %s, %s)\n", PROGRAM_NAME, version_prefix, version_string, __DATE__, __TIME__);
printf ("Compiler flags: %s\n", c_flags);
printf ("Linker flags: %s\n", ld_flags);
const char *color_string = arg_cnt >= 1 ? arg_strings[0] : NULL;
const char *file_string = arg_cnt == 2 ? arg_strings[1] : NULL;
- assert (color_string);
+ assert (color_string != NULL);
if (streq (color_string, "-"))
{
gather_color_names (color_string, attr, color_names);
- assert (color_names[FOREGROUND]);
+ assert (color_names[FOREGROUND] != NULL);
if (color_names[BACKGROUND])
{
}
find_color_entries (color_names, colors);
+ assert (colors[FOREGROUND] != NULL);
free_color_names (color_names);
if (!colors[FOREGROUND]->code && colors[BACKGROUND] && colors[BACKGROUND]->code)
color_name.name = color_name.orig = "default";
find_color_entry (&color_name, FOREGROUND, colors);
+ assert (colors[FOREGROUND]->code != NULL);
}
process_file_arg (file_string, file, stream);
*file = "stdin";
}
- assert (*stream);
- assert (*file);
+ assert (*stream != NULL);
+ assert (*file != NULL);
}
static void
if (have_file)
{
- const char *file_exists = color_string;
+ const char *file_existing = color_string;
if (file_string)
- vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_exists, "cannot be used as color string");
+ vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_existing, "cannot be used as color string");
else
{
if (VALID_FILE_TYPE (mode))
- vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_exists, "must be preceded by color string");
+ vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_existing, "must be preceded by color string");
else
- vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_exists, "is not a valid file type");
+ vfprintf_fail (formats[FMT_QUOTE], get_file_type (mode), file_existing, "is not a valid file type");
}
}
}
}
else
p = color + strlen (color);
- assert (p);
+ assert (p != NULL);
for (ch = color; *ch; ch++)
if (!isalpha (*ch))
line = buf;
while ((eol = strpbrk (line, "\n\r")))
{
+ const bool has_text = (eol > line);
const char *p;
flags &= ~(CR|LF);
if (*eol == '\r')
vfprintf_fail (formats[FMT_FILE], file, "unrecognized line ending");
p = eol + SKIP_LINE_ENDINGS (flags);
*eol = '\0';
- print_line (attr, colors, line, flags);
+ print_line (attr, colors, line, flags,
+ omit_color_empty ? has_text : true);
line = p;
}
if (feof (stream))
{
if (*line != '\0')
- print_line (attr, colors, line, 0);
+ print_line (attr, colors, line, 0, true);
}
else if (*line != '\0')
{
if ((clean || clean_all) && (p = strrchr (line, '\033')))
merge_print_line (line, p, stream);
else
- print_line (attr, colors, line, 0);
+ print_line (attr, colors, line, 0, true);
}
}
}
if (read_from_stream)
save_char (ch, buf, &i, &size);
}
- else /* read next character */
+ else /* got next character */
{
got_next_char = true;
break;
}
static void
-print_line (const char *attr, const struct color **colors, const char *const line, unsigned int flags)
+print_line (const char *attr, const struct color **colors, const char *const line, unsigned int flags, bool emit_colors)
{
/* --clean[-all] */
if (clean || clean_all)
print_clean (line);
- else
+ /* skip for --omit-color-empty? */
+ else if (emit_colors)
{
/* Foreground color code is guaranteed to be set when background color code is present. */
if (colors[BACKGROUND] && colors[BACKGROUND]->code)
{
char *p;
- assert (strlen (str));
- assert (strlen (name));
+ assert (strlen (str) > 0);
+ assert (strlen (name) > 0);
if (!(*str == *name || *str == toupper (*name)))
return false;
else if (*(name + 1) != '\0'
&& !((p = strstr (str + 1, name + 1)) && p == str + 1))
return false;
-
- return true;
+ else
+ return true;
}
static FILE *
va_start (ap, fmt); \
vfprintf (stderr, fmt, ap); \
va_end (ap); \
- fprintf (stderr, "\n"); \
+ fprintf (stderr, "\n");
static void
vfprintf_diag (const char *fmt, ...)
projects / colorize.git / blobdiff