]> git.ipfire.org Git - thirdparty/util-linux.git/blob - text-utils/column.c
projects / thirdparty / util-linux.git / blob
? search:


c3321ae166636e24196e39f67901cd0905f86247
[thirdparty/util-linux.git] / text-utils / column.c
1 /*
2 * Copyright (c) 1989, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Copyright (C) 2017 Karel Zak <kzak@redhat.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the University of
18 * California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35 #include <sys/types.h>
36 #include <sys/ioctl.h>
37
38 #include <ctype.h>
39 #include <errno.h>
40 #include <stdbool.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <unistd.h>
45 #include <getopt.h>
46
47 #include "nls.h"
48 #include "c.h"
49 #include "widechar.h"
50 #include "xalloc.h"
51 #include "strutils.h"
52 #include "closestream.h"
53 #include "ttyutils.h"
54 #include "strv.h"
55 #include "optutils.h"
56 #include "mbsalign.h"
57
58 #include "libsmartcols.h"
59
60 #define TABCHAR_CELLS 8
61
62 enum {
63 COLUMN_MODE_FILLCOLS = 0,
64 COLUMN_MODE_FILLROWS,
65 COLUMN_MODE_TABLE,
66 COLUMN_MODE_SIMPLE
67 };
68
69 struct column_control {
70 int mode; /* COLUMN_MODE_* */
71 size_t termwidth; /* -1 uninilialized, 0 unlimited, >0 width (default is 80) */
72
73 struct libscols_table *tab;
74
75 char **tab_colnames; /* array with column names */
76 const char *tab_name; /* table name */
77 const char *tab_order; /* --table-order */
78
79 char **tab_columns; /* array from --table-column */
80
81 const char *tab_colright; /* --table-right */
82 const char *tab_coltrunc; /* --table-trunc */
83 const char *tab_colnoextrem; /* --table-noextreme */
84 const char *tab_colwrap; /* --table-wrap */
85 const char *tab_colhide; /* --table-hide */
86
87 const char *tree;
88 const char *tree_id;
89 const char *tree_parent;
90
91 wchar_t *input_separator;
92 const char *output_separator;
93
94 wchar_t **ents; /* input entries */
95 size_t nents; /* number of entries */
96 size_t maxlength; /* longest input record (line) */
97 size_t maxncols; /* maximal number of input columns */
98 size_t mincolsep; /* minimal spaces between columns */
99
100 bool greedy,
101 json,
102 header_repeat,
103 hide_unnamed,
104 maxout : 1,
105 keep_empty_lines, /* --keep-empty-lines */
106 tab_noheadings,
107 use_spaces;
108 };
109
110 typedef enum {
111 ANSI_CHR = 'A',
112 ANSI_ESC = 0x1b,
113 ANSI_SGR = '[',
114 ANSI_OSC = ']',
115 ANSI_LNK = '8',
116 ANSI_LBL = 0x7,
117 ANSI_LSP = ';',
118 ANSI_LSG = 'M',
119 ANSI_END = '\\'
120 } ansi_esc_states;
121
122 /**
123 * Count how many characters are non-printable due to ANSI X3.41 escape codes.
124 *
125 * It detects and count Fe Escape and OSC 8 links sequences. These sequences contains
126 * characters that normally are printable, but due to being part of a escape sequence
127 * are ignored when displayed in console terminals.
128 */
129 static inline size_t ansi_esc_width(ansi_esc_states *state, size_t *found, const wchar_t *str, int chw)
130 {
131 switch (*state) {
132 case ANSI_CHR:
133 // ANSI X3.41 escape sequences begin with ESC ( written as \x1b \033 or ^[ )
134 if (*str == 0x1b)
135 *state = ANSI_ESC;
136 // Ignore 1 byte C1 control codes (0x80–0x9F) due to conflict with UTF-8 and CP-1252
137 return 0;
138 case ANSI_ESC:
139 // Fe escape sequences allows the range 0x40 to 0x5f
140 switch (*str) {
141 case '[': // CSI - Control Sequence Introducer
142 *state = ANSI_SGR;
143 break;
144 case ']': // OSC - Operating System Command
145 *state = ANSI_OSC;
146 break;
147 case '_': // APC - Application Program Command
148 case 'P': // DCS - Device Control String
149 case '^': // PM - Privacy Message
150 *state = ANSI_END;
151 break;
152 default:
153 *state = ANSI_CHR;
154 return 0;
155 }
156 *found = 1;
157 return 0;
158 case ANSI_SGR:
159 *found += chw;
160 // Fe escape sequences allows the range 0x30-0x3f
161 // However SGR (Select Graphic Rendition) only uses: 0-9 ';' ':'
162 if (*str >= '0' && *str <= '?')
163 return 0;
164 // Fe ends with the range 0x40-0x7e but SGR ends with 'm'
165 if (*str <= '@' && *str >= '~')
166 *found = 0;
167 break;
168 case ANSI_OSC:
169 *found += chw;
170 if (*str == ANSI_LNK) // OSC8-Link
171 *state = ANSI_LNK;
172 else
173 *state = ANSI_END; // other command sequences are ignored
174 return 0;
175 case ANSI_LNK: // OSC8 Terminal Hiperlink Sequence
176 switch (*str) {
177 case 0x7: // Separated by BEL
178 *state = ANSI_LBL; //# \e]8;;LINK\aTEXT\e]8;;\a #
179 break;
180 case 0x1b: // OSC8-Link separated by ESC-BACKSLASH
181 *found += 2;
182 *state = ANSI_LBL; //# \e]8;;LINK\e\\TEXT\e]8;;\e\\ #
183 break;
184 default:
185 *found += chw;
186 }
187 return 0; // ignore link width
188 case ANSI_LBL:
189 if (*str == 0x1b) { // Link label goes until ESC BACKSLASH
190 *found += chw;
191 *state = ANSI_LSP;
192 }
193 return 0;
194 case ANSI_LSP:
195 *found += chw;
196 if (*str == '[') // SGR FG/BG colors nested inside OSC8-Link sequence
197 *state = ANSI_LSG;
198 else
199 *state = ANSI_END; //# Link label ends with \e[8;;\e\\ #
200 return 0;
201 case ANSI_LSG: //# \e]8;;LINK\e\\\e[1;34mTEXT\e[0m\e]8;;\e\\ #
202 *found += chw;
203 if (*str < '0' || *str > '?') // SGR color sequence ends with 'm'
204 *state = ANSI_LBL;
205 return 0;
206 case ANSI_END:
207 switch (*str) {
208 case 0x1b: // APC/OSC8-Links ends with ESC-BACKSLASH
209 *found += chw;
210 break;
211 case 0x7: // APC/OSC/OSC8-Links ends with BEL
212 #ifdef HAVE_WIDECHAR
213 case 0x9c: // APC/DCS/DM ends with ST (String Terminator)
214 #endif
215 break;
216 default:
217 *found += chw;
218 return 0;
219 }
220 }
221 size_t res = *found;
222 *state = ANSI_CHR;
223 *found = 0;
224 return res;
225 }
226
227 static size_t width(const wchar_t *str)
228 {
229 size_t count = 0;
230 size_t found = 0;
231 ansi_esc_states state = ANSI_CHR;
232
233 for (; *str != '\0'; str++) {
234 #ifdef HAVE_WIDECHAR
235 int x = wcwidth(*str); /* don't use wcswidth(), need to ignore non-printable */
236 #else
237 int x = isprint(*str) ? 1 : 0;
238 #endif
239 int chw = x > 0 ? x : 0;
240 size_t nonpr = ansi_esc_width(&state, &found, str, chw);
241 count += chw - nonpr;
242 }
243 return count;
244 }
245
246 static wchar_t *mbs_to_wcs(const char *s)
247 {
248 #ifdef HAVE_WIDECHAR
249 ssize_t n;
250 wchar_t *wcs;
251
252 n = mbstowcs((wchar_t *)0, s, 0);
253 if (n < 0)
254 return NULL;
255 wcs = xcalloc((n + 1) * sizeof(wchar_t), 1);
256 n = mbstowcs(wcs, s, n + 1);
257 if (n < 0) {
258 free(wcs);
259 return NULL;
260 }
261 return wcs;
262 #else
263 return xstrdup(s);
264 #endif
265 }
266
267 static char *wcs_to_mbs(const wchar_t *s)
268 {
269 #ifdef HAVE_WIDECHAR
270 size_t n;
271 char *str;
272
273 n = wcstombs(NULL, s, 0);
274 if (n == (size_t) -1)
275 return NULL;
276
277 str = xcalloc(n + 1, 1);
278 if (wcstombs(str, s, n) == (size_t) -1) {
279 free(str);
280 return NULL;
281 }
282 return str;
283 #else
284 return xstrdup(s);
285 #endif
286 }
287
288 static wchar_t *local_wcstok(struct column_control const *const ctl, wchar_t *p,
289 wchar_t **state)
290 {
291 wchar_t *result = NULL;
292
293 if (ctl->greedy)
294 #ifdef HAVE_WIDECHAR
295 return wcstok(p, ctl->input_separator, state);
296 #else
297 return strtok_r(p, ctl->input_separator, state);
298 #endif
299 if (!p) {
300 if (!*state)
301 return NULL;
302 p = *state;
303 }
304 result = p;
305 #ifdef HAVE_WIDECHAR
306 p = wcspbrk(result, ctl->input_separator);
307 #else
308 p = strpbrk(result, ctl->input_separator);
309 #endif
310 if (!p)
311 *state = NULL;
312 else {
313 *p = '\0';
314 *state = p + 1;
315 }
316 return result;
317 }
318
319 static char **split_or_error(const char *str, const char *errmsg)
320 {
321 char **res = ul_strv_split(str, ",");
322 if (!res) {
323 if (errno == ENOMEM)
324 err_oom();
325 if (errmsg)
326 errx(EXIT_FAILURE, "%s: '%s'", errmsg, str);
327 else
328 return NULL;
329 }
330 return res;
331 }
332
333 static void init_table(struct column_control *ctl)
334 {
335 scols_init_debug(0);
336
337 ctl->tab = scols_new_table();
338 if (!ctl->tab)
339 err(EXIT_FAILURE, _("failed to allocate output table"));
340
341 scols_table_set_column_separator(ctl->tab, ctl->output_separator);
342 if (ctl->json) {
343 scols_table_enable_json(ctl->tab, 1);
344 scols_table_set_name(ctl->tab, ctl->tab_name ? : "table");
345 } else
346 scols_table_enable_noencoding(ctl->tab, 1);
347
348 scols_table_enable_maxout(ctl->tab, ctl->maxout ? 1 : 0);
349
350 if (ctl->tab_columns) {
351 char **opts;
352
353 UL_STRV_FOREACH(opts, ctl->tab_columns) {
354 struct libscols_column *cl;
355
356 cl = scols_table_new_column(ctl->tab, NULL, 0, 0);
357 scols_column_set_properties(cl, *opts);
358 }
359
360 } else if (ctl->tab_colnames) {
361 char **name;
362
363 UL_STRV_FOREACH(name, ctl->tab_colnames)
364 scols_table_new_column(ctl->tab, *name, 0, 0);
365 } else
366 scols_table_enable_noheadings(ctl->tab, 1);
367
368 if (ctl->tab_colnames || ctl->tab_columns) {
369 if (ctl->header_repeat)
370 scols_table_enable_header_repeat(ctl->tab, 1);
371 scols_table_enable_noheadings(ctl->tab, !!ctl->tab_noheadings);
372 }
373
374 }
375
376 static struct libscols_column *get_last_visible_column(struct column_control *ctl, int n)
377 {
378 struct libscols_iter *itr;
379 struct libscols_column *cl, *res = NULL;
380
381 itr = scols_new_iter(SCOLS_ITER_BACKWARD);
382 if (!itr)
383 err_oom();
384
385 while (scols_table_next_column(ctl->tab, itr, &cl) == 0) {
386 if (scols_column_get_flags(cl) & SCOLS_FL_HIDDEN)
387 continue;
388 if (n == 0) {
389 res = cl;
390 break;
391 }
392 n--;
393 }
394
395 scols_free_iter(itr);
396 return res;
397 }
398
399 static struct libscols_column *string_to_column(struct column_control *ctl, const char *str)
400 {
401 struct libscols_column *cl;
402
403 if (isdigit_string(str)) {
404 uint32_t n = strtou32_or_err(str, _("failed to parse column")) - 1;
405
406 cl = scols_table_get_column(ctl->tab, n);
407 } else if (strcmp(str, "-1") == 0)
408 cl = get_last_visible_column(ctl, 0);
409 else
410 cl = scols_table_get_column_by_name(ctl->tab, str);
411
412 if (!cl)
413 errx(EXIT_FAILURE, _("undefined column name '%s'"), str);
414
415 return cl;
416 }
417
418 static int column_set_flag(struct libscols_column *cl, int fl)
419 {
420 int cur = scols_column_get_flags(cl);
421
422 return scols_column_set_flags(cl, cur | fl);
423 }
424
425 static int has_unnamed(const char *list)
426 {
427 char **all, **one;
428 int rc = 0;
429
430 if (!list)
431 return 0;
432 if (strcmp(list, "-") == 0)
433 return 1;
434 if (!strchr(list, ','))
435 return 0;
436
437 all = split_or_error(list, NULL);
438 if (all) {
439 UL_STRV_FOREACH(one, all) {
440 if (strcmp(*one, "-") == 0) {
441 rc = 1;
442 break;
443 }
444 }
445 ul_strv_free(all);
446 }
447
448 return rc;
449 }
450
451 static void apply_columnflag_from_list(struct column_control *ctl, const char *list,
452 int flag, const char *errmsg)
453 {
454 char **all;
455 char **one;
456 int unnamed = 0;
457 struct libscols_column *cl;
458
459 /* apply to all */
460 if (list && strcmp(list, "0") == 0) {
461 struct libscols_iter *itr;
462
463 itr = scols_new_iter(SCOLS_ITER_FORWARD);
464 if (!itr)
465 err_oom();
466
467 while (scols_table_next_column(ctl->tab, itr, &cl) == 0)
468 column_set_flag(cl, flag);
469 scols_free_iter(itr);
470 return;
471 }
472
473 all = split_or_error(list, errmsg);
474
475 /* apply to columns specified by name */
476 UL_STRV_FOREACH(one, all) {
477 int low = 0, up = 0;
478
479 if (strcmp(*one, "-") == 0) {
480 unnamed = 1;
481 continue;
482 }
483
484 /* parse range (N-M) */
485 if (strchr(*one, '-') && ul_parse_range(*one, &low, &up, 0) == 0) {
486 for (; low <= up; low++) {
487 if (low < 0)
488 cl = get_last_visible_column(ctl, (low * -1) -1);
489 else
490 cl = scols_table_get_column(ctl->tab, low-1);
491 if (cl)
492 column_set_flag(cl, flag);
493 }
494 continue;
495 }
496
497 /* one item in the list */
498 cl = string_to_column(ctl, *one);
499 if (cl)
500 column_set_flag(cl, flag);
501 }
502 ul_strv_free(all);
503
504 /* apply flag to all columns without name */
505 if (unnamed) {
506 struct libscols_iter *itr;
507
508 itr = scols_new_iter(SCOLS_ITER_FORWARD);
509 if (!itr)
510 err_oom();
511
512 while (scols_table_next_column(ctl->tab, itr, &cl) == 0) {
513 if (!scols_column_get_name(cl))
514 column_set_flag(cl, flag);
515 }
516 scols_free_iter(itr);
517 }
518 }
519
520 static void reorder_table(struct column_control *ctl)
521 {
522 struct libscols_column **wanted, *last = NULL;
523 size_t i, count = 0;
524 size_t ncols = scols_table_get_ncols(ctl->tab);
525 char **order = split_or_error(ctl->tab_order, _("failed to parse --table-order list"));
526 char **one;
527
528 wanted = xcalloc(ncols, sizeof(struct libscols_column *));
529
530 UL_STRV_FOREACH(one, order) {
531 struct libscols_column *cl = string_to_column(ctl, *one);
532 if (cl)
533 wanted[count++] = cl;
534 }
535
536 for (i = 0; i < count; i++) {
537 scols_table_move_column(ctl->tab, last, wanted[i]);
538 last = wanted[i];
539 }
540
541 free(wanted);
542 ul_strv_free(order);
543 }
544
545 static void create_tree(struct column_control *ctl)
546 {
547 struct libscols_column *cl_tree = string_to_column(ctl, ctl->tree);
548 struct libscols_column *cl_p = string_to_column(ctl, ctl->tree_parent);
549 struct libscols_column *cl_i = string_to_column(ctl, ctl->tree_id);
550 struct libscols_iter *itr_p, *itr_i;
551 struct libscols_line *ln_i;
552
553 if (!cl_p || !cl_i || !cl_tree)
554 return; /* silently ignore the tree request */
555
556 column_set_flag(cl_tree, SCOLS_FL_TREE);
557
558 itr_p = scols_new_iter(SCOLS_ITER_FORWARD);
559 itr_i = scols_new_iter(SCOLS_ITER_FORWARD);
560 if (!itr_p || !itr_i)
561 err_oom();
562
563 /* scan all lines for ID */
564 while (scols_table_next_line(ctl->tab, itr_i, &ln_i) == 0) {
565 struct libscols_line *ln;
566 struct libscols_cell *ce = scols_line_get_column_cell(ln_i, cl_i);
567 const char *id = ce ? scols_cell_get_data(ce) : NULL;
568
569 if (!id)
570 continue;
571
572 /* see if the ID is somewhere used in parent column */
573 scols_reset_iter(itr_p, SCOLS_ITER_FORWARD);
574 while (scols_table_next_line(ctl->tab, itr_p, &ln) == 0) {
575 const char *parent;
576
577 ce = scols_line_get_column_cell(ln, cl_p);
578 parent = ce ? scols_cell_get_data(ce) : NULL;
579
580 if (!parent)
581 continue;
582 if (strcmp(id, parent) != 0)
583 continue;
584 if (scols_line_is_ancestor(ln, ln_i))
585 continue;
586 scols_line_add_child(ln_i, ln);
587 }
588 }
589
590 scols_free_iter(itr_p);
591 scols_free_iter(itr_i);
592 }
593
594 static void modify_table(struct column_control *ctl)
595 {
596 if (ctl->termwidth > 0) {
597 scols_table_set_termwidth(ctl->tab, ctl->termwidth);
598 scols_table_set_termforce(ctl->tab, SCOLS_TERMFORCE_ALWAYS);
599 }
600
601 if (ctl->tab_colhide)
602 apply_columnflag_from_list(ctl, ctl->tab_colhide,
603 SCOLS_FL_HIDDEN , _("failed to parse --table-hide list"));
604
605 if (ctl->tab_colright)
606 apply_columnflag_from_list(ctl, ctl->tab_colright,
607 SCOLS_FL_RIGHT, _("failed to parse --table-right list"));
608
609 if (ctl->tab_coltrunc)
610 apply_columnflag_from_list(ctl, ctl->tab_coltrunc,
611 SCOLS_FL_TRUNC , _("failed to parse --table-trunc list"));
612
613 if (ctl->tab_colnoextrem)
614 apply_columnflag_from_list(ctl, ctl->tab_colnoextrem,
615 SCOLS_FL_NOEXTREMES , _("failed to parse --table-noextreme list"));
616
617 if (ctl->tab_colwrap)
618 apply_columnflag_from_list(ctl, ctl->tab_colwrap,
619 SCOLS_FL_WRAP , _("failed to parse --table-wrap list"));
620
621 if (!ctl->tab_colnoextrem) {
622 struct libscols_column *cl = get_last_visible_column(ctl, 0);
623 if (cl)
624 column_set_flag(cl, SCOLS_FL_NOEXTREMES);
625 }
626
627 if (ctl->tree)
628 create_tree(ctl);
629
630 /* This must be the last step! */
631 if (ctl->tab_order)
632 reorder_table(ctl);
633 }
634
635
636 static int add_line_to_table(struct column_control *ctl, wchar_t *wcs0)
637 {
638 wchar_t *sv = NULL, *wcs = wcs0, *all = NULL;
639 size_t n = 0;
640 struct libscols_line *ln = NULL;
641
642
643 if (!ctl->tab)
644 init_table(ctl);
645
646 if (ctl->maxncols) {
647 all = wcsdup(wcs0);
648 if (!all)
649 err(EXIT_FAILURE, _("failed to allocate input line"));
650 }
651
652 do {
653 char *data;
654 wchar_t *wcdata = local_wcstok(ctl, wcs, &sv);
655
656 if (!wcdata)
657 break;
658
659 if (ctl->maxncols && n + 1 == ctl->maxncols) {
660 /* Use rest of the string as column data */
661 size_t skip = wcdata - wcs0;
662 wcdata = all + skip;
663 }
664
665 if (scols_table_get_ncols(ctl->tab) < n + 1) {
666 if (scols_table_is_json(ctl->tab) && !ctl->hide_unnamed)
667 errx(EXIT_FAILURE, _("line %zu: for JSON the name of the "
668 "column %zu is required"),
669 scols_table_get_nlines(ctl->tab) + 1,
670 n + 1);
671 scols_table_new_column(ctl->tab, NULL, 0,
672 ctl->hide_unnamed ? SCOLS_FL_HIDDEN : 0);
673 }
674 if (!ln) {
675 ln = scols_table_new_line(ctl->tab, NULL);
676 if (!ln)
677 err(EXIT_FAILURE, _("failed to allocate output line"));
678 }
679
680 data = wcs_to_mbs(wcdata);
681 if (!data)
682 err(EXIT_FAILURE, _("failed to allocate output data"));
683 if (scols_line_refer_data(ln, n, data))
684 err(EXIT_FAILURE, _("failed to add output data"));
685 n++;
686 wcs = NULL;
687 if (ctl->maxncols && n == ctl->maxncols)
688 break;
689 } while (1);
690
691 free(all);
692 return 0;
693 }
694
695 static int add_emptyline_to_table(struct column_control *ctl)
696 {
697 if (!ctl->tab)
698 init_table(ctl);
699
700 if (!scols_table_new_line(ctl->tab, NULL))
701 err(EXIT_FAILURE, _("failed to allocate output line"));
702
703 return 0;
704 }
705
706 static void add_entry(struct column_control *ctl, size_t *maxents, wchar_t *wcs)
707 {
708 if (ctl->nents <= *maxents) {
709 *maxents += 1000;
710 ctl->ents = xreallocarray(ctl->ents, *maxents, sizeof(wchar_t *));
711 }
712 ctl->ents[ctl->nents] = wcs;
713 ctl->nents++;
714 }
715
716 static int read_input(struct column_control *ctl, FILE *fp)
717 {
718 wchar_t *empty = NULL;
719 char *buf = NULL;
720 size_t bufsz = 0;
721 size_t maxents = 0;
722 int rc = 0;
723
724 /* Read input */
725 do {
726 char *str, *p;
727 wchar_t *wcs = NULL;
728 size_t len;
729
730 if (getline(&buf, &bufsz, fp) < 0) {
731 if (feof(fp))
732 break;
733 err(EXIT_FAILURE, _("read failed"));
734 }
735 str = (char *) skip_space(buf);
736 if (str) {
737 p = strchr(str, '\n');
738 if (p)
739 *p = '\0';
740 }
741 if (!str || !*str) {
742 if (ctl->keep_empty_lines) {
743 if (ctl->mode == COLUMN_MODE_TABLE) {
744 add_emptyline_to_table(ctl);
745 } else {
746 if (!empty)
747 empty = mbs_to_wcs("");
748 add_entry(ctl, &maxents, empty);
749 }
750 }
751 continue;
752 }
753
754 wcs = mbs_to_wcs(buf);
755 if (!wcs) {
756 /*
757 * Convert broken sequences to \x<hex> and continue.
758 */
759 size_t tmpsz = 0;
760 char *tmp = mbs_invalid_encode(buf, &tmpsz);
761
762 if (!tmp)
763 err(EXIT_FAILURE, _("read failed"));
764 wcs = mbs_to_wcs(tmp);
765 free(tmp);
766 }
767
768 switch (ctl->mode) {
769 case COLUMN_MODE_TABLE:
770 rc = add_line_to_table(ctl, wcs);
771 free(wcs);
772 break;
773
774 case COLUMN_MODE_FILLCOLS:
775 case COLUMN_MODE_FILLROWS:
776 add_entry(ctl, &maxents, wcs);
777 len = width(wcs);
778 if (ctl->maxlength < len)
779 ctl->maxlength = len;
780 break;
781 default:
782 free(wcs);
783 break;
784 }
785 } while (rc == 0);
786
787 free(buf);
788
789 return rc;
790 }
791
792
793 static void columnate_fillrows(struct column_control *ctl)
794 {
795 size_t chcnt, col, cnt, endcol, numcols, remains;
796 wchar_t **lp;
797
798 if (ctl->use_spaces)
799 ctl->maxlength += ctl->mincolsep;
800 else
801 ctl->maxlength = (ctl->maxlength + TABCHAR_CELLS) & ~(TABCHAR_CELLS - 1);
802 numcols = ctl->termwidth / ctl->maxlength;
803 remains = ctl->termwidth % ctl->maxlength;
804 if (ctl->use_spaces && remains + ctl->mincolsep >= ctl->maxlength)
805 numcols++;
806 endcol = ctl->maxlength;
807 for (chcnt = col = 0, lp = ctl->ents; /* nothing */; ++lp) {
808 fputws(*lp, stdout);
809 chcnt += width(*lp);
810 if (!--ctl->nents)
811 break;
812 if (++col == numcols) {
813 chcnt = col = 0;
814 endcol = ctl->maxlength;
815 putwchar('\n');
816 } else {
817 if (ctl->use_spaces) {
818 while (chcnt < endcol) {
819 putwchar(' ');
820 chcnt++;
821 }
822 } else {
823 while ((cnt = ((chcnt + TABCHAR_CELLS) & ~(TABCHAR_CELLS - 1))) <= endcol) {
824 putwchar('\t');
825 chcnt = cnt;
826 }
827 }
828 endcol += ctl->maxlength;
829 }
830 }
831 if (chcnt)
832 putwchar('\n');
833 }
834
835 static void columnate_fillcols(struct column_control *ctl)
836 {
837 size_t base, chcnt, cnt, col, endcol, numcols, numrows, row, remains;
838
839 if (ctl->use_spaces)
840 ctl->maxlength += ctl->mincolsep;
841 else
842 ctl->maxlength = (ctl->maxlength + TABCHAR_CELLS) & ~(TABCHAR_CELLS - 1);
843 numcols = ctl->termwidth / ctl->maxlength;
844 remains = ctl->termwidth % ctl->maxlength;
845 if (!numcols)
846 numcols = 1;
847 if (ctl->use_spaces && remains + ctl->mincolsep >= ctl->maxlength)
848 numcols++;
849 numrows = ctl->nents / numcols;
850 if (ctl->nents % numcols)
851 ++numrows;
852
853 for (row = 0; row < numrows; ++row) {
854 endcol = ctl->maxlength;
855 for (base = row, chcnt = col = 0; col < numcols; ++col) {
856 fputws(ctl->ents[base], stdout);
857 chcnt += width(ctl->ents[base]);
858 if ((base += numrows) >= ctl->nents)
859 break;
860 if (ctl->use_spaces) {
861 while (chcnt < endcol) {
862 putwchar(' ');
863 chcnt++;
864 }
865 } else {
866 while ((cnt = ((chcnt + TABCHAR_CELLS) & ~(TABCHAR_CELLS - 1))) <= endcol) {
867 putwchar('\t');
868 chcnt = cnt;
869 }
870 }
871 endcol += ctl->maxlength;
872 }
873 putwchar('\n');
874 }
875 }
876
877 static void simple_print(struct column_control *ctl)
878 {
879 int cnt;
880 wchar_t **lp;
881
882 for (cnt = ctl->nents, lp = ctl->ents; cnt--; ++lp) {
883 fputws(*lp, stdout);
884 putwchar('\n');
885 }
886 }
887
888 static void __attribute__((__noreturn__)) usage(void)
889 {
890 FILE *out = stdout;
891
892 fputs(USAGE_HEADER, out);
893 fprintf(out, _(" %s [options] [<file>...]\n"), program_invocation_short_name);
894
895 fputs(USAGE_SEPARATOR, out);
896 fputs(_("Columnate lists.\n"), out);
897
898 fputs(USAGE_OPTIONS, out);
899 fputs(_(" -t, --table create a table\n"), out);
900 fputs(_(" -n, --table-name <name> table name for JSON output\n"), out);
901 fputs(_(" -O, --table-order <columns> specify order of output columns\n"), out);
902 fputs(_(" -C, --table-column <properties> define column\n"), out);
903 fputs(_(" -N, --table-columns <names> comma separated columns names\n"), out);
904 fputs(_(" -l, --table-columns-limit <num> maximal number of input columns\n"), out);
905 fputs(_(" -E, --table-noextreme <columns> don't count long text from the columns to column width\n"), out);
906 fputs(_(" -d, --table-noheadings don't print header\n"), out);
907 fputs(_(" -m, --table-maxout fill all available space\n"), out);
908 fputs(_(" -e, --table-header-repeat repeat header for each page\n"), out);
909 fputs(_(" -H, --table-hide <columns> don't print the columns\n"), out);
910 fputs(_(" -R, --table-right <columns> right align text in these columns\n"), out);
911 fputs(_(" -T, --table-truncate <columns> truncate text in the columns when necessary\n"), out);
912 fputs(_(" -W, --table-wrap <columns> wrap text in the columns when necessary\n"), out);
913 fputs(_(" -L, --keep-empty-lines don't ignore empty lines\n"), out);
914 fputs(_(" -J, --json use JSON output format for table\n"), out);
915
916 fputs(USAGE_SEPARATOR, out);
917 fputs(_(" -r, --tree <column> column to use tree-like output for the table\n"), out);
918 fputs(_(" -i, --tree-id <column> line ID to specify child-parent relation\n"), out);
919 fputs(_(" -p, --tree-parent <column> parent to specify child-parent relation\n"), out);
920
921 fputs(USAGE_SEPARATOR, out);
922 fputs(_(" -c, --output-width <width> width of output in number of characters\n"), out);
923 fputs(_(" -o, --output-separator <string> columns separator for table output (default is two spaces)\n"), out);
924 fputs(_(" -s, --separator <string> possible table delimiters\n"), out);
925 fputs(_(" -x, --fillrows fill rows before columns\n"), out);
926 fputs(_(" -S, --use-spaces <number> minimal whitespaces between columns (no tabs)\n"), out);
927
928
929 fputs(USAGE_SEPARATOR, out);
930 fprintf(out, USAGE_HELP_OPTIONS(34));
931 fprintf(out, USAGE_MAN_TAIL("column(1)"));
932
933 exit(EXIT_SUCCESS);
934 }
935
936 int main(int argc, char **argv)
937 {
938 struct column_control ctl = {
939 .mode = COLUMN_MODE_FILLCOLS,
940 .greedy = 1,
941 .termwidth = (size_t) -1
942 };
943
944 int c;
945 unsigned int eval = 0; /* exit value */
946
947 static const struct option longopts[] =
948 {
949 { "columns", required_argument, NULL, 'c' }, /* deprecated */
950 { "fillrows", no_argument, NULL, 'x' },
951 { "help", no_argument, NULL, 'h' },
952 { "json", no_argument, NULL, 'J' },
953 { "keep-empty-lines", no_argument, NULL, 'L' },
954 { "output-separator", required_argument, NULL, 'o' },
955 { "output-width", required_argument, NULL, 'c' },
956 { "separator", required_argument, NULL, 's' },
957 { "table", no_argument, NULL, 't' },
958 { "table-columns", required_argument, NULL, 'N' },
959 { "table-column", required_argument, NULL, 'C' },
960 { "table-columns-limit", required_argument, NULL, 'l' },
961 { "table-hide", required_argument, NULL, 'H' },
962 { "table-name", required_argument, NULL, 'n' },
963 { "table-maxout", no_argument, NULL, 'm' },
964 { "table-noextreme", required_argument, NULL, 'E' },
965 { "table-noheadings", no_argument, NULL, 'd' },
966 { "table-order", required_argument, NULL, 'O' },
967 { "table-right", required_argument, NULL, 'R' },
968 { "table-truncate", required_argument, NULL, 'T' },
969 { "table-wrap", required_argument, NULL, 'W' },
970 { "table-empty-lines", no_argument, NULL, 'L' }, /* deprecated */
971 { "table-header-repeat", no_argument, NULL, 'e' },
972 { "tree", required_argument, NULL, 'r' },
973 { "tree-id", required_argument, NULL, 'i' },
974 { "tree-parent", required_argument, NULL, 'p' },
975 { "use-spaces", required_argument, NULL, 'S' },
976 { "version", no_argument, NULL, 'V' },
977 { NULL, 0, NULL, 0 },
978 };
979 static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
980 { 'C','N' },
981 { 'J','x' },
982 { 't','x' },
983 { 0 }
984 };
985 int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
986
987 setlocale(LC_ALL, "");
988 bindtextdomain(PACKAGE, LOCALEDIR);
989 textdomain(PACKAGE);
990 close_stdout_atexit();
991
992 ctl.output_separator = " ";
993 ctl.input_separator = mbs_to_wcs("\t ");
994
995 while ((c = getopt_long(argc, argv, "C:c:dE:eH:hi:Jl:LN:n:mO:o:p:R:r:S:s:T:tVW:x", longopts, NULL)) != -1) {
996
997 err_exclusive_options(c, longopts, excl, excl_st);
998
999 switch(c) {
1000 case 'C':
1001 if (ul_strv_extend(&ctl.tab_columns, optarg))
1002 err_oom();
1003 break;
1004 case 'c':
1005 if (strcmp(optarg, "unlimited") == 0)
1006 ctl.termwidth = 0;
1007 else
1008 ctl.termwidth = strtou32_or_err(optarg, _("invalid columns argument"));
1009 break;
1010 case 'd':
1011 ctl.tab_noheadings = 1;
1012 break;
1013 case 'E':
1014 ctl.tab_colnoextrem = optarg;
1015 break;
1016 case 'e':
1017 ctl.header_repeat = 1;
1018 break;
1019 case 'H':
1020 ctl.tab_colhide = optarg;
1021 ctl.hide_unnamed = has_unnamed(ctl.tab_colhide);
1022 break;
1023 case 'i':
1024 ctl.tree_id = optarg;
1025 break;
1026 case 'J':
1027 ctl.json = 1;
1028 ctl.mode = COLUMN_MODE_TABLE;
1029 break;
1030 case 'L':
1031 ctl.keep_empty_lines = 1;
1032 break;
1033 case 'l':
1034 ctl.maxncols = strtou32_or_err(optarg, _("invalid columns limit argument"));
1035 if (ctl.maxncols == 0)
1036 errx(EXIT_FAILURE, _("columns limit must be greater than zero"));
1037 break;
1038 case 'N':
1039 ctl.tab_colnames = split_or_error(optarg, _("failed to parse column names"));
1040 break;
1041 case 'n':
1042 ctl.tab_name = optarg;
1043 break;
1044 case 'm':
1045 ctl.maxout = 1;
1046 break;
1047 case 'O':
1048 ctl.tab_order = optarg;
1049 break;
1050 case 'o':
1051 ctl.output_separator = optarg;
1052 break;
1053 case 'p':
1054 ctl.tree_parent = optarg;
1055 break;
1056 case 'R':
1057 ctl.tab_colright = optarg;
1058 break;
1059 case 'r':
1060 ctl.tree = optarg;
1061 break;
1062 case 'S':
1063 ctl.use_spaces = 1;
1064 ctl.mincolsep = strtou32_or_err(optarg, _("invalid spaces argument"));
1065 break;
1066 case 's':
1067 free(ctl.input_separator);
1068 ctl.input_separator = mbs_to_wcs(optarg);
1069 if (!ctl.input_separator)
1070 err(EXIT_FAILURE, _("failed to parse input separator"));
1071 ctl.greedy = 0;
1072 break;
1073 case 'T':
1074 ctl.tab_coltrunc = optarg;
1075 break;
1076 case 't':
1077 ctl.mode = COLUMN_MODE_TABLE;
1078 break;
1079 case 'W':
1080 ctl.tab_colwrap = optarg;
1081 break;
1082 case 'x':
1083 ctl.mode = COLUMN_MODE_FILLROWS;
1084 break;
1085
1086 case 'h':
1087 usage();
1088 case 'V':
1089 print_version(EXIT_SUCCESS);
1090 default:
1091 errtryhelp(EXIT_FAILURE);
1092 }
1093 }
1094 argc -= optind;
1095 argv += optind;
1096
1097 if (ctl.termwidth == (size_t) -1)
1098 ctl.termwidth = get_terminal_width(80);
1099
1100 if (ctl.tree) {
1101 ctl.mode = COLUMN_MODE_TABLE;
1102 if (!ctl.tree_parent || !ctl.tree_id)
1103 errx(EXIT_FAILURE, _("options --tree-id and --tree-parent are "
1104 "required for tree formatting"));
1105 }
1106
1107 if (ctl.mode != COLUMN_MODE_TABLE
1108 && (ctl.tab_order || ctl.tab_name || ctl.tab_colwrap ||
1109 ctl.tab_colhide || ctl.tab_coltrunc || ctl.tab_colnoextrem ||
1110 ctl.tab_colright || ctl.tab_colnames || ctl.tab_columns))
1111 errx(EXIT_FAILURE, _("option --table required for all --table-*"));
1112
1113 if (!ctl.tab_colnames && !ctl.tab_columns && ctl.json)
1114 errx(EXIT_FAILURE, _("option --table-columns or --table-column required for --json"));
1115
1116 if (!*argv)
1117 eval += read_input(&ctl, stdin);
1118 else
1119 for (; *argv; ++argv) {
1120 FILE *fp;
1121
1122 if ((fp = fopen(*argv, "r")) != NULL) {
1123 eval += read_input(&ctl, fp);
1124 fclose(fp);
1125 } else {
1126 warn("%s", *argv);
1127 eval += EXIT_FAILURE;
1128 }
1129 }
1130
1131 if (ctl.mode != COLUMN_MODE_TABLE) {
1132 if (!ctl.nents)
1133 exit(eval);
1134 if (ctl.maxlength >= ctl.termwidth)
1135 ctl.mode = COLUMN_MODE_SIMPLE;
1136 }
1137
1138 switch (ctl.mode) {
1139 case COLUMN_MODE_TABLE:
1140 if (ctl.tab && scols_table_get_nlines(ctl.tab)) {
1141 modify_table(&ctl);
1142 eval = scols_print_table(ctl.tab);
1143
1144 scols_unref_table(ctl.tab);
1145 if (ctl.tab_colnames)
1146 ul_strv_free(ctl.tab_colnames);
1147 if (ctl.tab_columns)
1148 ul_strv_free(ctl.tab_columns);
1149 }
1150 break;
1151 case COLUMN_MODE_FILLCOLS:
1152 columnate_fillcols(&ctl);
1153 break;
1154 case COLUMN_MODE_FILLROWS:
1155 columnate_fillrows(&ctl);
1156 break;
1157 case COLUMN_MODE_SIMPLE:
1158 simple_print(&ctl);
1159 break;
1160 }
1161
1162 free(ctl.input_separator);
1163
1164 return eval == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1165 }
Unnamed repository; edit this file 'description' to name the repository.