X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Ftab.c;h=14d56586291d11a264b24bac4f631839b27a73ff;hb=b4953e577f4b83b16f3329e7ff22d60950f3b0d5;hp=8eab07e6f151a1490d30a7c3268212d35faf84b5;hpb=6fd821e557390a8f86f37c192fd1a4c4e057c9c3;p=pspp

diff --git a/src/output/tab.c b/src/output/tab.c
index 8eab07e6f1..14d5658629 100644
--- a/src/output/tab.c
+++ b/src/output/tab.c
@@ -55,29 +55,16 @@ static const bool debugging = true;
 struct tab_joined_cell
 {
   int d[TABLE_N_AXES][2];       /* Table region, same as struct table_cell. */
-  union
-  {
-    char *text;
-    struct table_item *subtable;
-  }
-    u;
+  char *text;
 
   size_t n_footnotes;
   const struct footnote **footnotes;
 
-  const struct cell_style *style;
+  const struct area_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 *
@@ -86,13 +73,8 @@ tab_create (int nc, int nr)
   struct tab_table *t;
 
   t = pool_create_container (struct tab_table, container);
-  table_init (&t->table, &tab_table_class);
-  table_set_nc (&t->table, nc);
-  table_set_nr (&t->table, nr);
+  table_init (&t->table, &tab_table_class, nc, nr);
 
-  t->title = NULL;
-  t->caption = NULL;
-  t->cf = nc;
   t->cc = pool_calloc (t->container, nr * nc, sizeof *t->cc);
   t->ct = pool_calloc (t->container, nr * nc, sizeof *t->ct);
 
@@ -102,124 +84,13 @@ tab_create (int nc, int nr)
   t->rv = pool_nmalloc (t->container, 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.
-
-   This function is obsolete.  Please do not add new uses of it.  (Instead, use
-   table_select() or one of its helper functions.) */
-void
-tab_resize (struct tab_table *t, int nc, int nr)
-{
-  if (nc != -1)
-    {
-      assert (nc + t->col_ofs <= t->cf);
-      table_set_nc (&t->table, nc + t->col_ofs);
-    }
-  if (nr != -1)
-    {
-      assert (nr + t->row_ofs <= tab_nr (t));
-      table_set_nr (&t->table, nr + t->row_ofs);
-    }
-}
-
-/* Changes either or both dimensions of a table and reallocates memory as
-   necessary.
-
-   This function is obsolete.  Please do not add new uses of it.  (Instead, use
-   table_paste() or one of its helper functions to paste multiple tables
-   together into a larger one.) */
-void
-tab_realloc (struct tab_table *t, int nc, int nr)
-{
-  int ro, co;
-
-  ro = t->row_ofs;
-  co = t->col_ofs;
-  if (ro || co)
-    tab_offset (t, 0, 0);
-
-  if (nc == -1)
-    nc = tab_nc (t);
-  if (nr == -1)
-    nr = tab_nr (t);
-
-  assert (nc == tab_nc (t));
-
-  if (nc > t->cf)
-    {
-      int mr1 = MIN (nr, tab_nr (t));
-      int mc1 = MIN (nc, tab_nc (t));
-
-      void **new_cc;
-      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 * 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;
-      t->ct = new_ct;
-      t->cf = nc;
-    }
-  else if (nr != tab_nr (t))
-    {
-      t->cc = pool_nrealloc (t->container, t->cc, nr * nc, sizeof *t->cc);
-      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_0,
-                  (nr - tab_nr (t)) * (nc + 1));
-        }
-    }
-
-  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);
-  table_set_nc (&t->table, nc);
-
-  if (ro || co)
-    tab_offset (t, co, ro);
-}
-
 /* Sets the number of header rows on each side of TABLE to L on the
    left, R on the right, T on the top, B on the bottom.  Header rows
    are repeated when a table is broken across multiple columns or
@@ -242,23 +113,16 @@ tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
 {
   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 (x < 0 || x > tab_nc (t)
+          || y1 < 0 || y1 >= tab_nr (t)
+          || y2 < 0 || y2 >= 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));
+          printf (_("bad vline: x=%d y=(%d,%d) in table size (%d,%d)\n"),
+                  x, y1, y2, tab_nc (t), tab_nr (t));
           return;
         }
     }
 
-  x += t->col_ofs;
-  y1 += t->row_ofs;
-  y2 += t->row_ofs;
-
   assert (x >= 0);
   assert (x <= tab_nc (t));
   assert (y1 >= 0);
@@ -269,7 +133,7 @@ tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
     {
       int y;
       for (y = y1; y <= y2; y++)
-        t->rv[x + (t->cf + 1) * y] = style;
+        t->rv[x + (tab_nc (t) + 1) * y] = style;
     }
 }
 
@@ -280,23 +144,16 @@ 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))
+      if (y < 0 || y > tab_nr (t)
+          || x1 < 0 || x1 >= tab_nc (t)
+          || x2 < 0 || x2 >= 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));
+          printf (_("bad hline: x=(%d,%d) y=%d in table size (%d,%d)\n"),
+                  x1, x2, y, tab_nc (t), tab_nr (t));
           return;
         }
     }
 
-  x1 += t->col_ofs;
-  x2 += t->col_ofs;
-  y += t->row_ofs;
-
   assert (y >= 0);
   assert (y <= tab_nr (t));
   assert (x2 >= x1);
@@ -307,7 +164,7 @@ tab_hline (struct tab_table *t, int style, int x1, int x2, int y)
     {
       int x;
       for (x = x1; x <= x2; x++)
-        t->rh[x + t->cf * y] = style;
+        t->rh[x + tab_nc (t) * y] = style;
     }
 }
 
@@ -323,26 +180,17 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
 {
   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 (x1 < 0 || x1 >= tab_nc (t)
+          || x2 < 0 || x2 >= tab_nc (t)
+          || y1 < 0 || y1 >= tab_nr (t)
+          || y2 < 0 || y2 >= 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));
+          printf (_("bad box: (%d,%d)-(%d,%d) in table size (%d,%d)\n"),
+                  x1, y1, x2, y2, tab_nc (t), tab_nr (t));
           NOT_REACHED ();
         }
     }
 
-  x1 += t->col_ofs;
-  x2 += t->col_ofs;
-  y1 += t->row_ofs;
-  y2 += t->row_ofs;
-
   assert (x2 >= x1);
   assert (y2 >= y1);
   assert (x1 >= 0);
@@ -355,8 +203,8 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
       int x;
       for (x = x1; x <= x2; x++)
         {
-          t->rh[x + t->cf * y1] = f_h;
-          t->rh[x + t->cf * (y2 + 1)] = f_h;
+          t->rh[x + tab_nc (t) * y1] = f_h;
+          t->rh[x + tab_nc (t) * (y2 + 1)] = f_h;
         }
     }
   if (f_v != -1)
@@ -364,8 +212,8 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
       int y;
       for (y = y1; y <= y2; y++)
         {
-          t->rv[x1 + (t->cf + 1) * y] = f_v;
-          t->rv[(x2 + 1) + (t->cf + 1) * y] = f_v;
+          t->rv[x1 + (tab_nc (t) + 1) * y] = f_v;
+          t->rv[(x2 + 1) + (tab_nc (t) + 1) * y] = f_v;
         }
     }
 
@@ -378,7 +226,7 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
           int x;
 
           for (x = x1; x <= x2; x++)
-            t->rh[x + t->cf * y] = i_h;
+            t->rh[x + tab_nc (t) * y] = i_h;
         }
     }
   if (i_v != -1)
@@ -390,88 +238,13 @@ tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
           int y;
 
           for (y = y1; y <= y2; y++)
-            t->rv[x + (t->cf + 1) * y] = i_v;
+            t->rv[x + (tab_nc (t) + 1) * y] = i_v;
         }
     }
 }
 
 /* Cells. */
 
-/* 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 short opt,
-           const union value *v, const struct variable *var,
-           const struct fmt_spec *f)
-{
-  char *contents;
-
-  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_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;
-        }
-    }
-
-  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 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 short opt,
-            double val, const struct fmt_spec *fmt, enum result_class rc)
-{
-  union value double_value;
-  char *s;
-
-  assert (c >= 0);
-  assert (c < tab_nc (table));
-  assert (r >= 0);
-  assert (r < tab_nr (table));
-
-  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))
-        {
-          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;
-        }
-    }
-
-  double_value.f = val;
-  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;
-}
-
-
 static void
 do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text)
 {
@@ -482,21 +255,16 @@ do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text)
 
   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 (c < 0 || r < 0 || c >= tab_nc (table) || r >= 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));
+          printf ("tab_text(): bad cell (%d,%d) in table size (%d,%d)\n",
+                  c, r, tab_nc (table), tab_nr (table));
           return;
         }
     }
 
-  table->cc[c + r * table->cf] = text;
-  table->ct[c + r * table->cf] = opt;
+  table->cc[c + r * tab_nc (table)] = text;
+  table->ct[c + r * tab_nc (table)] = opt;
 }
 
 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
@@ -528,27 +296,23 @@ add_joined_cell (struct tab_table *table, int x1, int y1, int x2, int y2,
 {
   struct tab_joined_cell *j;
 
-  assert (x1 + table->col_ofs >= 0);
-  assert (y1 + table->row_ofs >= 0);
+  assert (x1 >= 0);
+  assert (y1 >= 0);
   assert (y2 >= y1);
   assert (x2 >= x1);
-  assert (y2 + table->row_ofs < tab_nr (table));
-  assert (x2 + table->col_ofs < tab_nc (table));
+  assert (y2 < tab_nr (table));
+  assert (x2 < 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 < y1 || y2 + table->row_ofs >= tab_nr (table))
+      if (x1 < 0 || x1 >= tab_nc (table)
+          || y1 < 0 || y1 >= tab_nr (table)
+          || x2 < x1 || x2 >= tab_nc (table)
+          || y2 < y1 || y2 >= 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));
+                  "(%d,%d)-(%d,%d) in table size (%d,%d)\n",
+                  x1, y1, x2, y2, tab_nc (table), tab_nr (table));
           return NULL;
         }
     }
@@ -556,18 +320,18 @@ add_joined_cell (struct tab_table *table, int x1, int y1, int x2, int y2,
   tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2);
 
   j = pool_alloc (table->container, sizeof *j);
-  j->d[TABLE_HORZ][0] = x1 + table->col_ofs;
-  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->d[TABLE_HORZ][0] = x1;
+  j->d[TABLE_VERT][0] = y1;
+  j->d[TABLE_HORZ][1] = ++x2;
+  j->d[TABLE_VERT][1] = ++y2;
   j->n_footnotes = 0;
   j->footnotes = NULL;
   j->style = NULL;
 
   {
-    void **cc = &table->cc[x1 + y1 * table->cf];
-    unsigned short *ct = &table->ct[x1 + y1 * table->cf];
-    const int ofs = table->cf - (x2 - x1);
+    void **cc = &table->cc[x1 + y1 * tab_nc (table)];
+    unsigned short *ct = &table->ct[x1 + y1 * tab_nc (table)];
+    const int ofs = tab_nc (table) - (x2 - x1);
 
     int y;
 
@@ -599,29 +363,12 @@ tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
   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, ...)
-{
-  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;
+    add_joined_cell (table, x1, y1, x2, y2, opt)->text = s;
 }
 
 struct footnote *
 tab_create_footnote (struct tab_table *table, size_t idx, const char *content,
-                     const char *marker, struct cell_style *style)
+                     const char *marker, struct area_style *style)
 {
   struct footnote *f = pool_alloc (table->container, sizeof *f);
   f->idx = idx;
@@ -635,7 +382,7 @@ void
 tab_add_footnote (struct tab_table *table, int x, int y,
                   const struct footnote *f)
 {
-  int index = x + y * table->cf;
+  int index = x + y * tab_nc (table);
   unsigned short opt = table->ct[index];
   struct tab_joined_cell *j;
 
@@ -646,7 +393,7 @@ tab_add_footnote (struct tab_table *table, int x, int y,
       char *text = table->cc[index];
 
       j = add_joined_cell (table, x, y, x, y, table->ct[index]);
-      j->u.text = text ? text : xstrdup ("");
+      j->text = text ? text : xstrdup ("");
     }
 
   j->footnotes = pool_realloc (table->container, j->footnotes,
@@ -657,9 +404,9 @@ tab_add_footnote (struct tab_table *table, int x, int y,
 
 void
 tab_add_style (struct tab_table *table, int x, int y,
-               const struct cell_style *style)
+               const struct area_style *style)
 {
-  int index = x + y * table->cf;
+  int index = x + y * tab_nc (table);
   unsigned short opt = table->ct[index];
   struct tab_joined_cell *j;
 
@@ -670,7 +417,7 @@ tab_add_style (struct tab_table *table, int x, int y,
       char *text = table->cc[index];
 
       j = add_joined_cell (table, x, y, x, y, table->ct[index]);
-      j->u.text = text ? text : xstrdup ("");
+      j->text = text ? text : xstrdup ("");
     }
 
   j->style = style;
@@ -679,100 +426,20 @@ tab_add_style (struct tab_table *table, int x, int y,
 bool
 tab_cell_is_empty (const struct tab_table *table, int c, int r)
 {
-  return table->cc[c + r * table->cf] == NULL;
-}
-
-/* Miscellaneous. */
-
-/* Set the title of table T to TITLE, which is formatted as if
-   passed to printf(). */
-void
-tab_title (struct tab_table *t, const char *title, ...)
-{
-  va_list args;
-
-  free (t->title);
-  va_start (args, title);
-  t->title = xvasprintf (title, args);
-  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, t->caption));
+  return table->cc[c + r * tab_nc (table)] == NULL;
 }
 
 /* Editing. */
 
-/* Set table row and column offsets for all functions that affect
-   cells or rules. */
-void
-tab_offset (struct tab_table *t, int col, int row)
-{
-  int diff = 0;
-
-  if (debugging)
-    {
-      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 ();
-        }
-    }
-
-  if (row != -1)
-    diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
-  if (col != -1)
-    diff += (col - t->col_ofs), t->col_ofs = col;
-
-  t->cc += diff;
-  t->ct += diff;
-}
-
-/* Increment the row offset by one. If the table is too small,
-   increase its size. */
-void
-tab_next_row (struct tab_table *t)
-{
-  t->cc += t->cf;
-  t->ct += t->cf;
-  if (++t->row_ofs >= tab_nr (t))
-    tab_realloc (t, -1, tab_nr (t) * 4 / 3);
-}
-
 /* Writes STRING to the output.  OPTIONS may be any valid combination of TAB_*
    bits.
 
    This function is obsolete.  Please do not add new uses of it.  Instead, use
    a text_item (see output/text-item.h). */
 void
-tab_output_text (int options, const char *string)
+tab_output_text (int options UNUSED, const char *string)
 {
-  enum text_item_type type = (options & TAB_EMPH ? TEXT_ITEM_TITLE
-                              : options & TAB_FIX ? TEXT_ITEM_LOG
-                              : TEXT_ITEM_PARAGRAPH);
-  text_item_submit (text_item_create (type, string));
+  text_item_submit (text_item_create (TEXT_ITEM_LOG, string));
 }
 
 /* Same as tab_output_text(), but FORMAT is passed through printf-like
@@ -798,10 +465,6 @@ 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);
 }
 
@@ -810,23 +473,50 @@ 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;
+  int index = x + y * tab_nc (t);
   unsigned short opt = t->ct[index];
   const void *cc = t->cc[index];
 
   cell->options = opt;
   cell->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];
+  const struct area_style *style = t->styles[style_idx];
   if (style)
     cell->style = style;
+  else
+    {
+      static const struct area_style styles[3][3] = {
+#define S(H,V) [H][V] = { AREA_STYLE_INITIALIZER__,     \
+                          .cell_style.halign = H,       \
+                          .cell_style.valign = V }
+        S(TABLE_HALIGN_LEFT, TABLE_VALIGN_TOP),
+        S(TABLE_HALIGN_LEFT, TABLE_VALIGN_CENTER),
+        S(TABLE_HALIGN_LEFT, TABLE_VALIGN_BOTTOM),
+        S(TABLE_HALIGN_CENTER, TABLE_VALIGN_TOP),
+        S(TABLE_HALIGN_CENTER, TABLE_VALIGN_CENTER),
+        S(TABLE_HALIGN_CENTER, TABLE_VALIGN_BOTTOM),
+        S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_TOP),
+        S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_CENTER),
+        S(TABLE_HALIGN_RIGHT, TABLE_VALIGN_BOTTOM),
+      };
+
+      enum table_halign halign
+        = ((opt & TAB_HALIGN) == TAB_LEFT ? TABLE_HALIGN_LEFT
+           : (opt & TAB_HALIGN) == TAB_CENTER ? TABLE_HALIGN_CENTER
+           : TABLE_HALIGN_RIGHT);
+      enum table_valign valign
+        = ((opt & TAB_VALIGN) == TAB_TOP ? TABLE_VALIGN_TOP
+           : (opt & TAB_VALIGN) == TAB_MIDDLE ? TABLE_VALIGN_CENTER
+           : TABLE_VALIGN_BOTTOM);
+
+      cell->style = &styles[halign][valign];
+    }
 
   if (opt & TAB_JOIN)
     {
       const struct tab_joined_cell *jc = cc;
-      cell->text = jc->u.text;
+      cell->text = jc->text;
 
       cell->footnotes = jc->footnotes;
       cell->n_footnotes = jc->n_footnotes;
@@ -855,7 +545,8 @@ tab_get_rule (const struct table *table, enum table_axis axis, int x, int y,
 {
   const struct tab_table *t = tab_cast (table);
   uint8_t raw = (axis == TABLE_VERT
-                 ? t->rh[x + t->cf * y] : t->rv[x + (t->cf + 1) * y]);
+                 ? t->rh[x + tab_nc (t) * y]
+                 : t->rv[x + (tab_nc (t) + 1) * y]);
   struct cell_color *p = t->rule_colors[(raw & TAB_RULE_STYLE_MASK)
                                         >> TAB_RULE_STYLE_SHIFT];
   if (p)
@@ -867,8 +558,6 @@ static const struct table_class tab_table_class = {
   tab_destroy,
   tab_get_cell,
   tab_get_rule,
-  NULL,                         /* paste */
-  NULL,                         /* select */
 };
 
 struct tab_table *