table: Get rid of accessor functions for 'h' and 'n' members.

It's easier to read them directly.

diff --git a/src/output/csv.c b/src/output/csv.c
index e2c97a64cd479b3ad5b5e921f6e27ef9d8979bca..04939222410c9e914ceacd15cb02d3f761f3d523 100644 (file)
--- a/src/output/csv.c
+++ b/src/output/csv.c
@@ -215,9 +215,9 @@ csv_submit (struct output_driver *driver,
         csv_output_table_item_text (csv, table_item_get_title (table_item),
                                     "Table");
 
-      for (y = 0; y < table_nr (t); y++)
+      for (y = 0; y < t->n[TABLE_VERT]; y++)
         {
-          for (x = 0; x < table_nc (t); x++)
+          for (x = 0; x < t->n[TABLE_HORZ]; x++)
             {
               struct table_cell cell;
 

diff --git a/src/output/html.c b/src/output/html.c
index c1613c4fea24d5668322540f9e2087e2763b90b5..786d8b6e89842e7499a8a1eed9d6aaae3ac3185b 100644 (file)
--- a/src/output/html.c
+++ b/src/output/html.c
@@ -51,6 +51,10 @@
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
+/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
+#define H TABLE_HORZ
+#define V TABLE_VERT
+
 struct html_driver
   {
     struct output_driver driver;
@@ -448,7 +452,7 @@ put_tfoot (struct html_driver *html, const struct table *t, bool *tfoot)
     {
       fputs ("<tfoot>\n", html->file);
       fputs ("<tr>\n", html->file);
-      fprintf (html->file, "<td colspan=%d>\n", table_nc (t));
+      fprintf (html->file, "<td colspan=%d>\n", t->n[H]);
       *tfoot = true;
     }
   else
@@ -553,12 +557,12 @@ html_output_table (struct html_driver *html, const struct table_item *item)
 
   fputs ("<tbody>\n", html->file);
 
-  for (y = 0; y < table_nr (t); y++)
+  for (y = 0; y < t->n[V]; y++)
     {
       int x;
 
       fputs ("<tr>\n", html->file);
-      for (x = 0; x < table_nc (t);)
+      for (x = 0; x < t->n[H];)
         {
           struct table_cell cell;
           const char *tag;
@@ -568,10 +572,10 @@ html_output_table (struct html_driver *html, const struct table_item *item)
             goto next_1;
 
           /* output <td> or <th> tag. */
-          bool is_header = (y < table_ht (t)
-                       || y >= table_nr (t) - table_hb (t)
-                       || x < table_hl (t)
-                       || x >= table_nc (t) - table_hr (t));
+          bool is_header = (y < t->h[V][0]
+                            || y >= t->n[V] - t->h[V][1]
+                            || x < t->h[H][0]
+                            || x >= t->n[H] - t->h[H][1]);
           tag = is_header ? "th" : "td";
           fprintf (html->file, "<%s", tag);
 
@@ -610,7 +614,7 @@ html_output_table (struct html_driver *html, const struct table_item *item)
              int top = table_get_rule (t, TABLE_VERT, x, y, &color);
               put_border (style, top, "top");
 
-             if (y + rowspan == table_nr (t))
+             if (y + rowspan == t->n[V])
                {
                  int bottom = table_get_rule (t, TABLE_VERT, x, y + rowspan,
                                            &color);
@@ -620,7 +624,7 @@ html_output_table (struct html_driver *html, const struct table_item *item)
              int left = table_get_rule (t, TABLE_HORZ, x, y, &color);
               put_border (style, left, "left");
 
-             if (x + colspan == table_nc (t))
+             if (x + colspan == t->n[V])
                {
                  int right = table_get_rule (t, TABLE_HORZ, x + colspan, y,
                                           &color);

diff --git a/src/output/odt.c b/src/output/odt.c
index 256fd197dae1ae00807e4dd3b3e0fcb1c375fed9..65c46e1c67c03396448417334d6a3a56b80d5835 100644 (file)
--- a/src/output/odt.c
+++ b/src/output/odt.c
@@ -51,6 +51,10 @@
 
 #define _xml(X) (CHAR_CAST (const xmlChar *, X))
 
+/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
+#define H TABLE_HORZ
+#define V TABLE_VERT
+
 struct odt_driver
 {
   struct output_driver driver;
@@ -476,29 +480,29 @@ write_table (struct odt_driver *odt, const struct table_item *item)
 
   /* Start column definitions */
   xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-column"));
-  xmlTextWriterWriteFormatAttribute (odt->content_wtr, _xml("table:number-columns-repeated"), "%d", table_nc (tab));
+  xmlTextWriterWriteFormatAttribute (odt->content_wtr, _xml("table:number-columns-repeated"), "%d", tab->n[H]);
   xmlTextWriterEndElement (odt->content_wtr);
 
 
   /* Deal with row headers */
-  if (table_ht (tab) > 0)
+  if (tab->h[V][0] > 0)
     xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-header-rows"));
 
 
   /* Write all the rows */
-  for (r = 0 ; r < table_nr (tab); ++r)
+  for (r = 0 ; r < tab->n[V]; ++r)
     {
       /* Start row definition */
       xmlTextWriterStartElement (odt->content_wtr, _xml("table:table-row"));
 
       /* Write all the columns */
-      for (c = 0 ; c < table_nc (tab) ; ++c)
+      for (c = 0 ; c < tab->n[H] ; ++c)
        {
           struct table_cell cell;
 
           table_get_cell (tab, c, r, &cell);
 
-          if (c == cell.d[TABLE_HORZ][0] && r == cell.d[TABLE_VERT][0])
+          if (c == cell.d[H][0] && r == cell.d[V][0])
             {
               int colspan = table_cell_colspan (&cell);
               int rowspan = table_cell_rowspan (&cell);
@@ -518,7 +522,7 @@ write_table (struct odt_driver *odt, const struct table_item *item)
 
               xmlTextWriterStartElement (odt->content_wtr, _xml("text:p"));
 
-              if (r < table_ht (tab) || c < table_hl (tab))
+              if (r < tab->h[V][0] || c < tab->h[H][0])
                 xmlTextWriterWriteAttribute (odt->content_wtr, _xml("text:style-name"), _xml("Table_20_Heading"));
               else
                 xmlTextWriterWriteAttribute (odt->content_wtr, _xml("text:style-name"), _xml("Table_20_Contents"));
@@ -548,7 +552,8 @@ write_table (struct odt_driver *odt, const struct table_item *item)
 
       xmlTextWriterEndElement (odt->content_wtr); /* row */
 
-      if (table_ht (tab) > 0 && r == table_ht (tab) - 1)
+      int ht = tab->h[V][0];
+      if (ht > 0 && r == ht - 1)
        xmlTextWriterEndElement (odt->content_wtr); /* table-header-rows */
     }
 

diff --git a/src/output/pivot-output.c b/src/output/pivot-output.c
index ea0cdd4a6e6eea178b8b5f358b64df620b58cbda..64e72e23473655d8b2535dceeb9d540ace52a9cd 100644 (file)
--- a/src/output/pivot-output.c
+++ b/src/output/pivot-output.c
@@ -423,29 +423,29 @@ pivot_table_submit_layer (const struct pivot_table *pt,
                pt->corner_text, footnotes,
                pt->show_values, pt->show_variables, false);
 
-  if (table_nc (table) && table_nr (table))
+  if (table->n[H] && table->n[V])
     {
       table_hline (
         table, get_table_rule (pt->look->borders, PIVOT_BORDER_INNER_TOP),
-        0, table_nc (table) - 1, 0);
+        0, table->n[H] - 1, 0);
       table_hline (
         table, get_table_rule (pt->look->borders, PIVOT_BORDER_INNER_BOTTOM),
-        0, table_nc (table) - 1, table_nr (table));
+        0, table->n[H] - 1, table->n[V]);
       table_vline (
         table, get_table_rule (pt->look->borders, PIVOT_BORDER_INNER_LEFT),
-        0, 0, table_nr (table) - 1);
+        0, 0, table->n[V] - 1);
       table_vline (
         table, get_table_rule (pt->look->borders, PIVOT_BORDER_INNER_RIGHT),
-        table_nc (table), 0, table_nr (table) - 1);
+        table->n[H], 0, table->n[V] - 1);
 
       if (stub[V])
         table_hline (
           table, get_table_rule (pt->look->borders, PIVOT_BORDER_DATA_TOP),
-          0, table_nc (table) - 1, stub[V]);
+          0, table->n[H] - 1, stub[V]);
       if (stub[H])
         table_vline (
           table, get_table_rule (pt->look->borders, PIVOT_BORDER_DATA_LEFT),
-          stub[H], 0, table_nr (table) - 1);
+          stub[H], 0, table->n[V] - 1);
 
     }
   free (column_enumeration);

diff --git a/src/output/render.c b/src/output/render.c
index f9a93a4016113241ebfcc11983cae36b90a987bb..21fd53dc91a565b7c582dc18836490a9c2f4683a 100644 (file)
--- a/src/output/render.c
+++ b/src/output/render.c
@@ -714,8 +714,8 @@ render_page_create (const struct render_params *params, struct table *table,
 {
   enum { MIN, MAX };
 
-  int nc = table_nc (table);
-  int nr = table_nr (table);
+  int nc = table->n[H];
+  int nr = table->n[V];
 
   /* Figure out rule widths. */
   int *rules[TABLE_N_AXES];
@@ -790,7 +790,7 @@ render_page_create (const struct render_params *params, struct table *table,
   /* Decide final column widths. */
   int table_widths[2];
   for (int i = 0; i < 2; i++)
-    table_widths[i] = calculate_table_width (table_nc (table),
+    table_widths[i] = calculate_table_width (table->n[H],
                                              columns[i], rules[H]);
 
   struct render_page *page;

diff --git a/src/output/table.c b/src/output/table.c
index 4133e036d08494a370b79501d943a83d83060d7b..ace6c3cb59df74396fca4b2e2ac5cf06cb18ca8f 100644 (file)
--- a/src/output/table.c
+++ b/src/output/table.c
@@ -35,6 +35,10 @@
 
 #include "gl/xalloc.h"
 
+/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
+#define H TABLE_HORZ
+#define V TABLE_VERT
+
 /* Increases TABLE's reference count, indicating that it has an additional
    owner.  An table that is shared among multiple owners must not be
    modified. */
@@ -129,10 +133,10 @@ table_collect_footnotes (const struct table_item *item,
   size_t n = 0;
 
   struct table *t = item->table;
-  for (int y = 0; y < table_nr (t); y++)
+  for (int y = 0; y < t->n[V]; y++)
     {
       struct table_cell cell;
-      for (int x = 0; x < table_nc (t); x = cell.d[TABLE_HORZ][1])
+      for (int x = 0; x < t->n[H]; x = cell.d[TABLE_HORZ][1])
         {
           table_get_cell (t, x, y, &cell);
 
@@ -358,27 +362,27 @@ table_vline (struct table *t, int style, int x, int y1, int y2)
 {
   if (debugging)
     {
-      if (x < 0 || x > table_nc (t)
-          || y1 < 0 || y1 >= table_nr (t)
-          || y2 < 0 || y2 >= table_nr (t))
+      if (x < 0 || x > t->n[H]
+          || y1 < 0 || y1 >= t->n[V]
+          || y2 < 0 || y2 >= t->n[V])
         {
           printf ("bad vline: x=%d y=(%d,%d) in table size (%d,%d)\n",
-                  x, y1, y2, table_nc (t), table_nr (t));
+                  x, y1, y2, t->n[H], t->n[V]);
           return;
         }
     }
 
   assert (x >= 0);
-  assert (x <= table_nc (t));
+  assert (x <= t->n[H]);
   assert (y1 >= 0);
   assert (y2 >= y1);
-  assert (y2 <= table_nr (t));
+  assert (y2 <= t->n[V]);
 
   if (style != -1)
     {
       int y;
       for (y = y1; y <= y2; y++)
-        t->rv[x + (table_nc (t) + 1) * y] = style;
+        t->rv[x + (t->n[H] + 1) * y] = style;
     }
 }
 
@@ -389,27 +393,27 @@ table_hline (struct table *t, int style, int x1, int x2, int y)
 {
   if (debugging)
     {
-      if (y < 0 || y > table_nr (t)
-          || x1 < 0 || x1 >= table_nc (t)
-          || x2 < 0 || x2 >= table_nc (t))
+      if (y < 0 || y > t->n[V]
+          || x1 < 0 || x1 >= t->n[H]
+          || x2 < 0 || x2 >= t->n[H])
         {
           printf ("bad hline: x=(%d,%d) y=%d in table size (%d,%d)\n",
-                  x1, x2, y, table_nc (t), table_nr (t));
+                  x1, x2, y, t->n[H], t->n[V]);
           return;
         }
     }
 
   assert (y >= 0);
-  assert (y <= table_nr (t));
+  assert (y <= t->n[V]);
   assert (x2 >= x1);
   assert (x1 >= 0);
-  assert (x2 < table_nc (t));
+  assert (x2 < t->n[H]);
 
   if (style != -1)
     {
       int x;
       for (x = x1; x <= x2; x++)
-        t->rh[x + table_nc (t) * y] = style;
+        t->rh[x + t->n[H] * y] = style;
     }
 }
 
@@ -425,13 +429,13 @@ table_box (struct table *t, int f_h, int f_v, int i_h, int i_v,
 {
   if (debugging)
     {
-      if (x1 < 0 || x1 >= table_nc (t)
-          || x2 < 0 || x2 >= table_nc (t)
-          || y1 < 0 || y1 >= table_nr (t)
-          || y2 < 0 || y2 >= table_nr (t))
+      if (x1 < 0 || x1 >= t->n[H]
+          || x2 < 0 || x2 >= t->n[H]
+          || y1 < 0 || y1 >= t->n[V]
+          || y2 < 0 || y2 >= t->n[V])
         {
           printf ("bad box: (%d,%d)-(%d,%d) in table size (%d,%d)\n",
-                  x1, y1, x2, y2, table_nc (t), table_nr (t));
+                  x1, y1, x2, y2, t->n[H], t->n[V]);
           NOT_REACHED ();
         }
     }
@@ -440,16 +444,16 @@ table_box (struct table *t, int f_h, int f_v, int i_h, int i_v,
   assert (y2 >= y1);
   assert (x1 >= 0);
   assert (y1 >= 0);
-  assert (x2 < table_nc (t));
-  assert (y2 < table_nr (t));
+  assert (x2 < t->n[H]);
+  assert (y2 < t->n[V]);
 
   if (f_h != -1)
     {
       int x;
       for (x = x1; x <= x2; x++)
         {
-          t->rh[x + table_nc (t) * y1] = f_h;
-          t->rh[x + table_nc (t) * (y2 + 1)] = f_h;
+          t->rh[x + t->n[H] * y1] = f_h;
+          t->rh[x + t->n[H] * (y2 + 1)] = f_h;
         }
     }
   if (f_v != -1)
@@ -457,8 +461,8 @@ table_box (struct 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 + (table_nc (t) + 1) * y] = f_v;
-          t->rv[(x2 + 1) + (table_nc (t) + 1) * y] = f_v;
+          t->rv[x1 + (t->n[H] + 1) * y] = f_v;
+          t->rv[(x2 + 1) + (t->n[H] + 1) * y] = f_v;
         }
     }
 
@@ -471,7 +475,7 @@ table_box (struct 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 + table_nc (t) * y] = i_h;
+            t->rh[x + t->n[H] * y] = i_h;
         }
     }
   if (i_v != -1)
@@ -483,7 +487,7 @@ table_box (struct 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 + (table_nc (t) + 1) * y] = i_v;
+            t->rv[x + (t->n[H] + 1) * y] = i_v;
         }
     }
 }
@@ -495,21 +499,21 @@ do_table_text (struct table *table, int c, int r, unsigned opt, char *text)
 {
   assert (c >= 0);
   assert (r >= 0);
-  assert (c < table_nc (table));
-  assert (r < table_nr (table));
+  assert (c < table->n[H]);
+  assert (r < table->n[V]);
 
   if (debugging)
     {
-      if (c < 0 || r < 0 || c >= table_nc (table) || r >= table_nr (table))
+      if (c < 0 || r < 0 || c >= table->n[H] || r >= table->n[V])
         {
           printf ("table_text(): bad cell (%d,%d) in table size (%d,%d)\n",
-                  c, r, table_nc (table), table_nr (table));
+                  c, r, table->n[H], table->n[V]);
           return;
         }
     }
 
-  table->cc[c + r * table_nc (table)] = text;
-  table->ct[c + r * table_nc (table)] = opt;
+  table->cc[c + r * table->n[H]] = text;
+  table->ct[c + r * table->n[H]] = opt;
 }
 
 /* Sets cell (C,R) in TABLE, with options OPT, to have text value
@@ -543,19 +547,19 @@ add_joined_cell (struct table *table, int x1, int y1, int x2, int y2,
   assert (y1 >= 0);
   assert (y2 >= y1);
   assert (x2 >= x1);
-  assert (y2 < table_nr (table));
-  assert (x2 < table_nc (table));
+  assert (y2 < table->n[V]);
+  assert (x2 < table->n[H]);
 
   if (debugging)
     {
-      if (x1 < 0 || x1 >= table_nc (table)
-          || y1 < 0 || y1 >= table_nr (table)
-          || x2 < x1 || x2 >= table_nc (table)
-          || y2 < y1 || y2 >= table_nr (table))
+      if (x1 < 0 || x1 >= table->n[H]
+          || y1 < 0 || y1 >= table->n[V]
+          || x2 < x1 || x2 >= table->n[H]
+          || y2 < y1 || y2 >= table->n[V])
         {
           printf ("table_joint_text(): bad cell "
                   "(%d,%d)-(%d,%d) in table size (%d,%d)\n",
-                  x1, y1, x2, y2, table_nc (table), table_nr (table));
+                  x1, y1, x2, y2, table->n[H], table->n[V]);
           return NULL;
         }
     }
@@ -570,9 +574,9 @@ add_joined_cell (struct table *table, int x1, int y1, int x2, int y2,
     .options = opt,
   };
 
-  void **cc = &table->cc[x1 + y1 * table_nc (table)];
-  unsigned short *ct = &table->ct[x1 + y1 * table_nc (table)];
-  const int ofs = table_nc (table) - (x2 - x1);
+  void **cc = &table->cc[x1 + y1 * table->n[H]];
+  unsigned short *ct = &table->ct[x1 + y1 * table->n[H]];
+  const int ofs = table->n[H] - (x2 - x1);
   for (int y = y1; y < y2; y++)
     {
       for (int x = x1; x < x2; x++)
@@ -604,7 +608,7 @@ table_joint_text (struct table *table, int x1, int y1, int x2, int y2,
 static struct table_cell *
 get_joined_cell (struct table *table, int x, int y)
 {
-  int index = x + y * table_nc (table);
+  int index = x + y * table->n[H];
   unsigned short opt = table->ct[index];
   struct table_cell *cell;
 
@@ -694,7 +698,7 @@ table_add_style (struct table *table, int x, int y,
 bool
 table_cell_is_empty (const struct table *table, int c, int r)
 {
-  return table->cc[c + r * table_nc (table)] == NULL;
+  return table->cc[c + r * table->n[H]] == NULL;
 }
 \f
 /* Initializes CELL with the contents of the table cell at column X and row Y
@@ -708,7 +712,7 @@ table_get_cell (const struct table *t, int x, int y, struct table_cell *cell)
   assert (x >= 0 && x < t->n[TABLE_HORZ]);
   assert (y >= 0 && y < t->n[TABLE_VERT]);
 
-  int index = x + y * table_nc (t);
+  int index = x + y * t->n[H];
   unsigned short opt = t->ct[index];
   const void *cc = t->cc[index];
 
@@ -778,8 +782,8 @@ table_get_rule (const struct table *table, enum table_axis axis, int x, int y,
   assert (y >= 0 && y < table->n[TABLE_VERT] + (axis == TABLE_VERT));
 
   uint8_t raw = (axis == TABLE_VERT
-                 ? table->rh[x + table_nc (table) * y]
-                 : table->rv[x + (table_nc (table) + 1) * y]);
+                 ? table->rh[x + table->n[H] * y]
+                 : table->rv[x + (table->n[H] + 1) * y]);
   struct cell_color *p = table->rule_colors[(raw & TAB_RULE_STYLE_MASK)
                                             >> TAB_RULE_STYLE_SHIFT];
   *color = p ? *p : (struct cell_color) CELL_COLOR_BLACK;

diff --git a/src/output/table.h b/src/output/table.h
index 77315c9b9c381befda8af2c5f24e789442220172..aea925490f5a430c08e74d17ea6651bbe821e1e4 100644 (file)
--- a/src/output/table.h
+++ b/src/output/table.h
@@ -241,23 +241,6 @@ struct table *table_ref (const struct table *);
 void table_unref (struct table *);
 bool table_is_shared (const struct table *);
 
-/* Returns the number of columns or rows, respectively, in T. */
-static inline int table_nc (const struct table *t)
-        { return t->n[TABLE_HORZ]; }
-static inline int table_nr (const struct table *t)
-        { return t->n[TABLE_VERT]; }
-
-/* Returns the number of left, right, top, or bottom headers, respectively, in
-   T.  */
-static inline int table_hl (const struct table *t)
-        { return t->h[TABLE_HORZ][0]; }
-static inline int table_hr (const struct table *t)
-        { return t->h[TABLE_HORZ][1]; }
-static inline int table_ht (const struct table *t)
-        { return t->h[TABLE_VERT][0]; }
-static inline int table_hb (const struct table *t)
-        { return t->h[TABLE_VERT][1]; }
-
 /* Rule masks. */
 #define TAB_RULE_TYPE_MASK   7
 #define TAB_RULE_TYPE_SHIFT  0

diff --git a/src/output/tex.c b/src/output/tex.c
index 6b0175ed06f81bbcfaca0e7c95fd67eb69986d0a..bd1bbc0aba8b954970d1bf8766aff61e38f742a0 100644 (file)
--- a/src/output/tex.c
+++ b/src/output/tex.c
@@ -60,6 +60,10 @@
 #include "gettext.h"
 #define _(msgid) gettext (msgid)
 
+/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
+#define H TABLE_HORZ
+#define V TABLE_VERT
+
 /* The desired maximum line length in the TeX file.  */
 #define TEX_LINE_MAX 80
 
@@ -435,11 +439,11 @@ tex_output_table (struct tex_driver *tex, const struct table_item *item)
   shipout (&tex->token_list, "\\offinterlineskip\\halign{\\strut%%\n");
 
   /* Generate the preamble */
-  for (int x = 0; x < table_nc (t); ++x)
+  for (int x = 0; x < t->n[H]; ++x)
     {
-      shipout (&tex->token_list, "{\\vbox{\\cell{%d}#}}", table_nc (t));
+      shipout (&tex->token_list, "{\\vbox{\\cell{%d}#}}", t->n[H]);
 
-      if (x < table_nc (t) - 1)
+      if (x < t->n[H] - 1)
         {
           shipout (&tex->token_list, "\\hskip\\psppcolumnspace\\hfil");
           shipout (&tex->token_list, "&\\vrule\n");
@@ -449,13 +453,13 @@ tex_output_table (struct tex_driver *tex, const struct table_item *item)
     }
 
   /* Emit the row data */
-  for (int y = 0; y < table_nr (t); y++)
+  for (int y = 0; y < t->n[V]; y++)
     {
-      bool is_column_header = (y < table_ht (t)
-                               || y >= table_nr (t) - table_hb (t));
+      enum { H = TABLE_HORZ, V = TABLE_VERT };
+      bool is_column_header = y < t->h[V][0] || y >= t->n[V] - t->h[V][1];
       int prev_x = -1;
       int skipped = 0;
-      for (int x = 0; x < table_nc (t);)
+      for (int x = 0; x < t->n[H];)
         {
           struct table_cell cell;
 
@@ -472,11 +476,10 @@ tex_output_table (struct tex_driver *tex, const struct table_item *item)
           if (x != cell.d[TABLE_HORZ][0] || y != cell.d[TABLE_VERT][0])
             goto next_1;
 
-          /* bool is_header = (y < table_ht (t) */
-          /*                   || y >= table_nr (t) - table_hb (t) */
-          /*                   || x < table_hl (t) */
-          /*                   || x >= table_nc (t) - table_hr (t)); */
-
+          /* bool is_header = (y < t->h[V][0] */
+          /*                   || y >= t->n[V] - t->h[V][1] */
+          /*                   || x < t->h[H][0] */
+          /*                   || x >= t->n[H] - t->h[H][1]); */
 
           enum table_halign halign =
             table_halign_interpret (cell.style->cell_style.halign,