X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Ftab.c;h=435fa609ce06d4547f885f07aad3ad5c6e336e08;hb=01d6db8119ca4553d61841f2a9248712d4c6e0dc;hp=058cb974c6557a6870c445a697991e51aed090cc;hpb=dfd1972f7bcb550a4fc3b05dbe7e71d12334b0a7;p=pspp diff --git a/src/output/tab.c b/src/output/tab.c index 058cb974c6..435fa609ce 100644 --- a/src/output/tab.c +++ b/src/output/tab.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 1997-9, 2000, 2006, 2009 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013, 2014, 2016 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,46 +16,68 @@ #include -#include +#include "output/tab.h" #include #include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "error.h" -#include "minmax.h" -#include "xalloc.h" +#include "data/data-out.h" +#include "data/format.h" +#include "data/settings.h" +#include "data/value.h" +#include "data/variable.h" +#include "libpspp/assertion.h" +#include "libpspp/compiler.h" +#include "libpspp/i18n.h" +#include "libpspp/misc.h" +#include "libpspp/pool.h" +#include "output/driver.h" +#include "output/table-item.h" +#include "output/table-provider.h" +#include "output/text-item.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) -/* Set in the options field of cells that */ -#define TAB_JOIN (1u << TAB_FIRST_AVAILABLE) + +static const bool debugging = true; + + +/* Cell options. */ +#define TAB_JOIN (1u << TAB_FIRST_AVAILABLE) /* Joined cell. */ struct tab_joined_cell +{ + int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */ + union { - int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */ - char *contents; - }; + char *text; + struct table_item *subtable; + } + u; + + size_t n_footnotes; + const struct footnote **footnotes; + + const struct cell_style *style; +}; static const struct table_class tab_table_class; +struct fmt_spec ugly[n_RC] = { + {FMT_F, 8, 0}, /* INTEGER */ + {FMT_F, 8, 3}, /* WEIGHT (ignored) */ + {FMT_F, 8, 3}, /* PVALUE */ + {FMT_F, 8, 3} /* OTHER (ignored) */ +}; + + /* Creates and returns a new table with NC columns and NR rows and initially no header rows or columns. The table's cells are initially empty. */ struct tab_table * @@ -69,22 +91,39 @@ tab_create (int nc, int nr) table_set_nr (&t->table, nr); t->title = NULL; + t->caption = NULL; t->cf = nc; t->cc = pool_calloc (t->container, nr * nc, sizeof *t->cc); - t->ct = pool_malloc (t->container, nr * nc); - memset (t->ct, 0, nc * nr); + t->ct = pool_calloc (t->container, nr * nc, sizeof *t->ct); t->rh = pool_nmalloc (t->container, nc, nr + 1); - memset (t->rh, 0, nc * (nr + 1)); + memset (t->rh, TAL_0, nc * (nr + 1)); t->rv = pool_nmalloc (t->container, nr, nc + 1); - memset (t->rv, TAL_GAP, nr * (nc + 1)); + memset (t->rv, TAL_0, nr * (nc + 1)); + + memset (t->fmtmap, 0, sizeof (*t->fmtmap) * n_RC); + t->fmtmap[RC_PVALUE] = ugly[RC_PVALUE]; + t->fmtmap[RC_INTEGER] = ugly[RC_INTEGER]; + t->fmtmap[RC_OTHER] = *settings_get_format (); + + memset (t->styles, 0, sizeof t->styles); + memset (t->rule_colors, 0, sizeof t->rule_colors); t->col_ofs = t->row_ofs = 0; return t; } + +void +tab_set_format (struct tab_table *t, enum result_class rc, + const struct fmt_spec *fmt) +{ + t->fmtmap[rc] = *fmt; +} + + /* Sets the width and height of a table, in columns and rows, respectively. Use only to reduce the size of a table, since it does not change the amount of allocated memory. @@ -94,7 +133,6 @@ tab_create (int nc, int nr) void tab_resize (struct tab_table *t, int nc, int nr) { - assert (t != NULL); if (nc != -1) { assert (nc + t->col_ofs <= t->cf); @@ -118,7 +156,6 @@ tab_realloc (struct tab_table *t, int nc, int nr) { int ro, co; - assert (t != NULL); ro = t->row_ofs; co = t->col_ofs; if (ro || co) @@ -137,17 +174,19 @@ tab_realloc (struct tab_table *t, int nc, int nr) int mc1 = MIN (nc, tab_nc (t)); void **new_cc; - unsigned char *new_ct; + unsigned short *new_ct; int r; new_cc = pool_calloc (t->container, nr * nc, sizeof *new_cc); new_ct = pool_malloc (t->container, nr * nc); for (r = 0; r < mr1; r++) - { - memcpy (&new_cc[r * nc], &t->cc[r * tab_nc (t)], mc1 * sizeof *t->cc); - memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)], mc1); - memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t)); - } + { + memcpy (&new_cc[r * nc], &t->cc[r * tab_nc (t)], + mc1 * sizeof *t->cc); + memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)], + mc1 * sizeof *t->ct); + memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t)); + } pool_free (t->container, t->cc); pool_free (t->container, t->ct); t->cc = new_cc; @@ -157,20 +196,21 @@ tab_realloc (struct tab_table *t, int nc, int nr) else if (nr != tab_nr (t)) { t->cc = pool_nrealloc (t->container, t->cc, nr * nc, sizeof *t->cc); - t->ct = pool_realloc (t->container, t->ct, nr * nc); + t->ct = pool_nrealloc (t->container, t->ct, nr * nc, sizeof *t->ct); t->rh = pool_nrealloc (t->container, t->rh, nc, nr + 1); t->rv = pool_nrealloc (t->container, t->rv, nr, nc + 1); if (nr > tab_nr (t)) - { - memset (&t->rh[nc * (tab_nr (t) + 1)], TAL_0, (nr - tab_nr (t)) * nc); - memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_GAP, + { + memset (&t->rh[nc * (tab_nr (t) + 1)], TAL_0, + (nr - tab_nr (t)) * nc); + memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_0, (nr - tab_nr (t)) * (nc + 1)); - } + } } - memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t))); + memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->ct); memset (&t->cc[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->cc); table_set_nr (&t->table, nr); @@ -200,22 +240,20 @@ tab_headers (struct tab_table *table, int l, int r, int t, int b) void tab_vline (struct tab_table *t, int style, int x, int y1, int y2) { - assert (t != NULL); - -#if DEBUGGING - if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t) - || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t) - || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t)) + if (debugging) { - printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in " - "table size (%d,%d)\n"), - x, t->col_ofs, x + t->col_ofs, - y1, t->row_ofs, y1 + t->row_ofs, - y2, t->row_ofs, y2 + t->row_ofs, - tab_nc (t), tab_nr (t)); - return; + if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t) + || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t) + || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t)) + { + printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in " + "table size (%d,%d)\n"), + x, t->col_ofs, x + t->col_ofs, + y1, t->row_ofs, y1 + t->row_ofs, + y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t)); + return; + } } -#endif x += t->col_ofs; y1 += t->row_ofs; @@ -238,9 +276,22 @@ tab_vline (struct tab_table *t, int style, int x, int y1, int y2) /* Draws a horizontal line above cells at vertical position Y from X1 to X2 inclusive in style STYLE, if style is not -1. */ void -tab_hline (struct tab_table * t, int style, int x1, int x2, int y) +tab_hline (struct tab_table *t, int style, int x1, int x2, int y) { - assert (t != NULL); + if (debugging) + { + if (y + t->row_ofs < 0 || y + t->row_ofs > tab_nr (t) + || x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t) + || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t)) + { + printf (_("bad hline: x=(%d+%d=%d,%d+%d=%d) y=%d+%d=%d in " + "table size (%d,%d)\n"), + x1, t->col_ofs, x1 + t->col_ofs, + x2, t->col_ofs, x2 + t->col_ofs, + y, t->row_ofs, y + t->row_ofs, tab_nc (t), tab_nr (t)); + return; + } + } x1 += t->col_ofs; x2 += t->col_ofs; @@ -248,8 +299,8 @@ tab_hline (struct tab_table * t, int style, int x1, int x2, int y) assert (y >= 0); assert (y <= tab_nr (t)); - assert (x2 >= x1 ); - assert (x1 >= 0 ); + assert (x2 >= x1); + assert (x1 >= 0); assert (x2 < tab_nc (t)); if (style != -1) @@ -268,26 +319,24 @@ tab_hline (struct tab_table * t, int style, int x1, int x2, int y) line. */ void tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v, - int x1, int y1, int x2, int y2) + int x1, int y1, int x2, int y2) { - assert (t != NULL); - -#if DEBUGGING - if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t) - || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t) - || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t) - || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t)) + if (debugging) { - printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) " - "in table size (%d,%d)\n"), - x1, t->col_ofs, x1 + t->col_ofs, - y1, t->row_ofs, y1 + t->row_ofs, - x2, t->col_ofs, x2 + t->col_ofs, - y2, t->row_ofs, y2 + t->row_ofs, - tab_nc (t), tab_nr (t)); - NOT_REACHED (); + if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t) + || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t) + || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t) + || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t)) + { + printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) " + "in table size (%d,%d)\n"), + x1, t->col_ofs, x1 + t->col_ofs, + y1, t->row_ofs, y1 + t->row_ofs, + x2, t->col_ofs, x2 + t->col_ofs, + y2, t->row_ofs, y2 + t->row_ofs, tab_nc (t), tab_nr (t)); + NOT_REACHED (); + } } -#endif x1 += t->col_ofs; x2 += t->col_ofs; @@ -325,24 +374,24 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v, int y; for (y = y1 + 1; y <= y2; y++) - { - int x; + { + int x; for (x = x1; x <= x2; x++) t->rh[x + t->cf * y] = i_h; - } + } } if (i_v != -1) { int x; for (x = x1 + 1; x <= x2; x++) - { - int y; + { + int y; for (y = y1; y <= y2; y++) t->rv[x + (t->cf + 1) * y] = i_v; - } + } } } @@ -351,110 +400,73 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v, /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken from V, displayed with format spec F. */ void -tab_value (struct tab_table *table, int c, int r, unsigned char opt, - const union value *v, const struct dictionary *dict, - const struct fmt_spec *f) +tab_value (struct tab_table *table, int c, int r, unsigned short opt, + const union value *v, const struct variable *var, + const struct fmt_spec *f) { char *contents; - assert (table != NULL && v != NULL && f != NULL); -#if DEBUGGING - if (c + table->col_ofs < 0 || r + table->row_ofs < 0 - || c + table->col_ofs >= tab_nc (table) - || r + table->row_ofs >= tab_nr (table)) + if (debugging) { - printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size " - "(%d,%d)\n", - c, table->col_ofs, c + table->col_ofs, - r, table->row_ofs, r + table->row_ofs, - tab_nc (table), tab_nr (table)); - return; + if (c + table->col_ofs < 0 || r + table->row_ofs < 0 + || c + table->col_ofs >= tab_nc (table) + || r + table->row_ofs >= tab_nr (table)) + { + printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size " + "(%d,%d)\n", + c, table->col_ofs, c + table->col_ofs, + r, table->row_ofs, r + table->row_ofs, + tab_nc (table), tab_nr (table)); + return; + } } -#endif - contents = data_out_pool (v, dict_get_encoding (dict), f, table->container); + contents = data_out_stretchy (v, var_get_encoding (var), + f != NULL ? f : var_get_print_format (var), + table->container); table->cc[c + r * table->cf] = contents; table->ct[c + r * table->cf] = opt; } -/* Sets cell (C,R) in TABLE, with options OPT, to have value VAL - with NDEC decimal places. */ -void -tab_fixed (struct tab_table *table, int c, int r, unsigned char opt, - double val, int w, int d) -{ - struct fmt_spec f; - union value double_value; - char *s; - - assert (c >= 0); - assert (c < tab_nc (table)); - assert (r >= 0); - assert (r < tab_nr (table)); - - f = fmt_for_output (FMT_F, w, d); - -#if DEBUGGING - if (c + table->col_ofs < 0 || r + table->row_ofs < 0 - || c + table->col_ofs >= tab_nc (table) - || r + table->row_ofs >= tab_nr (table)) - { - printf ("tab_fixed(): bad cell (%d+%d=%d,%d+%d=%d) in table size " - "(%d,%d)\n", - c, table->col_ofs, c + table->col_ofs, - r, table->row_ofs, r + table->row_ofs, - tab_nc (table), tab_nr (table)); - return; - } -#endif - - double_value.f = val; - s = data_out_pool (&double_value, LEGACY_NATIVE, &f, table->container); - - table->cc[c + r * table->cf] = s + strspn (s, " "); - table->ct[c + r * table->cf] = opt; -} - /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL as formatted by FMT. If FMT is null, then the default print format will be used. */ void -tab_double (struct tab_table *table, int c, int r, unsigned char opt, - double val, const struct fmt_spec *fmt) +tab_double (struct tab_table *table, int c, int r, unsigned short opt, + double val, const struct fmt_spec *fmt, enum result_class rc) { - union value double_value ; + union value double_value; char *s; - assert (table != NULL); - assert (c >= 0); assert (c < tab_nc (table)); assert (r >= 0); assert (r < tab_nr (table)); - if ( fmt == NULL) - fmt = settings_get_format (); + if (fmt == NULL) + fmt = &table->fmtmap[rc]; fmt_check_output (fmt); -#if DEBUGGING - if (c + table->col_ofs < 0 || r + table->row_ofs < 0 - || c + table->col_ofs >= tab_nc (table) - || r + table->row_ofs >= tab_nr (table)) + if (debugging) { - printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size " - "(%d,%d)\n", - c, table->col_ofs, c + table->col_ofs, - r, table->row_ofs, r + table->row_ofs, - tab_nc (table), tab_nr (table)); - return; + if (c + table->col_ofs < 0 || r + table->row_ofs < 0 + || c + table->col_ofs >= tab_nc (table) + || r + table->row_ofs >= tab_nr (table)) + { + printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size " + "(%d,%d)\n", + c, table->col_ofs, c + table->col_ofs, + r, table->row_ofs, r + table->row_ofs, + tab_nc (table), tab_nr (table)); + return; + } } -#endif double_value.f = val; - s = data_out_pool (&double_value, LEGACY_NATIVE, fmt, table->container); + s = data_out_stretchy (&double_value, C_ENCODING, fmt, table->container); table->cc[c + r * table->cf] = s + strspn (s, " "); table->ct[c + r * table->cf] = opt; } @@ -463,24 +475,25 @@ tab_double (struct tab_table *table, int c, int r, unsigned char opt, static void do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text) { - assert (c >= 0 ); - assert (r >= 0 ); + assert (c >= 0); + assert (r >= 0); assert (c < tab_nc (table)); assert (r < tab_nr (table)); -#if DEBUGGING - if (c + table->col_ofs < 0 || r + table->row_ofs < 0 - || c + table->col_ofs >= tab_nc (table) - || r + table->row_ofs >= tab_nr (table)) + if (debugging) { - printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size " - "(%d,%d)\n", - c, table->col_ofs, c + table->col_ofs, - r, table->row_ofs, r + table->row_ofs, - tab_nc (table), tab_nr (table)); - return; + if (c + table->col_ofs < 0 || r + table->row_ofs < 0 + || c + table->col_ofs >= tab_nc (table) + || r + table->row_ofs >= tab_nr (table)) + { + printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size " + "(%d,%d)\n", + c, table->col_ofs, c + table->col_ofs, + r, table->row_ofs, r + table->row_ofs, + tab_nc (table), tab_nr (table)); + return; + } } -#endif table->cc[c + r * table->cf] = text; table->ct[c + r * table->cf] = opt; @@ -509,9 +522,9 @@ tab_text_format (struct tab_table *table, int c, int r, unsigned opt, va_end (args); } -static void -do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2, - unsigned opt, char *text) +static struct tab_joined_cell * +add_joined_cell (struct tab_table *table, int x1, int y1, int x2, int y2, + unsigned opt) { struct tab_joined_cell *j; @@ -522,22 +535,23 @@ do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2, assert (y2 + table->row_ofs < tab_nr (table)); assert (x2 + table->col_ofs < tab_nc (table)); -#if DEBUGGING - if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table) - || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table) - || x2 < x1 || x2 + table->col_ofs >= tab_nc (table) - || y2 < y2 || y2 + table->row_ofs >= tab_nr (table)) + if (debugging) { - printf ("tab_joint_text(): bad cell " - "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n", - x1, table->col_ofs, x1 + table->col_ofs, - y1, table->row_ofs, y1 + table->row_ofs, - x2, table->col_ofs, x2 + table->col_ofs, - y2, table->row_ofs, y2 + table->row_ofs, - tab_nc (table), tab_nr (table)); - return; + if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table) + || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table) + || x2 < x1 || x2 + table->col_ofs >= tab_nc (table) + || y2 < y1 || y2 + table->row_ofs >= tab_nr (table)) + { + printf ("tab_joint_text(): bad cell " + "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n", + x1, table->col_ofs, x1 + table->col_ofs, + y1, table->row_ofs, y1 + table->row_ofs, + x2, table->col_ofs, x2 + table->col_ofs, + y2, table->row_ofs, y2 + table->row_ofs, + tab_nc (table), tab_nr (table)); + return NULL; + } } -#endif tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2); @@ -546,31 +560,33 @@ do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2, j->d[TABLE_VERT][0] = y1 + table->row_ofs; j->d[TABLE_HORZ][1] = ++x2 + table->col_ofs; j->d[TABLE_VERT][1] = ++y2 + table->row_ofs; - j->contents = text; - - opt |= TAB_JOIN; + j->n_footnotes = 0; + j->footnotes = NULL; + j->style = NULL; { void **cc = &table->cc[x1 + y1 * table->cf]; - unsigned char *ct = &table->ct[x1 + y1 * table->cf]; + unsigned short *ct = &table->ct[x1 + y1 * table->cf]; const int ofs = table->cf - (x2 - x1); int y; for (y = y1; y < y2; y++) { - int x; + int x; - for (x = x1; x < x2; x++) - { - *cc++ = j; - *ct++ = opt; - } + for (x = x1; x < x2; x++) + { + *cc++ = j; + *ct++ = opt | TAB_JOIN; + } - cc += ofs; - ct += ofs; + cc += ofs; + ct += ofs; } } + + return j; } /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with @@ -579,23 +595,85 @@ void tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2, unsigned opt, const char *text) { - do_tab_joint_text (table, x1, y1, x2, y2, opt, - pool_strdup (table->container, text)); + char *s = pool_strdup (table->container, text); + if (x1 == x2 && y1 == y2) + do_tab_text (table, x1, y1, opt, s); + else + add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s; } /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with options OPT to have text value FORMAT, which is formatted as if passed to printf. */ void -tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2, int y2, - unsigned opt, const char *format, ...) +tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2, + int y2, unsigned opt, const char *format, ...) { va_list args; + char *s; va_start (args, format); - do_tab_joint_text (table, x1, y1, x2, y2, opt, - pool_vasprintf (table->container, format, args)); + s = pool_vasprintf (table->container, format, args); va_end (args); + + add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s; +} + +struct footnote * +tab_create_footnote (struct tab_table *table, size_t idx, const char *content, + const char *marker, struct cell_style *style) +{ + struct footnote *f = pool_alloc (table->container, sizeof *f); + f->idx = idx; + f->content = pool_strdup (table->container, content); + f->marker = pool_strdup (table->container, marker); + f->style = style; + return f; +} + +void +tab_add_footnote (struct tab_table *table, int x, int y, + const struct footnote *f) +{ + int index = x + y * table->cf; + unsigned short opt = table->ct[index]; + struct tab_joined_cell *j; + + if (opt & TAB_JOIN) + j = table->cc[index]; + else + { + char *text = table->cc[index]; + + j = add_joined_cell (table, x, y, x, y, table->ct[index]); + j->u.text = text ? text : xstrdup (""); + } + + j->footnotes = pool_realloc (table->container, j->footnotes, + (j->n_footnotes + 1) * sizeof *j->footnotes); + + j->footnotes[j->n_footnotes++] = f; +} + +void +tab_add_style (struct tab_table *table, int x, int y, + const struct cell_style *style) +{ + int index = x + y * table->cf; + unsigned short opt = table->ct[index]; + struct tab_joined_cell *j; + + if (opt & TAB_JOIN) + j = table->cc[index]; + else + { + char *text = table->cc[index]; + + j = add_joined_cell (table, x, y, x, y, table->ct[index]); + j->u.text = text ? text : xstrdup (""); + } + + j->style = style; } bool @@ -619,11 +697,24 @@ tab_title (struct tab_table *t, const char *title, ...) va_end (args); } +/* Set the caption of table T to CAPTION, which is formatted as if + passed to printf(). */ +void +tab_caption (struct tab_table *t, const char *caption, ...) +{ + va_list args; + + free (t->caption); + va_start (args, caption); + t->caption = xvasprintf (caption, args); + va_end (args); +} + /* Easy, type-safe way to submit a tab table to som. */ void tab_submit (struct tab_table *t) { - table_item_submit (table_item_create (&t->table, t->title)); + table_item_submit (table_item_create (&t->table, t->title, t->caption)); } /* Editing. */ @@ -635,19 +726,20 @@ tab_offset (struct tab_table *t, int col, int row) { int diff = 0; - assert (t != NULL); -#if DEBUGGING - if (row < -1 || row > tab_nr (t)) + if (debugging) { - printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t)); - NOT_REACHED (); - } - if (col < -1 || col > tab_nc (t)) - { - printf ("tab_offset(): col=%d in %d-column table\n", col, tab_nc (t)); - NOT_REACHED (); + if (row < -1 || row > tab_nr (t)) + { + printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t)); + NOT_REACHED (); + } + if (col < -1 || col > tab_nc (t)) + { + printf ("tab_offset(): col=%d in %d-column table\n", col, + tab_nc (t)); + NOT_REACHED (); + } } -#endif if (row != -1) diff += (row - t->row_ofs) * t->cf, t->row_ofs = row; @@ -663,7 +755,6 @@ tab_offset (struct tab_table *t, int col, int row) void tab_next_row (struct tab_table *t) { - assert (t != NULL); t->cc += t->cf; t->ct += t->cf; if (++t->row_ofs >= tab_nr (t)) @@ -707,26 +798,48 @@ static void tab_destroy (struct table *table) { struct tab_table *t = tab_cast (table); + free (t->title); + t->title = NULL; + free (t->caption); + t->caption = NULL; pool_destroy (t->container); } static void -tab_get_cell (const struct table *table, int x, int y, struct table_cell *cell) +tab_get_cell (const struct table *table, int x, int y, + struct table_cell *cell) { const struct tab_table *t = tab_cast (table); int index = x + y * t->cf; - unsigned char opt = t->ct[index]; - const void *content = t->cc[index]; + unsigned short opt = t->ct[index]; + const void *cc = t->cc[index]; + + cell->inline_contents.options = opt; + cell->inline_contents.n_footnotes = 0; + cell->destructor = NULL; + + int style_idx = (opt & TAB_STYLE_MASK) >> TAB_STYLE_SHIFT; + const struct cell_style *style = t->styles[style_idx]; + if (style) + cell->style = style; - cell->options = opt; if (opt & TAB_JOIN) { - const struct tab_joined_cell *jc = content; + const struct tab_joined_cell *jc = cc; + cell->contents = &cell->inline_contents; + cell->n_contents = 1; + cell->inline_contents.text = jc->u.text; + + cell->inline_contents.footnotes = jc->footnotes; + cell->inline_contents.n_footnotes = jc->n_footnotes; + cell->d[TABLE_HORZ][0] = jc->d[TABLE_HORZ][0]; cell->d[TABLE_HORZ][1] = jc->d[TABLE_HORZ][1]; cell->d[TABLE_VERT][0] = jc->d[TABLE_VERT][0]; cell->d[TABLE_VERT][1] = jc->d[TABLE_VERT][1]; - cell->contents = jc->contents; + + if (jc->style) + cell->style = jc->style; } else { @@ -734,32 +847,45 @@ tab_get_cell (const struct table *table, int x, int y, struct table_cell *cell) cell->d[TABLE_HORZ][1] = x + 1; cell->d[TABLE_VERT][0] = y; cell->d[TABLE_VERT][1] = y + 1; - cell->contents = content != NULL ? content : ""; + if (cc != NULL) + { + cell->contents = &cell->inline_contents; + cell->n_contents = 1; + cell->inline_contents.text = CONST_CAST (char *, cc); + } + else + { + cell->contents = NULL; + cell->n_contents = 0; + } } - cell->destructor = NULL; } static int -tab_get_rule (const struct table *table, enum table_axis axis, int x, int y) +tab_get_rule (const struct table *table, enum table_axis axis, int x, int y, + struct cell_color *color) { const struct tab_table *t = tab_cast (table); - return (axis == TABLE_VERT - ? t->rh[x + t->cf * y] - : t->rv[x + (t->cf + 1) * y]); + uint8_t raw = (axis == TABLE_VERT + ? t->rh[x + t->cf * y] : t->rv[x + (t->cf + 1) * y]); + struct cell_color *p = t->rule_colors[(raw & TAB_RULE_STYLE_MASK) + >> TAB_RULE_STYLE_SHIFT]; + if (p) + *color = *p; + return (raw & TAB_RULE_TYPE_MASK) >> TAB_RULE_TYPE_SHIFT; } -static const struct table_class tab_table_class = - { - tab_destroy, - tab_get_cell, - tab_get_rule, - NULL, /* paste */ - NULL, /* select */ - }; +static const struct table_class tab_table_class = { + tab_destroy, + tab_get_cell, + tab_get_rule, + NULL, /* paste */ + NULL, /* select */ +}; struct tab_table * tab_cast (const struct table *table) { - assert (table->class == &tab_table_class); + assert (table->klass == &tab_table_class); return UP_CAST (table, struct tab_table, table); }