1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013, 2014, 2016 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "output/tab.h"
26 #include "data/data-out.h"
27 #include "data/format.h"
28 #include "data/settings.h"
29 #include "data/value.h"
30 #include "data/variable.h"
31 #include "libpspp/assertion.h"
32 #include "libpspp/compiler.h"
33 #include "libpspp/i18n.h"
34 #include "libpspp/misc.h"
35 #include "libpspp/pool.h"
36 #include "output/driver.h"
37 #include "output/table-item.h"
38 #include "output/table-provider.h"
39 #include "output/text-item.h"
41 #include "gl/minmax.h"
42 #include "gl/xalloc.h"
45 #define _(msgid) gettext (msgid)
48 static const bool debugging = true;
52 #define TAB_JOIN (1u << TAB_FIRST_AVAILABLE)
55 struct tab_joined_cell
57 int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */
61 struct table_item *subtable;
66 const struct footnote **footnotes;
69 static const struct table_class tab_table_class;
71 struct fmt_spec ugly[n_RC] = {
72 {FMT_F, 8, 0}, /* INTEGER */
73 {FMT_F, 8, 3}, /* WEIGHT (ignored) */
74 {FMT_F, 8, 3}, /* PVALUE */
75 {FMT_F, 8, 3} /* OTHER (ignored) */
79 /* Creates and returns a new table with NC columns and NR rows and initially no
80 header rows or columns. The table's cells are initially empty. */
82 tab_create (int nc, int nr)
86 t = pool_create_container (struct tab_table, container);
87 table_init (&t->table, &tab_table_class);
88 table_set_nc (&t->table, nc);
89 table_set_nr (&t->table, nr);
94 t->cc = pool_calloc (t->container, nr * nc, sizeof *t->cc);
95 t->ct = pool_calloc (t->container, nr * nc, sizeof *t->ct);
97 t->rh = pool_nmalloc (t->container, nc, nr + 1);
98 memset (t->rh, TAL_0, nc * (nr + 1));
100 t->rv = pool_nmalloc (t->container, nr, nc + 1);
101 memset (t->rv, TAL_0, nr * (nc + 1));
103 memset (t->fmtmap, 0, sizeof (*t->fmtmap) * n_RC);
104 t->fmtmap[RC_PVALUE] = ugly[RC_PVALUE];
105 t->fmtmap[RC_INTEGER] = ugly[RC_INTEGER];
106 t->fmtmap[RC_OTHER] = *settings_get_format ();
108 memset (t->styles, 0, sizeof t->styles);
110 t->col_ofs = t->row_ofs = 0;
117 tab_set_format (struct tab_table *t, enum result_class rc,
118 const struct fmt_spec *fmt)
120 t->fmtmap[rc] = *fmt;
124 /* Sets the width and height of a table, in columns and rows,
125 respectively. Use only to reduce the size of a table, since it
126 does not change the amount of allocated memory.
128 This function is obsolete. Please do not add new uses of it. (Instead, use
129 table_select() or one of its helper functions.) */
131 tab_resize (struct tab_table *t, int nc, int nr)
135 assert (nc + t->col_ofs <= t->cf);
136 table_set_nc (&t->table, nc + t->col_ofs);
140 assert (nr + t->row_ofs <= tab_nr (t));
141 table_set_nr (&t->table, nr + t->row_ofs);
145 /* Changes either or both dimensions of a table and reallocates memory as
148 This function is obsolete. Please do not add new uses of it. (Instead, use
149 table_paste() or one of its helper functions to paste multiple tables
150 together into a larger one.) */
152 tab_realloc (struct tab_table *t, int nc, int nr)
159 tab_offset (t, 0, 0);
166 assert (nc == tab_nc (t));
170 int mr1 = MIN (nr, tab_nr (t));
171 int mc1 = MIN (nc, tab_nc (t));
174 unsigned short *new_ct;
177 new_cc = pool_calloc (t->container, nr * nc, sizeof *new_cc);
178 new_ct = pool_malloc (t->container, nr * nc);
179 for (r = 0; r < mr1; r++)
181 memcpy (&new_cc[r * nc], &t->cc[r * tab_nc (t)],
182 mc1 * sizeof *t->cc);
183 memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)],
184 mc1 * sizeof *t->ct);
185 memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t));
187 pool_free (t->container, t->cc);
188 pool_free (t->container, t->ct);
193 else if (nr != tab_nr (t))
195 t->cc = pool_nrealloc (t->container, t->cc, nr * nc, sizeof *t->cc);
196 t->ct = pool_nrealloc (t->container, t->ct, nr * nc, sizeof *t->ct);
198 t->rh = pool_nrealloc (t->container, t->rh, nc, nr + 1);
199 t->rv = pool_nrealloc (t->container, t->rv, nr, nc + 1);
203 memset (&t->rh[nc * (tab_nr (t) + 1)], TAL_0,
204 (nr - tab_nr (t)) * nc);
205 memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_0,
206 (nr - tab_nr (t)) * (nc + 1));
210 memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->ct);
211 memset (&t->cc[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->cc);
213 table_set_nr (&t->table, nr);
214 table_set_nc (&t->table, nc);
217 tab_offset (t, co, ro);
220 /* Sets the number of header rows on each side of TABLE to L on the
221 left, R on the right, T on the top, B on the bottom. Header rows
222 are repeated when a table is broken across multiple columns or
225 tab_headers (struct tab_table *table, int l, int r, int t, int b)
227 table_set_hl (&table->table, l);
228 table_set_hr (&table->table, r);
229 table_set_ht (&table->table, t);
230 table_set_hb (&table->table, b);
235 /* Draws a vertical line to the left of cells at horizontal position X
236 from Y1 to Y2 inclusive in style STYLE, if style is not -1. */
238 tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
242 if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t)
243 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
244 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
246 printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
247 "table size (%d,%d)\n"),
248 x, t->col_ofs, x + t->col_ofs,
249 y1, t->row_ofs, y1 + t->row_ofs,
250 y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t));
260 assert (x <= tab_nc (t));
263 assert (y2 <= tab_nr (t));
268 for (y = y1; y <= y2; y++)
269 t->rv[x + (t->cf + 1) * y] = style;
273 /* Draws a horizontal line above cells at vertical position Y from X1
274 to X2 inclusive in style STYLE, if style is not -1. */
276 tab_hline (struct tab_table *t, int style, int x1, int x2, int y)
280 if (y + t->row_ofs < 0 || y + t->row_ofs > tab_nr (t)
281 || x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
282 || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t))
284 printf (_("bad hline: x=(%d+%d=%d,%d+%d=%d) y=%d+%d=%d in "
285 "table size (%d,%d)\n"),
286 x1, t->col_ofs, x1 + t->col_ofs,
287 x2, t->col_ofs, x2 + t->col_ofs,
288 y, t->row_ofs, y + t->row_ofs, tab_nc (t), tab_nr (t));
298 assert (y <= tab_nr (t));
301 assert (x2 < tab_nc (t));
306 for (x = x1; x <= x2; x++)
307 t->rh[x + t->cf * y] = style;
311 /* Draws a box around cells (X1,Y1)-(X2,Y2) inclusive with horizontal
312 lines of style F_H and vertical lines of style F_V. Fills the
313 interior of the box with horizontal lines of style I_H and vertical
314 lines of style I_V. Any of the line styles may be -1 to avoid
315 drawing those lines. This is distinct from 0, which draws a null
318 tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
319 int x1, int y1, int x2, int y2)
323 if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
324 || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t)
325 || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
326 || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
328 printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
329 "in table size (%d,%d)\n"),
330 x1, t->col_ofs, x1 + t->col_ofs,
331 y1, t->row_ofs, y1 + t->row_ofs,
332 x2, t->col_ofs, x2 + t->col_ofs,
333 y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t));
347 assert (x2 < tab_nc (t));
348 assert (y2 < tab_nr (t));
353 for (x = x1; x <= x2; x++)
355 t->rh[x + t->cf * y1] = f_h;
356 t->rh[x + t->cf * (y2 + 1)] = f_h;
362 for (y = y1; y <= y2; y++)
364 t->rv[x1 + (t->cf + 1) * y] = f_v;
365 t->rv[(x2 + 1) + (t->cf + 1) * y] = f_v;
373 for (y = y1 + 1; y <= y2; y++)
377 for (x = x1; x <= x2; x++)
378 t->rh[x + t->cf * y] = i_h;
385 for (x = x1 + 1; x <= x2; x++)
389 for (y = y1; y <= y2; y++)
390 t->rv[x + (t->cf + 1) * y] = i_v;
397 /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
398 from V, displayed with format spec F. */
400 tab_value (struct tab_table *table, int c, int r, unsigned short opt,
401 const union value *v, const struct variable *var,
402 const struct fmt_spec *f)
408 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
409 || c + table->col_ofs >= tab_nc (table)
410 || r + table->row_ofs >= tab_nr (table))
412 printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
414 c, table->col_ofs, c + table->col_ofs,
415 r, table->row_ofs, r + table->row_ofs,
416 tab_nc (table), tab_nr (table));
421 contents = data_out_stretchy (v, var_get_encoding (var),
422 f != NULL ? f : var_get_print_format (var),
425 table->cc[c + r * table->cf] = contents;
426 table->ct[c + r * table->cf] = opt;
429 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL as
431 If FMT is null, then the default print format will be used.
434 tab_double (struct tab_table *table, int c, int r, unsigned short opt,
435 double val, const struct fmt_spec *fmt, enum result_class rc)
437 union value double_value;
441 assert (c < tab_nc (table));
443 assert (r < tab_nr (table));
446 fmt = &table->fmtmap[rc];
448 fmt_check_output (fmt);
452 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
453 || c + table->col_ofs >= tab_nc (table)
454 || r + table->row_ofs >= tab_nr (table))
456 printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
458 c, table->col_ofs, c + table->col_ofs,
459 r, table->row_ofs, r + table->row_ofs,
460 tab_nc (table), tab_nr (table));
465 double_value.f = val;
466 s = data_out_stretchy (&double_value, C_ENCODING, fmt, table->container);
467 table->cc[c + r * table->cf] = s + strspn (s, " ");
468 table->ct[c + r * table->cf] = opt;
473 do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text)
477 assert (c < tab_nc (table));
478 assert (r < tab_nr (table));
482 if (c + table->col_ofs < 0 || r + table->row_ofs < 0
483 || c + table->col_ofs >= tab_nc (table)
484 || r + table->row_ofs >= tab_nr (table))
486 printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
488 c, table->col_ofs, c + table->col_ofs,
489 r, table->row_ofs, r + table->row_ofs,
490 tab_nc (table), tab_nr (table));
495 table->cc[c + r * table->cf] = text;
496 table->ct[c + r * table->cf] = opt;
499 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
502 tab_text (struct tab_table *table, int c, int r, unsigned opt,
505 do_tab_text (table, c, r, opt, pool_strdup (table->container, text));
508 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
509 FORMAT, which is formatted as if passed to printf. */
511 tab_text_format (struct tab_table *table, int c, int r, unsigned opt,
512 const char *format, ...)
516 va_start (args, format);
517 do_tab_text (table, c, r, opt,
518 pool_vasprintf (table->container, format, args));
522 static struct tab_joined_cell *
523 add_joined_cell (struct tab_table *table, int x1, int y1, int x2, int y2,
526 struct tab_joined_cell *j;
528 assert (x1 + table->col_ofs >= 0);
529 assert (y1 + table->row_ofs >= 0);
532 assert (y2 + table->row_ofs < tab_nr (table));
533 assert (x2 + table->col_ofs < tab_nc (table));
537 if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table)
538 || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table)
539 || x2 < x1 || x2 + table->col_ofs >= tab_nc (table)
540 || y2 < y1 || y2 + table->row_ofs >= tab_nr (table))
542 printf ("tab_joint_text(): bad cell "
543 "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
544 x1, table->col_ofs, x1 + table->col_ofs,
545 y1, table->row_ofs, y1 + table->row_ofs,
546 x2, table->col_ofs, x2 + table->col_ofs,
547 y2, table->row_ofs, y2 + table->row_ofs,
548 tab_nc (table), tab_nr (table));
553 tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2);
555 j = pool_alloc (table->container, sizeof *j);
556 j->d[TABLE_HORZ][0] = x1 + table->col_ofs;
557 j->d[TABLE_VERT][0] = y1 + table->row_ofs;
558 j->d[TABLE_HORZ][1] = ++x2 + table->col_ofs;
559 j->d[TABLE_VERT][1] = ++y2 + table->row_ofs;
564 void **cc = &table->cc[x1 + y1 * table->cf];
565 unsigned short *ct = &table->ct[x1 + y1 * table->cf];
566 const int ofs = table->cf - (x2 - x1);
570 for (y = y1; y < y2; y++)
574 for (x = x1; x < x2; x++)
577 *ct++ = opt | TAB_JOIN;
588 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
589 options OPT to have text value TEXT. */
591 tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
592 unsigned opt, const char *text)
594 char *s = pool_strdup (table->container, text);
595 if (x1 == x2 && y1 == y2)
596 do_tab_text (table, x1, y1, opt, s);
598 add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
601 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them
602 with options OPT to have text value FORMAT, which is formatted
603 as if passed to printf. */
605 tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2,
606 int y2, unsigned opt, const char *format, ...)
611 va_start (args, format);
612 s = pool_vasprintf (table->container, format, args);
615 add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s;
619 tab_create_footnote (struct tab_table *table, size_t idx, const char *content,
622 struct footnote *f = pool_alloc (table->container, sizeof *f);
624 f->content = pool_strdup (table->container, content);
625 f->marker = pool_strdup (table->container, marker);
630 tab_add_footnote (struct tab_table *table, int x, int y,
631 const struct footnote *f)
633 int index = x + y * table->cf;
634 unsigned short opt = table->ct[index];
635 struct tab_joined_cell *j;
638 j = table->cc[index];
641 char *text = table->cc[index];
643 j = add_joined_cell (table, x, y, x, y, table->ct[index]);
644 j->u.text = text ? text : xstrdup ("");
647 j->footnotes = pool_realloc (table->container, j->footnotes,
648 (j->n_footnotes + 1) * sizeof *j->footnotes);
650 j->footnotes[j->n_footnotes++] = f;
654 tab_cell_is_empty (const struct tab_table *table, int c, int r)
656 return table->cc[c + r * table->cf] == NULL;
661 /* Set the title of table T to TITLE, which is formatted as if
662 passed to printf(). */
664 tab_title (struct tab_table *t, const char *title, ...)
669 va_start (args, title);
670 t->title = xvasprintf (title, args);
674 /* Set the caption of table T to CAPTION, which is formatted as if
675 passed to printf(). */
677 tab_caption (struct tab_table *t, const char *caption, ...)
682 va_start (args, caption);
683 t->caption = xvasprintf (caption, args);
687 /* Easy, type-safe way to submit a tab table to som. */
689 tab_submit (struct tab_table *t)
691 table_item_submit (table_item_create (&t->table, t->title, t->caption));
696 /* Set table row and column offsets for all functions that affect
699 tab_offset (struct tab_table *t, int col, int row)
705 if (row < -1 || row > tab_nr (t))
707 printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t));
710 if (col < -1 || col > tab_nc (t))
712 printf ("tab_offset(): col=%d in %d-column table\n", col,
719 diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
721 diff += (col - t->col_ofs), t->col_ofs = col;
727 /* Increment the row offset by one. If the table is too small,
728 increase its size. */
730 tab_next_row (struct tab_table *t)
734 if (++t->row_ofs >= tab_nr (t))
735 tab_realloc (t, -1, tab_nr (t) * 4 / 3);
738 /* Writes STRING to the output. OPTIONS may be any valid combination of TAB_*
741 This function is obsolete. Please do not add new uses of it. Instead, use
742 a text_item (see output/text-item.h). */
744 tab_output_text (int options, const char *string)
746 enum text_item_type type = (options & TAB_EMPH ? TEXT_ITEM_SUBHEAD
747 : options & TAB_FIX ? TEXT_ITEM_MONOSPACE
748 : TEXT_ITEM_PARAGRAPH);
749 text_item_submit (text_item_create (type, string));
752 /* Same as tab_output_text(), but FORMAT is passed through printf-like
753 formatting before output. */
755 tab_output_text_format (int options, const char *format, ...)
760 va_start (args, format);
761 text = xvasprintf (format, args);
764 tab_output_text (options, text);
769 /* Table class implementation. */
772 tab_destroy (struct table *table)
774 struct tab_table *t = tab_cast (table);
779 pool_destroy (t->container);
783 tab_get_cell (const struct table *table, int x, int y,
784 struct table_cell *cell)
786 const struct tab_table *t = tab_cast (table);
787 int index = x + y * t->cf;
788 unsigned short opt = t->ct[index];
789 const void *cc = t->cc[index];
791 cell->inline_contents.options = opt;
792 cell->inline_contents.n_footnotes = 0;
793 cell->destructor = NULL;
797 const struct tab_joined_cell *jc = cc;
798 cell->contents = &cell->inline_contents;
799 cell->n_contents = 1;
800 cell->inline_contents.text = jc->u.text;
802 cell->inline_contents.footnotes = jc->footnotes;
803 cell->inline_contents.n_footnotes = jc->n_footnotes;
805 cell->d[TABLE_HORZ][0] = jc->d[TABLE_HORZ][0];
806 cell->d[TABLE_HORZ][1] = jc->d[TABLE_HORZ][1];
807 cell->d[TABLE_VERT][0] = jc->d[TABLE_VERT][0];
808 cell->d[TABLE_VERT][1] = jc->d[TABLE_VERT][1];
812 cell->d[TABLE_HORZ][0] = x;
813 cell->d[TABLE_HORZ][1] = x + 1;
814 cell->d[TABLE_VERT][0] = y;
815 cell->d[TABLE_VERT][1] = y + 1;
818 cell->contents = &cell->inline_contents;
819 cell->n_contents = 1;
820 cell->inline_contents.text = CONST_CAST (char *, cc);
824 cell->contents = NULL;
825 cell->n_contents = 0;
829 int style_idx = (opt & TAB_STYLE_MASK) >> TAB_STYLE_SHIFT;
830 const struct cell_style *style = t->styles[style_idx];
836 tab_get_rule (const struct table *table, enum table_axis axis, int x, int y)
838 const struct tab_table *t = tab_cast (table);
839 return (axis == TABLE_VERT
840 ? t->rh[x + t->cf * y] : t->rv[x + (t->cf + 1) * y]);
843 static const struct table_class tab_table_class = {
852 tab_cast (const struct table *table)
854 assert (table->klass == &tab_table_class);
855 return UP_CAST (table, struct tab_table, table);