X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Ftab.c;h=8ef077e38fae99f8a8b2d8c54b4c3b22f541e296;hb=5b5099296b3c7212623991de8920e1459e234922;hp=3092c04372618938c2058364bacde9109491ac91;hpb=b703dab672466b340ca9ade0d249459bc6b2ba4c;p=pspp diff --git a/src/output/tab.c b/src/output/tab.c index 3092c04372..8ef077e38f 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, 2010 Free Software Foundation, Inc. + Copyright (C) 1997-9, 2000, 2006, 2009, 2010, 2011, 2013, 2014 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,65 @@ #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) +/* Cell options. */ +#define TAB_JOIN (1u << TAB_FIRST_AVAILABLE) +#define TAB_SUBTABLE (1u << (TAB_FIRST_AVAILABLE + 1)) +#define TAB_BARE (1u << (TAB_FIRST_AVAILABLE + 2)) /* Joined cell. */ struct tab_joined_cell { int d[TABLE_N_AXES][2]; /* Table region, same as struct table_cell. */ - char *contents; + union + { + char *text; + struct table_item *subtable; + } + u; + + size_t n_footnotes; + char **footnotes; }; 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 * @@ -78,13 +97,27 @@ tab_create (int nc, int nr) memset (t->rh, 0, nc * (nr + 1)); t->rv = pool_nmalloc (t->container, nr, nc + 1); + memset (t->fmtmap, 0, sizeof (*t->fmtmap) * n_RC); + memset (t->rv, TAL_GAP, nr * (nc + 1)); + t->fmtmap[RC_PVALUE] = ugly[RC_PVALUE]; + t->fmtmap[RC_INTEGER] = ugly[RC_INTEGER]; + t->fmtmap[RC_OTHER] = *settings_get_format (); + 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. @@ -236,6 +269,21 @@ tab_vline (struct tab_table *t, int style, int x, int y1, int y2) void tab_hline (struct tab_table * t, int style, int x1, int x2, int y) { +#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; + } +#endif + x1 += t->col_ofs; x2 += t->col_ofs; y += t->row_ofs; @@ -344,7 +392,7 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v, 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 union value *v, const struct variable *var, const struct fmt_spec *f) { char *contents; @@ -363,57 +411,21 @@ tab_value (struct tab_table *table, int c, int r, unsigned char opt, } #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) + double val, const struct fmt_spec *fmt, enum result_class rc) { union value double_value ; char *s; @@ -423,9 +435,9 @@ tab_double (struct tab_table *table, int c, int r, unsigned char opt, 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 @@ -443,7 +455,7 @@ tab_double (struct tab_table *table, int c, int r, unsigned char opt, #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; } @@ -498,9 +510,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; @@ -535,9 +547,8 @@ 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; { void **cc = &table->cc[x1 + y1 * table->cf]; @@ -553,13 +564,15 @@ do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2, for (x = x1; x < x2; x++) { *cc++ = j; - *ct++ = opt; + *ct++ = opt | TAB_JOIN; } cc += ofs; ct += ofs; } } + + return j; } /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with @@ -568,8 +581,8 @@ 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); + add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s; } /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them @@ -580,13 +593,74 @@ 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); + s = pool_vasprintf (table->container, format, args); + va_end (args); + + add_joined_cell (table, x1, y1, x2, y2, opt)->u.text = s; +} + +void +tab_footnote (struct tab_table *table, int x, int y, const char *format, ...) +{ + int index = x + y * table->cf; + unsigned char opt = table->ct[index]; + struct tab_joined_cell *j; + va_list args; + + 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 = xrealloc (j->footnotes, + (j->n_footnotes + 1) * sizeof *j->footnotes); va_start (args, format); - do_tab_joint_text (table, x1, y1, x2, y2, opt, - pool_vasprintf (table->container, format, args)); + j->footnotes[j->n_footnotes++] = pool_vasprintf (table->container, format, args); va_end (args); } +static void +subtable_unref (void *subtable) +{ + table_item_unref (subtable); +} + +/* Places SUBTABLE as the content for cells (X1,X2)-(Y1,Y2) inclusive in TABLE + with options OPT. */ +void +tab_subtable (struct tab_table *table, int x1, int y1, int x2, int y2, + unsigned opt, struct table_item *subtable) +{ + add_joined_cell (table, x1, y1, x2, y2, opt | TAB_SUBTABLE)->u.subtable + = subtable; + pool_register (table->container, subtable_unref, subtable); +} + +/* Places the contents of SUBTABLE as the content for cells (X1,X2)-(Y1,Y2) + inclusive in TABLE with options OPT. + + SUBTABLE must have exactly one row and column. The contents of its single + cell are used as the contents of TABLE's cell; that is, SUBTABLE is not used + as a nested table but its contents become part of TABLE. */ +void +tab_subtable_bare (struct tab_table *table, int x1, int y1, int x2, int y2, + unsigned opt, struct table_item *subtable) +{ + const struct table *t UNUSED = table_item_get_table (subtable); + assert (table_nc (t) == 1); + assert (table_nr (t) == 1); + tab_subtable (table, x1, y1, x2, y2, opt | TAB_BARE, subtable); +} + bool tab_cell_is_empty (const struct tab_table *table, int c, int r) { @@ -694,6 +768,8 @@ static void tab_destroy (struct table *table) { struct tab_table *t = tab_cast (table); + free (t->title); + t->title = NULL; pool_destroy (t->container); } @@ -703,17 +779,43 @@ 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]; + const void *cc = t->cc[index]; + + cell->inline_contents.options = opt; + cell->inline_contents.table = NULL; + cell->inline_contents.n_footnotes = 0; + cell->destructor = NULL; - cell->options = opt; if (opt & TAB_JOIN) { - const struct tab_joined_cell *jc = content; + const struct tab_joined_cell *jc = cc; + if (opt & TAB_BARE) + { + assert (opt & TAB_SUBTABLE); + + /* This overwrites all of the members of CELL. */ + table_get_cell (table_item_get_table (jc->u.subtable), 0, 0, cell); + } + else + { + cell->contents = &cell->inline_contents; + cell->n_contents = 1; + if (opt & TAB_SUBTABLE) + { + cell->inline_contents.table = jc->u.subtable; + cell->inline_contents.text = NULL; + } + else + 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; } else { @@ -721,9 +823,18 @@ 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 @@ -747,6 +858,6 @@ static const struct table_class tab_table_class = 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); }