]> git.refcnt.org Git - colorize.git/blob - colorize.c
Replace option part of identifiers with arg
[colorize.git] / colorize.c
1 /*
2 * colorize - Read text from standard input stream or file and print
3 * it colorized through use of ANSI escape sequences
4 *
5 * Copyright (c) 2011-2013 Steven Schubiger
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 *
20 */
21
22 #define _POSIX_C_SOURCE 200809L
23 #include <assert.h>
24 #include <ctype.h>
25 #include <errno.h>
26 #include <getopt.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/time.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <time.h>
35 #include <unistd.h>
36
37 #ifndef DEBUG
38 # define DEBUG 0
39 #endif
40
41 #define str(arg) #arg
42 #define to_str(arg) str(arg)
43
44 #define streq(s1, s2) (strcmp (s1, s2) == 0)
45
46 #if DEBUG
47 # define xmalloc(size) malloc_wrap_debug(size, __FILE__, __LINE__)
48 # define xcalloc(nmemb, size) calloc_wrap_debug(nmemb, size, __FILE__, __LINE__)
49 # define xrealloc(ptr, size) realloc_wrap_debug(ptr, size, __FILE__, __LINE__)
50 #else
51 # define xmalloc(size) malloc_wrap(size)
52 # define xcalloc(nmemb, size) calloc_wrap(nmemb, size)
53 # define xrealloc(ptr, size) realloc_wrap(ptr, size)
54 #endif
55
56 #define free_null(ptr) free_wrap((void **)&ptr)
57 #define xstrdup(str) strdup_wrap(str)
58
59 #if !defined BUF_SIZE || BUF_SIZE <= 0
60 # undef BUF_SIZE
61 # define BUF_SIZE 4096 + 1
62 #endif
63
64 #define LF 0x01
65 #define CR 0x02
66
67 #define SKIP_LINE_ENDINGS(flags) (((flags) & CR) && ((flags) & LF) ? 2 : 1)
68
69 #define STACK_VAR(ptr) do { \
70 stack_var (&vars_list, &stacked_vars, stacked_vars, ptr); \
71 } while (false);
72
73 #define RELEASE_VAR(ptr) do { \
74 release_var (vars_list, stacked_vars, (void **)&ptr); \
75 } while (false);
76
77 #define MEM_ALLOC_FAIL_DEBUG(file, line) do { \
78 fprintf (stderr, "Memory allocation failure in source file %s, line %u\n", file, line); \
79 exit (2); \
80 } while (false);
81 #define MEM_ALLOC_FAIL() do { \
82 fprintf (stderr, "%s: memory allocation failure\n", program_name); \
83 exit (2); \
84 } while (false);
85
86 #define ABORT_TRACE() \
87 fprintf (stderr, "Aborting in source file %s, line %u\n", __FILE__, __LINE__); \
88 abort (); \
89
90 #define CHECK_COLORS_RANDOM(color1, color2) \
91 streq (color_names[color1]->name, "random") \
92 && (streq (color_names[color2]->name, "none") \
93 || streq (color_names[color2]->name, "default")) \
94
95 #define COLOR_SEP_CHAR '/'
96
97 #define VERSION "0.51"
98
99 typedef unsigned short bool;
100
101 enum { false, true };
102
103 struct color_name {
104 char *name;
105 char *orig;
106 };
107
108 static struct color_name *color_names[3] = { NULL, NULL, NULL };
109
110 struct color {
111 const char *name;
112 const char *code;
113 };
114
115 static const struct color fg_colors[] = {
116 { "none", NULL },
117 { "black", "30m" },
118 { "red", "31m" },
119 { "green", "32m" },
120 { "yellow", "33m" },
121 { "blue", "34m" },
122 { "cyan", "35m" },
123 { "magenta", "36m" },
124 { "white", "37m" },
125 { "default", "39m" },
126 };
127 static const struct color bg_colors[] = {
128 { "none", NULL },
129 { "black", "40m" },
130 { "red", "41m" },
131 { "green", "42m" },
132 { "yellow", "43m" },
133 { "blue", "44m" },
134 { "cyan", "45m" },
135 { "magenta", "46m" },
136 { "white", "47m" },
137 { "default", "49m" },
138 };
139
140 enum fmts {
141 FMT_GENERIC,
142 FMT_COLOR,
143 FMT_RANDOM,
144 FMT_ERROR,
145 FMT_FILE
146 };
147 static const char *formats[] = {
148 "%s", /* generic */
149 "%s color '%s' %s", /* color */
150 "%s color '%s' %s '%s'", /* random */
151 "less than %u bytes %s", /* error */
152 "%s: %s", /* file */
153 };
154
155 enum { FOREGROUND, BACKGROUND };
156
157 static const struct {
158 struct color const *entries;
159 unsigned int count;
160 const char *desc;
161 } tables[] = {
162 { fg_colors, sizeof (fg_colors) / sizeof (struct color), "foreground" },
163 { bg_colors, sizeof (bg_colors) / sizeof (struct color), "background" },
164 };
165
166 static FILE *stream = NULL;
167
168 static unsigned int stacked_vars = 0;
169 static void **vars_list = NULL;
170
171 static bool clean = false;
172 static bool clean_all = false;
173
174 static char *exclude = NULL;
175
176 static const char *program_name;
177
178 static void print_help (void);
179 static void print_version (void);
180 static void cleanup (void);
181 static void free_color_names (struct color_name **);
182 static void process_args (unsigned int, char **, bool *, const struct color **, const char **, FILE **);
183 static void process_file_arg (const char *, const char **, FILE **);
184 static void read_print_stream (bool, const struct color **, const char *, FILE *);
185 static void find_color_entries (struct color_name **, const struct color **);
186 static void find_color_entry (const struct color_name *, unsigned int, const struct color **);
187 static void print_line (const struct color **, bool, const char * const, unsigned int);
188 static void print_clean (const char *);
189 static void print_free_offsets (const char *, char ***, unsigned int);
190 static void *malloc_wrap (size_t);
191 static void *calloc_wrap (size_t, size_t);
192 static void *realloc_wrap (void *, size_t);
193 static void *malloc_wrap_debug (size_t, const char *, unsigned int);
194 static void *calloc_wrap_debug (size_t, size_t, const char *, unsigned int);
195 static void *realloc_wrap_debug (void *, size_t, const char *, unsigned int);
196 static void free_wrap (void **);
197 static char *strdup_wrap (const char *);
198 static char *str_concat (const char *, const char *);
199 static void vfprintf_diag (const char *, ...);
200 static void vfprintf_fail (const char *, ...);
201 static void stack_var (void ***, unsigned int *, unsigned int, void *);
202 static void release_var (void **, unsigned int, void **);
203
204 #define SET_OPT_TYPE(type) \
205 opt_type = type; \
206 opt = 0; \
207 goto PARSE_OPT; \
208
209 extern char *optarg;
210 extern int optind;
211
212 int
213 main (int argc, char **argv)
214 {
215 unsigned int arg_cnt = 0;
216
217 enum {
218 OPT_CLEAN = 1,
219 OPT_CLEAN_ALL,
220 OPT_EXCLUDE_RANDOM,
221 OPT_HELP,
222 OPT_VERSION
223 };
224
225 int opt, opt_type = 0;
226 struct option long_opts[] = {
227 { "clean", no_argument, &opt_type, OPT_CLEAN },
228 { "clean-all", no_argument, &opt_type, OPT_CLEAN_ALL },
229 { "exclude-random", required_argument, &opt_type, OPT_EXCLUDE_RANDOM },
230 { "help", no_argument, &opt_type, OPT_HELP },
231 { "version", no_argument, &opt_type, OPT_VERSION },
232 { 0, 0, 0, 0 },
233 };
234
235 bool bold = false;
236
237 const struct color *colors[2] = {
238 NULL, /* foreground */
239 NULL, /* background */
240 };
241
242 const char *file = NULL;
243
244 program_name = argv[0];
245 atexit (cleanup);
246
247 setvbuf (stdout, NULL, _IOLBF, 0);
248
249 while ((opt = getopt_long (argc, argv, "hv", long_opts, NULL)) != -1)
250 {
251 PARSE_OPT:
252 switch (opt)
253 {
254 case 0: /* long opts */
255 switch (opt_type)
256 {
257 case OPT_CLEAN:
258 clean = true;
259 break;
260 case OPT_CLEAN_ALL:
261 clean_all = true;
262 break;
263 case OPT_EXCLUDE_RANDOM: {
264 char *p;
265 exclude = xstrdup (optarg);
266 STACK_VAR (exclude);
267 for (p = exclude; *p; p++)
268 *p = tolower (*p);
269 if (streq (exclude, "random"))
270 vfprintf_fail (formats[FMT_GENERIC], "--exclude-random switch must be provided a color");
271 break;
272 }
273 case OPT_HELP:
274 print_help ();
275 exit (EXIT_SUCCESS);
276 case OPT_VERSION:
277 print_version ();
278 exit (EXIT_SUCCESS);
279 default: /* never reached */
280 ABORT_TRACE ();
281 }
282 break;
283 case 'h':
284 SET_OPT_TYPE (OPT_HELP);
285 case 'v':
286 SET_OPT_TYPE (OPT_VERSION);
287 case '?':
288 print_help ();
289 exit (EXIT_FAILURE);
290 default: /* never reached */
291 ABORT_TRACE ();
292 }
293 }
294
295 arg_cnt = argc - optind;
296
297 if (clean || clean_all)
298 {
299 if (clean && clean_all)
300 vfprintf_fail (formats[FMT_GENERIC], "--clean and --clean-all switch are mutually exclusive");
301 if (arg_cnt > 1)
302 {
303 const char *format = "%s %s";
304 const char *message = "switch cannot be used with more than one file";
305 if (clean)
306 vfprintf_fail (format, "--clean", message);
307 else if (clean_all)
308 vfprintf_fail (format, "--clean-all", message);
309 }
310 }
311 else
312 {
313 if (arg_cnt == 0 || arg_cnt > 2)
314 {
315 vfprintf_diag ("%u arguments provided, expected 1-2 arguments or option", arg_cnt);
316 print_help ();
317 exit (EXIT_FAILURE);
318 }
319 }
320
321 if (clean || clean_all)
322 process_file_arg (argv[optind], &file, &stream);
323 else
324 process_args (arg_cnt, &argv[optind], &bold, colors, &file, &stream);
325 read_print_stream (bold, colors, file, stream);
326
327 RELEASE_VAR (exclude);
328
329 exit (EXIT_SUCCESS);
330 }
331
332 static void
333 print_help (void)
334 {
335 unsigned int i;
336
337 printf ("Usage: %s (foreground) OR (foreground)%c(background) OR --clean[-all] [-|file]\n\n", program_name, COLOR_SEP_CHAR);
338 printf ("\tColors (foreground) (background)\n");
339 for (i = 0; i < tables[FOREGROUND].count; i++)
340 {
341 const struct color *entry = &tables[FOREGROUND].entries[i];
342 const char *name = entry->name;
343 const char *code = entry->code;
344 if (code)
345 printf ("\t\t{\033[%s#\033[0m} [%c%c]%s%*s%s\n",
346 code, toupper (*name), *name, name + 1, 10 - (int)strlen (name), " ", name);
347 else
348 printf ("\t\t{-} %s%*s%s\n", name, 13 - (int)strlen (name), " ", name);
349 }
350 printf ("\t\t{*} [Rr]%s%*s%s [--exclude-random=<foreground color>]\n", "andom", 10 - (int)strlen ("random"), " ", "random");
351
352 printf ("\n\tFirst character of color name in upper case denotes increased intensity,\n");
353 printf ("\twhereas for lower case colors will be of normal intensity.\n");
354
355 printf ("\n\tOptions\n");
356 printf ("\t\t --clean\n");
357 printf ("\t\t --clean-all\n");
358 printf ("\t\t --exclude-random\n");
359 printf ("\t\t-h, --help\n");
360 printf ("\t\t-v, --version\n\n");
361 }
362
363 static void
364 print_version (void)
365 {
366 const char *c_flags;
367 printf ("%s v%s (compiled at %s, %s)\n", "colorize", VERSION, __DATE__, __TIME__);
368 #ifdef CFLAGS
369 c_flags = to_str (CFLAGS);
370 #else
371 c_flags = "unknown";
372 #endif
373 printf ("Compiler flags: %s\n", c_flags);
374 printf ("Buffer size: %u bytes\n", BUF_SIZE - 1);
375 }
376
377 static void
378 cleanup (void)
379 {
380 free_color_names (color_names);
381
382 if (stream && fileno (stream) != STDIN_FILENO)
383 fclose (stream);
384
385 if (vars_list)
386 {
387 unsigned int i;
388 for (i = 0; i < stacked_vars; i++)
389 if (vars_list[i])
390 free_null (vars_list[i]);
391
392 free_null (vars_list);
393 }
394 }
395
396 static void
397 free_color_names (struct color_name **color_names)
398 {
399 unsigned int i;
400 for (i = 0; color_names[i]; i++)
401 {
402 free_null (color_names[i]->name);
403 free_null (color_names[i]->orig);
404 free_null (color_names[i]);
405 }
406 }
407
408 static void
409 process_args (unsigned int arg_cnt, char **arg_strings, bool *bold, const struct color **colors, const char **file, FILE **stream)
410 {
411 int ret;
412 unsigned int index;
413 char *color, *p, *str;
414 struct stat sb;
415
416 const char *color_string = arg_cnt >= 1 ? arg_strings[0] : NULL;
417 const char *file_string = arg_cnt == 2 ? arg_strings[1] : NULL;
418
419 assert (color_string);
420
421 if (streq (color_string, "-"))
422 {
423 if (file_string)
424 vfprintf_fail (formats[FMT_GENERIC], "hyphen cannot be used as color string");
425 else
426 vfprintf_fail (formats[FMT_GENERIC], "hyphen must be preceeded by color string");
427 }
428
429 ret = stat (color_string, &sb);
430
431 /* Ensure that we don't fail if there's a file with one or more
432 color names in its path. */
433 if (ret != -1)
434 {
435 bool have_file;
436 unsigned int c;
437 const char *color = color_string;
438
439 for (c = 1; c <= 2 && *color; c++)
440 {
441 bool matched = false;
442 unsigned int i;
443 for (i = 0; i < tables[FOREGROUND].count; i++)
444 {
445 const struct color *entry = &tables[FOREGROUND].entries[i];
446 char *p;
447 if ((p = strstr (color, entry->name)) && p == color)
448 {
449 color = p + strlen (entry->name);
450 matched = true;
451 break;
452 }
453 }
454 if (matched && *color == COLOR_SEP_CHAR && *(color + 1))
455 color++;
456 else
457 break;
458 }
459
460 have_file = (*color != '\0');
461
462 if (have_file)
463 {
464 if (file_string)
465 vfprintf_fail (formats[FMT_GENERIC], "file cannot be used as color string");
466 else
467 vfprintf_fail (formats[FMT_GENERIC], "file must be preceeded by color string");
468 }
469 }
470
471 if ((p = strchr (color_string, COLOR_SEP_CHAR)))
472 {
473 if (p == color_string)
474 vfprintf_fail (formats[FMT_GENERIC], "foreground color missing");
475 else if (p == color_string + strlen (color_string) - 1)
476 vfprintf_fail (formats[FMT_GENERIC], "background color missing");
477 else if (strchr (++p, COLOR_SEP_CHAR))
478 vfprintf_fail (formats[FMT_GENERIC], "one color pair allowed only");
479 }
480
481 str = xstrdup (color_string);
482 STACK_VAR (str);
483
484 for (index = 0, color = str; *color; index++, color = p)
485 {
486 char *ch, *sep;
487 if ((sep = strchr (color, COLOR_SEP_CHAR)))
488 {
489 *sep = '\0';
490 p = sep + 1;
491 }
492 else
493 p = color + strlen (color);
494
495 for (ch = color; *ch; ch++)
496 if (!isalpha (*ch))
497 vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be made of non-alphabetic characters");
498
499 for (ch = color + 1; *ch; ch++)
500 if (!islower (*ch))
501 vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be in mixed lower/upper case");
502
503 if (streq (color, "None"))
504 vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be bold");
505
506 if (isupper (*color))
507 {
508 switch (index)
509 {
510 case FOREGROUND:
511 *bold = true;
512 break;
513 case BACKGROUND:
514 vfprintf_fail (formats[FMT_COLOR], tables[BACKGROUND].desc, color, "cannot be bold");
515 break;
516 default: /* never reached */
517 ABORT_TRACE ();
518 }
519 }
520
521 color_names[index] = xcalloc (1, sizeof (struct color_name));
522
523 color_names[index]->orig = xstrdup (color);
524
525 for (ch = color; *ch; ch++)
526 *ch = tolower (*ch);
527
528 color_names[index]->name = xstrdup (color);
529 }
530
531 RELEASE_VAR (str);
532
533 assert (color_names[FOREGROUND]);
534
535 if (color_names[BACKGROUND])
536 {
537 unsigned int i;
538 unsigned int color_sets[2][2] = { { FOREGROUND, BACKGROUND }, { BACKGROUND, FOREGROUND } };
539 for (i = 0; i < 2; i++)
540 {
541 unsigned int color1 = color_sets[i][0];
542 unsigned int color2 = color_sets[i][1];
543 if (CHECK_COLORS_RANDOM (color1, color2))
544 vfprintf_fail (formats[FMT_RANDOM], tables[color1].desc, color_names[color1]->orig, "cannot be combined with", color_names[color2]->orig);
545 }
546 }
547
548 find_color_entries (color_names, colors);
549 free_color_names (color_names);
550
551 if (!colors[FOREGROUND]->code && colors[BACKGROUND] && colors[BACKGROUND]->code)
552 {
553 struct color_name color_name;
554 color_name.name = color_name.orig = "default";
555
556 find_color_entry (&color_name, FOREGROUND, colors);
557 }
558
559 process_file_arg (file_string, file, stream);
560 }
561
562 static void
563 process_file_arg (const char *file_string, const char **file, FILE **stream)
564 {
565 if (file_string)
566 {
567 if (streq (file_string, "-"))
568 *stream = stdin;
569 else
570 {
571 FILE *s;
572 const char *file = file_string;
573 struct stat sb;
574 int errno, ret;
575
576 errno = 0;
577 ret = stat (file, &sb);
578
579 if (ret == -1)
580 vfprintf_fail (formats[FMT_FILE], file, strerror (errno));
581
582 if (!(S_ISREG (sb.st_mode) || S_ISLNK (sb.st_mode) || S_ISFIFO (sb.st_mode)))
583 vfprintf_fail (formats[FMT_FILE], file, "unrecognized file type");
584
585 errno = 0;
586
587 s = fopen (file, "r");
588 if (!s)
589 vfprintf_fail (formats[FMT_FILE], file, strerror (errno));
590 *stream = s;
591 }
592 *file = file_string;
593 }
594 else
595 {
596 *stream = stdin;
597 *file = "stdin";
598 }
599
600 assert (*stream);
601 assert (*file);
602 }
603
604 #define MERGE_PRINT_LINE(part_line, line, flags, check_eof) do { \
605 char *current_line, *merged_line = NULL; \
606 if (part_line) \
607 { \
608 merged_line = str_concat (part_line, line); \
609 free_null (part_line); \
610 } \
611 current_line = merged_line ? merged_line : (char *)line; \
612 if (!check_eof || *current_line != '\0') \
613 print_line (colors, bold, current_line, flags); \
614 free (merged_line); \
615 } while (false);
616
617 static void
618 read_print_stream (bool bold, const struct color **colors, const char *file, FILE *stream)
619 {
620 char buf[BUF_SIZE], *part_line = NULL;
621 unsigned int flags = 0;
622
623 while (!feof (stream))
624 {
625 size_t bytes_read;
626 char *eol;
627 const char *line;
628 memset (buf, '\0', BUF_SIZE);
629 bytes_read = fread (buf, 1, BUF_SIZE - 1, stream);
630 if (bytes_read != (BUF_SIZE - 1) && ferror (stream))
631 vfprintf_fail (formats[FMT_ERROR], BUF_SIZE - 1, "read");
632 line = buf;
633 while ((eol = strpbrk (line, "\n\r")))
634 {
635 char *p;
636 flags &= ~(CR|LF);
637 if (*eol == '\r')
638 {
639 flags |= CR;
640 if (*(eol + 1) == '\n')
641 flags |= LF;
642 }
643 else if (*eol == '\n')
644 flags |= LF;
645 else
646 vfprintf_fail (formats[FMT_FILE], file, "unrecognized line ending");
647 p = eol + SKIP_LINE_ENDINGS (flags);
648 *eol = '\0';
649 MERGE_PRINT_LINE (part_line, line, flags, false);
650 line = p;
651 }
652 if (feof (stream)) {
653 MERGE_PRINT_LINE (part_line, line, 0, true);
654 }
655 else if (*line != '\0')
656 {
657 if (!clean && !clean_all) /* efficiency */
658 print_line (colors, bold, line, 0);
659 else if (!part_line)
660 part_line = xstrdup (line);
661 else
662 {
663 char *merged_line = str_concat (part_line, line);
664 free (part_line);
665 part_line = merged_line;
666 }
667 }
668 }
669 }
670
671 static void
672 find_color_entries (struct color_name **color_names, const struct color **colors)
673 {
674 struct timeval tv;
675 unsigned int index;
676
677 /* randomness */
678 gettimeofday (&tv, NULL);
679 srand (tv.tv_usec * tv.tv_sec);
680
681 for (index = 0; color_names[index]; index++)
682 {
683 const char *color_name = color_names[index]->name;
684
685 const unsigned int count = tables[index].count;
686 const struct color *const color_entries = tables[index].entries;
687
688 if (streq (color_name, "random"))
689 {
690 bool excludable;
691 unsigned int i;
692 do {
693 excludable = false;
694 i = rand() % (count - 2) + 1; /* omit color none and default */
695 switch (index)
696 {
697 case FOREGROUND:
698 /* --exclude-random */
699 if (exclude && streq (exclude, color_entries[i].name))
700 excludable = true;
701 else if (color_names[BACKGROUND] && streq (color_names[BACKGROUND]->name, color_entries[i].name))
702 excludable = true;
703 break;
704 case BACKGROUND:
705 if (streq (colors[FOREGROUND]->name, color_entries[i].name))
706 excludable = true;
707 break;
708 default: /* never reached */
709 ABORT_TRACE ();
710 }
711 } while (excludable);
712 colors[index] = (struct color *)&color_entries[i];
713 }
714 else
715 find_color_entry (color_names[index], index, colors);
716 }
717 }
718
719 static void
720 find_color_entry (const struct color_name *color_name, unsigned int index, const struct color **colors)
721 {
722 bool found = false;
723 unsigned int i;
724
725 const unsigned int count = tables[index].count;
726 const struct color *const color_entries = tables[index].entries;
727
728 for (i = 0; i < count; i++)
729 if (streq (color_name->name, color_entries[i].name))
730 {
731 colors[index] = (struct color *)&color_entries[i];
732 found = true;
733 break;
734 }
735 if (!found)
736 vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color_name->orig, "not recognized");
737 }
738
739 static void
740 print_line (const struct color **colors, bool bold, const char *const line, unsigned int flags)
741 {
742 /* --clean[-all] */
743 if (clean || clean_all)
744 print_clean (line);
745 else
746 {
747 /* Foreground color code is guaranteed to be set when background color code is present. */
748 if (colors[BACKGROUND] && colors[BACKGROUND]->code)
749 printf ("\033[%s", colors[BACKGROUND]->code);
750 if (colors[FOREGROUND]->code)
751 printf ("\033[%s%s%s\033[0m", bold ? "1;" : "", colors[FOREGROUND]->code, line);
752 else
753 printf (formats[FMT_GENERIC], line);
754 }
755 if (flags & CR)
756 putchar ('\r');
757 if (flags & LF)
758 putchar ('\n');
759 }
760
761 static void
762 print_clean (const char *line)
763 {
764 const char *p;
765 char ***offsets = NULL;
766 unsigned int count = 0, i = 0;
767
768 for (p = line; *p;)
769 {
770 /* ESC[ */
771 if (*p == 27 && *(p + 1) == '[')
772 {
773 const char *begin = p;
774 p += 2;
775 if (clean_all)
776 {
777 while (isdigit (*p) || *p == ';')
778 p++;
779 }
780 else if (clean)
781 {
782 bool check_values;
783 unsigned int iter = 0;
784 const char *digit;
785 do {
786 check_values = false;
787 iter++;
788 if (!isdigit (*p))
789 goto DISCARD;
790 digit = p;
791 while (isdigit (*p))
792 p++;
793 if (p - digit > 2)
794 goto DISCARD;
795 else /* check range */
796 {
797 char val[3];
798 int value;
799 unsigned int i;
800 const unsigned int digits = p - digit;
801 for (i = 0; i < digits; i++)
802 val[i] = *digit++;
803 val[i] = '\0';
804 value = atoi (val);
805 if (value == 0) /* reset */
806 {
807 if (iter > 1)
808 goto DISCARD;
809 goto END;
810 }
811 else if (value == 1) /* bold */
812 {
813 bool discard = false;
814 if (iter > 1)
815 discard = true;
816 else if (*p != ';')
817 discard = true;
818 if (discard)
819 goto DISCARD;
820 p++;
821 check_values = true;
822 }
823 else if ((value >= 30 && value <= 37) || value == 39) /* foreground colors */
824 goto END;
825 else if ((value >= 40 && value <= 47) || value == 49) /* background colors */
826 {
827 if (iter > 1)
828 goto DISCARD;
829 goto END;
830 }
831 else
832 goto DISCARD;
833 }
834 } while (iter == 1 && check_values);
835 }
836 END: if (*p == 'm')
837 {
838 const char *end = p++;
839 if (!offsets)
840 offsets = xmalloc (++count * sizeof (char **));
841 else
842 offsets = xrealloc (offsets, ++count * sizeof (char **));
843 offsets[i] = xmalloc (2 * sizeof (char *));
844 offsets[i][0] = (char *)begin; /* ESC */
845 offsets[i][1] = (char *)end; /* m */
846 i++;
847 continue;
848 }
849 DISCARD:
850 continue;
851 }
852 p++;
853 }
854
855 if (offsets)
856 print_free_offsets (line, offsets, count);
857 else
858 printf (formats[FMT_GENERIC], line);
859 }
860
861 #define SET_CHAR(offset, new, old) \
862 *old = *offset; \
863 *offset = new; \
864
865 #define RESTORE_CHAR(offset, old) \
866 *offset = old; \
867
868 static void
869 print_free_offsets (const char *line, char ***offsets, unsigned int count)
870 {
871 char ch;
872 unsigned int i;
873
874 SET_CHAR (offsets[0][0], '\0', &ch);
875 printf (formats[FMT_GENERIC], line);
876 RESTORE_CHAR (offsets[0][0], ch);
877
878 for (i = 0; i < count; i++)
879 {
880 char ch;
881 bool next_offset = false;
882 if (i + 1 < count)
883 {
884 SET_CHAR (offsets[i + 1][0], '\0', &ch);
885 next_offset = true;
886 }
887 printf (formats[FMT_GENERIC], offsets[i][1] + 1);
888 if (next_offset)
889 RESTORE_CHAR (offsets[i + 1][0], ch);
890 }
891 for (i = 0; i < count; i++)
892 free_null (offsets[i]);
893 free_null (offsets);
894 }
895
896 static void *
897 malloc_wrap (size_t size)
898 {
899 void *p = malloc (size);
900 if (!p)
901 MEM_ALLOC_FAIL ();
902 return p;
903 }
904
905 static void *
906 calloc_wrap (size_t nmemb, size_t size)
907 {
908 void *p = calloc (nmemb, size);
909 if (!p)
910 MEM_ALLOC_FAIL ();
911 return p;
912 }
913
914 static void *
915 realloc_wrap (void *ptr, size_t size)
916 {
917 void *p = realloc (ptr, size);
918 if (!p)
919 MEM_ALLOC_FAIL ();
920 return p;
921 }
922
923 static void *
924 malloc_wrap_debug (size_t size, const char *file, unsigned int line)
925 {
926 void *p = malloc (size);
927 if (!p)
928 MEM_ALLOC_FAIL_DEBUG (file, line);
929 return p;
930 }
931
932 static void *
933 calloc_wrap_debug (size_t nmemb, size_t size, const char *file, unsigned int line)
934 {
935 void *p = calloc (nmemb, size);
936 if (!p)
937 MEM_ALLOC_FAIL_DEBUG (file, line);
938 return p;
939 }
940
941 static void *
942 realloc_wrap_debug (void *ptr, size_t size, const char *file, unsigned int line)
943 {
944 void *p = realloc (ptr, size);
945 if (!p)
946 MEM_ALLOC_FAIL_DEBUG (file, line);
947 return p;
948 }
949
950 static void
951 free_wrap (void **ptr)
952 {
953 free (*ptr);
954 *ptr = NULL;
955 }
956
957 static char *
958 strdup_wrap (const char *str)
959 {
960 const size_t len = strlen (str) + 1;
961 char *p = xmalloc (len);
962 strncpy (p, str, len);
963 return p;
964 }
965
966 static char *
967 str_concat (const char *str1, const char *str2)
968 {
969 const size_t len = strlen (str1) + strlen (str2) + 1;
970 char *p, *str;
971
972 p = str = xmalloc (len);
973 strncpy (p, str1, strlen (str1));
974 p += strlen (str1);
975 strncpy (p, str2, strlen (str2));
976 p += strlen (str2);
977 *p = '\0';
978
979 return str;
980 }
981
982 #define DO_VFPRINTF(fmt) \
983 va_list ap; \
984 fprintf (stderr, "%s: ", program_name); \
985 va_start (ap, fmt); \
986 vfprintf (stderr, fmt, ap); \
987 va_end (ap); \
988 fprintf (stderr, "\n"); \
989
990 static void
991 vfprintf_diag (const char *fmt, ...)
992 {
993 DO_VFPRINTF (fmt);
994 }
995
996 static void
997 vfprintf_fail (const char *fmt, ...)
998 {
999 DO_VFPRINTF (fmt);
1000 exit (EXIT_FAILURE);
1001 }
1002
1003 static void
1004 stack_var (void ***list, unsigned int *stacked, unsigned int index, void *ptr)
1005 {
1006 /* nothing to stack */
1007 if (ptr == NULL)
1008 return;
1009 if (!*list)
1010 *list = xmalloc (sizeof (void *));
1011 else
1012 {
1013 unsigned int i;
1014 for (i = 0; i < *stacked; i++)
1015 if (!(*list)[i])
1016 {
1017 (*list)[i] = ptr;
1018 return; /* reused */
1019 }
1020 *list = xrealloc (*list, (*stacked + 1) * sizeof (void *));
1021 }
1022 (*list)[index] = ptr;
1023 (*stacked)++;
1024 }
1025
1026 static void
1027 release_var (void **list, unsigned int stacked, void **ptr)
1028 {
1029 unsigned int i;
1030 /* nothing to release */
1031 if (*ptr == NULL)
1032 return;
1033 for (i = 0; i < stacked; i++)
1034 if (list[i] == *ptr)
1035 {
1036 free (*ptr);
1037 *ptr = NULL;
1038 list[i] = NULL;
1039 return;
1040 }
1041 }