tab: Drop redundant assertions.
[pspp-builds.git] / src / output / tab.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2006, 2009, 2010 Free Software Foundation, Inc.
3
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.
8
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.
13
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/>. */
16
17 #include <config.h>
18
19 #include <output/tab.h>
20
21 #include <ctype.h>
22 #include <stdarg.h>
23 #include <limits.h>
24 #include <stdlib.h>
25
26 #include <data/data-out.h>
27 #include <data/format.h>
28 #include <data/settings.h>
29 #include <data/value.h>
30 #include <data/dictionary.h>
31 #include <libpspp/assertion.h>
32 #include <libpspp/compiler.h>
33 #include <libpspp/misc.h>
34 #include <libpspp/pool.h>
35 #include <output/driver.h>
36 #include <output/table-item.h>
37 #include <output/table-provider.h>
38 #include <output/text-item.h>
39
40 #include "error.h"
41 #include "minmax.h"
42 #include "xalloc.h"
43
44 #include "gettext.h"
45 #define _(msgid) gettext (msgid)
46 \f
47 /* Set in the options field of cells that  */
48 #define TAB_JOIN (1u << TAB_FIRST_AVAILABLE)
49
50 /* Joined cell. */
51 struct tab_joined_cell
52   {
53     int d[TABLE_N_AXES][2];     /* Table region, same as struct table_cell. */
54     char *contents;
55   };
56
57 static const struct table_class tab_table_class;
58
59 /* Creates and returns a new table with NC columns and NR rows and initially no
60    header rows or columns.  The table's cells are initially empty. */
61 struct tab_table *
62 tab_create (int nc, int nr)
63 {
64   struct tab_table *t;
65
66   t = pool_create_container (struct tab_table, container);
67   table_init (&t->table, &tab_table_class);
68   table_set_nc (&t->table, nc);
69   table_set_nr (&t->table, nr);
70
71   t->title = NULL;
72   t->cf = nc;
73   t->cc = pool_calloc (t->container, nr * nc, sizeof *t->cc);
74   t->ct = pool_malloc (t->container, nr * nc);
75   memset (t->ct, 0, nc * nr);
76
77   t->rh = pool_nmalloc (t->container, nc, nr + 1);
78   memset (t->rh, 0, nc * (nr + 1));
79
80   t->rv = pool_nmalloc (t->container, nr, nc + 1);
81   memset (t->rv, TAL_GAP, nr * (nc + 1));
82
83   t->col_ofs = t->row_ofs = 0;
84
85   return t;
86 }
87
88 /* Sets the width and height of a table, in columns and rows,
89    respectively.  Use only to reduce the size of a table, since it
90    does not change the amount of allocated memory.
91
92    This function is obsolete.  Please do not add new uses of it.  (Instead, use
93    table_select() or one of its helper functions.) */
94 void
95 tab_resize (struct tab_table *t, int nc, int nr)
96 {
97   if (nc != -1)
98     {
99       assert (nc + t->col_ofs <= t->cf);
100       table_set_nc (&t->table, nc + t->col_ofs);
101     }
102   if (nr != -1)
103     {
104       assert (nr + t->row_ofs <= tab_nr (t));
105       table_set_nr (&t->table, nr + t->row_ofs);
106     }
107 }
108
109 /* Changes either or both dimensions of a table and reallocates memory as
110    necessary.
111
112    This function is obsolete.  Please do not add new uses of it.  (Instead, use
113    table_paste() or one of its helper functions to paste multiple tables
114    together into a larger one.) */
115 void
116 tab_realloc (struct tab_table *t, int nc, int nr)
117 {
118   int ro, co;
119
120   ro = t->row_ofs;
121   co = t->col_ofs;
122   if (ro || co)
123     tab_offset (t, 0, 0);
124
125   if (nc == -1)
126     nc = tab_nc (t);
127   if (nr == -1)
128     nr = tab_nr (t);
129
130   assert (nc == tab_nc (t));
131
132   if (nc > t->cf)
133     {
134       int mr1 = MIN (nr, tab_nr (t));
135       int mc1 = MIN (nc, tab_nc (t));
136
137       void **new_cc;
138       unsigned char *new_ct;
139       int r;
140
141       new_cc = pool_calloc (t->container, nr * nc, sizeof *new_cc);
142       new_ct = pool_malloc (t->container, nr * nc);
143       for (r = 0; r < mr1; r++)
144         {
145           memcpy (&new_cc[r * nc], &t->cc[r * tab_nc (t)], mc1 * sizeof *t->cc);
146           memcpy (&new_ct[r * nc], &t->ct[r * tab_nc (t)], mc1);
147           memset (&new_ct[r * nc + tab_nc (t)], 0, nc - tab_nc (t));
148         }
149       pool_free (t->container, t->cc);
150       pool_free (t->container, t->ct);
151       t->cc = new_cc;
152       t->ct = new_ct;
153       t->cf = nc;
154     }
155   else if (nr != tab_nr (t))
156     {
157       t->cc = pool_nrealloc (t->container, t->cc, nr * nc, sizeof *t->cc);
158       t->ct = pool_realloc (t->container, t->ct, nr * nc);
159
160       t->rh = pool_nrealloc (t->container, t->rh, nc, nr + 1);
161       t->rv = pool_nrealloc (t->container, t->rv, nr, nc + 1);
162
163       if (nr > tab_nr (t))
164         {
165           memset (&t->rh[nc * (tab_nr (t) + 1)], TAL_0, (nr - tab_nr (t)) * nc);
166           memset (&t->rv[(nc + 1) * tab_nr (t)], TAL_GAP,
167                   (nr - tab_nr (t)) * (nc + 1));
168         }
169     }
170
171   memset (&t->ct[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)));
172   memset (&t->cc[nc * tab_nr (t)], 0, nc * (nr - tab_nr (t)) * sizeof *t->cc);
173
174   table_set_nr (&t->table, nr);
175   table_set_nc (&t->table, nc);
176
177   if (ro || co)
178     tab_offset (t, co, ro);
179 }
180
181 /* Sets the number of header rows on each side of TABLE to L on the
182    left, R on the right, T on the top, B on the bottom.  Header rows
183    are repeated when a table is broken across multiple columns or
184    multiple pages. */
185 void
186 tab_headers (struct tab_table *table, int l, int r, int t, int b)
187 {
188   table_set_hl (&table->table, l);
189   table_set_hr (&table->table, r);
190   table_set_ht (&table->table, t);
191   table_set_hb (&table->table, b);
192 }
193 \f
194 /* Rules. */
195
196 /* Draws a vertical line to the left of cells at horizontal position X
197    from Y1 to Y2 inclusive in style STYLE, if style is not -1. */
198 void
199 tab_vline (struct tab_table *t, int style, int x, int y1, int y2)
200 {
201 #if DEBUGGING
202   if (x + t->col_ofs < 0 || x + t->col_ofs > tab_nc (t)
203       || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
204       || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
205     {
206       printf (_("bad vline: x=%d+%d=%d y=(%d+%d=%d,%d+%d=%d) in "
207                 "table size (%d,%d)\n"),
208               x, t->col_ofs, x + t->col_ofs,
209               y1, t->row_ofs, y1 + t->row_ofs,
210               y2, t->row_ofs, y2 + t->row_ofs,
211               tab_nc (t), tab_nr (t));
212       return;
213     }
214 #endif
215
216   x += t->col_ofs;
217   y1 += t->row_ofs;
218   y2 += t->row_ofs;
219
220   assert (x >= 0);
221   assert (x <= tab_nc (t));
222   assert (y1 >= 0);
223   assert (y2 >= y1);
224   assert (y2 <= tab_nr (t));
225
226   if (style != -1)
227     {
228       int y;
229       for (y = y1; y <= y2; y++)
230         t->rv[x + (t->cf + 1) * y] = style;
231     }
232 }
233
234 /* Draws a horizontal line above cells at vertical position Y from X1
235    to X2 inclusive in style STYLE, if style is not -1. */
236 void
237 tab_hline (struct tab_table * t, int style, int x1, int x2, int y)
238 {
239   x1 += t->col_ofs;
240   x2 += t->col_ofs;
241   y += t->row_ofs;
242
243   assert (y >= 0);
244   assert (y <= tab_nr (t));
245   assert (x2 >= x1 );
246   assert (x1 >= 0 );
247   assert (x2 < tab_nc (t));
248
249   if (style != -1)
250     {
251       int x;
252       for (x = x1; x <= x2; x++)
253         t->rh[x + t->cf * y] = style;
254     }
255 }
256
257 /* Draws a box around cells (X1,Y1)-(X2,Y2) inclusive with horizontal
258    lines of style F_H and vertical lines of style F_V.  Fills the
259    interior of the box with horizontal lines of style I_H and vertical
260    lines of style I_V.  Any of the line styles may be -1 to avoid
261    drawing those lines.  This is distinct from 0, which draws a null
262    line. */
263 void
264 tab_box (struct tab_table *t, int f_h, int f_v, int i_h, int i_v,
265          int x1, int y1, int x2, int y2)
266 {
267 #if DEBUGGING
268   if (x1 + t->col_ofs < 0 || x1 + t->col_ofs >= tab_nc (t)
269       || x2 + t->col_ofs < 0 || x2 + t->col_ofs >= tab_nc (t)
270       || y1 + t->row_ofs < 0 || y1 + t->row_ofs >= tab_nr (t)
271       || y2 + t->row_ofs < 0 || y2 + t->row_ofs >= tab_nr (t))
272     {
273       printf (_("bad box: (%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) "
274                 "in table size (%d,%d)\n"),
275               x1, t->col_ofs, x1 + t->col_ofs,
276               y1, t->row_ofs, y1 + t->row_ofs,
277               x2, t->col_ofs, x2 + t->col_ofs,
278               y2, t->row_ofs, y2 + t->row_ofs,
279               tab_nc (t), tab_nr (t));
280       NOT_REACHED ();
281     }
282 #endif
283
284   x1 += t->col_ofs;
285   x2 += t->col_ofs;
286   y1 += t->row_ofs;
287   y2 += t->row_ofs;
288
289   assert (x2 >= x1);
290   assert (y2 >= y1);
291   assert (x1 >= 0);
292   assert (y1 >= 0);
293   assert (x2 < tab_nc (t));
294   assert (y2 < tab_nr (t));
295
296   if (f_h != -1)
297     {
298       int x;
299       for (x = x1; x <= x2; x++)
300         {
301           t->rh[x + t->cf * y1] = f_h;
302           t->rh[x + t->cf * (y2 + 1)] = f_h;
303         }
304     }
305   if (f_v != -1)
306     {
307       int y;
308       for (y = y1; y <= y2; y++)
309         {
310           t->rv[x1 + (t->cf + 1) * y] = f_v;
311           t->rv[(x2 + 1) + (t->cf + 1) * y] = f_v;
312         }
313     }
314
315   if (i_h != -1)
316     {
317       int y;
318
319       for (y = y1 + 1; y <= y2; y++)
320         {
321           int x;
322
323           for (x = x1; x <= x2; x++)
324             t->rh[x + t->cf * y] = i_h;
325         }
326     }
327   if (i_v != -1)
328     {
329       int x;
330
331       for (x = x1 + 1; x <= x2; x++)
332         {
333           int y;
334
335           for (y = y1; y <= y2; y++)
336             t->rv[x + (t->cf + 1) * y] = i_v;
337         }
338     }
339 }
340 \f
341 /* Cells. */
342
343 /* Sets cell (C,R) in TABLE, with options OPT, to have a value taken
344    from V, displayed with format spec F. */
345 void
346 tab_value (struct tab_table *table, int c, int r, unsigned char opt,
347            const union value *v, const struct dictionary *dict, 
348            const struct fmt_spec *f)
349 {
350   char *contents;
351
352 #if DEBUGGING
353   if (c + table->col_ofs < 0 || r + table->row_ofs < 0
354       || c + table->col_ofs >= tab_nc (table)
355       || r + table->row_ofs >= tab_nr (table))
356     {
357       printf ("tab_value(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
358               "(%d,%d)\n",
359               c, table->col_ofs, c + table->col_ofs,
360               r, table->row_ofs, r + table->row_ofs,
361               tab_nc (table), tab_nr (table));
362       return;
363     }
364 #endif
365
366   contents = data_out_pool (v, dict_get_encoding (dict), f, table->container);
367
368   table->cc[c + r * table->cf] = contents;
369   table->ct[c + r * table->cf] = opt;
370 }
371
372 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL
373    with NDEC decimal places. */
374 void
375 tab_fixed (struct tab_table *table, int c, int r, unsigned char opt,
376            double val, int w, int d)
377 {
378   struct fmt_spec f;
379   union value double_value;
380   char *s;
381
382   assert (c >= 0);
383   assert (c < tab_nc (table));
384   assert (r >= 0);
385   assert (r < tab_nr (table));
386
387   f = fmt_for_output (FMT_F, w, d);
388
389 #if DEBUGGING
390   if (c + table->col_ofs < 0 || r + table->row_ofs < 0
391       || c + table->col_ofs >= tab_nc (table)
392       || r + table->row_ofs >= tab_nr (table))
393     {
394       printf ("tab_fixed(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
395               "(%d,%d)\n",
396               c, table->col_ofs, c + table->col_ofs,
397               r, table->row_ofs, r + table->row_ofs,
398               tab_nc (table), tab_nr (table));
399       return;
400     }
401 #endif
402
403   double_value.f = val;
404   s = data_out_pool (&double_value, LEGACY_NATIVE, &f, table->container);
405
406   table->cc[c + r * table->cf] = s + strspn (s, " ");
407   table->ct[c + r * table->cf] = opt;
408 }
409
410 /* Sets cell (C,R) in TABLE, with options OPT, to have value VAL as
411    formatted by FMT.
412    If FMT is null, then the default print format will be used.
413 */
414 void
415 tab_double (struct tab_table *table, int c, int r, unsigned char opt,
416            double val, const struct fmt_spec *fmt)
417 {
418   union value double_value ;
419   char *s;
420
421   assert (c >= 0);
422   assert (c < tab_nc (table));
423   assert (r >= 0);
424   assert (r < tab_nr (table));
425
426   if ( fmt == NULL)
427     fmt = settings_get_format ();
428
429   fmt_check_output (fmt);
430
431 #if DEBUGGING
432   if (c + table->col_ofs < 0 || r + table->row_ofs < 0
433       || c + table->col_ofs >= tab_nc (table)
434       || r + table->row_ofs >= tab_nr (table))
435     {
436       printf ("tab_double(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
437               "(%d,%d)\n",
438               c, table->col_ofs, c + table->col_ofs,
439               r, table->row_ofs, r + table->row_ofs,
440               tab_nc (table), tab_nr (table));
441       return;
442     }
443 #endif
444
445   double_value.f = val;
446   s = data_out_pool (&double_value, LEGACY_NATIVE, fmt, table->container);
447   table->cc[c + r * table->cf] = s + strspn (s, " ");
448   table->ct[c + r * table->cf] = opt;
449 }
450
451
452 static void
453 do_tab_text (struct tab_table *table, int c, int r, unsigned opt, char *text)
454 {
455   assert (c >= 0 );
456   assert (r >= 0 );
457   assert (c < tab_nc (table));
458   assert (r < tab_nr (table));
459
460 #if DEBUGGING
461   if (c + table->col_ofs < 0 || r + table->row_ofs < 0
462       || c + table->col_ofs >= tab_nc (table)
463       || r + table->row_ofs >= tab_nr (table))
464     {
465       printf ("tab_text(): bad cell (%d+%d=%d,%d+%d=%d) in table size "
466               "(%d,%d)\n",
467               c, table->col_ofs, c + table->col_ofs,
468               r, table->row_ofs, r + table->row_ofs,
469               tab_nc (table), tab_nr (table));
470       return;
471     }
472 #endif
473
474   table->cc[c + r * table->cf] = text;
475   table->ct[c + r * table->cf] = opt;
476 }
477
478 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
479    TEXT. */
480 void
481 tab_text (struct tab_table *table, int c, int r, unsigned opt,
482           const char *text)
483 {
484   do_tab_text (table, c, r, opt, pool_strdup (table->container, text));
485 }
486
487 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
488    FORMAT, which is formatted as if passed to printf. */
489 void
490 tab_text_format (struct tab_table *table, int c, int r, unsigned opt,
491                  const char *format, ...)
492 {
493   va_list args;
494
495   va_start (args, format);
496   do_tab_text (table, c, r, opt,
497                pool_vasprintf (table->container, format, args));
498   va_end (args);
499 }
500
501 static void
502 do_tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
503                    unsigned opt, char *text)
504 {
505   struct tab_joined_cell *j;
506
507   assert (x1 + table->col_ofs >= 0);
508   assert (y1 + table->row_ofs >= 0);
509   assert (y2 >= y1);
510   assert (x2 >= x1);
511   assert (y2 + table->row_ofs < tab_nr (table));
512   assert (x2 + table->col_ofs < tab_nc (table));
513
514 #if DEBUGGING
515   if (x1 + table->col_ofs < 0 || x1 + table->col_ofs >= tab_nc (table)
516       || y1 + table->row_ofs < 0 || y1 + table->row_ofs >= tab_nr (table)
517       || x2 < x1 || x2 + table->col_ofs >= tab_nc (table)
518       || y2 < y2 || y2 + table->row_ofs >= tab_nr (table))
519     {
520       printf ("tab_joint_text(): bad cell "
521               "(%d+%d=%d,%d+%d=%d)-(%d+%d=%d,%d+%d=%d) in table size (%d,%d)\n",
522               x1, table->col_ofs, x1 + table->col_ofs,
523               y1, table->row_ofs, y1 + table->row_ofs,
524               x2, table->col_ofs, x2 + table->col_ofs,
525               y2, table->row_ofs, y2 + table->row_ofs,
526               tab_nc (table), tab_nr (table));
527       return;
528     }
529 #endif
530
531   tab_box (table, -1, -1, TAL_0, TAL_0, x1, y1, x2, y2);
532
533   j = pool_alloc (table->container, sizeof *j);
534   j->d[TABLE_HORZ][0] = x1 + table->col_ofs;
535   j->d[TABLE_VERT][0] = y1 + table->row_ofs;
536   j->d[TABLE_HORZ][1] = ++x2 + table->col_ofs;
537   j->d[TABLE_VERT][1] = ++y2 + table->row_ofs;
538   j->contents = text;
539
540   opt |= TAB_JOIN;
541
542   {
543     void **cc = &table->cc[x1 + y1 * table->cf];
544     unsigned char *ct = &table->ct[x1 + y1 * table->cf];
545     const int ofs = table->cf - (x2 - x1);
546
547     int y;
548
549     for (y = y1; y < y2; y++)
550       {
551         int x;
552
553         for (x = x1; x < x2; x++)
554           {
555             *cc++ = j;
556             *ct++ = opt;
557           }
558
559         cc += ofs;
560         ct += ofs;
561       }
562   }
563 }
564
565 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them with
566    options OPT to have text value TEXT. */
567 void
568 tab_joint_text (struct tab_table *table, int x1, int y1, int x2, int y2,
569                 unsigned opt, const char *text)
570 {
571   do_tab_joint_text (table, x1, y1, x2, y2, opt,
572                      pool_strdup (table->container, text));
573 }
574
575 /* Joins cells (X1,X2)-(Y1,Y2) inclusive in TABLE, and sets them
576    with options OPT to have text value FORMAT, which is formatted
577    as if passed to printf. */
578 void
579 tab_joint_text_format (struct tab_table *table, int x1, int y1, int x2, int y2,
580                        unsigned opt, const char *format, ...)
581 {
582   va_list args;
583
584   va_start (args, format);
585   do_tab_joint_text (table, x1, y1, x2, y2, opt,
586                      pool_vasprintf (table->container, format, args));
587   va_end (args);
588 }
589
590 bool
591 tab_cell_is_empty (const struct tab_table *table, int c, int r)
592 {
593   return table->cc[c + r * table->cf] == NULL;
594 }
595 \f
596 /* Miscellaneous. */
597
598 /* Set the title of table T to TITLE, which is formatted as if
599    passed to printf(). */
600 void
601 tab_title (struct tab_table *t, const char *title, ...)
602 {
603   va_list args;
604
605   free (t->title);
606   va_start (args, title);
607   t->title = xvasprintf (title, args);
608   va_end (args);
609 }
610
611 /* Easy, type-safe way to submit a tab table to som. */
612 void
613 tab_submit (struct tab_table *t)
614 {
615   table_item_submit (table_item_create (&t->table, t->title));
616 }
617 \f
618 /* Editing. */
619
620 /* Set table row and column offsets for all functions that affect
621    cells or rules. */
622 void
623 tab_offset (struct tab_table *t, int col, int row)
624 {
625   int diff = 0;
626
627 #if DEBUGGING
628   if (row < -1 || row > tab_nr (t))
629     {
630       printf ("tab_offset(): row=%d in %d-row table\n", row, tab_nr (t));
631       NOT_REACHED ();
632     }
633   if (col < -1 || col > tab_nc (t))
634     {
635       printf ("tab_offset(): col=%d in %d-column table\n", col, tab_nc (t));
636       NOT_REACHED ();
637     }
638 #endif
639
640   if (row != -1)
641     diff += (row - t->row_ofs) * t->cf, t->row_ofs = row;
642   if (col != -1)
643     diff += (col - t->col_ofs), t->col_ofs = col;
644
645   t->cc += diff;
646   t->ct += diff;
647 }
648
649 /* Increment the row offset by one. If the table is too small,
650    increase its size. */
651 void
652 tab_next_row (struct tab_table *t)
653 {
654   t->cc += t->cf;
655   t->ct += t->cf;
656   if (++t->row_ofs >= tab_nr (t))
657     tab_realloc (t, -1, tab_nr (t) * 4 / 3);
658 }
659 \f
660 /* Writes STRING to the output.  OPTIONS may be any valid combination of TAB_*
661    bits.
662
663    This function is obsolete.  Please do not add new uses of it.  Instead, use
664    a text_item (see output/text-item.h). */
665 void
666 tab_output_text (int options, const char *string)
667 {
668   enum text_item_type type = (options & TAB_EMPH ? TEXT_ITEM_SUBHEAD
669                               : options & TAB_FIX ? TEXT_ITEM_MONOSPACE
670                               : TEXT_ITEM_PARAGRAPH);
671   text_item_submit (text_item_create (type, string));
672 }
673
674 /* Same as tab_output_text(), but FORMAT is passed through printf-like
675    formatting before output. */
676 void
677 tab_output_text_format (int options, const char *format, ...)
678 {
679   va_list args;
680   char *text;
681
682   va_start (args, format);
683   text = xvasprintf (format, args);
684   va_end (args);
685
686   tab_output_text (options, text);
687
688   free (text);
689 }
690 \f
691 /* Table class implementation. */
692
693 static void
694 tab_destroy (struct table *table)
695 {
696   struct tab_table *t = tab_cast (table);
697   pool_destroy (t->container);
698 }
699
700 static void
701 tab_get_cell (const struct table *table, int x, int y, struct table_cell *cell)
702 {
703   const struct tab_table *t = tab_cast (table);
704   int index = x + y * t->cf;
705   unsigned char opt = t->ct[index];
706   const void *content = t->cc[index];
707
708   cell->options = opt;
709   if (opt & TAB_JOIN)
710     {
711       const struct tab_joined_cell *jc = content;
712       cell->d[TABLE_HORZ][0] = jc->d[TABLE_HORZ][0];
713       cell->d[TABLE_HORZ][1] = jc->d[TABLE_HORZ][1];
714       cell->d[TABLE_VERT][0] = jc->d[TABLE_VERT][0];
715       cell->d[TABLE_VERT][1] = jc->d[TABLE_VERT][1];
716       cell->contents = jc->contents;
717     }
718   else
719     {
720       cell->d[TABLE_HORZ][0] = x;
721       cell->d[TABLE_HORZ][1] = x + 1;
722       cell->d[TABLE_VERT][0] = y;
723       cell->d[TABLE_VERT][1] = y + 1;
724       cell->contents = content != NULL ? content : "";
725     }
726   cell->destructor = NULL;
727 }
728
729 static int
730 tab_get_rule (const struct table *table, enum table_axis axis, int x, int y)
731 {
732   const struct tab_table *t = tab_cast (table);
733   return (axis == TABLE_VERT
734           ? t->rh[x + t->cf * y]
735           : t->rv[x + (t->cf + 1) * y]);
736 }
737
738 static const struct table_class tab_table_class =
739   {
740     tab_destroy,
741     tab_get_cell,
742     tab_get_rule,
743     NULL,                       /* paste */
744     NULL,                       /* select */
745   };
746
747 struct tab_table *
748 tab_cast (const struct table *table)
749 {
750   assert (table->class == &tab_table_class);
751   return UP_CAST (table, struct tab_table, table);
752 }