int main(int argc, char *argv[])
{
struct libscols_table *tb;
struct libscols_line *ln, *xln;
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "faild to create output table");
scols_table_enable_colors(tb, 1);
setup_columns(tb);
ln = add_line(tb, NULL, "A");
add_line(tb, ln, "aa");
add_line(tb, ln, "ab");
ln = add_line(tb, NULL, "B");
xln = add_line(tb, ln, "ba");
add_line(tb, xln, "baa");
add_line(tb, xln, "bab");
add_line(tb, ln, "bb");
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
struct libscols_symbols *sy;
struct libscols_cell *title;
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
setup_columns(tb);
add_line(tb, "foo", "bla bla bla");
add_line(tb, "bar", "alb alb alb");
title = scols_table_get_title(tb);
/* right */
scols_cell_set_data(title, "This is right title");
scols_cell_set_color(title, "red");
scols_cell_set_flags(title, SCOLS_CELL_FL_RIGHT);
scols_print_table(tb);
/* center */
sy = scols_new_symbols();
if (!sy)
err_oom();
scols_table_set_symbols(tb, sy);
scols_symbols_set_title_padding(sy, "=");
scols_cell_set_data(title, "This is center title (with padding)");
scols_cell_set_color(title, "green");
scols_cell_set_flags(title, SCOLS_CELL_FL_CENTER);
scols_print_table(tb);
/* left */
scols_symbols_set_title_padding(sy, "-");
scols_cell_set_data(title, "This is left title (with padding)");
scols_cell_set_color(title, "blue");
scols_cell_set_flags(title, SCOLS_CELL_FL_LEFT);
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
void list_disklabel(struct fdisk_context *cxt)
{
struct fdisk_table *tb = NULL;
struct fdisk_partition *pa = NULL;
struct fdisk_iter *itr = NULL;
struct fdisk_label *lb;
struct libscols_table *out = NULL;
const char *bold = NULL;
int *ids = NULL; /* IDs of fdisk_fields */
size_t nids = 0, i;
int post = 0;
/* print label specific stuff by libfdisk FDISK_ASK_INFO API */
fdisk_list_disklabel(cxt);
/* get partitions and generate output */
if (fdisk_get_partitions(cxt, &tb) || fdisk_table_get_nents(tb) <= 0)
goto done;
ids = init_fields(cxt, NULL, &nids);
if (!ids)
goto done;
itr = fdisk_new_iter(FDISK_ITER_FORWARD);
if (!itr) {
fdisk_warn(cxt, _("faild to allocate iterator"));
goto done;
}
out = scols_new_table();
if (!out) {
fdisk_warn(cxt, _("faild to allocate output table"));
goto done;
}
if (colors_wanted()) {
scols_table_enable_colors(out, 1);
bold = color_scheme_get_sequence("header", UL_COLOR_BOLD);
}
lb = fdisk_get_label(cxt, NULL);
assert(lb);
/* define output table columns */
for (i = 0; i < nids; i++) {
int fl = 0;
struct libscols_column *co;
const struct fdisk_field *field =
fdisk_label_get_field(lb, ids[i]);
if (!field)
continue;
if (fdisk_field_is_number(field))
fl |= SCOLS_FL_RIGHT;
if (fdisk_field_get_id(field) == FDISK_FIELD_TYPE)
fl |= SCOLS_FL_TRUNC;
co = scols_table_new_column(out,
fdisk_field_get_name(field),
fdisk_field_get_width(field), fl);
if (!co)
goto done;
/* set colum header color */
if (bold)
scols_cell_set_color(scols_column_get_header(co), bold);
}
/* fill-in output table */
while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
struct libscols_line *ln = scols_table_new_line(out, NULL);
if (!ln) {
fdisk_warn(cxt, _("faild to allocate output line"));
goto done;
}
for (i = 0; i < nids; i++) {
char *data = NULL;
if (fdisk_partition_to_string(pa, cxt, ids[i], &data))
continue;
scols_line_refer_data(ln, i, data);
}
}
/* print */
if (!scols_table_is_empty(out)) {
fputc('\n', stdout);
scols_print_table(out);
}
/* print warnings */
fdisk_reset_iter(itr, FDISK_ITER_FORWARD);
while (itr && fdisk_table_next_partition(tb, itr, &pa) == 0) {
if (!fdisk_partition_has_start(pa))
continue;
if (!fdisk_lba_is_phy_aligned(cxt, fdisk_partition_get_start(pa))) {
if (!post)
fputc('\n', stdout);
fdisk_warnx(cxt, _("Partition %zu does not start on physical sector boundary."),
fdisk_partition_get_partno(pa) + 1);
post++;
}
}
if (fdisk_table_wrong_order(tb)) {
if (!post)
fputc('\n', stdout);
fdisk_info(cxt, _("Partition table entries are not in disk order."));
}
done:
scols_unref_table(out);
fdisk_unref_table(tb);
fdisk_free_iter(itr);
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
int c, notree = 0, nstart = -1, nend = -1;
static const struct option longopts[] = {
{ "ascii", 0, 0, 'i' },
{ "csv", 0, 0, 'c' },
{ "list", 0, 0, 'l' },
{ "noheadings", 0, 0, 'n' },
{ "pairs", 0, 0, 'p' },
{ "json", 0, 0, 'J' },
{ "raw", 0, 0, 'r' },
{ "range-start",1, 0, 'S' },
{ "range-end", 1, 0, 'E' },
{ NULL, 0, 0, 0 },
};
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "ciJlnprS:E:", longopts, NULL)) != -1) {
switch(c) {
case 'c':
scols_table_set_column_separator(tb, ",");
scols_table_enable_raw(tb, 1);
notree = 1;
break;
case 'i':
scols_table_enable_ascii(tb, 1);
break;
case 'J':
scols_table_set_name(tb, "scolstest");
scols_table_enable_json(tb, 1);
break;
case 'l':
notree = 1;
break;
case 'n':
scols_table_enable_noheadings(tb, 1);
break;
case 'p':
scols_table_enable_export(tb, 1);
notree = 1;
break;
case 'r':
scols_table_enable_raw(tb, 1);
notree = 1;
break;
case 'S':
nstart = strtos32_or_err(optarg, "failed to parse range start") - 1;
break;
case 'E':
nend = strtos32_or_err(optarg, "failed to parse range end") - 1;
break;
default:
usage(stderr);
}
}
scols_table_enable_colors(tb, 1);
setup_columns(tb, notree);
if (optind == argc)
add_lines(tb, ".");
else while (optind < argc)
add_lines(tb, argv[optind++]);
if (nstart >= 0 || nend >= 0) {
/* print subset */
struct libscols_line *start = NULL, *end = NULL;
if (nstart >= 0)
start = scols_table_get_line(tb, nstart);
if (nend >= 0)
end = scols_table_get_line(tb, nend);
if (start || end)
scols_table_print_range(tb, start, end);
} else
/* print all table */
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
void list_freespace(struct fdisk_context *cxt)
{
struct fdisk_table *tb = NULL;
struct fdisk_partition *pa = NULL;
struct fdisk_iter *itr = NULL;
struct libscols_table *out = NULL;
const char *bold = NULL;
size_t i;
uintmax_t sumsize = 0, bytes = 0;
char *strsz;
static const char *colnames[] = { N_("Start"), N_("End"), N_("Sectors"), N_("Size") };
static const int colids[] = { FDISK_FIELD_START, FDISK_FIELD_END, FDISK_FIELD_SECTORS, FDISK_FIELD_SIZE };
if (fdisk_get_freespaces(cxt, &tb))
goto done;
itr = fdisk_new_iter(FDISK_ITER_FORWARD);
if (!itr) {
fdisk_warn(cxt, _("failed to allocate iterator"));
goto done;
}
out = scols_new_table();
if (!out) {
fdisk_warn(cxt, _("failed to allocate output table"));
goto done;
}
if (colors_wanted()) {
scols_table_enable_colors(out, 1);
bold = color_scheme_get_sequence("header", UL_COLOR_BOLD);
}
for (i = 0; i < ARRAY_SIZE(colnames); i++) {
struct libscols_column *co = scols_table_new_column(out, _(colnames[i]), 5, SCOLS_FL_RIGHT);
if (!co)
goto done;
if (bold)
scols_cell_set_color(scols_column_get_header(co), bold);
}
/* fill-in output table */
while (fdisk_table_next_partition(tb, itr, &pa) == 0) {
struct libscols_line *ln = scols_table_new_line(out, NULL);
char *data;
if (!ln) {
fdisk_warn(cxt, _("failed to allocate output line"));
goto done;
}
for (i = 0; i < ARRAY_SIZE(colids); i++) {
if (fdisk_partition_to_string(pa, cxt, colids[i], &data))
continue;
scols_line_refer_data(ln, i, data);
}
if (fdisk_partition_has_size(pa))
sumsize += fdisk_partition_get_size(pa);
}
bytes = sumsize * fdisk_get_sector_size(cxt);
strsz = size_to_human_string(SIZE_SUFFIX_SPACE
| SIZE_SUFFIX_3LETTER, bytes);
color_scheme_enable("header", UL_COLOR_BOLD);
fdisk_info(cxt, _("Unpartitioned space %s: %s, %ju bytes, %ju sectors"),
fdisk_get_devname(cxt), strsz,
bytes, sumsize);
color_disable();
free(strsz);
fdisk_info(cxt, _("Units: %s of %d * %ld = %ld bytes"),
fdisk_get_unit(cxt, FDISK_PLURAL),
fdisk_get_units_per_sector(cxt),
fdisk_get_sector_size(cxt),
fdisk_get_units_per_sector(cxt) * fdisk_get_sector_size(cxt));
fdisk_info(cxt, _("Sector size (logical/physical): %lu bytes / %lu bytes"),
fdisk_get_sector_size(cxt),
fdisk_get_physector_size(cxt));
/* print */
if (!scols_table_is_empty(out)) {
fdisk_info(cxt, ""); /* line break */
scols_print_table(out);
}
done:
scols_unref_table(out);
fdisk_unref_table(tb);
fdisk_free_iter(itr);
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
int c, n, nlines = 0;
int parent_col = -1, id_col = -1;
static const struct option longopts[] = {
{ "maxout", 0, NULL, 'm' },
{ "column", 1, NULL, 'c' },
{ "nlines", 1, NULL, 'n' },
{ "width", 1, NULL, 'w' },
{ "tree-parent-column", 1, NULL, 'p' },
{ "tree-id-column", 1, NULL, 'i' },
{ "json", 0, NULL, 'J' },
{ "raw", 0, NULL, 'r' },
{ "export", 0, NULL, 'E' },
{ "colsep", 1, NULL, 'C' },
{ "help", 0, NULL, 'h' },
{ NULL, 0, NULL, 0 },
};
static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
{ 'E', 'J', 'r' },
{ 0 }
};
int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "hCc:Ei:Jmn:p:rw:", longopts, NULL)) != -1) {
err_exclusive_options(c, longopts, excl, excl_st);
switch(c) {
case 'c': /* add column from file */
{
struct libscols_column *cl;
FILE *f = fopen(optarg, "r");
if (!f)
err(EXIT_FAILURE, "%s: open failed", optarg);
cl = parse_column(f);
if (cl && scols_table_add_column(tb, cl))
err(EXIT_FAILURE, "%s: failed to add column", optarg);
scols_unref_column(cl);
fclose(f);
break;
}
case 'p':
parent_col = strtou32_or_err(optarg, "failed to parse tree PARENT column");
break;
case 'i':
id_col = strtou32_or_err(optarg, "failed to parse tree ID column");
break;
case 'J':
scols_table_enable_json(tb, 1);
scols_table_set_name(tb, "testtable");
break;
case 'm':
scols_table_enable_maxout(tb, TRUE);
break;
case 'r':
scols_table_enable_raw(tb, TRUE);
break;
case 'E':
scols_table_enable_export(tb, TRUE);
break;
case 'C':
scols_table_set_column_separator(tb, optarg);
break;
case 'n':
nlines = strtou32_or_err(optarg, "failed to parse number of lines");
break;
case 'w':
scols_table_set_termforce(tb, SCOLS_TERMFORCE_ALWAYS);
scols_table_set_termwidth(tb, strtou32_or_err(optarg, "failed to parse terminal width"));
break;
case 'h':
usage();
default:
errtryhelp(EXIT_FAILURE);
}
}
if (nlines <= 0)
errx(EXIT_FAILURE, "--nlines not set");
for (n = 0; n < nlines; n++) {
struct libscols_line *ln = scols_new_line();
if (!ln || scols_table_add_line(tb, ln))
err(EXIT_FAILURE, "failed to add a new line");
scols_unref_line(ln);
}
n = 0;
while (optind < argc) {
FILE *f = fopen(argv[optind], "r");
if (!f)
err(EXIT_FAILURE, "%s: open failed", argv[optind]);
parse_column_data(f, tb, n);
optind++;
n++;
}
if (scols_table_is_tree(tb) && parent_col >= 0 && id_col >= 0)
compose_tree(tb, parent_col, id_col);
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
struct libscols_line *ln; /* any line */
struct libscols_line *g1, *g2, *g3; /* groups */
struct libscols_line *p1; /* parents */
int c;
static const struct option longopts[] = {
{ "maxout", 0, NULL, 'm' },
{ "width", 1, NULL, 'w' },
{ "help", 1, NULL, 'h' },
{ NULL, 0, NULL, 0 },
};
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "hmw:", longopts, NULL)) != -1) {
switch(c) {
case 'h':
printf("%s [--help | --maxout | --width <num>]\n", program_invocation_short_name);
break;
case 'm':
scols_table_enable_maxout(tb, TRUE);
break;
case 'w':
scols_table_set_termforce(tb, SCOLS_TERMFORCE_ALWAYS);
scols_table_set_termwidth(tb, strtou32_or_err(optarg, "failed to parse terminal width"));
break;
}
}
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
setup_columns(tb);
add_line(tb, NULL, "Alone", "bla bla bla");
p1 = add_line(tb, NULL, "A", "bla bla bla");
add_line(tb, p1, "A:B", "bla bla bla");
add_line(tb, p1, "A:C", "bla bla bla");
g1 = add_line(tb, NULL, "B", "bla bla bla");
g2 = add_line(tb, NULL, "C", "bla bla bla");
ln = add_line(tb, NULL, "D", "bla bla bla");
scols_table_group_lines(tb, g2, ln, 0);
ln = add_line(tb, NULL, "G2:A", "alb alb alb");
scols_line_link_group(ln, g2, 0);
ln = add_line(tb, NULL, "E", "bla bla bla");
scols_table_group_lines(tb, g1, ln, 0);
ln = add_line(tb, NULL, "G1:A", "alb alb alb");
scols_line_link_group(ln, g1, 0);
add_line(tb, NULL, "G", "bla bla bla");
g3 = ln = add_line(tb, NULL, "G1:B", "alb alb alb");
scols_line_link_group(ln, g1, 0);
ln = add_line(tb, NULL, "F", "bla bla bla");
scols_table_group_lines(tb, g3, ln, 0);
ln = add_line(tb, NULL, "G3:A", "alb alb alb");
scols_line_link_group(ln, g3, 0);
add_line(tb, NULL, "foo", "bla bla bla");
add_line(tb, NULL, "bar", "bla bla bla");
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
struct libscols_symbols *sy;
struct libscols_cell *title;
int c;
static const struct option longopts[] = {
{ "maxout", 0, NULL, 'm' },
{ "width", 1, NULL, 'w' },
{ NULL, 0, NULL, 0 },
};
setlocale(LC_ALL, ""); /* just to have enable UTF8 chars */
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "mw:", longopts, NULL)) != -1) {
switch(c) {
case 'm':
scols_table_enable_maxout(tb, TRUE);
break;
case 'w':
scols_table_set_termforce(tb, SCOLS_TERMFORCE_ALWAYS);
scols_table_set_termwidth(tb, strtou32_or_err(optarg, "failed to parse terminal width"));
break;
}
}
scols_table_enable_colors(tb, isatty(STDOUT_FILENO));
setup_columns(tb);
add_line(tb, "foo", "bla bla bla");
add_line(tb, "bar", "alb alb alb");
title = scols_table_get_title(tb);
/* right */
scols_cell_set_data(title, "This is right title");
scols_cell_set_color(title, "red");
scols_cell_set_flags(title, SCOLS_CELL_FL_RIGHT);
scols_print_table(tb);
/* center */
sy = scols_new_symbols();
if (!sy)
err_oom();
scols_table_set_symbols(tb, sy);
scols_symbols_set_title_padding(sy, "=");
scols_cell_set_data(title, "This is center title (with padding)");
scols_cell_set_color(title, "green");
scols_cell_set_flags(title, SCOLS_CELL_FL_CENTER);
scols_print_table(tb);
/* left */
scols_symbols_set_title_padding(sy, "-");
scols_cell_set_data(title, "This is left title (with padding)");
scols_cell_set_color(title, "blue");
scols_cell_set_flags(title, SCOLS_CELL_FL_LEFT);
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
struct libscols_table *tb;
int c, notree = 0, clonetb = 0;
static const struct option longopts[] = {
{ "help", 0, 0, 'h' },
{ "noheadings", 0, 0, 'n' },
{ "list", 0, 0, 'l' },
{ "ascii", 0, 0, 'i' },
{ "pairs", 0, 0, 'p' },
{ "clone", 0, 0, 'C' },
{ "csv", 0, 0, 'c' },
{ NULL, 0, 0, 0 },
};
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
scols_init_debug(0);
tb = scols_new_table();
if (!tb)
err(EXIT_FAILURE, "faild to create output table");
while((c = getopt_long(argc, argv, "nlirpCc", longopts, NULL)) != -1) {
switch(c) {
case 'h':
usage(stdout);
break;
case 'l':
notree = 1;
break;
case 'n':
scols_table_enable_noheadings(tb, 1);
break;
case 'p':
scols_table_enable_export(tb, 1);
notree = 1;
break;
case 'i':
scols_table_enable_ascii(tb, 1);
break;
case 'r':
scols_table_enable_raw(tb, 1);
notree = 1;
break;
case 'c':
scols_table_set_column_separator(tb, ",");
scols_table_enable_raw(tb, 1);
notree = 1;
break;
case 'C':
clonetb = 1;
default:
usage(stderr);
}
}
scols_table_enable_colors(tb, 1);
set_columns(tb, notree);
while (optind < argc)
add_lines(tb, argv[optind++]);
if (clonetb) {
struct libscols_table *xtb = scols_copy_table(tb);
scols_print_table(xtb);
scols_unref_table(xtb);
} else
scols_print_table(tb);
scols_unref_table(tb);
return EXIT_SUCCESS;
}
