Lout 3.17.

git-svn-id: http://svn.savannah.nongnu.org/svn/lout/trunk@2 9365b830-b601-4143-9ba8-b4a8e2c3339c

1 files changed, 971 insertions, 0 deletions

diff --git a/z20.c b/z20.c
new file mode 100644
index 0000000..405599a
--- /dev/null
+++ b/z20.c
@@ -0,0 +1,971 @@
+/*@z20.c:Galley Flushing:DebugInnersNames()@**********************************/
+/*                                                                           */
+/*  THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.17)                       */
+/*  COPYRIGHT (C) 1991, 1999 Jeffrey H. Kingston                             */
+/*                                                                           */
+/*  Jeffrey H. Kingston (jeff@cs.usyd.edu.au)                                */
+/*  Basser Department of Computer Science                                    */
+/*  The University of Sydney 2006                                            */
+/*  AUSTRALIA                                                                */
+/*                                                                           */
+/*  This program is free software; you can redistribute it and/or modify     */
+/*  it under the terms of the GNU General Public License as published by     */
+/*  the Free Software Foundation; either Version 2, or (at your option)      */
+/*  any later version.                                                       */
+/*                                                                           */
+/*  This program is distributed in the hope that it will be useful,          */
+/*  but WITHOUT ANY WARRANTY; without even the implied warranty of           */
+/*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            */
+/*  GNU General Public License for more details.                             */
+/*                                                                           */
+/*  You should have received a copy of the GNU General Public License        */
+/*  along with this program; if not, write to the Free Software              */
+/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA   */
+/*                                                                           */
+/*  FILE:         z20.c                                                      */
+/*  MODULE:       Galley Flushing                                            */
+/*  EXTERNS:      FlushGalley()                                              */
+/*                                                                           */
+/*****************************************************************************/
+#include "externs.h"
+
+#if DEBUG_ON
+FULL_CHAR *DebugInnersNames(OBJECT inners)
+{ static FULL_CHAR buff[MAX_BUFF];
+  OBJECT link, y, z;
+  StringCopy(buff, STR_EMPTY);
+  if( inners != nilobj )
+  { for( link = Down(inners);  link != inners;  link = NextDown(link) )
+    { Child(y, link);
+      if( link != Down(inners) )  StringCat(buff, STR_SPACE);
+      switch( type(y) )
+      {
+
+        case RECEIVING:
+        case UNATTACHED:
+      
+	  assert( Down(y) != y, "DebugInnersNames: UNATTACHED!");
+	  Child(z, Down(y));
+          StringCat(buff, SymName(actual(z)));
+	  break;
+
+
+        case PRECEDES:
+        case GALL_PREC:
+        case DEAD:
+      
+	  StringCat(buff, Image(type(y)));
+	  break;
+
+
+        default:
+      
+	  assert1(FALSE, "DebugInnersNames:", Image(type(y)));
+	  break;
+      }
+    }
+  }
+  return buff;
+} /* end DebugInnersNames */
+#endif
+
+
+/*@::ParentFlush(), FlushGalley()@********************************************/
+/*                                                                           */
+/*  ParentFlush(prnt_flush, dest_index, kill)                                */
+/*                                                                           */
+/*  Flush the galley which is the parent of dest_index, if likely to flush.  */
+/*  If kill is TRUE, delete dest_index.                                      */
+/*                                                                           */
+/*****************************************************************************/
+
+static void ParentFlush(BOOLEAN prnt_flush, OBJECT dest_index, BOOLEAN kill)
+{ OBJECT prnt;
+  debug3(DGF, D, "ParentFlush(%s, %s, %s)",
+    bool(prnt_flush), EchoIndex(dest_index), bool(kill));
+  if( prnt_flush )
+  { Parent(prnt, Up(dest_index));
+    if( kill )  DeleteNode(dest_index);
+    debug0(DGF, D, "  calling FlushGalley from ParentFlush");
+    FlushGalley(prnt);
+  }
+  else if( kill )  DeleteNode(dest_index)
+  debug0(DGF, D, "ParentFlush returning.");
+} /* end ParentFlush */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  FlushGalley(hd)                                                          */
+/*                                                                           */
+/*  Flush galley hd as far as possible.  It could be the root galley.        */
+/*                                                                           */
+/*****************************************************************************/
+
+void FlushGalley(OBJECT hd)
+{ OBJECT dest;			/* the target galley hd empties into         */
+  OBJECT dest_index;		/* the index of dest                         */
+  OBJECT inners;		/* list of galleys and PRECEDES to flush     */
+  OBJECT link, y;		/* for scanning through the components of hd */
+  int dim;			/* direction of galley                       */
+  CONSTRAINT dest_par_constr;	/* the parallel size constraint on dest      */
+  CONSTRAINT dest_perp_constr;	/* the perpendicular size constraint on dest */
+  int pb, pf, f;		/* candidate replacement sizes for dest      */
+
+  OBJECT dest_encl;		/* the VCAT or ACAT enclosing dest, if any   */
+  int    dest_side;		/* if dest_encl != nilobj, side dest is on   */
+  BOOLEAN need_adjust;		/* TRUE as soon as dest_encl needs adjusting */
+  FULL_LENGTH dest_back, dest_fwd; /* the current size of dest_encl or dest  */
+  FULL_LENGTH frame_size;	/* the total constraint of dest_encl         */
+  OBJECT prec_gap;		/* the gap preceding dest if any else nilobj */
+  OBJECT prec_def;		/* the component preceding dest, if any      */
+  OBJECT succ_gap;		/* the gap following dest if any else nilobj */
+  OBJECT succ_def;		/* the component following dest, if any      */
+  OBJECT stop_link;		/* most recently seen gap link of hd         */
+  FULL_LENGTH stop_back;        /* back(dest_encl) incl all before stop_link */
+  FULL_LENGTH stop_fwd;         /* fwd(dest_encl) incl. all before stop_link */
+  FULL_LENGTH stop_perp_back;   /* back(dest_encl) in other direction        */
+  FULL_LENGTH stop_perp_fwd;    /* fwd(dest_encl) in other direction         */
+  BOOLEAN prnt_flush;		/* TRUE when the parent of hd needs a flush  */
+  BOOLEAN target_is_internal;   /* TRUE if flushing into an internal target  */
+  OBJECT zlink, z, tmp, prnt;  int attach_status;  BOOLEAN remove_target;
+  OBJECT why;
+  FULL_LENGTH perp_back, perp_fwd;  /* current perp size of dest_encl        */
+
+  debug1(DGF, D, "[ FlushGalley %s (hd)", SymName(actual(hd)));
+  prnt_flush = FALSE;
+  dim = gall_dir(hd);
+
+  RESUME:
+  assert( type(hd) == HEAD, "FlushGalley: type(hd) != HEAD!" );
+  debug1(DGF, D, "  resuming FlushGalley %s, hd =", SymName(actual(hd)));
+  ifdebugcond(DGF, D, actual(hd) == nilobj, DebugGalley(hd, nilobj, 4));
+  assert( Up(hd) != hd, "FlushGalley: resume found no parent to hd!" );
+
+
+  /*@@************************************************************************/
+  /*                                                                         */
+  /*  The first step is to examine the parent of galley hd to determine the  */
+  /*  status of the galley.  If this is not suitable for flushing, we do     */
+  /*  what we can to change the status.  If still no good, return; so if     */
+  /*  this code does not return, then the galley is ready to flush into a    */
+  /*  destination in the normal way, and the following variables are set:    */
+  /*                                                                         */
+  /*     dest_index   the parent of the galley and index of its destination  */
+  /*     dest         the destination of the galley, a @Galley object        */
+  /*                                                                         */
+  /***************************************************************************/
+
+  Parent(dest_index, Up(hd));
+  switch( type(dest_index) )
+  {
+
+    case DEAD:
+    
+      /* the galley has been killed off while this process was sleeping */
+      debug1(DGF, D, "] FlushGalley %s returning (DEAD)", SymName(actual(hd)));
+      return;
+
+
+    case UNATTACHED:
+    
+      /* the galley is currently not attached to a destination */
+      attach_status = AttachGalley(hd, &inners, &y);
+      debug1(DGF, D, "  ex-AttachGalley inners: %s", DebugInnersNames(inners));
+      Parent(dest_index, Up(hd));
+      switch( attach_status )
+      {
+
+	case ATTACH_KILLED:
+
+	  assert(inners==nilobj, "FlushGalley/ATTACH_KILLED: inners!=nilobj!");
+	  debug1(DGF, D, "] FlushGalley %s returning (ATTACH_KILLED)",
+	    SymName(actual(hd)));
+	  debug1(DGF, D, "    prnt_flush = %s", bool(prnt_flush));
+	  return;
+
+
+	case ATTACH_INPUT:
+
+	  ParentFlush(prnt_flush, dest_index, FALSE);
+	  assert(inners==nilobj, "FlushGalley/ATTACH_INPUT: inners!=nilobj!");
+	  debug1(DGF, D, "] FlushGalley %s returning (ATTACH_INPUT)",
+	    SymName(actual(hd)));
+	  return;
+
+
+	case ATTACH_NOTARGET:
+
+	  ParentFlush(prnt_flush, dest_index, FALSE);
+	  assert(inners==nilobj, "FlushGalley/ATTACH_NOTARG: inners!=nilobj!");
+	  debug1(DGF, D, "] FlushGalley %s returning (ATTACH_NOTARGET)",
+	    SymName(actual(hd)));
+	  return;
+
+
+	case ATTACH_SUSPEND:
+
+	  /* AttachGalley only returns inners here if they really need to */
+	  /* be flushed; in particular the galley must be unsized before  */
+	  if( inners != nilobj )
+	  {
+	    debug0(DGF, D, "  calling FlushInners() from FlushGalley (a)");
+	    FlushInners(inners, nilobj);
+	    goto RESUME;
+	  }
+	  stop_link = nilobj;
+	  goto SUSPEND;	/* nb y will be set by AttachGalley in this case */
+
+
+	case ATTACH_NULL:
+
+	  /* hd will have been linked to the unexpanded target in this case */
+	  remove_target = (actual(actual(dest_index)) == whereto(hd));
+          if( force_gall(hd) )
+          {
+            /* if hd is a forcing galley, close all predecessors */
+	    debug3(DGA, D, "  forcing ATTACH_NULL case for %s into %s (%s)",
+	      SymName(actual(hd)), SymName(whereto(hd)),
+	      remove_target ? "remove_target" : "not remove_target");
+	    Parent(prnt, Up(dest_index));
+	    if( !non_blocking(dest_index) && remove_target )
+	    {
+	      /* ***
+	      prnt_flush = TRUE;
+	      *** */
+	      prnt_flush = non_blocking(dest_index) = TRUE;
+	    }
+	    FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
+	      whereto(hd));
+          }
+          else
+	  {
+	    debug3(DGA, D, "  non-force ATTACH_NULL case for %s into %s (%s)",
+	      SymName(actual(hd)), SymName(whereto(hd)),
+	      remove_target ? "remove_target" : "not remove_target");
+	    if( blocked(dest_index) && remove_target )  prnt_flush = TRUE;
+	  }
+	  DetachGalley(hd);
+	  KillGalley(hd, TRUE);
+          if( inners != nilobj )
+	  {
+	    debug0(DGF, D, "  calling FlushInners() from FlushGalley (b)");
+	    FlushInners(inners, nilobj);
+	  }
+	  else ParentFlush(prnt_flush, dest_index, remove_target);
+	  debug0(DGF, D, "] FlushGalley returning ATTACH_NULL");
+	  return;
+
+
+	case ATTACH_ACCEPT:
+
+          /* if hd is a forcing galley, or actual(dest_index) is   */
+	  /* @ForceGalley, then close all predecessors             */
+          if( force_gall(hd) || actual(actual(dest_index)) == ForceGalleySym )
+          { Parent(prnt, Up(dest_index));
+	    debug1(DGA, D, "  forcing ATTACH_ACCEPT case for %s",
+	      SymName(actual(hd)));
+	    /* debug0(DGA, DD, "  force: prnt ="); */
+	    /* ifdebug(DGA, DD, DebugObject(prnt)); */
+	    /* debug1(DGA, D,"  calling FreeGalley from FlushGalley(%s)", */
+	    /*   SymName(actual(hd))); */
+	    if( !non_blocking(dest_index) )  prnt_flush = TRUE; /* bug fix */
+	    FreeGalley(prnt, Up(dest_index), &inners, Up(dest_index),
+	      whereto(hd));
+	    /* debug0(DGA, DD, "  force: after FreeGalley, prnt ="); */
+	    /* ifdebug(DGA, DD, DebugObject(prnt)); */
+          }
+          else prnt_flush = prnt_flush || blocked(dest_index);
+          debug1(DGF, D, "    force: prnt_flush = %s", bool(prnt_flush));
+          if( inners != nilobj )
+	  {
+	    debug0(DGF, D, "  calling FlushInners() from FlushGalley (c)");
+	    FlushInners(inners, nilobj);
+	  }
+          goto RESUME;
+
+
+	default:
+
+	  assert(FALSE, "FlushGalley: attach_status");
+	  break;
+
+      }
+      break;
+
+
+    case RECEIVING:
+    
+      if( actual(actual(dest_index)) == InputSym )
+      { ParentFlush(prnt_flush, dest_index, FALSE);
+	debug1(DGF, D, "] FlushGalley %s retn, input", SymName(actual(hd)));
+	return;
+      }
+      break;
+
+
+    default:
+    
+      assert1(FALSE, "FlushGalley: dest_index", Image(type(dest_index)));
+      break;
+  }
+  dest = actual(dest_index);
+  if( underline(dest) == UNDER_UNDEF )  underline(dest) = UNDER_OFF;
+  target_is_internal =
+    (dim==ROWM && !external_ver(dest)) || (dim==COLM && !external_hor(dest));
+  debug1(DGF, DD, "  dest_index: %s", EchoObject(dest_index));
+
+
+  /*@@************************************************************************/
+  /*                                                                         */
+  /*  The second step is to examine the components of the galley one by one  */
+  /*  to determine if they can be promoted.  Each component has the format   */
+  /*                                                                         */
+  /*    { <index> } <object>                                                 */
+  /*                                                                         */
+  /*  and is always followed by a gap object (except the last component).    */
+  /*  An index indicates that the following object has some interesting      */
+  /*  feature, and it points to that feature inside the object.  There are   */
+  /*  two possible actions for each component, in addition to accepting it:  */
+  /*                                                                         */
+  /*    REJECT:   The component does not fit, so detach the galley           */
+  /*    SUSPEND:  The component is incomplete; go to sleep and wait          */
+  /*                                                                         */
+  /***************************************************************************/
+
+  stop_link = dest_encl = inners = nilobj;
+  need_adjust = FALSE;
+
+  /***************************************************************************/
+  /*                                                                         */
+  /*  Loop invariant                                                         */
+  /*                                                                         */
+  /*  The children of hd up to but not including Child(link) have been       */
+  /*  examined and pronounced to be promotable, if unbreakable gaps are      */
+  /*  ignored.  When unbreakable gaps are taken into account, the most       */
+  /*  recent gap where a break is possible is at Child(stop_link), or        */
+  /*  nowhere if stop_link == nilobj.                                        */
+  /*                                                                         */
+  /*  Case 1:  target_is_internal == FALSE                                   */
+  /*                                                                         */
+  /*  If this flag is FALSE, it means that the target of this galley is      */
+  /*  external.  Consequently, there is no need to calculate sizes because   */
+  /*  there is no constraint on them.  Also, a REJECT action is impossible   */
+  /*  so unbreakable gaps are no impediment.  Variable dest_encl is nilobj.  */
+  /*                                                                         */
+  /*  Case 2:  target_is_internal == TRUE                                    */
+  /*                                                                         */
+  /*  If this flag is TRUE, it means that the target of this galley is       */
+  /*  internal.  Consequently, sizes need to be calculated, and unbreakable  */
+  /*  gaps need to be taken into account.  Variable dest_encl may be not     */
+  /*  nilobj, in which case the following variables are defined:             */
+  /*                                                                         */
+  /*    dest_encl        the object enclosing dest (which must exist)        */
+  /*    prec_gap         gap object preceding dest (which must exist)        */
+  /*    prec_def         first definite object preceding dest (must exist)   */
+  /*    dest_back        back(dest_encl) including effect of accepted compts */
+  /*    dest_fwd         fwd(dest_encl) including effect of accepted compts  */
+  /*    dest_side        BACK or FWD, i.e. which side of the mark dest is on */
+  /*    dest_par_constr  the parallel size constraint on dest                */
+  /*    dest_perp_constr the perpendicular size constraint on dest           */
+  /*    frame_size       size of frame enclosing dest_encl                   */
+  /*    perp_back        back(dest_encl) in other direction, incl accepteds  */
+  /*    perp_fwd         fwd(dest_encl) in other direction,  incl accepteds  */
+  /*                                                                         */
+  /*  if dest_encl is nilobj, these variables are not defined.               */
+  /*                                                                         */
+  /*  If stop_link is non-nilobj, then in the internal case dest_encl must   */
+  /*  be non-nilobj, and the following variables are defined:                */
+  /*                                                                         */
+  /*    stop_back        back(dest_encl) including all before stop_link      */
+  /*    stop_fwd         fwd(dest_encl)  including all before stop_link      */
+  /*    stop_perp_back   back(dest_encl) in other direction                  */
+  /*    stop_perp_fwd    fwd(dest_encl) in other direction                   */
+  /*                                                                         */
+  /*  need_adjust is true if at least one definite component has been        */
+  /*  accepted for promotion and the destination is internal; hence,         */
+  /*  dest_encl is defined and its size needs to be adjusted.                */
+  /*                                                                         */
+  /*  inners is the set of all PRECEDES and UNATTACHED indexes found.        */
+  /*                                                                         */
+  /***************************************************************************/
+
+  for( link = Down(hd);  link != hd;  link = NextDown(link) )
+  {
+    Child(y, link);
+    if( type(y) == SPLIT )  Child(y, DownDim(y, dim));
+    debug2(DGF, DD, "  examining %s %s", Image(type(y)), EchoObject(y));
+    switch( type(y) )
+    {
+
+      case GAP_OBJ:
+
+	underline(y) = underline(dest);
+	prec_gap = y;
+	if( target_is_internal )
+	{ assert( dest_encl != nilobj, "FlushGalley/GAP_OBJ: dest_encl!" );
+	  if( !nobreak(gap(prec_gap)) )
+	  {
+	    stop_link = link;
+	    stop_back = dest_back;
+	    stop_fwd  = dest_fwd;
+	    stop_perp_back = perp_back;
+	    stop_perp_fwd = perp_fwd;
+	  }
+	}
+	else stop_link = link;
+	if( !join(gap(y)) )  seen_nojoin(hd) = TRUE;
+	break;
+
+
+      case SCALE_IND:
+      case COVER_IND:
+      case EXPAND_IND:
+      case GALL_PREC:
+      case GALL_FOLL:
+      case GALL_FOLL_OR_PREC:
+      case GALL_TARG:
+      case CROSS_PREC:
+      case CROSS_FOLL:
+      case CROSS_FOLL_OR_PREC:
+      case CROSS_TARG:
+      case PAGE_LABEL_IND:
+
+	underline(y) = underline(dest);
+	break;
+
+
+      case PRECEDES:
+      case UNATTACHED:
+	  
+	if( inners == nilobj )  New(inners, ACAT);
+	Link(inners, y);
+	break;
+
+
+      case RECEIVING:
+      case RECEPTIVE:
+	  
+	goto SUSPEND;
+
+
+      case FOLLOWS:
+	  
+	Child(tmp, Down(y));
+	if( Up(tmp) == LastUp(tmp) )
+	{ link = PrevDown(link);
+	  DisposeChild(NextDown(link));
+	  break;
+	}
+	Parent(tmp, Up(tmp));
+	assert(type(tmp) == PRECEDES, "Flush: PRECEDES!");
+	switch( CheckComponentOrder(tmp, dest_index) )
+	{
+	  case CLEAR:	DeleteNode(tmp);
+			link = PrevDown(link);
+			DisposeChild(NextDown(link));
+			break;
+
+	  case PROMOTE:	break;
+
+	  case BLOCK:	goto SUSPEND;
+
+	  case CLOSE:	if( opt_components(hd) != nilobj )
+			{ DisposeObject(opt_components(hd));
+			  opt_components(hd) = nilobj;
+			  debug2(DOG, D, "FlushGalley(%s) de-optimizing %s",
+			    "(CLOSE problem)", SymName(actual(hd)));
+			}
+			debug1(DGF, D, "  reject (a) %s", EchoObject(y));
+			goto REJECT;
+	}
+	break;
+
+
+      case NULL_CLOS:
+      case PAGE_LABEL:
+      case WORD:
+      case QWORD:
+      case ONE_COL:
+      case ONE_ROW:
+      case WIDE:
+      case HIGH:
+      case HSHIFT:
+      case VSHIFT:
+      case HSCALE:
+      case VSCALE:
+      case HCOVER:
+      case VCOVER:
+      case HCONTRACT:
+      case VCONTRACT:
+      case HLIMITED:
+      case VLIMITED:
+      case HEXPAND:
+      case VEXPAND:
+      case START_HVSPAN:
+      case START_HSPAN:
+      case START_VSPAN:
+      case HSPAN:
+      case VSPAN:
+      case ROTATE:
+      case BACKGROUND:
+      case SCALE:
+      case KERN_SHRINK:
+      case INCGRAPHIC:
+      case SINCGRAPHIC:
+      case PLAIN_GRAPHIC:
+      case GRAPHIC:
+      case ACAT:
+      case HCAT:
+      case VCAT:
+      case ROW_THR:
+      case CLOSURE:
+      case CROSS:
+      case FORCE_CROSS:
+
+	underline(y) = underline(dest);
+	if( dim == ROWM )
+	{
+	  /* make sure y is not joined to a target below (vertical case only) */
+	  for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
+	  { Child(z, zlink);
+	    switch( type(z) )
+	    {
+	      case RECEPTIVE:
+	      case RECEIVING:	y = z;
+				goto SUSPEND;
+
+	      case GAP_OBJ:	if( !join(gap(z)) )  zlink = PrevDown(hd);
+				break;
+
+	      default:		break;
+	    }
+	  }
+
+	  /* try vertical hyphenation before anything else */
+	  if( type(y) == HCAT )  VerticalHyphenate(y);
+
+	}
+
+	/* check size constraint */
+	if( target_is_internal )
+	{
+	  /* initialise dest_encl etc if not done yet */
+	  if( dest_encl == nilobj )
+	  { assert( UpDim(dest,1-dim) == UpDim(dest,dim), "FlushG: UpDims!" );
+	    /* *** weird old code, trying for UpDim(dest, ROWM)?
+	    Parent(dest_encl, NextDown(Up(dest)));
+	    *** */
+	    Parent(dest_encl, Up(dest));
+	    debug4(DGF, D, "  flush dest = %s %s, dest_encl = %s %s",
+	      Image(type(dest)), EchoObject(dest),
+	      Image(type(dest_encl)), EchoObject(dest_encl));
+	    assert( (dim==ROWM && type(dest_encl)==VCAT) ||
+	            (dim==COLM && type(dest_encl)==ACAT),
+	      "FlushGalley: dest != VCAT or ACAT!" );
+	    SetNeighbours(Up(dest), FALSE, &prec_gap, &prec_def,
+	      &succ_gap, &succ_def, &dest_side);
+	    assert(prec_gap != nilobj || is_indefinite(type(y)),
+	      "FlushGalley: prec_gap == nilobj && !is_indefinite(type(y))!" );
+	    assert(succ_gap == nilobj, "FlushGalley: succ_gap != nilobj!" );
+	    assert(dest_side == FWD || is_indefinite(type(y)),
+	      "FlushGalley: dest_side != FWD || !is_indefinite(type(y))!");
+	    dest_back = back(dest_encl, dim);
+	    dest_fwd  = fwd(dest_encl, dim);
+	    perp_back = back(dest_encl, 1-dim);
+	    perp_fwd  = fwd(dest_encl, 1-dim);
+	    Constrained(dest_encl, &dest_par_constr, dim, &why);
+	    Constrained(dest_encl, &dest_perp_constr, 1-dim, &why);
+	    debug1(DGF, D, "  setting dest_perp_constr = %s",
+	      EchoConstraint(&dest_perp_constr));
+	    frame_size = constrained(dest_par_constr) ? bfc(dest_par_constr) :0;
+	  }
+
+	  if( !is_indefinite(type(y)) )
+	  {
+	    ifdebugcond(DGF, D,  mode(gap(prec_gap)) == NO_MODE,
+	      DebugGalley(hd, y, 4));
+
+	    /* calculate parallel effect of adding y to dest */
+	    f = dest_fwd  + fwd(y, dim) - fwd(prec_def, dim) +
+		  ActualGap(fwd(prec_def, dim), back(y, dim),
+			fwd(y, dim), &gap(prec_gap), frame_size,
+			dest_back + dest_fwd - fwd(prec_def, dim));
+	    debug5(DGF, D, "  f = %s + %s - %s + %s (prec_gap %s)",
+	      EchoLength(dest_fwd), EchoLength(fwd(y, dim)),
+	      EchoLength(fwd(prec_def, dim)), EchoLength(
+		  ActualGap(fwd(prec_def, dim), back(y, dim),
+			fwd(y, dim), &gap(prec_gap), frame_size,
+			dest_back + dest_fwd - fwd(prec_def, dim))
+	      ), EchoGap(&gap(prec_gap)));
+	    debug3(DGF, D, "  b,f: %s,%s;   dest_encl: %s",
+			EchoLength(dest_back), EchoLength(f),
+			EchoConstraint(&dest_par_constr));
+
+	    /* check new size against parallel constraint */
+	    if( (units(gap(prec_gap))==FRAME_UNIT && width(gap(prec_gap)) > FR)
+	        || !FitsConstraint(dest_back, f, dest_par_constr)
+		|| (opt_components(hd) != nilobj && opt_comps_permitted(hd)<=0)
+	      )
+	    {
+	      if( opt_components(hd) != nilobj )
+	      { OBJECT z;
+
+		/* record the size of this just-completed target area for hd */
+		New(z, WIDE);
+		CopyConstraint(constraint(z), dest_par_constr);
+		Link(opt_constraints(hd), z);
+		ifdebug(DOG, D,
+		  debug2(DOG, D, "FlushGalley(%s) adding constraint %s",
+		    SymName(actual(hd)), EchoConstraint(&constraint(z)));
+		  if( units(gap(prec_gap))==FRAME_UNIT &&
+		      width(gap(prec_gap)) > FR ) 
+		  { debug1(DOG, D, "  prec_gap = %s", EchoGap(&gap(prec_gap)));
+		  }
+		  if( !FitsConstraint(dest_back, f, dest_par_constr) )
+		  { debug3(DOG, D, "  !FitsConstraint(%s, %s, %s)",
+		      EchoLength(dest_back), EchoLength(f),
+		      EchoConstraint(&dest_par_constr));
+		  }
+		  if( opt_comps_permitted(hd) <= 0 )
+		  { debug1(DOG, D, "  opt_comps_permitted = %2d",
+		      opt_comps_permitted(hd));
+		  }
+		  debug4(DOG, D, "prec_gap = %s;  y = %s (%s,%s):",
+		    EchoGap(&gap(prec_gap)), Image(type(y)),
+		    EchoLength(back(y, dim)), EchoLength(fwd(y, dim)));
+		  DebugObject(y);
+		)
+
+		/* refresh the number of components permitted into the next target */
+		if( opt_counts(hd) != nilobj && Down(opt_counts(hd)) != opt_counts(hd) )
+		{ Child(z, Down(opt_counts(hd)));
+		  opt_comps_permitted(hd) += comp_count(z) - 1;
+		  DisposeChild(Up(z));
+		}
+		else opt_comps_permitted(hd) = MAX_FILES;  /* a large number */
+		debug1(DOG, D, "  REJECT permitted = %2d", opt_comps_permitted(hd));
+	      }
+	      debug1(DGF, D, "  reject (b) %s", EchoObject(y));
+	      goto REJECT;
+	    }
+
+	    /* calculate perpendicular effect of adding y to dest */
+	    if( seen_nojoin(hd) )
+	    {
+	      pb = 0;
+	      pf = find_max(perp_fwd,  size(y, 1-dim));
+	    }
+	    else
+	    {
+	      pb = find_max(perp_back, back(y, 1-dim));
+	      pf = find_max(perp_fwd,  fwd(y,  1-dim));
+	    }
+
+	    /* check new size against perpendicular constraint */
+	    if( !FitsConstraint(pb, pf, dest_perp_constr) )
+	    {
+	      if( opt_components(hd) != nilobj )
+	      { DisposeObject(opt_components(hd));
+		opt_components(hd) = nilobj;
+		debug1(DOG, D, "FlushGalley(%s) de-optimizing (perp problem)",
+		  SymName(actual(hd)));
+	      }
+	      if( dim == ROWM )
+	      {
+		Error(20, 3, "component too wide for available space",
+		  WARN, &fpos(y));
+		debug6(DGF, D, "  %s,%s [%s,%s] too wide for %s, y = %s",
+		  EchoLength(pb), EchoLength(pf),
+		  EchoLength(back(y, 1-dim)), EchoLength(fwd(y, 1-dim)),
+		  EchoConstraint(&dest_perp_constr), EchoObject(y));
+	      }
+	      debug1(DGF, D, "  reject (c) %s", EchoObject(y));
+	      goto REJECT;
+	    }
+
+	    /* accept definite component */
+	    dest_fwd = f;  prec_def = y;
+	    perp_back = pb;  perp_fwd = pf;
+	    need_adjust = TRUE;
+	    if( opt_components(hd) != nilobj )
+	    { opt_comps_permitted(hd)--;
+	      debug1(DOG, D, "  ACCEPT permitted = %2d", opt_comps_permitted(hd));
+	    }
+	  }
+	  /* accept indefinite component */
+	} /* end if( target_is_internal ) */
+
+	/* accept this component into dest, subject to following nobreaks */
+	debug3(DGF, D, "  t-accept %s %s %s", Image(type(y)), EchoObject(y),
+	  EchoFilePos(&fpos(y)));
+	prnt_flush = prnt_flush || blocked(dest_index);
+	debug1(DGF, DDD, "    prnt_flush = %s", bool(prnt_flush));
+	debug1(DGF, DDD, "    inners = %s", DebugInnersNames(inners));
+	if( inners != nilobj )
+	{ BOOLEAN promotable;  OBJECT tgp;
+
+	  /* We would prefer to promote right now, then give these inners */
+	  /* a chance.  However this is not possible unless the following */
+	  /* gap (if any) is breakable                                    */
+
+	  if( type(NextDown(link)) == LINK )
+	  { Child(tgp, NextDown(link));
+	    assert( type(tgp) == GAP_OBJ, "FlushGalley:  tgp!" );
+	    promotable = !nobreak(gap(tgp));
+	  }
+	  else promotable = TRUE;
+
+	  if( promotable )
+	  {
+	    Promote(hd, NextDown(link), dest_index, TRUE);
+	    if( need_adjust )
+	    { debug0(DSA, D, "  calling AdjustSize from FlushGalley (ACCEPT)");
+	      AdjustSize(dest_encl, dest_back, dest_fwd, dim);
+	      AdjustSize(dest_encl, perp_back, perp_fwd, 1-dim);
+	    }
+	    debug0(DGF, D, "  calling FlushInners() from FlushGalley (d)");
+	    FlushInners(inners, hd);
+	    goto RESUME;
+	  }
+	}
+	break;
+
+
+      default:
+	  
+	assert1(FALSE, "FlushGalley:", Image(type(y)));
+	break;
+
+    } /* end switch */
+  } /* end for */
+
+
+  /* EMPTY: */
+
+    /* galley is now completely accepted; clean up and exit */
+    debug0(DGF, D, "  galley empty now");
+    if( inners != nilobj )  DisposeObject(inners);
+    if( Down(hd) != hd )
+    { Promote(hd, hd, dest_index, TRUE);
+      if( need_adjust )
+      { debug0(DSA, D, "  calling AdjustSize from FlushGalley (EMPTY)");
+	AdjustSize(dest_encl, dest_back, dest_fwd, dim);
+	AdjustSize(dest_encl, perp_back, perp_fwd, 1-dim);
+      }
+    }
+    if( opt_components(hd) != nilobj )
+    { OBJECT z;
+      New(z, WIDE);
+      if( dest_encl != nilobj )
+        CopyConstraint(constraint(z), dest_par_constr);
+      else
+        SetConstraint(constraint(z),
+	  MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH);
+      Link(opt_constraints(hd), z);
+      debug2(DOG, D, "FlushGalley(%s) empty adding constraint %s",
+        SymName(actual(hd)), EchoConstraint(&constraint(z)));
+    }
+    DetachGalley(hd);
+    debug0(DGF, D, "  calling KillGalley from FlushGalley");
+    KillGalley(hd, TRUE);
+    ParentFlush(prnt_flush, dest_index, TRUE);
+    debug1(DGF,D,"] FlushGalley %s returning (emptied).", SymName(actual(hd)));
+    return;
+
+
+  REJECT:
+  
+    /* reject this component and move to a new dest */
+    assert(actual(dest) != PrintSym, "FlushGalley: reject print!");
+    if( inners != nilobj )  DisposeObject(inners);
+    if( stop_link != nilobj )
+    { Promote(hd, stop_link, dest_index, TRUE);
+      if( need_adjust )
+      { debug0(DSA, D, "  calling AdjustSize from FlushGalley (REJECT)");
+	AdjustSize(dest_encl, stop_back, stop_fwd, dim);
+	AdjustSize(dest_encl, stop_perp_back, stop_perp_fwd, 1-dim);
+      }
+    }
+    DetachGalley(hd);
+    assert( type(dest_index) == RECEIVING, "FlushGalley/REJECT: dest_index!" );
+    prnt_flush = prnt_flush || blocked(dest_index);
+    DeleteNode(dest_index);
+    goto RESUME;
+
+
+  SUSPEND:
+  
+    /* suspend this component */
+    debug1(DGF, D, "  suspend %s", EchoIndex(y));
+    if( inners != nilobj )  DisposeObject(inners);
+    if( stop_link != nilobj )
+    { Promote(hd, stop_link, dest_index, TRUE);
+      if( need_adjust )
+      { debug0(DSA, D, "  calling AdjustSize from FlushGalley (SUSPEND)");
+	AdjustSize(dest_encl, stop_back, stop_fwd, dim);
+	AdjustSize(dest_encl, stop_perp_back, stop_perp_fwd, 1-dim);
+      }
+    }
+
+    /* check whether external galleys can remove the blockage */
+    if( type(y) == RECEPTIVE && ready_galls(hd) != nilobj && AllowCrossDb )
+    { OBJECT eg, val, index2, hd2, tag, seq, newsym;
+      BOOLEAN found, gall;  FULL_CHAR newtag[MAX_BUFF], newseq[MAX_BUFF];
+
+      /* get first ready galley in from cross reference database */
+      Child(eg, Down(ready_galls(hd)));
+      SwitchScope(nilobj);
+      val = ReadFromFile(eg_fnum(eg), eg_fpos(eg), eg_lnum(eg));
+      UnSwitchScope(nilobj);
+      if( val == nilobj )
+	Error(20, 1, "error in database file %s",
+	  FATAL, &fpos(y), FileName(eg_fnum(eg)));
+      assert( type(val) == CLOSURE, "AttachG: db CLOSURE!" );
+      New(index2, UNATTACHED);
+      pinpoint(index2) = nilobj;
+      New(hd2, HEAD);
+      FposCopy(fpos(hd2), fpos(val));
+      actual(hd2) = actual(val);
+      limiter(hd2) = nilobj;
+      opt_components(hd2) = opt_constraints(hd2) = nilobj;
+      gall_dir(hd2) = horiz_galley(actual(val));
+      sized(hd2) = FALSE;
+      ready_galls(hd2) = nilobj;
+      must_expand(hd2) = TRUE;
+      Link(index2, hd2);
+      Link(hd2, val);
+      SetTarget(hd2);
+      foll_or_prec(hd2) = GALL_FOLL;
+      enclose_obj(hd2) = (has_enclose(actual(hd2)) ? BuildEnclose(hd2) : nilobj);
+      Link(Up(y), index2);
+
+      /* set up the next ready galley for reading next time */
+      Child(tag, Down(eg));  Child(seq, LastDown(eg));
+      do /* skip duplicate seq values */
+      {	found = DbRetrieveNext(OldCrossDb, &gall, &newsym, newtag, newseq,
+		&eg_fnum(eg), &eg_fpos(eg), &eg_lnum(eg), &eg_cont(eg));
+	debug2(DGF, DD, "  ext gall  found:   %15s  gall:    %15s",
+			bool(gall), bool(found));
+	debug2(DGF, DD, "  ext gall  new sym: %15s  old sym: %15s",
+			SymName(newsym), SymName(eg_symbol(eg)));
+	debug2(DGF, DD, "  ext gall  new tag: %15s  old tag: %15s",
+			newtag, string(tag));
+	debug2(DGF, DD, "  ext gall  new seq: %15s  old seq: %15s",
+			newseq, string(seq));
+	if( found )  found = gall && newsym == eg_symbol(eg) &&
+			StringEqual(newtag, string(tag));
+
+	/* merge galleys whose seq strings are equal */
+	if( found && StringEqual(newseq, string(seq)) )
+	{
+	  SwitchScope(nilobj);
+	  val = ReadFromFile(eg_fnum(eg), eg_fpos(eg), eg_lnum(eg));
+	  UnSwitchScope(nilobj);
+	  if( val == nilobj )
+	    Error(20, 2, "error in database file %s",
+	      FATAL, &fpos(y), FileName(eg_fnum(eg)));
+	  assert( type(val) == CLOSURE, "AttachG: db CLOSURE!" );
+	  if( !has_merge(actual(val)) )  DisposeObject(val);
+	  else /* add val to hd2 */
+	  { if( type(hd2) != ACAT )
+	    { OBJECT tmp = hd2;
+	      New(hd2, ACAT);
+	      MoveLink(Up(tmp), hd2, CHILD);
+	      Link(hd2, tmp);
+	    }
+	    Link(hd2, val);
+	  }
+	}
+
+      } while( found && StringEqual(newseq, string(seq)) );
+      if( found )
+      {	DisposeChild(Up(tag));
+	DisposeChild(Up(seq));
+	tag = MakeWord(WORD, newtag, no_fpos);
+	seq = MakeWord(WORD, newseq, no_fpos);
+	Link(eg, tag);  Link(eg, seq);
+	debug1(DGF, DD, "  another ext gall: into %s", SymName(newsym));
+      }
+      else
+      {	DisposeChild(Up(eg));
+	debug1(DGF, DD, "  last ext gall into ", SymName(eg_symbol(eg)));
+	if( Down(ready_galls(hd)) == ready_galls(hd) )
+	{ Dispose(ready_galls(hd));
+	  ready_galls(hd) = nilobj;
+	  debug0(DGF, DD, "  all ext galls exhausted");
+	}
+      }
+
+      /* flush the ready galley found above, and resume */
+      debug2(DGF, DD, "  ext gall FlushGalley (%s into %s)",
+	SymName(actual(hd2)), SymName(whereto(hd2)));
+      debug0(DGF, DD, "  calling FlushGalley from FlushGalley/SUSPEND");
+      if( type(hd2) == ACAT )
+	hd2 = ConvertGalleyList(hd2);
+      FlushGalley(hd2);
+      goto RESUME;
+    }
+    else if( type(y) == RECEPTIVE && trigger_externs(y) && AllowCrossDb )
+    { OBJECT sym, cr, ins, tag, seq, eg, cnt;  BOOLEAN found;
+      FULL_CHAR newseq[MAX_BUFF];  FILE_NUM tfnum;  long tfpos, tcont;
+      int tlnum;
+      debug1(DGF, DD, "  ext gall target %s", SymName(actual(actual(y))));
+      for( sym = FirstExternTarget(actual(actual(y)), &cnt);
+	     sym != nilobj;  sym = NextExternTarget(actual(actual(y)), &cnt) )
+      {
+	debug1(DGF, DD, "  ext gall gall_targ %s", SymName(sym));
+	cr = GallTargEval(sym, &fpos(actual(y)));
+	New(ins, GALL_TARG);
+	actual(ins) = cr;
+	Link(Up(y), ins);
+	Child(tag, LastDown(cr));
+	assert( is_word(type(tag)), "FlushGalley: cr is_word(type(tag))!" );
+	found = DbRetrieve(OldCrossDb, TRUE, sym, string(tag),
+		newseq, &tfnum, &tfpos, &tlnum, &tcont);
+	if( found )
+	{ if( ready_galls(hd) == nilobj )  New(ready_galls(hd), ACAT);
+	  New(eg, EXT_GALL);
+	  debug1(DGF, DD, "  ext gall retrieved: into %s", SymName(sym));
+	  eg_fnum(eg) = tfnum;
+	  eg_fpos(eg) = tfpos;
+	  eg_lnum(eg) = tlnum;
+	  eg_symbol(eg) = sym;
+	  eg_cont(eg) = tcont;
+	  tag = MakeWord(WORD, string(tag), no_fpos);
+	  Link(eg, tag);
+	  seq = MakeWord(WORD, newseq, no_fpos);
+	  Link(eg, seq);
+	  Link(ready_galls(hd), eg);
+	}
+      }
+      trigger_externs(y) = FALSE;
+      if( ready_galls(hd) != nilobj )  goto RESUME;
+    } /* end if external galleys */
+
+    /* if non-blocking, delete the index and resume */
+    if( type(y) == RECEPTIVE && non_blocking(y) )
+    { DeleteNode(y);
+      goto RESUME;
+    }
+    else if( type(y) == RECEIVING && non_blocking(y) )
+    {	
+      if( Down(y) == y )
+      {	DeleteNode(y);
+      }
+      else
+      {	Child(z, Down(y));
+	if( opt_components(z) != nilobj )
+	  GazumpOptimize(z, actual(y));
+	DetachGalley(z);
+      }
+      goto RESUME;
+    }
+
+    /* if all the above fail to remove the blockage, suspend */
+    blocked(y) = TRUE;
+    ParentFlush(prnt_flush, dest_index, FALSE);
+    debug1(DGF,D, "] FlushGalley %s returning (suspend)", SymName(actual(hd)));
+    return;
+
+} /* end FlushGalley */