Adding upstream version 2.9.0dev.12.upstream/2.9.0dev.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2017 insertions, 0 deletions

diff --git a/src/TRSTable.c b/src/TRSTable.c
new file mode 100644
index 0000000..2a9461c
--- /dev/null
+++ b/src/TRSTable.c
@@ -0,0 +1,2017 @@
+/*
+ * $LynxId: TRSTable.c,v 1.39 2021/10/24 18:05:05 tom Exp $
+ *		Simple table object
+ *		===================
+ * Authors
+ *	KW	Klaus Weide <kweide@enteract.com>
+ * History:
+ *   2 Jul 1999	KW	Created.
+ */
+
+#include <HTUtils.h>
+#include <HTStyle.h>		/* for HT_LEFT, HT_CENTER, HT_RIGHT */
+#include <LYCurses.h>
+#include <TRSTable.h>
+#include <LYGlobalDefs.h>
+
+#include <LYLeaks.h>
+
+#ifdef SAVE_TIME_NOT_SPACE
+#define CELLS_GROWBY 16
+#define ROWS_GROWBY 16
+#else
+#define CELLS_GROWBY 2
+#define ROWS_GROWBY 2
+#endif
+
+#ifdef USE_CURSES_PADS
+#  define MAX_STBL_POS (LYwideLines ? MAX_COLS - 1 : LYcolLimit)
+#else
+#  define MAX_STBL_POS (LYcolLimit)
+#endif
+
+/* must be different from HT_ALIGN_NONE and HT_LEFT, HT_CENTER etc.: */
+#define RESERVEDCELL (-2)	/* cell's alignment field is overloaded, this
+				   value means cell was reserved by ROWSPAN */
+#define EOCOLG (-2)		/* sumcols' Line field isn't used for line info, this
+				   special value means end of COLGROUP */
+#ifndef NO_AGGRESSIVE_NEWROW
+#  define NO_AGGRESSIVE_NEWROW	0
+#endif
+
+typedef enum {
+    CS_invalid = -1,		/* cell "before the first",
+				   or empty lines after [ce]bc,
+				   or TRST aborted */
+    CS__new = 0,
+    CS__0new,			/* new, at BOL */
+    CS__0eb,			/* starts at BOL, empty, break */
+    CS__eb,			/* empty, break */
+    CS__0cb,			/* starts at BOL, content, break */
+    CS__cb,			/* content, break */
+    CS__0ef,			/* starts at BOL, empty, finished */
+    CS__ef,			/* empty, finished */
+    CS__0cf,			/* starts at BOL, content, finished */
+    CS__cf,			/* content, finished */
+    CS__ebc,			/* empty, break, more content (maybe @BOL) */
+    CS__cbc			/* content, break, more content (maybe @BOL) */
+} cellstate_t;
+
+typedef struct _STable_states {
+    cellstate_t prev_state;	/* Contents type of the previous cell */
+    cellstate_t state;		/* Contents type of the worked-on cell */
+    int lineno;			/* Start line of the current cell */
+    int icell_core;		/* -1 or the 1st cell with <BR></TD> on row */
+    int x_td;			/* x start pos of the current cell or -1 */
+    int pending_len;		/* For multiline cells, the length of
+				   the part on the first line (if
+				   state is CS__0?[ec]b) (??), or 0 */
+} STable_states;
+
+typedef struct _STable_cellinfo {
+    int cLine;			/* lineno in doc (zero-based): -1 for
+				   contentless cells (and cells we do
+				   not want to measure and count?),
+				   line-of-the-start otherwise.  */
+    int pos;			/* column where cell starts */
+    int len;			/* number of character positions */
+    int colspan;		/* number of columns to span */
+    int alignment;		/* one of HT_LEFT, HT_CENTER, HT_RIGHT,
+				   or RESERVEDCELL */
+} STable_cellinfo;
+
+enum ended_state {
+    ROW_not_ended,
+    ROW_ended_by_endtr,
+    ROW_ended_by_splitline
+};
+
+#define HAS_END_OF_CELL			1
+#define HAS_BEG_OF_CELL			2
+#define IS_CONTINUATION_OF_CELL		4
+#define OFFSET_IS_VALID			8
+#define OFFSET_IS_VALID_LAST_CELL	0x10
+#define BELIEVE_OFFSET			0x20
+
+typedef struct _STable_rowinfo {
+    /* Each row may be displayed on many display lines, but we fix up
+       positions of cells on this display line only: */
+    int Line;			/* lineno in doc (zero-based) */
+    int ncells;			/* number of table cells */
+
+    /* What is the meaning of this?!  It is set if:
+       [search for      def of fixed_line       below]
+
+       a1) a non-last cell is not at BOL,
+       a2) a non-last cell has something on the first line,
+       b) a >=3-lines-cell not at BOL, the first row non-empty, the 2nd empty;
+       c) a multiline cell not at BOL, the first row non-empty, the rest empty;
+       d) a multiline cell not at BOL, the first row non-empty;
+       e) a singleline non-empty cell not at BOL;
+
+       Summary: have seen a cell which is one of:
+       (Notation: B: at BOL; L: last; E: the first row is non-empty)
+
+       bcde:    !B && !E
+       a1:      !L && !B
+       a2:      !L && !E
+
+       Or: has at least two of !B, !L, !E, or: has at most one of B,L,E.
+
+       REMARK: If this variable is not set, but icell_core is, Line is
+       reset to the line of icell_core.
+     */
+    BOOL fixed_line;		/* if we have a 'core' line of cells */
+    enum ended_state ended;	/* if we saw </tr> etc */
+    int content;		/* Whether contains end-of-cell etc */
+    int offset;			/* >=0 after line break in a multiline cell */
+    int allocated;		/* number of table cells allocated */
+    STable_cellinfo *cells;
+    int alignment;		/* global align attribute for this row */
+} STable_rowinfo;
+
+struct _STable_info {
+#ifdef EXP_NESTED_TABLES
+    struct _STable_info *enclosing;	/* The table which contain us */
+    struct _TextAnchor *enclosing_last_anchor_before_stbl;
+#endif
+    int startline;		/* lineno where table starts (zero-based) */
+    int nrows;			/* number of rows */
+    int ncols;			/* number of rows */
+    int maxlen;			/* sum of max. cell lengths of any row */
+    int maxpos;			/* max. of max. cell pos's of any row */
+    int allocated_rows;		/* number of rows allocated */
+    int allocated_sumcols;	/* number of sumcols allocated */
+    int ncolinfo;		/* number of COL info collected */
+    STable_cellinfo *sumcols;	/* for summary (max len/pos) col info */
+    STable_rowinfo *rows;
+    STable_rowinfo rowspans2eog;
+    short alignment;		/* global align attribute for this table */
+    short rowgroup_align;	/* align default for current group of rows */
+    short pending_colgroup_align;
+    int pending_colgroup_next;
+    STable_states s;
+};
+
+/*
+ *  Functions and structures in this source file keep track of positions.
+ *  They don't know about the character data in those lines, or about
+ *  the HText and HTLine structures.  GridText.c doesn't know about our
+ *  structures.  It should stay that way.
+ *
+ *  The basic idea: we let the code in HTML.c/GridText.c produce and format
+ *  output "as usual", i.e. as without Simple Table support.  We keep track
+ *  of the positions in the generated output where cells and rows start (or
+ *  end).  If all goes well, that preliminary output (stored in HText/HTLine
+ *  structures) can be fixed up when the TABLE end tag is processed, by just
+ *  inserting spaces in the right places (and possibly changing alignment).
+ *  If all goes not well, we already have a safe fallback.
+ *
+ *  Note that positions passed to and from these functions should be
+ *  in terms of screen positions, not just byte counts in a HTLine.data
+ *  (cf. line->data vs. HText_TrueLineSize).
+ *
+ *  Memory is allocated dynamically, so we can have tables of arbitrary
+ *  length.  On allocation error we just return and error indication
+ *  instead of outofmem(), so caller can give up table tracking and maybe
+ *  recover memory.
+ *
+ *  Implemented:
+ *  - ALIGN={left,right,center,justify} applied to individual table cells
+ *    ("justify" is treated as "left")
+ *  - Inheritance of horizontal alignment according to HTML 4.0
+ *  - COLSPAN >1 (may work incorrectly for some tables?)
+ *  - ROWSPAN >1 (reserving cells in following rows)
+ *  - Line breaks at start of first cell or at end of last cell are treated
+ *    as if they were not part of the cell and row.  This allows us to
+ *    cooperate with one way in which tables have been made friendly to
+ *    browsers without any table support.
+ *  Missing, but can be added:
+ *  - Support for COLGROUP/COL
+ *  - Tables wider than display.  The limitation is not here but in GridText.c
+ *    etc.  If horizontal scrolling were implemented there, the mechanisms
+ *    here could deal with wide tables (just change MAX_STBL_POS code).
+ *  Missing, unlikely to add:
+ *  - Support for non-LTR directionality.  A general problem, support is
+ *    lacking throughout the lynx code.
+ *  - Support for most other table-related attributes.  Most of them are
+ *    for decorative purposes.
+ *  Impossible or very unlikely (because it doesn't fit the model):
+ *  - Any cell contents of more than one line, line breaks within cells.
+ *    Anything that requires handling cell contents as paragraphs (block
+ *    elements), like reflowing.  Vertical alignment.
+ */
+static int Stbl_finishRowInTable(STable_info *me);
+
+static const char *cellstate_s(cellstate_t state)
+{
+    const char *result = "?";
+    /* *INDENT-OFF* */
+    switch (state) {
+    case CS_invalid:	result = "CS_invalid";	break;
+    case CS__new:	result = "CS__new";	break;
+    case CS__0new:	result = "CS__0new";	break;
+    case CS__0eb:	result = "CS__0eb";	break;
+    case CS__eb:	result = "CS__eb";	break;
+    case CS__0cb:	result = "CS__0cb";	break;
+    case CS__cb:	result = "CS__cb";	break;
+    case CS__0ef:	result = "CS__0ef";	break;
+    case CS__ef:	result = "CS__ef";	break;
+    case CS__0cf:	result = "CS__0cf";	break;
+    case CS__cf:	result = "CS__cf";	break;
+    case CS__ebc:	result = "CS__ebc";	break;
+    case CS__cbc:	result = "CS__cbc";	break;
+    }
+    /* *INDENT-ON* */
+
+    return result;
+}
+
+struct _STable_info *Stbl_startTABLE(int alignment)
+{
+    STable_info *me = typecalloc(STable_info);
+
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_startTABLE(align=%d)\n", (int) alignment));
+    if (me) {
+	me->alignment = (short) alignment;
+	me->rowgroup_align = HT_ALIGN_NONE;
+	me->pending_colgroup_align = HT_ALIGN_NONE;
+	me->s.x_td = -1;
+	me->s.icell_core = -1;
+#ifdef EXP_NESTED_TABLES
+	if (nested_tables)
+	    me->enclosing = 0;
+#endif
+    }
+    return me;
+}
+
+static void free_rowinfo(STable_rowinfo *me)
+{
+    if (me && me->allocated) {
+	FREE(me->cells);
+    }
+}
+
+void Stbl_free(STable_info *me)
+{
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_free()\n"));
+    if (me && me->allocated_rows && me->rows) {
+	int i;
+
+	for (i = 0; i < me->allocated_rows; i++)
+	    free_rowinfo(me->rows + i);
+	FREE(me->rows);
+    }
+    free_rowinfo(&me->rowspans2eog);
+    if (me)
+	FREE(me->sumcols);
+    FREE(me);
+}
+
+/*
+ * Returns -1 on error, otherwise index of just-added table cell.
+ */
+static int Stbl_addCellToRow(STable_rowinfo *me, STable_cellinfo *colinfo, int ncolinfo,
+			     STable_states *s,
+			     int colspan,
+			     int alignment,
+			     int isheader,
+			     int lineno,
+			     int *ppos)
+{
+    STable_cellinfo *cells;
+    int i;
+    int last_colspan = me->ncells ?
+    me->cells[me->ncells - 1].colspan : 1;
+    cellstate_t newstate;
+    int ret;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_addCellToRow, line=%d, pos=%d, colspan=%d\n",
+	     lineno, *ppos, colspan));
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     " ncells=%d, stateLine=%d, pending_len=%d, pstate=%s, state=%s\n",
+	     me->ncells, s->lineno, s->pending_len,
+	     cellstate_s(s->prev_state), cellstate_s(s->state)));
+    if (me->ncells == 0)
+	s->prev_state = CS_invalid;
+    else if (s->prev_state == CS_invalid ||
+	     (s->state != CS__0new &&
+	      s->state != CS__ef && s->state != CS__0ef))
+	s->prev_state = s->state;
+
+    if (me->ncells == 0 || *ppos == 0)
+	newstate = CS__0new;
+    else
+	newstate = CS__new;
+
+    if (me->ncells > 0 && s->pending_len > 0) {
+	if (s->prev_state != CS__cbc)
+	    me->cells[me->ncells - 1].len = s->pending_len;
+	s->pending_len = 0;
+    }
+    s->x_td = *ppos;
+
+    if (lineno != s->lineno) {
+	if (!me->fixed_line) {
+	    if (me->ncells == 0 || *ppos == 0) {
+		switch (s->prev_state) {
+		case CS_invalid:
+		case CS__0new:
+		case CS__0eb:
+		case CS__0cb:
+		case CS__0ef:
+		case CS__0cf:
+		    if (me->ncells > 0)
+			for (i = me->ncells + last_colspan - 2;
+			     i >= me->ncells - 1; i--) {
+			    me->cells[i].pos = *ppos;
+			    me->cells[i].cLine = lineno;
+			}
+		    me->Line = lineno;
+		    break;
+		case CS__new:
+		case CS__eb:
+		case CS__ef:
+		case CS__cf:
+		default:
+		    break;
+		case CS__cb:
+		    *ppos = me->cells[me->ncells - 1].pos +
+			me->cells[me->ncells - 1].len;
+		}
+	    } else {		/* last cell multiline, ncells != 0, pos != 0 */
+		switch (s->prev_state) {
+		case CS__0new:
+		case CS__0eb:
+		case CS__0ef:
+		    /* Do not fail, but do not set fixed_line either */
+		    break;
+		case CS__cb:
+		    goto trace_and_fail;
+		case CS__cf:
+		    goto trace_and_fail;
+		case CS__0cb:
+		case CS__0cf:
+		    if (*ppos > me->cells[0].pos)
+			me->Line = lineno;
+		    me->fixed_line = YES;	/* type=a def of fixed_line i */
+		    break;
+		case CS__new:
+		case CS__eb:
+		case CS__ef:
+		default:
+		    me->fixed_line = YES;	/* type=e def of fixed_line ii */
+		    break;
+		case CS__cbc:
+		    goto trace_and_fail;
+		}
+	    }
+	}
+	if (me->fixed_line && lineno != me->Line) {
+	    switch (s->prev_state) {
+	    case CS__cb:
+	    case CS__cf:
+		if (*ppos > 0)
+		    goto trace_and_fail;
+		else
+		    *ppos = me->cells[me->ncells - 1].pos /* == 0 */  +
+			me->cells[me->ncells - 1].len;
+		break;
+	    case CS__0cf:
+	    case CS__0cb:
+		if (*ppos == 0 || *ppos <= me->cells[0].pos)
+		    *ppos = me->cells[me->ncells - 1].pos /* == 0 */  +
+			me->cells[me->ncells - 1].len;
+		break;
+	    case CS__0new:
+	    case CS__0ef:
+	    case CS__0eb:
+		break;
+	    case CS__new:
+	    case CS__eb:
+	    case CS__ef:
+	    default:
+		*ppos = me->cells[me->ncells - 1].pos;
+		break;
+	    case CS__cbc:
+		break;
+	    case CS_invalid:
+		break;
+	    }
+	}
+	s->lineno = lineno;
+    } else {			/* lineno == s->lineno: */
+	switch (s->prev_state) {
+	case CS_invalid:
+	case CS__0new:
+	case CS__0eb:		/* cannot happen */
+	case CS__0cb:		/* cannot happen */
+	case CS__0ef:
+	case CS__0cf:		/* ##302?? set icell_core? or only in finish? */
+	    break;
+	case CS__eb:		/* cannot happen */
+	case CS__cb:		/* cannot happen */
+	case CS__ef:
+	    break;
+	case CS__ebc:		/* should have done smth in finish */
+	case CS__cbc:		/* should have done smth in finish */
+	    break;
+	case CS__new:
+	case CS__cf:
+	    if (me->fixed_line && me->Line != lineno) {
+		goto trace_and_fail;
+	    } else {
+		me->fixed_line = YES;
+		me->Line = lineno;
+	    }
+	}
+    }
+
+    s->state = newstate;
+
+    if (me->ncells > 0 && me->cells[me->ncells - 1].colspan > 1) {
+	me->ncells += me->cells[me->ncells - 1].colspan - 1;
+    }
+    while (me->ncells < me->allocated &&
+	   me->cells[me->ncells].alignment == RESERVEDCELL) {
+	me->ncells++;
+    }
+    {
+	int growby = 0;
+
+	while (me->ncells + colspan + 1 >= me->allocated + growby)
+	    growby += CELLS_GROWBY;
+	if (growby) {
+	    if (me->allocated == 0 && !me->cells) {
+		cells = typecallocn(STable_cellinfo, (unsigned) growby);
+	    } else {
+		cells = typeRealloc(STable_cellinfo, me->cells,
+				      (unsigned) (me->allocated + growby));
+
+		for (i = 0; cells && i < growby; i++) {
+		    cells[me->allocated + i].alignment = HT_ALIGN_NONE;
+		}
+	    }
+	    if (cells) {
+		me->allocated += growby;
+		me->cells = cells;
+	    } else {
+		goto trace_and_fail;
+	    }
+	}
+    }
+
+    me->cells[me->ncells].cLine = lineno;
+    me->cells[me->ncells].pos = *ppos;
+    me->cells[me->ncells].len = -1;
+    me->cells[me->ncells].colspan = colspan;
+
+    if (alignment != HT_ALIGN_NONE)
+	me->cells[me->ncells].alignment = alignment;
+    else {
+	if (ncolinfo >= me->ncells + 1)
+	    me->cells[me->ncells].alignment = colinfo[me->ncells].alignment;
+	else
+	    me->cells[me->ncells].alignment = me->alignment;
+	if (me->cells[me->ncells].alignment == HT_ALIGN_NONE)
+	    me->cells[me->ncells].alignment = me->alignment;
+	if (me->cells[me->ncells].alignment == HT_ALIGN_NONE)
+	    me->cells[me->ncells].alignment = isheader ? HT_CENTER : HT_LEFT;
+    }
+    for (i = me->ncells + 1; i < me->ncells + colspan; i++) {
+	me->cells[i].cLine = lineno;
+	me->cells[i].pos = *ppos;
+	me->cells[i].len = -1;
+	me->cells[i].colspan = 0;
+	me->cells[i].alignment = HT_LEFT;
+    }
+    me->cells[me->ncells + colspan].pos = -1;	/* not yet used */
+    me->ncells++;
+
+    ret = me->ncells - 1;
+  trace_and_return:
+    CTRACE2(TRACE_TRST,
+	    (tfp, " => prev_state=%s, state=%s, ret=%d\n",
+	     cellstate_s(s->prev_state), cellstate_s(s->state), ret));
+    return (ret);
+
+  trace_and_fail:
+    ret = -1;
+    goto trace_and_return;
+}
+
+/* returns -1 on error, 0 otherwise */
+/* assumes cells have already been allocated (but may need more) */
+static int Stbl_reserveCellsInRow(STable_rowinfo *me, int icell,
+				  int colspan)
+{
+    STable_cellinfo *cells;
+    int i;
+    int growby = 1 + icell + colspan - me->allocated;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     "TRST:Stbl_reserveCellsInRow(icell=%d, colspan=%d) growby=%d\n",
+	     icell, colspan, growby));
+    if (growby > 0) {
+	cells = typeRealloc(STable_cellinfo, me->cells,
+			      (unsigned) (me->allocated + growby));
+
+	if (cells) {
+	    for (i = 0; i < growby; i++) {
+		cells[me->allocated + i].alignment = HT_ALIGN_NONE;
+	    }
+	    me->allocated += growby;
+	    me->cells = cells;
+	} else {
+	    return -1;
+	}
+    }
+    for (i = icell; i < icell + colspan; i++) {
+	me->cells[i].cLine = -1;
+	me->cells[i].pos = -1;
+	me->cells[i].len = -1;
+	me->cells[i].colspan = 0;
+	me->cells[i].alignment = RESERVEDCELL;
+    }
+    me->cells[icell].colspan = colspan;
+    return 0;
+}
+
+/* Returns -1 on failure. */
+static int Stbl_finishCellInRow(STable_rowinfo *me, STable_states *s, int end_td,
+				int lineno,
+				int pos)
+{
+    STable_cellinfo *lastcell;
+    cellstate_t newstate = CS_invalid;
+    int multiline = NO, empty;
+    int ret;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     "TRST:Stbl_finishCellInRow line=%d pos=%d end_td=%d ncells=%d pnd_len=%d\n",
+	     lineno, pos, (int) end_td, me->ncells, s->pending_len));
+
+    if (me->ncells <= 0)
+	return -1;
+    lastcell = me->cells + (me->ncells - 1);
+    multiline = (lineno != lastcell->cLine || lineno != s->lineno);
+    empty = multiline ? (pos == 0) : (pos <= s->x_td);
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     " [lines: lastCell=%d state=%d multi=%d] empty=%d (prev)state=(%s) %s\n",
+	     lastcell->cLine, s->lineno, multiline, empty,
+	     cellstate_s(s->prev_state), cellstate_s(s->state)));
+
+    if (multiline) {
+	if ((end_td & TRST_ENDCELL_MASK) == TRST_ENDCELL_LINEBREAK) {
+	    switch (s->state) {
+	    case CS_invalid:
+		newstate = empty ? CS_invalid : CS__cbc;
+		break;
+	    case CS__0new:
+		newstate = empty ? CS__0eb : CS__0cb;
+		break;
+	    case CS__0eb:
+		newstate = empty ? CS__0eb : CS__ebc;
+		s->state = newstate;
+		if (empty) {
+		    ret = (lastcell->len <= 0 ? 0 : lastcell->len);
+		} else {
+		    ret = (lastcell->len <= 0 ? 0 : -1);
+		}
+		goto trace_and_return;
+	    case CS__0cb:
+		if (!me->fixed_line) {
+		    if (!empty) {
+			if (s->icell_core == -1)
+			    me->Line = -1;
+		    }
+		}
+		if (s->pending_len && empty) {	/* First line non-empty */
+		    if ((me->fixed_line && me->Line == lastcell->cLine) ||
+			s->icell_core == me->ncells - 1)
+			lastcell->len = s->pending_len;
+		    s->pending_len = 0;
+		}		/* @@@ for empty do smth. about ->Line / ->icell_core !! */
+		newstate = empty ? CS__0cb : CS__cbc;	/* ##474_needs_len!=-1? */
+		break;
+	    case CS__0ef:
+	    case CS__0cf:
+		break;
+	    case CS__new:
+		newstate = empty ? CS__eb : CS__cb;
+		break;
+	    case CS__eb:	/* ##484_set_pending_ret_0_if_empty? */
+		newstate = empty ? CS__eb : CS__ebc;
+		s->state = newstate;
+		if (empty) {
+		    ret = (lastcell->len <= 0 ? 0 : lastcell->len);
+		} else {
+		    ret = (lastcell->len <= 0 ? 0 : -1);
+		}
+		goto trace_and_return;
+	    case CS__cb:
+		if (s->pending_len && empty) {	/* ##496: */
+		    lastcell->len = s->pending_len;
+		    s->pending_len = 0;
+		}		/* @@@ for empty do smth. about ->Line / ->icell_core !! */
+		ret = -1;
+		if (empty) {
+		    if (!me->fixed_line) {
+			me->fixed_line = YES;	/* type=b def of fixed_line i */
+			me->Line = lastcell->cLine;	/* should've happened in break */
+		    } else {
+			if (me->Line != lastcell->cLine)
+			    goto trace_and_return;
+		    }
+		    newstate = CS__cb;
+		} else {
+		    if (!me->fixed_line) {
+			me->fixed_line = YES;	/* type=b def of fixed_line ii */
+			me->Line = lastcell->cLine;	/* should've happened in break */
+		    }
+		    s->state = CS__cbc;
+		    goto trace_and_return;
+		}
+		break;
+	    case CS__ef:
+		ret = 0;
+		goto trace_and_return;
+	    case CS__cf:
+		ret = lastcell->len;	/* ##523_change_state? */
+		goto trace_and_return;
+	    case CS__cbc:
+		if (!me->fixed_line) {
+		    if (empty) {
+			if (s->icell_core == -1)	/* ##528??: */
+			    me->Line = lineno;
+			/* lastcell->Line = lineno; */
+		    } else {	/* !empty */
+			if (s->icell_core == -1)
+			    me->Line = -1;
+		    }
+		}
+		s->pending_len = 0;
+		newstate = empty ? CS_invalid : CS__cbc;
+		break;
+	    default:
+		break;
+	    }
+	} else {		/* multiline cell, processing </TD>: */
+	    s->x_td = -1;
+	    switch (s->state) {
+	    case CS_invalid:
+		/* ##540_return_-1_for_invalid_if_len!: */
+		if (!empty && lastcell->len > 0) {
+		    newstate = CS__0cf;
+		    s->state = newstate;
+		    ret = -1;
+		    goto trace_and_return;
+		}
+		/* ##541_set_len_0_Line_-1_sometimes: */
+		lastcell->len = 0;
+		lastcell->cLine = -1;
+		/* fall thru ##546 really fall thru??: */
+		newstate = empty ? CS_invalid : CS__cbc;
+		break;
+	    case CS__0new:
+		newstate = empty ? CS__0ef : CS__0cf;
+		break;
+	    case CS__0eb:
+		newstate = empty ? CS__0ef : CS__0cf;	/* ebc?? */
+		s->state = newstate;
+		if (empty) {
+		    ret = (lastcell->len <= 0 ? 0 : lastcell->len);
+		} else {
+		    ret = (lastcell->len <= 0 ? 0 : -1);
+		}
+		goto trace_and_return;
+	    case CS__0cb:
+		if (s->pending_len) {
+		    if (empty)
+			lastcell->len = s->pending_len;
+		    else
+			lastcell->len = 0;
+		    s->pending_len = 0;
+		}
+		if (!me->fixed_line) {
+		    if (empty) {
+			if (s->icell_core == -1)
+			    /* first cell before <BR></TD> => the core cell */
+			    s->icell_core = me->ncells - 1;
+			/* lastcell->cLine = lineno; */
+		    } else {	/* !empty */
+			if (s->icell_core == -1)
+			    me->Line = -1;
+		    }
+		}
+		if (s->pending_len && empty) {
+		    lastcell->len = s->pending_len;
+		    s->pending_len = 0;
+		}		/* @@@ for empty do smth. about ->Line / ->icell_core !! */
+		newstate = empty ? CS__0cf : CS__cbc;
+		break;
+	    case CS__0ef:
+		newstate = CS__0ef;
+		/* FALLTHRU */
+	    case CS__0cf:
+		break;
+	    case CS__new:
+		newstate = empty ? CS__ef : CS__cf;
+		break;
+	    case CS__eb:
+		newstate = CS__ef;
+		s->state = newstate;
+		if (empty) {
+		    ret = (lastcell->len <= 0 ? 0 : lastcell->len);
+		} else {
+		    ret = (lastcell->len <= 0 ? 0 : -1);
+		}
+		goto trace_and_return;
+	    case CS__cb:
+		if (s->pending_len && empty) {
+		    lastcell->len = s->pending_len;
+		    s->pending_len = 0;
+		}
+		ret = -1;
+		if (empty) {
+		    if (!me->fixed_line) {
+			me->fixed_line = YES;	/* type=c def of fixed_line */
+			me->Line = lastcell->cLine;	/* should've happened in break */
+		    } else {
+			if (me->Line != lastcell->cLine)
+			    goto trace_and_return;
+		    }
+		    newstate = CS__cf;
+		} else {
+		    goto trace_and_return;
+		}
+		break;
+	    case CS__ef:	/* ignored error */
+	    case CS__cf:	/* ignored error */
+		break;
+	    case CS__ebc:	/* ##540_handle_ebc: */
+		lastcell->len = 0;
+		if (!me->fixed_line) {
+		    if (!empty) {
+			if (s->icell_core == -1)
+			    lastcell->cLine = -1;
+		    }
+		}
+		s->pending_len = 0;
+		newstate = empty ? CS_invalid : CS__cbc;
+		break;
+	    case CS__cbc:	/* ##586 */
+		lastcell->len = 0;	/* ##613 */
+		ret = -1;
+		if (me->fixed_line && me->Line == lastcell->cLine)
+		    goto trace_and_return;
+		if (!me->fixed_line) {
+		    if (empty) {
+			if (s->icell_core == -1)
+			    me->Line = lineno;
+		    }
+		}
+		s->pending_len = 0;	/* ##629 v */
+		newstate = empty ? CS_invalid : CS__cbc;
+		break;
+	    }
+	}
+    } else {			/* (!multiline) */
+	if ((end_td & TRST_ENDCELL_MASK) == TRST_ENDCELL_LINEBREAK) {
+	    switch (s->state) {
+	    case CS_invalid:
+	    case CS__0new:
+		s->pending_len = empty ? 0 : pos - lastcell->pos;
+		newstate = empty ? CS__0eb : CS__0cb;
+		s->state = newstate;
+		ret = 0;	/* or 0 for xlen to s->pending_len?? */
+		goto trace_and_return;
+	    case CS__0eb:	/* cannot happen */
+		newstate = CS__eb;
+		break;
+	    case CS__0cb:	/* cannot happen */
+		newstate = CS__cb;
+		break;
+	    case CS__0ef:
+	    case CS__0cf:
+		break;
+	    case CS__new:
+		ret = -1;
+		if (!empty && s->prev_state == CS__cbc)		/* ##609: */
+		    goto trace_and_return;
+		if (!empty) {
+		    if (!me->fixed_line) {
+			me->fixed_line = YES;	/* type=d def of fixed_line */
+			me->Line = lineno;
+		    } else {
+			if (me->Line != lineno)
+			    goto trace_and_return;
+		    }
+		}
+		newstate = empty ? CS__eb : CS__cb;
+		s->state = newstate;
+		if (!me->fixed_line) {
+		    s->pending_len = empty ? 0 : pos - lastcell->pos;
+		    ret = 0;
+		    goto trace_and_return;
+		} else {
+		    s->pending_len = 0;
+		    lastcell->len = empty ? 0 : pos - lastcell->pos;
+		    ret = lastcell->len;
+		    goto trace_and_return;
+		}
+	    case CS__eb:	/* cannot happen */
+		newstate = empty ? CS__eb : CS__ebc;
+		break;
+	    case CS__cb:	/* cannot happen */
+		newstate = empty ? CS__cb : CS__cbc;
+		break;
+	    case CS__ef:
+		ret = 0;
+		goto trace_and_return;
+	    case CS__cf:
+		ret = lastcell->len;
+		goto trace_and_return;
+	    case CS__cbc:	/* ??? */
+		break;
+	    default:
+		break;
+	    }
+	} else {		/* !multiline, processing </TD>: */
+	    s->x_td = -1;
+	    switch (s->state) {
+	    case CS_invalid:	/* ##691_no_lastcell_len_for_invalid: */
+		if (!(me->fixed_line && me->Line == lastcell->cLine))
+		    lastcell->len = 0;
+		/* FALLTHRU */
+	    case CS__0new:
+		newstate = empty ? CS__0ef : CS__0cf;
+		break;		/* ##630 */
+	    case CS__0eb:
+		newstate = CS__0ef;
+		break;		/* ??? */
+	    case CS__0cb:
+		newstate = empty ? CS__0cf : CS__cbc;
+		break;		/* ??? */
+	    case CS__0ef:
+		newstate = CS__0ef;
+		break;		/* ??? */
+	    case CS__0cf:
+		break;		/* ??? */
+	    case CS__new:
+		ret = -1;
+		if (!empty && s->prev_state == CS__cbc)
+		    goto trace_and_return;
+		if (!empty) {	/* ##642_set_fixed!: */
+		    if (!me->fixed_line) {
+			me->fixed_line = YES;	/* type=e def of fixed_line */
+			me->Line = lineno;
+		    } else {
+			if (me->Line != lineno)
+			    goto trace_and_return;
+		    }
+		}
+		if (lastcell->len < 0)
+		    lastcell->len = empty ? 0 : pos - lastcell->pos;
+		newstate = empty ? CS__ef : CS__cf;
+		s->state = newstate;
+		ret = ((me->fixed_line && lineno != me->Line)
+		       ? -1 : lastcell->len);
+		goto trace_and_return;
+	    case CS__eb:
+		newstate = empty ? CS__ef : CS__cf;
+		break;		/* ??? */
+	    case CS__cb:
+		newstate = CS__cf;
+		break;		/* ??? */
+	    case CS__ef:	/* ignored error */
+	    case CS__cf:	/* ignored error */
+	    default:
+		break;
+	    }
+	    lastcell->len = pos - lastcell->pos;
+	}			/* if (!end_td) ... else */
+    }				/* if (multiline) ... else */
+
+    s->state = newstate;
+    ret = lastcell->len;
+#ifdef EXP_NESTED_TABLES
+    if (nested_tables) {
+	if (ret == -1 && pos == 0)
+	    ret = 0;		/* XXXX Hack to allow trailing <P> in multiline cells. */
+    }
+#endif
+
+/*    lastcell->len = pos - lastcell->pos; */
+  trace_and_return:
+    CTRACE2(TRACE_TRST,
+	    (tfp, " => prev_state=%s, state=%s, return=%d\n",
+	     cellstate_s(s->prev_state), cellstate_s(s->state), ret));
+    return ret;
+}
+
+/*
+ * Reserve cells, each of given colspan, in (rowspan-1) rows after the current
+ * row of rowspan>1.  If rowspan==0, use special 'row' rowspans2eog to keep
+ * track of rowspans that are to remain in effect until the end of the row
+ * group (until next THEAD/TFOOT/TBODY) or table.
+ */
+static int Stbl_reserveCellsInTable(STable_info *me, int icell,
+				    int colspan,
+				    int rowspan)
+{
+    STable_rowinfo *rows, *row;
+    int growby;
+    int i;
+
+    if (colspan > TRST_MAXCOLSPAN) {
+	CTRACE2(TRACE_TRST,
+		(tfp,
+		 "TRST:*** COLSPAN=%d is too large, ignored!\n",
+		 colspan));
+	return -1;
+    }
+    if (rowspan > TRST_MAXROWSPAN) {
+	CTRACE2(TRACE_TRST,
+		(tfp,
+		 "TRST:*** ROWSPAN=%d is too large, ignored!\n",
+		 rowspan));
+	return -1;
+    }
+    if (me->nrows <= 0)
+	return -1;		/* must already have at least one row */
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     "TRST:Stbl_reserveCellsInTable(icell=%d, colspan=%d, rowspan=%d)\n",
+	     icell, colspan, rowspan));
+    if (rowspan == 0) {
+	if (!me->rowspans2eog.cells) {
+	    me->rowspans2eog.cells = typecallocn(STable_cellinfo,
+						   (unsigned) HTMAX(1, icell + colspan));
+
+	    if (!me->rowspans2eog.cells)
+		return 0;	/* fail silently */
+	    else
+		me->rowspans2eog.allocated = icell + colspan;
+	}
+	Stbl_reserveCellsInRow(&me->rowspans2eog, icell, colspan);
+    }
+
+    growby = me->nrows + rowspan - 1 - me->allocated_rows;
+    if (growby > 0) {
+	rows = typeRealloc(STable_rowinfo, me->rows,
+			     (unsigned) (me->allocated_rows + growby));
+
+	if (!rows)
+	    return 0;		/* ignore silently, no free memory, may be recoverable */
+	for (i = 0; i < growby; i++) {
+	    row = rows + me->allocated_rows + i;
+	    row->allocated = 0;
+	    row->offset = 0;
+	    row->content = 0;
+	    if (!me->rowspans2eog.allocated) {
+		row->cells = NULL;
+	    } else {
+		row->cells = typecallocn(STable_cellinfo,
+					   (unsigned) me->rowspans2eog.allocated);
+
+		if (row->cells) {
+		    row->allocated = me->rowspans2eog.allocated;
+		    memcpy(row->cells, me->rowspans2eog.cells,
+			   ((unsigned) row->allocated * sizeof(STable_cellinfo)));
+		}
+	    }
+	    row->ncells = 0;
+	    row->fixed_line = NO;
+	    row->alignment = HT_ALIGN_NONE;
+	}
+	me->allocated_rows += growby;
+	me->rows = rows;
+    }
+    for (i = me->nrows;
+	 i < (rowspan == 0 ? me->allocated_rows : me->nrows + rowspan - 1);
+	 i++) {
+	if (!me->rows[i].allocated) {
+	    me->rows[i].cells = typecallocn(STable_cellinfo,
+					      (unsigned) HTMAX(1,
+							       icell
+							       + colspan));
+
+	    if (!me->rows[i].cells)
+		return 0;	/* fail silently */
+	    else
+		me->rows[i].allocated = icell + colspan;
+	}
+	Stbl_reserveCellsInRow(me->rows + i, icell, colspan);
+    }
+    return 0;
+}
+
+/* Remove reserved cells in trailing rows that were added for rowspan,
+ * to be used when a THEAD/TFOOT/TBODY ends. */
+static void Stbl_cancelRowSpans(STable_info *me)
+{
+    int i;
+
+    CTRACE2(TRACE_TRST, (tfp, "TRST:Stbl_cancelRowSpans()"));
+    for (i = me->nrows; i < me->allocated_rows; i++) {
+	if (!me->rows[i].ncells) {	/* should always be the case */
+	    FREE(me->rows[i].cells);
+	    me->rows[i].allocated = 0;
+	}
+    }
+    free_rowinfo(&me->rowspans2eog);
+    me->rowspans2eog.allocated = 0;
+}
+
+/*
+ * Returns -1 on error, otherwise index of just-added table row.
+ */
+int Stbl_addRowToTable(STable_info *me, int alignment,
+		       int lineno)
+{
+    STable_rowinfo *rows, *row;
+    STable_states *s = &me->s;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_addRowToTable(alignment=%d, lineno=%d)\n",
+	     alignment, lineno));
+    if (me->nrows > 0 && me->rows[me->nrows - 1].ncells > 0) {
+	if (s->pending_len > 0)
+	    me->rows[me->nrows - 1].cells[
+					     me->rows[me->nrows - 1].ncells - 1
+		].len =
+		s->pending_len;
+	s->pending_len = 0;
+    }
+    Stbl_finishRowInTable(me);
+    if (me->nrows > 0 && me->rows[me->nrows - 1].Line == lineno)
+	me->rows[me->nrows - 1].Line = -1;
+    s->pending_len = 0;
+    s->x_td = -1;
+
+    {
+	int i;
+	int growby = 0;
+
+	while (me->nrows + 2 >= me->allocated_rows + growby)
+	    growby += ROWS_GROWBY;
+	if (growby) {
+	    if (me->allocated_rows == 0 && !me->rows) {
+		rows = typecallocn(STable_rowinfo, (unsigned) growby);
+	    } else {
+		rows = typeRealloc(STable_rowinfo, me->rows,
+				     (unsigned) (me->allocated_rows + growby));
+
+		for (i = 0; rows && i < growby; i++) {
+		    row = rows + me->allocated_rows + i;
+		    if (!me->rowspans2eog.allocated) {
+			row->allocated = 0;
+			row->cells = NULL;
+		    } else {
+			row->cells = typecallocn(STable_cellinfo,
+						   (unsigned) me->rowspans2eog.allocated);
+
+			if (row->cells) {
+			    row->allocated = me->rowspans2eog.allocated;
+			    memcpy(row->cells, me->rowspans2eog.cells,
+				   (unsigned) row->allocated * sizeof(STable_cellinfo));
+			} else {
+			    FREE(rows);
+			    break;
+			}
+		    }
+		    row->ncells = 0;
+		    row->fixed_line = NO;
+		    row->alignment = HT_ALIGN_NONE;
+		    row->offset = 0;
+		    row->content = 0;
+		}
+	    }
+	    if (rows) {
+		me->allocated_rows += growby;
+		me->rows = rows;
+	    } else {
+		return -1;
+	    }
+	}
+    }
+
+    me->rows[me->nrows].Line = lineno;
+    if (me->nrows == 0)
+	me->startline = lineno;
+    if (alignment != HT_ALIGN_NONE)
+	me->rows[me->nrows].alignment = alignment;
+    else
+	me->rows[me->nrows].alignment =
+	    (me->rowgroup_align == HT_ALIGN_NONE) ?
+	    me->alignment : me->rowgroup_align;
+    me->nrows++;
+    if (me->pending_colgroup_next > me->ncolinfo) {
+	me->ncolinfo = me->pending_colgroup_next;
+	me->pending_colgroup_next = 0;
+    }
+    me->rows[me->nrows].Line = -1;	/* not yet used */
+    me->rows[me->nrows].ended = ROW_not_ended;	/* No </tr> yet */
+    return (me->nrows - 1);
+}
+
+/*
+ * Returns -1 on error, otherwise current number of rows.
+ */
+static int Stbl_finishRowInTable(STable_info *me)
+{
+    STable_rowinfo *lastrow;
+    STable_states *s = &me->s;
+
+    CTRACE2(TRACE_TRST, (tfp, "TRST:Stbl_finishRowInTable()\n"));
+    if (!me->rows || !me->nrows)
+	return -1;		/* no row started! */
+    lastrow = me->rows + (me->nrows - 1);
+    lastrow->ended = ROW_ended_by_endtr;
+    if (lastrow->ncells > 0) {
+	if (s->pending_len > 0)
+	    lastrow->cells[lastrow->ncells - 1].len = s->pending_len;
+	s->pending_len = 0;
+    }
+    s->prev_state = s->state = CS_invalid;
+    s->lineno = -1;
+
+    if (s->icell_core >= 0 && !lastrow->fixed_line &&
+	lastrow->cells[s->icell_core].cLine >= 0)
+	lastrow->Line = lastrow->cells[s->icell_core].cLine;
+    s->icell_core = -1;
+    return (me->nrows);
+}
+
+static void update_sumcols0(STable_cellinfo *sumcols,
+			    STable_rowinfo *lastrow,
+			    int pos,
+			    int len,
+			    int icell,
+			    int ispan,
+			    int allocated_sumcols)
+{
+    int i;
+
+    if (len > 0) {
+	int sumpos = pos;
+	int prevsumpos = sumcols[icell + ispan].pos;
+	int advance;
+
+	if (ispan > 0) {
+	    if (lastrow->cells[icell].pos + len > sumpos)
+		sumpos = lastrow->cells[icell].pos + len;
+	    if (sumcols[icell + ispan - 1].pos +
+		sumcols[icell + ispan - 1].len >
+		sumpos)
+		sumpos = sumcols[icell + ispan - 1].pos +
+		    sumcols[icell + ispan - 1].len;
+	}
+	advance = sumpos - prevsumpos;
+	if (advance > 0) {
+	    for (i = icell + ispan; i < allocated_sumcols; i++) {
+		if (ispan > 0 && sumcols[i].colspan < -1) {
+		    if (i + sumcols[i].colspan < icell + ispan) {
+			advance = sumpos - sumcols[i].pos;
+			if (i > 0)
+			    advance = HTMAX(advance,
+					    sumcols[i - 1].pos +
+					    sumcols[i - 1].len
+					    - (sumcols[i].pos));
+			if (advance <= 0)
+			    break;
+		    }
+		}
+		if (sumcols[i].pos >= 0)
+		    sumcols[i].pos += advance;
+		else {
+		    sumcols[i].pos = sumpos;
+		    break;
+		}
+	    }
+	}
+    }
+}
+
+static int get_remaining_colspan(STable_rowinfo *me,
+				 STable_cellinfo *colinfo,
+				 int ncolinfo,
+				 int colspan,
+				 int ncols_sofar)
+{
+    int i;
+    int last_colspan = (me->ncells
+			? me->cells[me->ncells - 1].colspan
+			: 1);
+
+    if (ncolinfo == 0 || me->ncells + last_colspan > ncolinfo) {
+	colspan = HTMIN(TRST_MAXCOLSPAN,
+			ncols_sofar - (me->ncells + last_colspan - 1));
+	colspan = HTMAX(colspan, 0);
+    } else {
+	for (i = me->ncells + last_colspan - 1; i < ncolinfo - 1; i++)
+	    if (colinfo[i].cLine == EOCOLG)
+		break;
+	colspan = i - (me->ncells + last_colspan - 2);
+    }
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:get_remaining_colspan; colspan = %d\n",
+	     colspan));
+    return colspan;
+}
+
+#ifdef EXP_NESTED_TABLES
+/* Returns -1 on failure, 1 if faking was performed, 0 if not needed. */
+static int Stbl_fakeFinishCellInTable(STable_info *me,
+				      STable_rowinfo *lastrow,
+				      int lineno,
+				      int finishing)	/* Processing finish or start */
+{
+    STable_states *s = &me->s;
+    int fake = 0;
+
+    switch (s->state) {		/* We care only about trailing <BR> */
+    case CS_invalid:
+    case CS__0new:
+    case CS__0ef:
+    case CS__0cf:
+    case CS__new:
+    case CS__cbc:
+    case CS__ef:
+    case CS__cf:
+    default:
+	/* <BR></TD> may produce these (XXXX instead of CS__cbf?).  But if
+	   finishing==0, the caller already checked that we are on a
+	   different line.  */
+	if (finishing == 0)
+	    fake = 1;
+	break;			/* Either can't happen, or may be ignored */
+    case CS__eb:
+    case CS__0eb:
+    case CS__0cb:
+    case CS__cb:
+	fake = 1;
+	break;
+    }
+    if (fake) {
+	/* The previous action we did was putting a linebreak.  Now we
+	   want to put another one.  Fake necessary
+	   </TD></TR><TR><TD></TD><TD> (and possibly </TD>) instead. */
+	int ncells = lastrow->ncells;
+	int i;
+	int al = lastrow->alignment;
+	int cs = lastrow->cells[lastrow->ncells - 1].colspan;
+	int rs = 1;		/* XXXX How to find rowspan? */
+	int ih = 0;		/* XXXX How to find is_header? */
+	int end_td = (TRST_ENDCELL_ENDTD | TRST_FAKING_CELLS);
+	int need_reserved = 0;
+	int prev_reserved_last = -1;
+	STable_rowinfo *prev_row;
+	int prev_row_n2 = (int) (lastrow - me->rows);
+
+	CTRACE2(TRACE_TRST,
+		(tfp,
+		 "TRST:Stbl_fakeFinishCellInTable(lineno=%d, finishing=%d) START FAKING\n",
+		 lineno, finishing));
+
+	/* Although here we use pos=0, this may commit the previous
+	   cell which had <BR> as a last element.  This may overflow
+	   the screen width, so the additional checks performed in
+	   Stbl_finishCellInTable (comparing to Stbl_finishCellInRow)
+	   are needed. */
+	if (finishing) {
+	    /* Fake </TD> at BOL */
+	    if (Stbl_finishCellInTable(me, end_td, lineno, 0, 0) < 0) {
+		return -1;
+	    }
+	}
+
+	/* Fake </TR> at BOL */
+	/* Stbl_finishCellInTable(lineno, 0, 0); */
+	/* Needed? */
+
+	/* Fake <TR> at BOL */
+	if (Stbl_addRowToTable(me, al, lineno) < 0) {
+	    return -1;
+	}
+	lastrow = me->rows + (me->nrows - 1);
+	lastrow->content = IS_CONTINUATION_OF_CELL;
+	for (i = 0; i < lastrow->allocated; i++) {
+	    if (lastrow->cells[i].alignment == RESERVEDCELL) {
+		need_reserved = 1;
+		break;
+	    }
+	}
+
+	prev_row = me->rows + prev_row_n2;
+	for (i = ncells; i < prev_row->allocated; i++) {
+	    if (prev_row->cells[i].alignment == RESERVEDCELL)
+		prev_reserved_last = i;
+	}
+	if (need_reserved || prev_reserved_last >= 0) {
+	    /* Oups, we are going to stomp over a line which somebody
+	       cares about already, or the previous line had reserved
+	       cells which were not skipped over.
+
+	       Remember that STable_rowinfo is about logical (TR)
+	       table lines, not displayed lines.  We need to duplicate
+	       the reservation structure when we fake new logical lines.  */
+	    int prev_row_n = (int) (prev_row - me->rows);
+	    STable_rowinfo *rows = typeRealloc(STable_rowinfo, me->rows,
+					       (unsigned) (me->allocated_rows
+							   + 1));
+	    int need_cells = prev_reserved_last + 1;
+	    int n;
+
+	    if (!rows)
+		return -1;	/* ignore silently, no free memory, may be recoverable */
+
+	    CTRACE2(TRACE_TRST,
+		    (tfp, "TRST:Stbl_fakeFinishCellInTable REALLOC ROWSPAN\n"));
+	    me->rows = rows;
+	    lastrow = me->rows + (me->nrows - 1);
+	    prev_row = me->rows + prev_row_n;
+	    me->allocated_rows++;
+
+	    /* Insert a duplicate row after lastrow */
+	    for (n = me->allocated_rows - me->nrows - 1; n >= 0; --n)
+		lastrow[n + 1] = lastrow[n];
+
+	    /* Ignore cells, they belong to the next row now */
+	    lastrow->allocated = 0;
+	    lastrow->cells = 0;
+	    if (need_cells) {
+		lastrow->cells = typecallocn(STable_cellinfo, (unsigned) need_cells);
+
+		/* ignore silently, no free memory, may be recoverable */
+		if (!lastrow->cells) {
+		    return -1;
+		}
+		lastrow->allocated = need_cells;
+		memcpy(lastrow->cells, prev_row->cells,
+		       (unsigned) lastrow->allocated * sizeof(STable_cellinfo));
+
+		i = -1;
+		while (++i < ncells) {
+		    /* Stbl_addCellToTable grants RESERVEDCELL, but we do not
+		       want this action for fake cells.
+		       XXX Maybe always fake RESERVEDCELL instead of explicitly
+		       creating/destroying cells?  */
+		    if (lastrow->cells[i].alignment == RESERVEDCELL)
+			lastrow->cells[i].alignment = HT_LEFT;
+		}
+	    }
+	}
+
+	/* Fake <TD></TD>...<TD> (and maybe a </TD>) at BOL. */
+	CTRACE2(TRACE_TRST,
+		(tfp, "TRST:Stbl_fakeFinishCellInTable FAKE %d elts%s\n",
+		 ncells, (finishing ? ", last unfinished" : "")));
+	i = 0;
+	while (++i <= ncells) {
+	    /* XXXX A lot of args may be wrong... */
+	    if (Stbl_addCellToTable(me, (i == ncells ? cs : 1), rs, al,
+				    ih, lineno, 0, 0) < 0) {
+		return -1;
+	    }
+	    lastrow->content &= ~HAS_BEG_OF_CELL;	/* BEG_OF_CELL was fake */
+	    /* We cannot run out of width here, so it is safe to not
+	       call Stbl_finishCellInTable(), but Stbl_finishCellInRow. */
+	    if (!finishing || (i != ncells)) {
+		if (Stbl_finishCellInRow(lastrow, s, end_td, lineno, 0) < 0) {
+		    return -1;
+		}
+	    }
+	}
+	CTRACE2(TRACE_TRST,
+		(tfp,
+		 "TRST:Stbl_fakeFinishCellInTable(lineno=%d) FINISH FAKING\n",
+		 lineno));
+	return 1;
+    }
+    return 0;
+}
+#endif
+
+/*
+ * Returns -1 on error, otherwise 0.
+ */
+int Stbl_addCellToTable(STable_info *me, int colspan,
+			int rowspan,
+			int alignment,
+			int isheader,
+			int lineno,
+			int offset_not_used_yet GCC_UNUSED,
+			int pos)
+{
+    STable_states *s = &me->s;
+    STable_rowinfo *lastrow;
+    STable_cellinfo *sumcols, *sumcol;
+    int i, icell, ncells, sumpos;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     "TRST:Stbl_addCellToTable(lineno=%d, pos=%d, isheader=%d, cs=%d, rs=%d, al=%d)\n",
+	     lineno, pos, (int) isheader, colspan, rowspan, alignment));
+    if (!me->rows || !me->nrows)
+	return -1;		/* no row started! */
+    /* ##850_fail_if_fail?? */
+    if (me->rows[me->nrows - 1].ended != ROW_not_ended) {
+	Stbl_addRowToTable(me, alignment, lineno);
+    }
+    Stbl_finishCellInTable(me, TRST_ENDCELL_ENDTD, lineno, 0, pos);
+    lastrow = me->rows + (me->nrows - 1);
+
+#ifdef EXP_NESTED_TABLES
+    if (nested_tables) {
+	/* If the last cell was finished by <BR></TD>, we need to fake an
+	   appropriate amount of cells */
+	if (!NO_AGGRESSIVE_NEWROW && pos == 0 && lastrow->ncells > 0
+	    && lastrow->cells[lastrow->ncells - 1].cLine != lineno) {
+	    int rc;
+
+	    rc = Stbl_fakeFinishCellInTable(me, lastrow, lineno, 0);
+
+	    if (rc < 0)
+		return -1;
+	    if (rc)
+		lastrow = me->rows + (me->nrows - 1);
+	}
+    }
+#endif
+    if (colspan == 0) {
+	colspan = get_remaining_colspan(lastrow, me->sumcols, me->ncolinfo,
+					colspan, me->ncols);
+    }
+    ncells = lastrow->ncells;	/* remember what it was before adding cell. */
+    icell = Stbl_addCellToRow(lastrow, me->sumcols, me->ncolinfo, s,
+			      colspan, alignment, isheader,
+			      lineno, &pos);
+    if (icell < 0)
+	return icell;
+    if (me->nrows == 1 && me->startline < lastrow->Line)
+	me->startline = lastrow->Line;
+
+    if (rowspan != 1) {
+	Stbl_reserveCellsInTable(me, icell, colspan, rowspan);
+	/* me->rows may now have been realloc'd, make lastrow valid pointer */
+	lastrow = me->rows + (me->nrows - 1);
+    }
+    lastrow->content |= HAS_BEG_OF_CELL;
+
+    {
+	int growby = 0;
+
+	while (icell + colspan + 1 >= me->allocated_sumcols + growby)
+	    growby += CELLS_GROWBY;
+	if (growby) {
+	    if (me->allocated_sumcols == 0 && !me->sumcols) {
+		sumcols = typecallocn(STable_cellinfo, (unsigned) growby);
+	    } else {
+		sumcols = typeRealloc(STable_cellinfo, me->sumcols,
+				        (unsigned) (me->allocated_sumcols + growby));
+
+		for (i = 0; sumcols && i < growby; i++) {
+		    sumcol = sumcols + me->allocated_sumcols + i;
+		    sumcol->pos = sumcols[me->allocated_sumcols - 1].pos;
+		    sumcol->len = 0;
+		    sumcol->colspan = 0;
+		    sumcol->cLine = 0;
+		    sumcol->alignment = HT_ALIGN_NONE;
+		}
+	    }
+	    if (sumcols) {
+		me->allocated_sumcols += growby;
+		me->sumcols = sumcols;
+	    } else {
+		return -1;
+	    }
+	}
+    }
+    if (icell + 1 > me->ncols) {
+	me->ncols = icell + 1;
+    }
+    if (colspan > 1 && colspan + me->sumcols[icell + colspan].colspan > 0)
+	me->sumcols[icell + colspan].colspan = -colspan;
+    sumpos = pos;
+    if (ncells > 0)
+	sumpos += me->sumcols[ncells - 1].pos - lastrow->cells[ncells - 1].pos;
+    update_sumcols0(me->sumcols, lastrow, sumpos,
+		    sumpos - me->sumcols[icell].pos,
+		    icell, 0, me->allocated_sumcols);
+
+    me->maxpos = me->sumcols[me->allocated_sumcols - 1].pos;
+    if (me->maxpos > /* @@@ max. line length we can accept */ MAX_STBL_POS)
+	return -1;
+    return 0;
+}
+
+/*
+ * Returns -1 on error, otherwise 0.
+ */
+int Stbl_finishCellInTable(STable_info *me, int end_td,
+			   int lineno,
+			   int offset,
+			   int pos)
+{
+    STable_states *s = &me->s;
+    STable_rowinfo *lastrow;
+    int len, xlen, icell;
+    int i;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp,
+	     "TRST:Stbl_finishCellInTable(lineno=%d, pos=%d, off=%d, end_td=%d)\n",
+	     lineno, pos, offset, (int) end_td));
+    if (me->nrows == 0)
+	return -1;
+    lastrow = me->rows + (me->nrows - 1);
+    icell = lastrow->ncells - 1;
+    if (icell < 0)
+	return icell;
+    if (s->x_td == -1) {	/* Stray </TD> or just-in-case, as on </TR> */
+	if ((end_td & TRST_ENDCELL_MASK) == TRST_ENDCELL_LINEBREAK)
+	    lastrow->ended = ROW_ended_by_splitline;
+	return 0;
+    }
+#ifdef EXP_NESTED_TABLES
+    if (nested_tables) {
+	if (!NO_AGGRESSIVE_NEWROW && !(end_td & TRST_FAKING_CELLS)) {
+	    int rc;
+
+	    rc = Stbl_fakeFinishCellInTable(me, lastrow, lineno, 1);
+
+	    if (rc) {
+		if (rc < 0)
+		    return -1;
+		lastrow = me->rows + (me->nrows - 1);
+		icell = lastrow->ncells - 1;
+	    }
+	}
+    }
+#endif
+    len = Stbl_finishCellInRow(lastrow, s, end_td, lineno, pos);
+    if (len == -1) {
+	return len;
+    }
+    xlen = (len > 0) ? len : s->pending_len;	/* ##890 use xlen if fixed_line?: */
+    if (lastrow->Line == lineno)
+	len = xlen;
+    if (lastrow->cells[icell].colspan > 1) {
+	/*
+	 * @@@ This is all a too-complicated mess; do we need
+	 * sumcols len at all, or is pos enough??
+	 * Answer: sumcols len is at least used for center/right
+	 * alignment, and should probably continue to be used there;
+	 * all other uses are probably not necessary.
+	 */
+	int spanlen = 0, spanlend = 0;
+
+	for (i = icell; i < icell + lastrow->cells[icell].colspan; i++) {
+	    if (me->sumcols[i].len > 0) {
+		spanlen += me->sumcols[i].len;
+		if (i > icell)
+		    spanlen++;
+	    }
+	    spanlend = HTMAX(spanlend,
+			     me->sumcols[i + 1].pos - me->sumcols[icell].pos);
+	}
+	if (spanlend)
+	    spanlend--;
+	if (spanlend > spanlen)
+	    spanlen = spanlend;
+	/* @@@ could overcount? */
+	if (len > spanlen)
+	    me->maxlen += (len - spanlen);
+    } else if (len > me->sumcols[icell].len) {
+	if (me->sumcols[icell + 1].colspan >= -1)
+	    me->maxlen += (len - me->sumcols[icell].len);
+	me->sumcols[icell].len = len;
+    }
+
+    if (len > 0) {
+	update_sumcols0(me->sumcols, lastrow, pos, len,
+			icell, lastrow->cells[icell].colspan,
+			me->allocated_sumcols);
+	me->maxpos = me->sumcols[me->allocated_sumcols - 1].pos;
+    }
+
+    if ((end_td & TRST_ENDCELL_MASK) == TRST_ENDCELL_LINEBREAK) {
+	lastrow->ended = ROW_ended_by_splitline;
+	lastrow->content |= BELIEVE_OFFSET;
+	lastrow->offset = offset;
+    }
+#ifdef EXP_NESTED_TABLES	/* maxlen may already include contribution of a cell in this column */
+    if (nested_tables) {
+	if (me->maxlen > MAX_STBL_POS) {
+	    return -1;
+	}
+    } else
+#endif
+    {
+	if (me->maxlen + (xlen - len) > MAX_STBL_POS)
+	    return -1;
+    }
+    if (me->maxpos > /* @@@ max. line length we can accept */ MAX_STBL_POS) {
+	return -1;
+    }
+
+    if (lineno != lastrow->Line) {
+	/* @@@ Do something here?  Or is it taken care of in
+	   Stbl_finishCellInRow ? */
+    }
+
+    return 0;
+}
+
+/*
+ * Returns -1 on error, otherwise 0.
+ */
+int Stbl_addColInfo(STable_info *me,
+		    int colspan,
+		    int alignment,
+		    int isgroup)
+{
+    STable_cellinfo *sumcols, *sumcol;
+    int i, icolinfo;
+
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_addColInfo(cs=%d, al=%d, isgroup=%d)\n",
+	     colspan, alignment, (int) isgroup));
+    if (isgroup) {
+	if (me->pending_colgroup_next > me->ncolinfo)
+	    me->ncolinfo = me->pending_colgroup_next;
+	me->pending_colgroup_next = me->ncolinfo + colspan;
+	if (me->ncolinfo > 0)
+	    me->sumcols[me->ncolinfo - 1].cLine = EOCOLG;
+	me->pending_colgroup_align = (short) alignment;
+    } else {
+	for (i = me->pending_colgroup_next - 1;
+	     i >= me->ncolinfo + colspan; i--)
+	    me->sumcols[i].alignment = HT_ALIGN_NONE;
+	me->pending_colgroup_next = me->ncolinfo + colspan;
+    }
+    icolinfo = me->ncolinfo;
+    if (!isgroup)
+	me->ncolinfo += colspan;
+
+    {
+	int growby = 0;
+
+	while (icolinfo + colspan + 1 >= me->allocated_sumcols + growby)
+	    growby += CELLS_GROWBY;
+	if (growby) {
+	    if (me->allocated_sumcols == 0) {
+		sumcols = typecallocn(STable_cellinfo, (unsigned) growby);
+	    } else {
+		sumcols = typeRealloc(STable_cellinfo, me->sumcols,
+				        (unsigned) (me->allocated_sumcols + growby));
+
+		for (i = 0; sumcols && i < growby; i++) {
+		    sumcol = sumcols + me->allocated_sumcols + i;
+		    sumcol->pos = sumcols[me->allocated_sumcols - 1].pos;
+		    sumcol->len = 0;
+		    sumcol->colspan = 0;
+		    sumcol->cLine = 0;
+		}
+	    }
+	    if (sumcols) {
+		me->allocated_sumcols += growby;
+		me->sumcols = sumcols;
+	    } else {
+		return -1;
+	    }
+	}
+    }
+
+    if (alignment == HT_ALIGN_NONE)
+	alignment = me->pending_colgroup_align;
+    for (i = icolinfo; i < icolinfo + colspan; i++) {
+	me->sumcols[i].alignment = alignment;
+    }
+    return 0;
+}
+
+/*
+ * Returns -1 on error, otherwise 0.
+ */
+int Stbl_finishColGroup(STable_info *me)
+{
+    CTRACE2(TRACE_TRST, (tfp, "TRST:Stbl_finishColGroup()\n"));
+    if (me->pending_colgroup_next >= me->ncolinfo) {
+	me->ncolinfo = me->pending_colgroup_next;
+	if (me->ncolinfo > 0)
+	    me->sumcols[me->ncolinfo - 1].cLine = EOCOLG;
+    }
+    me->pending_colgroup_next = 0;
+    me->pending_colgroup_align = HT_ALIGN_NONE;
+    return 0;
+}
+
+int Stbl_addRowGroup(STable_info *me, int alignment)
+{
+    CTRACE2(TRACE_TRST, (tfp, "TRST:Stbl_addRowGroup()\n"));
+    Stbl_cancelRowSpans(me);
+    me->rowgroup_align = (short) alignment;
+    return 0;			/* that's all! */
+}
+
+int Stbl_finishTABLE(STable_info *me)
+{
+    STable_states *s = &me->s;
+    int i;
+    int curpos = 0;
+
+    CTRACE2(TRACE_TRST, (tfp, "TRST:Stbl_finishTABLE()\n"));
+    if (!me || me->nrows <= 0 || me->ncols <= 0) {
+	return -1;
+    }
+    if (me->nrows > 0 && me->rows[me->nrows - 1].ncells > 0) {
+	if (s->pending_len > 0)
+	    me->rows[me->nrows - 1].cells[
+					     me->rows[me->nrows - 1].ncells - 1
+		].len = s->pending_len;
+	s->pending_len = 0;
+    }
+    Stbl_finishRowInTable(me);
+    /* take into account offsets on multi-line cells.
+       XXX We cannot do it honestly, since two cells on the same row may
+       participate in multi-line table entries, and we preserve only
+       one offset per row.  This implementation may ignore
+       horizontal offsets for the last row of a multirow table entry.  */
+    for (i = 0; i < me->nrows - 1; i++) {
+	int j = i + 1, leading = i, non_empty = 0;
+	STable_rowinfo *nextrow = me->rows + j;
+	int minoffset, have_offsets;
+	int foundcell = -1, max_width;
+
+	if ((nextrow->content & (IS_CONTINUATION_OF_CELL | HAS_BEG_OF_CELL | BELIEVE_OFFSET))
+	    != (IS_CONTINUATION_OF_CELL | BELIEVE_OFFSET))
+	    continue;		/* Not a continuation line */
+	minoffset = nextrow[-1].offset;		/* Line before first continuation */
+	CTRACE2(TRACE_TRST, (tfp,
+			     "TRST:Stbl_finishTABLE, l=%d, offset=%d, ended=%u.\n",
+			     i, nextrow[-1].offset, nextrow[-1].ended));
+
+	/* Find the common part of the requested offsets */
+	while (j < me->nrows
+	       && ((nextrow->content &
+		    (IS_CONTINUATION_OF_CELL
+		     | HAS_BEG_OF_CELL
+		     | BELIEVE_OFFSET))
+		   == (IS_CONTINUATION_OF_CELL | BELIEVE_OFFSET))) {
+	    if (minoffset > nextrow->offset)
+		minoffset = nextrow->offset;
+	    CTRACE2(TRACE_TRST,
+		    (tfp,
+		     "TRST:Stbl_finishTABLE, l=%d, offset=%d, ended=%u.\n",
+		     j, nextrow->offset, nextrow[-1].ended));
+	    nextrow++;
+	    j++;
+	}
+	i = j - 1;		/* Continue after this line */
+	/* Cancel the common part of offsets */
+	j = leading;		/* Restart */
+	nextrow = me->rows + j;	/* Line before first continuation */
+	have_offsets = 0;
+	nextrow->content |= OFFSET_IS_VALID_LAST_CELL;
+	while (j <= i) {	/* A continuation line */
+	    nextrow->offset -= minoffset;
+	    nextrow->content |= OFFSET_IS_VALID;
+	    if (nextrow->offset)
+		have_offsets = 1;
+	    nextrow++;
+	    j++;
+	}
+	if (!have_offsets)
+	    continue;		/* No offsets to deal with */
+
+	/* Find the cell number */
+	foundcell = -1;
+	j = leading + 1;	/* Restart */
+	nextrow = me->rows + j;	/* First continuation line */
+	while (foundcell == -1 && j <= i) {	/* A continuation line */
+	    int curcell = -1;
+
+	    while (foundcell == -1 && ++curcell < nextrow->ncells)
+		if (nextrow->cells[curcell].len)
+		    foundcell = curcell, non_empty = j;
+	    nextrow++;
+	    j++;
+	}
+	if (foundcell == -1)	/* Can it happen? */
+	    continue;
+	/* Find the max width */
+	max_width = 0;
+	j = leading;		/* Restart */
+	nextrow = me->rows + j;	/* Include the pre-continuation line */
+	while (j <= i) {	/* A continuation line */
+	    if (nextrow->ncells > foundcell) {
+		int curwid = nextrow->cells[foundcell].len + nextrow->offset;
+
+		if (curwid > max_width)
+		    max_width = curwid;
+	    }
+	    nextrow++;
+	    j++;
+	}
+	/* Update the widths */
+	j = non_empty;		/* Restart from the first nonempty */
+	nextrow = me->rows + j;
+	/* Register the increase of the width */
+	update_sumcols0(me->sumcols, me->rows + non_empty,
+			0 /* width only */ , max_width,
+			foundcell, nextrow->cells[foundcell].colspan,
+			me->allocated_sumcols);
+	j = leading;		/* Restart from pre-continuation */
+	nextrow = me->rows + j;
+	while (j <= i) {	/* A continuation line */
+	    if (nextrow->ncells > foundcell)
+		nextrow->cells[foundcell].len = max_width;
+	    nextrow++;
+	    j++;
+	}
+    }				/* END of Offsets processing */
+
+    for (i = 0; i < me->ncols; i++) {
+	if (me->sumcols[i].pos < curpos) {
+	    me->sumcols[i].pos = curpos;
+	} else {
+	    curpos = me->sumcols[i].pos;
+	}
+	if (me->sumcols[i].len > 0) {
+	    curpos += me->sumcols[i].len;
+	}
+    }
+    /* need to recheck curpos: though it is checked each time a cell
+       is added, sometimes the result is ignored, as in split_line(). */
+    return (curpos > MAX_STBL_POS ? -1 : me->ncols);
+}
+
+short Stbl_getAlignment(STable_info *me)
+{
+    return (short) (me ? me->alignment : HT_ALIGN_NONE);
+}
+
+static int get_fixup_positions(STable_rowinfo *me, int *oldpos,
+			       int *newpos,
+			       STable_cellinfo *sumcols)
+{
+    int i = 0, ip = 0;
+    int next_i, newlen;
+    int ninserts;
+
+    if (!me)
+	return -1;
+    while (i < me->ncells) {
+	int offset;
+
+	next_i = i + HTMAX(1, me->cells[i].colspan);
+	if (me->cells[i].cLine != me->Line) {
+	    if (me->cells[i].cLine > me->Line)
+		break;
+	    i = next_i;
+	    continue;
+	}
+	oldpos[ip] = me->cells[i].pos;
+	if ((me->content & OFFSET_IS_VALID)
+	    && (i == me->ncells - 1
+		|| !((me->content & OFFSET_IS_VALID_LAST_CELL))))
+	    offset = me->offset;
+	else
+	    offset = 0;
+	newpos[ip] = sumcols[i].pos + offset;
+	if ((me->cells[i].alignment == HT_CENTER ||
+	     me->cells[i].alignment == HT_RIGHT) &&
+	    me->cells[i].len > 0) {
+	    newlen = sumcols[next_i].pos - newpos[ip] - 1;
+	    newlen = HTMAX(newlen, sumcols[i].len);
+	    if (me->cells[i].len < newlen) {
+		if (me->cells[i].alignment == HT_RIGHT) {
+		    newpos[ip] += newlen - me->cells[i].len;
+		} else {
+		    newpos[ip] += (newlen - me->cells[i].len) / 2;
+		}
+	    }
+	}
+	ip++;
+	i = next_i;
+    }
+    ninserts = ip;
+    return ninserts;
+}
+
+/*
+ * Returns -1 if we have no row for this lineno, or for other error,
+ *	    0 or greater (number of oldpos/newpos pairs) if we have
+ *	      a table row.
+ */
+int Stbl_getFixupPositions(STable_info *me, int lineno,
+			   int *oldpos,
+			   int *newpos)
+{
+    STable_rowinfo *row;
+    int j;
+    int ninserts = -1;
+
+    if (!me || !me->nrows)
+	return -1;
+    for (j = 0; j < me->nrows; j++) {
+	row = me->rows + j;
+	if (row->Line == lineno) {
+	    ninserts = get_fixup_positions(row, oldpos, newpos,
+					   me->sumcols);
+	    break;
+	}
+    }
+    return ninserts;
+}
+
+int Stbl_getStartLine(STable_info *me)
+{
+    if (!me)
+	return -1;
+    else
+	return me->startline;
+}
+
+#ifdef EXP_NESTED_TABLES
+
+int Stbl_getStartLineDeep(STable_info *me)
+{
+    if (!me)
+	return -1;
+    while (me->enclosing)
+	me = me->enclosing;
+    return me->startline;
+}
+
+void Stbl_update_enclosing(STable_info *me, int max_width,
+			   int last_lineno)
+{
+    int l;
+
+    if (!me || !me->enclosing || !max_width)
+	return;
+    CTRACE2(TRACE_TRST,
+	    (tfp, "TRST:Stbl_update_enclosing, width=%d, lines=%d...%d.\n",
+	     max_width, me->startline, last_lineno));
+    for (l = me->startline; l <= last_lineno; l++) {
+	/* Fake <BR> in appropriate positions */
+	if (Stbl_finishCellInTable(me->enclosing,
+				   TRST_ENDCELL_LINEBREAK,
+				   l,
+				   0,
+				   max_width) < 0) {
+	    /* It is not handy to let the caller delete me->enclosing,
+	       and it does not buy us anything.  Do it directly. */
+	    STable_info *stbl = me->enclosing;
+
+	    CTRACE2(TRACE_TRST, (tfp,
+				 "TRST:Stbl_update_enclosing: width too large, aborting enclosing\n"));
+	    me->enclosing = 0;
+	    while (stbl) {
+		STable_info *enclosing = stbl->enclosing;
+
+		Stbl_free(stbl);
+		stbl = enclosing;
+	    }
+	    break;
+	}
+    }
+    return;
+}
+
+void Stbl_set_enclosing(STable_info *me, STable_info *enclosing, struct _TextAnchor *enclosing_last_anchor_before_stbl)
+{
+    if (!me)
+	return;
+    me->enclosing = enclosing;
+    me->enclosing_last_anchor_before_stbl = enclosing_last_anchor_before_stbl;
+}
+
+STable_info *Stbl_get_enclosing(STable_info *me)
+{
+    if (!me)
+	return 0;
+    return me->enclosing;
+}
+
+struct _TextAnchor *Stbl_get_last_anchor_before(STable_info *me)
+{
+    if (!me)
+	return 0;
+    return me->enclosing_last_anchor_before_stbl;
+}
+#endif