]> mj.ucw.cz Git - libucw.git/blob - ucw/table.c
Merge remote-tracking branch 'origin/dev-table' into dev-table
[libucw.git] / ucw / table.c
1 /*
2  *      UCW Library -- Table printer
3  *
4  *      (c) 2014 Robert Kessl <robert.kessl@economia.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/string.h>
9 #include <ucw/stkstring.h>
10 #include <ucw/gary.h>
11 #include <ucw/table.h>
12 #include <ucw/strtonum.h>
13
14 #include <stdlib.h>
15 #include <stdio.h>
16
17 /* Forward declarations */
18
19 static void table_update_ll(struct table *tbl);
20
21 /*** Management of tables ***/
22
23 static struct table *table_make_instance(const struct table_template *tbl_template)
24 {
25   struct mempool *pool = mp_new(4096);
26   struct table *new_inst = mp_alloc_zero(pool, sizeof(struct table));
27
28   new_inst->pool = pool;
29
30   // initialize column definitions
31   uint col_count = 0; // count the number of columns in the struct table
32   for(;;) {
33     if(tbl_template->columns[col_count].name == NULL &&
34        tbl_template->columns[col_count].width == 0 &&
35        tbl_template->columns[col_count].type_def == COL_TYPE_ANY)
36       break;
37     ASSERT(tbl_template->columns[col_count].name != NULL);
38     ASSERT(tbl_template->columns[col_count].width != 0);
39
40     col_count++;
41   }
42   new_inst->column_count = col_count;
43
44   new_inst->columns = tbl_template->columns;
45   new_inst->ll_headers = mp_alloc(new_inst->pool, sizeof(int) * col_count);
46   for(uint i = 0; i < col_count; i++) {
47     new_inst->ll_headers[i] = -1;
48   }
49
50   // initialize column_order
51   if(tbl_template->column_order) {
52     new_inst->column_order = mp_alloc_zero(new_inst->pool, sizeof(struct table_col_instance) * tbl_template->cols_to_output);
53     memcpy(new_inst->column_order, tbl_template->column_order, sizeof(struct table_col_instance) * tbl_template->cols_to_output);
54     for(uint i = 0; i < new_inst->cols_to_output; i++) {
55       new_inst->column_order[i].cell_content = NULL;
56       int col_idx = new_inst->column_order[i].idx;
57       new_inst->column_order[i].col_def = new_inst->columns + col_idx;
58       new_inst->column_order[i].output_type = tbl_template->columns[col_idx].fmt;
59     }
60
61     new_inst->cols_to_output = tbl_template->cols_to_output;
62   }
63
64   new_inst->col_delimiter = tbl_template->col_delimiter;
65   new_inst->print_header = 1;
66   new_inst->out = 0;
67   new_inst->last_printed_col = -1;
68   new_inst->row_printing_started = 0;
69   new_inst->col_out = -1;
70   new_inst->formatter = tbl_template->formatter;
71   new_inst->data = NULL;
72   return new_inst;
73 }
74
75 struct table *table_init(const struct table_template *tbl_template)
76 {
77   struct table *tbl = table_make_instance(tbl_template);
78
79   if(!tbl->formatter) {
80     tbl->formatter = &table_fmt_human_readable;
81   }
82
83   tbl->print_header = 1; // by default, print header
84   return tbl;
85 }
86
87 void table_cleanup(struct table *tbl)
88 {
89   mp_delete(tbl->pool);
90 }
91
92 // TODO: test default column order
93 static void table_make_default_column_order(struct table *tbl)
94 {
95   int *col_order_int = mp_alloc_zero(tbl->pool, sizeof(int) * tbl->column_count); // FIXME: use stack instead of memory pool
96   for(int i = 0; i < tbl->column_count; i++) {
97     col_order_int[i] = i;
98   }
99   table_set_col_order(tbl, col_order_int, tbl->column_count);
100 }
101
102 void table_start(struct table *tbl, struct fastbuf *out)
103 {
104   tbl->last_printed_col = -1;
105   tbl->row_printing_started = 0;
106   tbl->out = out;
107
108   ASSERT_MSG(tbl->out, "Output fastbuf not specified.");
109
110   if(tbl->column_order == NULL) table_make_default_column_order(tbl);
111   else {
112     // update linked lists
113     table_update_ll(tbl);
114   }
115   if(tbl->formatter->table_start != NULL) tbl->formatter->table_start(tbl);
116
117   mp_save(tbl->pool, &tbl->pool_state);
118
119   ASSERT_MSG(tbl->col_delimiter, "In-between column delimiter not specified.");
120 }
121
122 void table_end(struct table *tbl)
123 {
124   tbl->last_printed_col = -1;
125   tbl->row_printing_started = 0;
126
127   mp_restore(tbl->pool, &tbl->pool_state);
128
129   if(tbl->formatter->table_end) tbl->formatter->table_end(tbl);
130 }
131
132 /*** Configuration ***/
133
134 void table_set_formatter(struct table *tbl, struct table_formatter *fmt)
135 {
136   tbl->formatter = fmt;
137 }
138
139 int table_get_col_idx(struct table *tbl, const char *col_name)
140 {
141   for(int i = 0; i < tbl->column_count; i++) {
142     if(strcmp(tbl->columns[i].name, col_name) == 0) return i;
143   }
144   return -1;
145 }
146
147 const char * table_get_col_list(struct table *tbl)
148 {
149   if(tbl->column_count == 0) return "";
150
151   char *tmp = mp_strdup(tbl->pool, tbl->columns[0].name);
152
153   for(int i = 1; i < tbl->column_count; i++) {
154     tmp = mp_printf_append(tbl->pool, tmp, ", %s", tbl->columns[i].name);
155   }
156
157   return tmp;
158 }
159
160 static void table_update_ll(struct table *tbl)
161 {
162   int cols_to_output = tbl->cols_to_output;
163
164   for(int i = 0; i < tbl->column_count; i++) {
165     tbl->ll_headers[i] = -1;
166   }
167
168   for(int i = 0; i < cols_to_output; i++) {
169     int idx = tbl->column_order[i].idx;
170     tbl->column_order[i].col_def = tbl->columns + idx;
171   }
172
173   for(int i = 0; i < cols_to_output; i++) {
174     int col_def_idx = tbl->column_order[i].col_def - tbl->columns;
175     int first = tbl->ll_headers[col_def_idx];
176     tbl->ll_headers[col_def_idx] = i;
177     tbl->column_order[i].next_column = first;
178   }
179 }
180
181 void table_set_col_order(struct table *tbl, int *col_order, int cols_to_output)
182 {
183   for(int i = 0; i < cols_to_output; i++) {
184     ASSERT_MSG(col_order[i] >= 0 && col_order[i] < tbl->column_count, "Column %d does not exist (column number should be between 0 and %d).", col_order[i], tbl->column_count - 1);
185   }
186
187   tbl->cols_to_output = cols_to_output;
188   tbl->column_order = mp_alloc_zero(tbl->pool, sizeof(struct table_col_instance) * cols_to_output);
189   for(int i = 0; i < cols_to_output; i++) {
190     int col_idx = col_order[i];
191     tbl->column_order[i].idx = col_idx;
192     tbl->column_order[i].col_def = tbl->columns + col_idx;
193     tbl->column_order[i].cell_content = NULL;
194     tbl->column_order[i].output_type = tbl->columns[col_idx].fmt;
195   }
196   table_update_ll(tbl);
197 }
198
199 bool table_col_is_printed(struct table *tbl, uint col_idx)
200 {
201   if(tbl->ll_headers[col_idx] == -1) return 0;
202
203   return 1;
204 }
205
206 static char * table_parse_col_arg(char *col_def)
207 {
208   // FIXME: should be switched to str_sepsplit
209   char * left_br = strchr(col_def, '[');
210   if(left_br == NULL) return NULL;
211   *left_br = 0;
212   left_br++;
213   char *right_br = strchr(left_br, ']');
214   *right_br = 0;
215   return left_br;
216 }
217
218 /**
219  * Setting options for basic table types (as defined in table.h)
220  **/
221 int table_set_col_opt_default(struct table *tbl, int col_idx, const char *col_arg, char **err)
222 {
223   const struct table_column *col_def = tbl->column_order[col_idx].col_def;
224
225   if(col_def->type_def == &xt_double) {
226     uint precision = 0;
227     const char *tmp_err = str_to_uint(&precision, col_arg, NULL, 0);
228     if(tmp_err) {
229       *err = mp_printf(tbl->pool, "An error occured while parsing precision: %s.", tmp_err);
230       return false;
231     }
232     tbl->column_order[col_idx].output_type = precision; // FIXME: shift the value of precision
233     return true;
234   }
235
236   *err = mp_printf(tbl->pool, "Invalid column format option: '%s' for column %d.", col_arg, col_idx);
237   return false;
238 }
239
240 /**
241  * TODO: This function deliberately leaks memory. When it is called multiple times,
242  * previous column orders still remain allocated in the table's memory pool.
243  **/
244 const char * table_set_col_order_by_name(struct table *tbl, const char *col_order_str)
245 {
246   if(col_order_str[0] == '*') {
247     int *col_order_int = alloca(sizeof(int) * tbl->column_count);
248     for(int i = 0; i < tbl->column_count; i++) {
249       col_order_int[i] = i;
250     }
251     table_set_col_order(tbl, col_order_int, tbl->column_count);
252
253     return NULL;
254   }
255
256   if(!col_order_str[0]) {
257     tbl->column_order = mp_alloc(tbl->pool, 0);
258     tbl->cols_to_output = 0;
259     return NULL;
260   }
261
262   char *tmp_col_order = stk_strdup(col_order_str);
263
264   int col_count = 1;
265   for(int i = 0; col_order_str[i] != 0; i++) {
266     if(col_order_str[i] == ',') {
267       col_count++;
268     }
269   }
270
271   tbl->cols_to_output = col_count;
272   tbl->column_order = mp_alloc_zero(tbl->pool, sizeof(struct table_col_instance) * col_count);
273
274   int curr_col_idx = 0;
275   char *name_start = tmp_col_order;
276   while(name_start) {
277     char *next = strchr(name_start, ',');
278     if(next) {
279       *next++ = 0;
280     }
281
282     char *arg = table_parse_col_arg(name_start); // this sets 0 on the '['
283     int col_idx = table_get_col_idx(tbl, name_start);
284
285     if(col_idx == -1) {
286       return mp_printf(tbl->pool, "Unknown table column '%s', possible column names are: %s.", name_start, table_get_col_list(tbl));
287     }
288     tbl->column_order[curr_col_idx].col_def = tbl->columns + col_idx;
289     tbl->column_order[curr_col_idx].idx = col_idx;
290     tbl->column_order[curr_col_idx].cell_content = NULL;
291     tbl->column_order[curr_col_idx].output_type = tbl->columns[col_idx].fmt;
292     if(tbl->columns[col_idx].type_def && tbl->columns[col_idx].set_col_instance_option) {
293       char *err = NULL;
294       tbl->columns[col_idx].set_col_instance_option(tbl, curr_col_idx, arg, &err);
295       if(err) return mp_printf(tbl->pool, "Error occured while setting column option: %s.", err);
296     }
297
298     name_start = next;
299     curr_col_idx++;
300   }
301
302   table_update_ll(tbl);
303
304   return NULL;
305 }
306
307 /*** Table cells ***/
308
309 static void table_set_all_inst_content(struct table *tbl, int col_templ, const char *col_content)
310 {
311   TBL_COL_ITER_START(tbl, col_templ, curr_col_ptr, curr_col) {
312     curr_col_ptr->cell_content = col_content;
313   } TBL_COL_ITER_END
314 }
315
316 void table_col_generic_format(struct table *tbl, int col, void *value, const struct xtype *expected_type)
317 {
318   ASSERT_MSG(col < tbl->column_count && col >= 0, "Table column %d does not exist.", col);
319   ASSERT(tbl->columns[col].type_def == COL_TYPE_ANY || expected_type == tbl->columns[col].type_def);
320   tbl->last_printed_col = col;
321   tbl->row_printing_started = 1;
322   const char *cell_content = NULL;
323   TBL_COL_ITER_START(tbl, col, curr_col, curr_col_idx) {
324     enum xtype_fmt fmt = curr_col->output_type;
325     cell_content = expected_type->format(value, fmt, tbl->pool);
326     curr_col->cell_content = cell_content;
327   } TBL_COL_ITER_END
328 }
329
330 void table_col_printf(struct table *tbl, int col, const char *fmt, ...)
331 {
332   ASSERT_MSG(col < tbl->column_count && col >= 0, "Table column %d does not exist.", col);
333   tbl->last_printed_col = col;
334   tbl->row_printing_started = 1;
335   va_list args;
336   va_start(args, fmt);
337   char *cell_content = mp_vprintf(tbl->pool, fmt, args);
338   table_set_all_inst_content(tbl, col, cell_content);
339   va_end(args);
340 }
341
342 TABLE_COL_BODY(int, int)
343 TABLE_COL_BODY(uint, uint)
344 TABLE_COL_BODY(double, double)
345 TABLE_COL_BODY(intmax, intmax_t)
346 TABLE_COL_BODY(uintmax, uintmax_t)
347 TABLE_COL_BODY(s64, s64)
348 TABLE_COL_BODY(u64, u64)
349 TABLE_COL_BODY(bool, bool)
350
351 void table_col_str(struct table *tbl, int col, const char *val) {
352   table_col_generic_format(tbl, col, (void*)val, &xt_str);
353 }
354
355 void table_reset_row(struct table *tbl)
356 {
357   for(uint i = 0; i < tbl->cols_to_output; i++) {
358     tbl->column_order[i].cell_content = NULL;
359   }
360   mp_restore(tbl->pool, &tbl->pool_state);
361   tbl->last_printed_col = -1;
362   tbl->row_printing_started = 0;
363 }
364
365 void table_end_row(struct table *tbl)
366 {
367   ASSERT(tbl->formatter->row_output);
368   if(tbl->row_printing_started == 0) return;
369   tbl->formatter->row_output(tbl);
370   table_reset_row(tbl);
371 }
372
373 /* Construction of a cell using a fastbuf */
374
375 struct fastbuf *table_col_fbstart(struct table *tbl, int col)
376 {
377   fbpool_init(&tbl->fb_col_out);
378   fbpool_start(&tbl->fb_col_out, tbl->pool, 1);
379   tbl->col_out = col;
380   return &tbl->fb_col_out.fb;
381 }
382
383 void table_col_fbend(struct table *tbl)
384 {
385   char *cell_content = fbpool_end(&tbl->fb_col_out);
386   table_set_all_inst_content(tbl, tbl->col_out, cell_content);
387   tbl->col_out = -1;
388 }
389
390 /*** Option parsing ***/
391
392 const char *table_set_option_value(struct table *tbl, const char *key, const char *value)
393 {
394   // Options with no value
395   if(value == NULL || (value != NULL && strlen(value) == 0)) {
396     if(strcmp(key, "noheader") == 0) {
397       tbl->print_header = 0;
398       return NULL;
399     }
400   }
401
402   // Options with a value
403   if(value) {
404     if(strcmp(key, "header") == 0) {
405       if(value[1] != 0)
406         return mp_printf(tbl->pool, "Invalid header parameter: '%s' has invalid value: '%s'.", key, value);
407       uint tmp = value[0] - '0';
408       if(tmp > 1)
409         return mp_printf(tbl->pool, "Invalid header parameter: '%s' has invalid value: '%s'.", key, value);
410       tbl->print_header = tmp;
411       return NULL;
412     } else if(strcmp(key, "cols") == 0) {
413       return table_set_col_order_by_name(tbl, value);
414     } else if(strcmp(key, "fmt") == 0) {
415       if(strcmp(value, "human") == 0) table_set_formatter(tbl, &table_fmt_human_readable);
416       else if(strcmp(value, "machine") == 0) table_set_formatter(tbl, &table_fmt_machine_readable);
417       else if(strcmp(value, "blockline") == 0) table_set_formatter(tbl, &table_fmt_blockline);
418       else {
419         return "Invalid argument to output-type option.";
420       }
421       return NULL;
422     } else if(strcmp(key, "cell-fmt") == 0) {
423       u32 fmt = 0;
424       const char *err = xtype_parse_fmt(NULL, value, &fmt, tbl->pool);
425       if(err) return mp_printf(tbl->pool, "Invalid cell format: '%s'.", err);
426       for(uint i = 0; i < tbl->cols_to_output; i++) {
427         tbl->column_order[i].output_type = fmt;
428       }
429       return NULL;
430     } else if(strcmp(key, "col-delim") == 0) {
431       char * d = mp_printf(tbl->pool, "%s", value);
432       tbl->col_delimiter = d;
433       return NULL;
434     }
435   }
436
437   // Formatter options
438   if(tbl->formatter && tbl->formatter->process_option) {
439     const char *err = NULL;
440     if(tbl->formatter->process_option(tbl, key, value, &err)) {
441       return err;
442     }
443   }
444
445   // Unrecognized option
446   return mp_printf(tbl->pool, "Invalid option: '%s%s%s'.", key, (value ? ":" : ""), (value ? : ""));
447 }
448
449 const char *table_set_option(struct table *tbl, const char *opt)
450 {
451   char *key = stk_strdup(opt);
452   char *value = strchr(key, ':');
453   if(value) {
454     *value++ = 0;
455   }
456   return table_set_option_value(tbl, key, value);
457 }
458
459 const char *table_set_gary_options(struct table *tbl, char **gary_table_opts)
460 {
461   for (uint i = 0; i < GARY_SIZE(gary_table_opts); i++) {
462     const char *rv = table_set_option(tbl, gary_table_opts[i]);
463     if(rv != NULL) {
464       return rv;
465     }
466   }
467   return NULL;
468 }
469
470 /*** Default formatter for human-readable output ***/
471
472 static void table_row_human_readable(struct table *tbl)
473 {
474   for(uint i = 0; i < tbl->cols_to_output; i++) {
475     const struct table_column *col_def = tbl->column_order[i].col_def;
476     if(i) {
477       bputs(tbl->out, tbl->col_delimiter);
478     }
479     int col_width = col_def->width & CELL_WIDTH_MASK;
480     if(col_def->width & CELL_ALIGN_LEFT) col_width = -1 * col_width;
481     bprintf(tbl->out, "%*s", col_width, tbl->column_order[i].cell_content);
482   }
483   bputc(tbl->out, '\n');
484 }
485
486 static void table_write_header(struct table *tbl)
487 {
488   for(uint i = 0; i < tbl->cols_to_output; i++) {
489     const struct table_column *col_def = tbl->column_order[i].col_def;
490     if(i) {
491       bputs(tbl->out, tbl->col_delimiter);
492     }
493     int col_width = col_def->width & CELL_WIDTH_MASK;
494     if(col_def->width & CELL_ALIGN_LEFT) col_width = -1 * col_width;
495     bprintf(tbl->out, "%*s", col_width, col_def->name);
496   }
497   bputc(tbl->out, '\n');
498 }
499
500 static void table_start_human_readable(struct table *tbl)
501 {
502   if(tbl->col_delimiter == NULL) {
503     tbl->col_delimiter = " ";
504   }
505
506   if(tbl->print_header != 0) {
507     table_write_header(tbl);
508   }
509 }
510
511 struct table_formatter table_fmt_human_readable = {
512   .row_output = table_row_human_readable,
513   .table_start = table_start_human_readable,
514 };
515
516 /*** Default formatter for machine-readable output ***/
517
518 static void table_row_machine_readable(struct table *tbl)
519 {
520   for(uint i = 0; i < tbl->cols_to_output; i++) {
521     if(i) {
522       bputs(tbl->out, tbl->col_delimiter);
523     }
524     bputs(tbl->out, tbl->column_order[i].cell_content);
525   }
526   bputc(tbl->out, '\n');
527 }
528
529 static void table_start_machine_readable(struct table *tbl)
530 {
531   if(tbl->col_delimiter == NULL) {
532     tbl->col_delimiter = "\t";
533   }
534
535   if(tbl->print_header != 0 && tbl->cols_to_output > 0) {
536     bputs(tbl->out, tbl->column_order[0].col_def->name);
537     for(uint i = 1; i < tbl->cols_to_output; i++) {
538       bputs(tbl->out, tbl->col_delimiter);
539       bputs(tbl->out, tbl->column_order[i].col_def->name);
540     }
541     bputc(tbl->out, '\n');
542   }
543 }
544
545 struct table_formatter table_fmt_machine_readable = {
546   .row_output = table_row_machine_readable,
547   .table_start = table_start_machine_readable,
548 };
549
550
551 /*** Blockline formatter ***/
552
553 static void table_row_blockline_output(struct table *tbl)
554 {
555   for(uint i = 0; i < tbl->cols_to_output; i++) {
556     const struct table_column *col_def = tbl->column_order[i].col_def;
557     bprintf(tbl->out, "%s: %s\n", col_def->name, tbl->column_order[i].cell_content);
558   }
559   bputc(tbl->out, '\n');
560 }
561
562 static void table_start_blockline(struct table *tbl)
563 {
564   if(tbl->col_delimiter == NULL) {
565     tbl->col_delimiter = "\n";
566   }
567 }
568
569 struct table_formatter table_fmt_blockline = {
570   .row_output = table_row_blockline_output,
571   .table_start = table_start_blockline
572 };
573
574 /*** Tests ***/
575
576 #ifdef TEST
577
578 #include <stdio.h>
579
580 enum test_table_cols {
581   TEST_COL0_STR, TEST_COL1_INT, TEST_COL2_UINT, TEST_COL3_BOOL, TEST_COL4_DOUBLE
582 };
583
584 static struct table_col_instance test_column_order[] = { TBL_COL(TEST_COL3_BOOL), TBL_COL(TEST_COL4_DOUBLE), TBL_COL(TEST_COL2_UINT), TBL_COL(TEST_COL1_INT), TBL_COL(TEST_COL0_STR) };
585
586 static struct table_template test_tbl = {
587   TBL_COLUMNS {
588     [TEST_COL0_STR] = TBL_COL_STR("col0_str", 20),
589     [TEST_COL1_INT] = TBL_COL_INT("col1_int", 8),
590     [TEST_COL2_UINT] = TBL_COL_UINT("col2_uint", 9),
591     [TEST_COL3_BOOL] = TBL_COL_BOOL("col3_bool", 9),
592     [TEST_COL4_DOUBLE] = TBL_COL_DOUBLE("col4_double", 11),
593     TBL_COL_END
594   },
595   TBL_COL_ORDER(test_column_order),
596   TBL_OUTPUT_HUMAN_READABLE,
597   TBL_COL_DELIMITER("\t"),
598 };
599
600 /**
601  * tests: table_set_nt, table_set_uint, table_set_bool, table_set_double, table_set_printf
602  **/
603 static void do_print1(struct table *test_tbl)
604 {
605   table_col_str(test_tbl, TEST_COL0_STR, "sdsdf");
606   table_col_int(test_tbl, TEST_COL1_INT, -10);
607   table_col_int(test_tbl, TEST_COL1_INT, 10000);
608   table_col_uint(test_tbl, TEST_COL2_UINT, 10);
609   table_col_printf(test_tbl, TEST_COL2_UINT, "XXX-%u", 22222);
610   table_col_bool(test_tbl, TEST_COL3_BOOL, true);
611   table_col_double(test_tbl, TEST_COL4_DOUBLE, 1.5);
612   table_col_printf(test_tbl, TEST_COL4_DOUBLE, "AAA");
613   table_end_row(test_tbl);
614
615   table_col_str(test_tbl, TEST_COL0_STR, "test");
616   table_col_int(test_tbl, TEST_COL1_INT, -100);
617   table_col_uint(test_tbl, TEST_COL2_UINT, 100);
618   table_col_bool(test_tbl, TEST_COL3_BOOL, false);
619   table_col_printf(test_tbl, TEST_COL4_DOUBLE, "%.2lf", 1.5);
620   table_end_row(test_tbl);
621 }
622
623 static void test_simple1(struct fastbuf *out)
624 {
625   struct table *tbl = table_init(&test_tbl);
626
627   // print table with header
628   table_set_col_order_by_name(tbl, "col3_bool");
629   table_start(tbl, out);
630   do_print1(tbl);
631   table_end(tbl);
632
633   // print the same table as in the previous case without header
634   table_set_col_order_by_name(tbl, "col0_str,col2_uint,col1_int,col3_bool");
635   table_start(tbl, out);
636   do_print1(tbl);
637   table_end(tbl);
638
639   // this also tests whether there is need to call table_set_col_order_by_name after table_end was called
640   tbl->print_header = 0;
641   table_start(tbl, out);
642   do_print1(tbl);
643   table_end(tbl);
644   tbl->print_header = 1;
645
646   table_set_col_order_by_name(tbl, "col3_bool");
647   table_start(tbl, out);
648   do_print1(tbl);
649   table_end(tbl);
650
651   table_set_col_order_by_name(tbl, "col3_bool,col0_str");
652   table_start(tbl, out);
653   do_print1(tbl);
654   table_end(tbl);
655
656   table_set_col_order_by_name(tbl, "col0_str,col3_bool,col2_uint");
657   table_start(tbl, out);
658   do_print1(tbl);
659   table_end(tbl);
660
661   table_set_col_order_by_name(tbl, "col0_str,col3_bool,col2_uint,col0_str,col3_bool,col2_uint,col0_str,col3_bool,col2_uint");
662   table_start(tbl, out);
663   do_print1(tbl);
664   table_end(tbl);
665
666   table_set_col_order_by_name(tbl, "col0_str,col1_int,col2_uint,col3_bool,col4_double");
667   table_start(tbl, out);
668   do_print1(tbl);
669   table_end(tbl);
670
671   table_cleanup(tbl);
672 }
673
674 enum test_any_table_cols {
675   TEST_ANY_COL0_INT, TEST_ANY_COL1_ANY
676 };
677
678 static struct table_col_instance test_any_column_order[] = { TBL_COL(TEST_ANY_COL0_INT), TBL_COL_FMT(TEST_ANY_COL1_ANY, XTYPE_FMT_PRETTY) };
679
680 static struct table_template test_any_tbl = {
681   TBL_COLUMNS {
682     [TEST_ANY_COL0_INT] = TBL_COL_INT("col0_int", 8),
683     [TEST_ANY_COL1_ANY] = TBL_COL_ANY_FMT("col1_any", 9, XTYPE_FMT_PRETTY),
684     TBL_COL_END
685   },
686   TBL_COL_ORDER(test_any_column_order),
687   TBL_OUTPUT_HUMAN_READABLE,
688   TBL_COL_DELIMITER("\t"),
689 };
690
691 static void test_any_type(struct fastbuf *out)
692 {
693   struct table *tbl = table_init(&test_any_tbl);
694
695   table_start(tbl, out);
696
697   table_col_int(tbl, TEST_ANY_COL0_INT, -10);
698   table_col_int(tbl, TEST_ANY_COL1_ANY, 10000);
699   table_end_row(tbl);
700
701   table_col_int(tbl, TEST_ANY_COL0_INT, -10);
702   table_col_double(tbl, TEST_ANY_COL1_ANY, 1.4);
703   table_end_row(tbl);
704
705   table_col_printf(tbl, TEST_ANY_COL0_INT, "%d", 10);
706   table_col_double(tbl, TEST_ANY_COL1_ANY, 1.4);
707   table_end_row(tbl);
708
709   table_end(tbl);
710   table_cleanup(tbl);
711 }
712
713 int main(int argc UNUSED, char **argv UNUSED)
714 {
715   struct fastbuf *out;
716   out = bfdopen_shared(1, 4096);
717
718   test_simple1(out);
719
720   test_any_type(out);
721
722   bclose(out);
723   return 0;
724 }
725
726 #endif