]> git.refcnt.org Git - colorize.git/blob - colorize.c
3bb628a8883efbe36f192252d8e2da3f8eb70e7b
[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_SOURCE
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.50"
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_options (unsigned int, char **, bool *, const struct color **, const char **, FILE **);
183 static void process_file_option (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;
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_option (argv[optind], &file, &stream);
323 else
324 process_options (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_options (unsigned int arg_cnt, char **option_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 ? option_strings[0] : NULL;
417 const char *file_string = arg_cnt == 2 ? option_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_option (file_string, file, stream);
560 }
561
562 static void
563 process_file_option (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 }
602
603 #define MERGE_PRINT_LINE(part_line, line, flags, check_eof) do { \
604 char *current_line, *merged_line = NULL; \
605 if (part_line) \
606 { \
607 merged_line = str_concat (part_line, line); \
608 free_null (part_line); \
609 } \
610 current_line = merged_line ? merged_line : (char *)line; \
611 if (!check_eof || *current_line != '\0') \
612 print_line (colors, bold, current_line, flags); \
613 free (merged_line); \
614 } while (false);
615
616 static void
617 read_print_stream (bool bold, const struct color **colors, const char *file, FILE *stream)
618 {
619 char buf[BUF_SIZE], *part_line = NULL;
620 unsigned int flags = 0;
621
622 while (!feof (stream))
623 {
624 size_t bytes_read;
625 char *eol;
626 const char *line;
627 memset (buf, '\0', BUF_SIZE);
628 bytes_read = fread (buf, 1, BUF_SIZE - 1, stream);
629 if (bytes_read != (BUF_SIZE - 1) && ferror (stream))
630 vfprintf_fail (formats[FMT_ERROR], BUF_SIZE - 1, "read");
631 line = buf;
632 while ((eol = strpbrk (line, "\n\r")))
633 {
634 char *p;
635 flags &= ~(CR|LF);
636 if (*eol == '\r')
637 {
638 flags |= CR;
639 if (*(eol + 1) == '\n')
640 flags |= LF;
641 }
642 else if (*eol == '\n')
643 flags |= LF;
644 else
645 vfprintf_fail (formats[FMT_FILE], file, "unrecognized line ending");
646 p = eol + SKIP_LINE_ENDINGS (flags);
647 *eol = '\0';
648 MERGE_PRINT_LINE (part_line, line, flags, false);
649 line = p;
650 }
651 if (feof (stream)) {
652 MERGE_PRINT_LINE (part_line, line, 0, true);
653 }
654 else if (*line != '\0')
655 {
656 if (!clean && !clean_all) /* efficiency */
657 print_line (colors, bold, line, 0);
658 else if (!part_line)
659 part_line = xstrdup (line);
660 else
661 {
662 char *merged_line = str_concat (part_line, line);
663 free (part_line);
664 part_line = merged_line;
665 }
666 }
667 }
668 }
669
670 static void
671 find_color_entries (struct color_name **color_names, const struct color **colors)
672 {
673 struct timeval tv;
674 unsigned int index;
675
676 /* randomness */
677 gettimeofday (&tv, NULL);
678 srand (tv.tv_usec * tv.tv_sec);
679
680 for (index = 0; color_names[index]; index++)
681 {
682 const char *color_name = color_names[index]->name;
683
684 const unsigned int count = tables[index].count;
685 const struct color *const color_entries = tables[index].entries;
686
687 if (streq (color_name, "random"))
688 {
689 bool excludable;
690 unsigned int i;
691 do {
692 excludable = false;
693 i = rand() % (count - 2) + 1; /* omit color none and default */
694 switch (index)
695 {
696 case FOREGROUND:
697 /* --exclude-random */
698 if (exclude && streq (exclude, color_entries[i].name))
699 excludable = true;
700 else if (color_names[BACKGROUND] && streq (color_names[BACKGROUND]->name, color_entries[i].name))
701 excludable = true;
702 break;
703 case BACKGROUND:
704 if (streq (colors[FOREGROUND]->name, color_entries[i].name))
705 excludable = true;
706 break;
707 default: /* never reached */
708 ABORT_TRACE ();
709 }
710 } while (excludable);
711 colors[index] = (struct color *)&color_entries[i];
712 }
713 else
714 find_color_entry (color_names[index], index, colors);
715 }
716 }
717
718 static void
719 find_color_entry (const struct color_name *color_name, unsigned int index, const struct color **colors)
720 {
721 bool found = false;
722 unsigned int i;
723
724 const unsigned int count = tables[index].count;
725 const struct color *const color_entries = tables[index].entries;
726
727 for (i = 0; i < count; i++)
728 if (streq (color_name->name, color_entries[i].name))
729 {
730 colors[index] = (struct color *)&color_entries[i];
731 found = true;
732 break;
733 }
734 if (!found)
735 vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color_name->orig, "not recognized");
736 }
737
738 static void
739 print_line (const struct color **colors, bool bold, const char *const line, unsigned int flags)
740 {
741 /* --clean[-all] */
742 if (clean || clean_all)
743 print_clean (line);
744 else
745 {
746 /* Foreground color code is guaranteed to be set when background color code is present. */
747 if (colors[BACKGROUND] && colors[BACKGROUND]->code)
748 printf ("\033[%s", colors[BACKGROUND]->code);
749 if (colors[FOREGROUND]->code)
750 printf ("\033[%s%s%s\033[0m", bold ? "1;" : "", colors[FOREGROUND]->code, line);
751 else
752 printf (formats[FMT_GENERIC], line);
753 }
754 if (flags & CR)
755 putchar ('\r');
756 if (flags & LF)
757 putchar ('\n');
758 }
759
760 static void
761 print_clean (const char *line)
762 {
763 const char *p;
764 char ***offsets = NULL;
765 unsigned int count = 0, i = 0;
766
767 for (p = line; *p;)
768 {
769 /* ESC[ */
770 if (*p == 27 && *(p + 1) == '[')
771 {
772 const char *begin = p;
773 p += 2;
774 if (clean_all)
775 {
776 while (isdigit (*p) || *p == ';')
777 p++;
778 }
779 else if (clean)
780 {
781 bool check_values;
782 unsigned int iter = 0;
783 const char *digit;
784 do {
785 check_values = false;
786 iter++;
787 if (!isdigit (*p))
788 goto DISCARD;
789 digit = p;
790 while (isdigit (*p))
791 p++;
792 if (p - digit > 2)
793 goto DISCARD;
794 else /* check range */
795 {
796 char val[3];
797 int value;
798 unsigned int i;
799 const unsigned int digits = p - digit;
800 for (i = 0; i < digits; i++)
801 val[i] = *digit++;
802 val[i] = '\0';
803 value = atoi (val);
804 if (value == 0) /* reset */
805 {
806 if (iter > 1)
807 goto DISCARD;
808 goto END;
809 }
810 else if (value == 1) /* bold */
811 {
812 bool discard = false;
813 if (iter > 1)
814 discard = true;
815 else if (*p != ';')
816 discard = true;
817 if (discard)
818 goto DISCARD;
819 p++;
820 check_values = true;
821 }
822 else if ((value >= 30 && value <= 37) || value == 39) /* foreground colors */
823 goto END;
824 else if ((value >= 40 && value <= 47) || value == 49) /* background colors */
825 {
826 if (iter > 1)
827 goto DISCARD;
828 goto END;
829 }
830 else
831 goto DISCARD;
832 }
833 } while (iter == 1 && check_values);
834 }
835 END: if (*p == 'm')
836 {
837 const char *end = p++;
838 if (!offsets)
839 offsets = xmalloc (++count * sizeof (char **));
840 else
841 offsets = xrealloc (offsets, ++count * sizeof (char **));
842 offsets[i] = xmalloc (2 * sizeof (char *));
843 offsets[i][0] = (char *)begin; /* ESC */
844 offsets[i][1] = (char *)end; /* m */
845 i++;
846 continue;
847 }
848 DISCARD:
849 continue;
850 }
851 p++;
852 }
853
854 if (offsets)
855 print_free_offsets (line, offsets, count);
856 else
857 printf (formats[FMT_GENERIC], line);
858 }
859
860 #define SET_CHAR(offset, new, old) \
861 *old = *offset; \
862 *offset = new; \
863
864 #define RESTORE_CHAR(offset, old) \
865 *offset = old; \
866
867 static void
868 print_free_offsets (const char *line, char ***offsets, unsigned int count)
869 {
870 char ch;
871 unsigned int i;
872
873 SET_CHAR (offsets[0][0], '\0', &ch);
874 printf (formats[FMT_GENERIC], line);
875 RESTORE_CHAR (offsets[0][0], ch);
876
877 for (i = 0; i < count; i++)
878 {
879 char ch;
880 bool next_offset = false;
881 if (i + 1 < count)
882 {
883 SET_CHAR (offsets[i + 1][0], '\0', &ch);
884 next_offset = true;
885 }
886 printf (formats[FMT_GENERIC], offsets[i][1] + 1);
887 if (next_offset)
888 RESTORE_CHAR (offsets[i + 1][0], ch);
889 }
890 for (i = 0; i < count; i++)
891 free_null (offsets[i]);
892 free_null (offsets);
893 }
894
895 static void *
896 malloc_wrap (size_t size)
897 {
898 void *p = malloc (size);
899 if (!p)
900 MEM_ALLOC_FAIL ();
901 return p;
902 }
903
904 static void *
905 calloc_wrap (size_t nmemb, size_t size)
906 {
907 void *p = calloc (nmemb, size);
908 if (!p)
909 MEM_ALLOC_FAIL ();
910 return p;
911 }
912
913 static void *
914 realloc_wrap (void *ptr, size_t size)
915 {
916 void *p = realloc (ptr, size);
917 if (!p)
918 MEM_ALLOC_FAIL ();
919 return p;
920 }
921
922 static void *
923 malloc_wrap_debug (size_t size, const char *file, unsigned int line)
924 {
925 void *p = malloc (size);
926 if (!p)
927 MEM_ALLOC_FAIL_DEBUG (file, line);
928 return p;
929 }
930
931 static void *
932 calloc_wrap_debug (size_t nmemb, size_t size, const char *file, unsigned int line)
933 {
934 void *p = calloc (nmemb, size);
935 if (!p)
936 MEM_ALLOC_FAIL_DEBUG (file, line);
937 return p;
938 }
939
940 static void *
941 realloc_wrap_debug (void *ptr, size_t size, const char *file, unsigned int line)
942 {
943 void *p = realloc (ptr, size);
944 if (!p)
945 MEM_ALLOC_FAIL_DEBUG (file, line);
946 return p;
947 }
948
949 static void
950 free_wrap (void **ptr)
951 {
952 free (*ptr);
953 *ptr = NULL;
954 }
955
956 static char *
957 strdup_wrap (const char *str)
958 {
959 const size_t len = strlen (str) + 1;
960 char *p = xmalloc (len);
961 strncpy (p, str, len);
962 return p;
963 }
964
965 static char *
966 str_concat (const char *str1, const char *str2)
967 {
968 const size_t len = strlen (str1) + strlen (str2) + 1;
969 char *p, *str;
970
971 p = str = xmalloc (len);
972 strncpy (p, str1, strlen (str1));
973 p += strlen (str1);
974 strncpy (p, str2, strlen (str2));
975 p += strlen (str2);
976 *p = '\0';
977
978 return str;
979 }
980
981 #define DO_VFPRINTF(fmt) \
982 va_list ap; \
983 fprintf (stderr, "%s: ", program_name); \
984 va_start (ap, fmt); \
985 vfprintf (stderr, fmt, ap); \
986 va_end (ap); \
987 fprintf (stderr, "\n"); \
988
989 static void
990 vfprintf_diag (const char *fmt, ...)
991 {
992 DO_VFPRINTF (fmt);
993 }
994
995 static void
996 vfprintf_fail (const char *fmt, ...)
997 {
998 DO_VFPRINTF (fmt);
999 exit (EXIT_FAILURE);
1000 }
1001
1002 static void
1003 stack_var (void ***list, unsigned int *stacked, unsigned int index, void *ptr)
1004 {
1005 /* nothing to stack */
1006 if (ptr == NULL)
1007 return;
1008 if (!*list)
1009 *list = xmalloc (sizeof (void *));
1010 else
1011 {
1012 unsigned int i;
1013 for (i = 0; i < *stacked; i++)
1014 if (!(*list)[i])
1015 {
1016 (*list)[i] = ptr;
1017 return; /* reused */
1018 }
1019 *list = xrealloc (*list, (*stacked + 1) * sizeof (void *));
1020 }
1021 (*list)[index] = ptr;
1022 (*stacked)++;
1023 }
1024
1025 static void
1026 release_var (void **list, unsigned int stacked, void **ptr)
1027 {
1028 unsigned int i;
1029 /* nothing to release */
1030 if (*ptr == NULL)
1031 return;
1032 for (i = 0; i < stacked; i++)
1033 if (list[i] == *ptr)
1034 {
1035 free (*ptr);
1036 *ptr = NULL;
1037 list[i] = NULL;
1038 return;
1039 }
1040 }