diff options
Diffstat (limited to 'z22.c')
| -rw-r--r-- | z22.c | 1070 |
1 files changed, 1070 insertions, 0 deletions
@@ -0,0 +1,1070 @@ +/*@z22.c:Galley Service:Interpose()@******************************************/ +/* */ +/* 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: z22.c */ +/* MODULE: Galley Service */ +/* EXTERNS: Interpose(), FlushInners(), ExpandRecursives(), */ +/* Promote(), KillGalley(), FreeGalley(), */ +/* SetTarget(), CheckComponentOrder() */ +/* */ +/*****************************************************************************/ +#include "externs.h" + + +/*****************************************************************************/ +/* */ +/* Interpose(z, typ, x, y) */ +/* */ +/* Insert a new typ object above z. Its sizes are to be taken from x */ +/* (column) and y (row). */ +/* */ +/*****************************************************************************/ + +void Interpose(OBJECT z, int typ, OBJECT x, OBJECT y) +{ OBJECT encl; + New(encl, typ); + FposCopy(fpos(encl), fpos(y)); + ReplaceNode(encl, z); Link(encl, z); + back(encl, COLM) = back(x, COLM); + fwd(encl, COLM) = fwd(x, COLM); + back(encl, ROWM) = back(y, ROWM); + fwd(encl, ROWM) = fwd(y, ROWM); + underline(encl) = underline(z); +} /* end Interpose */ + + +/*@::FlushInners()@***********************************************************/ +/* */ +/* FlushInners(inners, hd) */ +/* */ +/* Flush each galley on the list inners. These have become flushable */ +/* by being promoted off the top of galley hd; if hd is the root galley, */ +/* identifiable by having PrintSym as target, do not flush inners at all. */ +/* */ +/*****************************************************************************/ + +void FlushInners(OBJECT inners, OBJECT hd) +{ OBJECT y, z, tmp, dest_index; + + ifdebug(DGF, D, + OBJECT link; + fprintf(stderr, "dgf: [ FlushInners("); + for( link = Down(inners); link != inners; link = NextDown(link) ) + { + Child(y, link); + fprintf(stderr, " %s", Image(type(y))); + switch( type(y) ) + { + + case DEAD: + + break; + + + case RECEIVING: + case UNATTACHED: + + if( Down(y) != y ) /* bug fix (was assert before) */ + { assert( Down(y) != y, "FlushInners: UNATTACHED!"); + Child(z, Down(y)); + fprintf(stderr, " %s", SymName(actual(z))); + } + break; + + + case PRECEDES: + + break; + + + case GALL_PREC: + + break; + + + default: + + break; + } + } + fprintf(stderr, ")\n"); + ) + + /* check for root galley case */ + if( hd != nilobj ) + { assert( Up(hd) != hd, "FlushInners: Up(hd)!" ); + Parent(dest_index, Up(hd)); + if( actual(actual(dest_index)) == PrintSym ) + { DisposeObject(inners); + debug0(DGF, D, "] FlushInners returning (PrintSym)"); + return; + } + } + + while( Down(inners) != inners ) + { Child(y, Down(inners)); + DeleteLink(Down(inners)); + switch( type(y) ) + { + + case DEAD: + + break; + + + case RECEIVING: + case UNATTACHED: + + if( Down(y) != y ) /* bug fix (was assert before) */ + { assert( Down(y) != y, "FlushInners: UNATTACHED!"); + Child(z, Down(y)); + debug1(DGF,D," possibly calling FlushGalley %s from FlushInners (a)", + SymName(actual(z))); + if( whereto(z)==nilobj || !uses_extern_target(whereto(z)) ) /* &&& */ + FlushGalley(z); + } + break; + + + case PRECEDES: + + Child(tmp, Down(y)); + if( Up(tmp) != LastUp(tmp) ) + { Parent(tmp, LastUp(tmp)); + assert(type(tmp)==FOLLOWS, "FlushInners: FOLLOWS!"); + if( blocked(tmp) ) + { blocked(tmp) = FALSE; + Parent(z, Up(tmp)); + debug0(DGF, D, " calling FlushGalley from FlushInners (b)"); + if( whereto(z)==nilobj || !uses_extern_target(whereto(z)) )/* &&& */ + FlushGalley(z); + } + } + break; + + + case GALL_PREC: + + /* someone else is looking after this now */ + break; + + + default: + + assert1(FALSE, "FlushInners:", Image(type(y))); + break; + } + } + Dispose(inners); + debug0(DGF, D, "] FlushInners returning"); +} /* end FlushInners */ + + +/*@::ExpandRecursives()@******************************************************/ +/* */ +/* ExpandRecursives(recs) */ +/* */ +/* Expand each of the recursive definite objects in the list recs. */ +/* */ +/*****************************************************************************/ + +void ExpandRecursives(OBJECT recs) +{ CONSTRAINT non_c, hc, vc; + OBJECT target_index, target, z, n1, inners, newrecs, hd, tmp, env, why; + debug0(DCR, DD, "ExpandRecursives(recs)"); + SetConstraint(non_c, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH); + n1 = nilobj; + assert(recs != nilobj, "ExpandRecursives: recs == nilobj!"); + while( Down(recs) != recs ) + { Child(target_index, Down(recs)); DeleteLink( Down(recs) ); + assert( type(target_index) == RECURSIVE, "ExpandRecursives: index!" ); + target = actual(target_index); + debug2(DCR, DD, " expanding %s %s", Image(type(target_index)), + EchoObject(target)); + + /* expand body of target, convert to galley, and check size */ + New(hd, HEAD); actual(hd) = actual(target); must_expand(hd) = TRUE; + force_gall(hd) = FALSE; + enclose_obj(hd) = limiter(hd) = nilobj; + opt_components(hd) = opt_constraints(hd) = nilobj; + gall_dir(hd) = horiz_galley(actual(target)); + whereto(hd) = ready_galls(hd) = nilobj; + foll_or_prec(hd) = GALL_FOLL; + sized(hd) = FALSE; + tmp = CopyObject(target, &fpos(target)); env = DetachEnv(tmp); + Link(hd, tmp); Link(target_index, hd); + SizeGalley(hd, env, external_ver(target), + gall_dir(hd) == ROWM ? threaded(target) : FALSE, FALSE, FALSE, + &save_style(target), &non_c, nilobj, &n1, &newrecs, &inners, nilobj); + debug0(DCR, DDD, " as galley:"); + ifdebug(DCR, DDD, DebugObject(hd)); + debug1(DGS, D, "[ ExpandRecursives calling Constrained(%s, COLM)", + EchoObject(target)); + Constrained(target, &hc, COLM, &why); + debug2(DGS, D, "] ExpandRecursives Constrained(%s, COLM) = %s", + EchoObject(target), EchoConstraint(&hc)); + debug3(DCR, DD, " horizontal size: (%s, %s); constraint: %s", + EchoLength(back(hd, COLM)), EchoLength(fwd(hd, COLM)), EchoConstraint(&hc)); + if( !FitsConstraint(back(hd, COLM), fwd(hd, COLM), hc) ) + { DisposeChild(Up(hd)); + if( inners != nilobj ) DisposeObject(inners); + if( newrecs != nilobj ) DisposeObject(newrecs); + DeleteNode(target_index); + debug0(DCR, DD, " rejecting (too wide)"); + continue; + } + if( !external_ver(target) ) + { Constrained(target, &vc, ROWM, &why); + debug2(DSC, DD, "Constrained( %s, ROWM ) = %s", + EchoObject(target), EchoConstraint(&vc)); + Child(z, LastDown(hd)); + debug3(DCR, DD, " vsize: (%s, %s); constraint: %s", + EchoLength(back(z, ROWM)), EchoLength(fwd(z, ROWM)), EchoConstraint(&vc)); + if( !FitsConstraint(back(z, ROWM), fwd(z, ROWM), vc) ) + { DisposeChild(Up(hd)); + if( inners != nilobj ) DisposeObject(inners); + if( newrecs != nilobj ) DisposeObject(newrecs); + DeleteNode(target_index); + debug0(DCR, DD, " rejecting (too high)"); + continue; + } + } + + /* object fits; adjust sizes and promote */ + debug0(DSA, D, "calling AdjustSize from ExpandRecursives (a)"); + AdjustSize(target, back(hd, COLM), fwd(hd, COLM), COLM); + if( !external_ver(target) ) + { debug0(DSA, D, "calling AdjustSize from ExpandRecursives (b)"); + AdjustSize(target, back(z, ROWM), fwd(z, ROWM), ROWM); + Interpose(target, VCAT, z, z); + } + Promote(hd, hd, target_index, TRUE); DeleteNode(hd); + DeleteNode(target_index); + if( inners != nilobj ) + { + debug0(DGF, D, " calling FlushInners from ExpandRecursives"); + FlushInners(inners, nilobj); + } + if( newrecs != nilobj ) MergeNode(recs, newrecs); + } /* end while */ + Dispose(recs); + debug0(DCR, DD, "ExpandRecursives returning."); +} /* end ExpandRecursives */ + +/*@::FindSplitInGalley()@*****************************************************/ +/* */ +/* static OBJECT FindSplitInGalley(hd) */ +/* */ +/* Search simply joined galley hd for a SPLIT object, which must be there. */ +/* */ +/*****************************************************************************/ + +static OBJECT FindSplitInGalley(OBJECT hd) +{ OBJECT link, y; + debug0(DGF, D, "FindSplitInGalley(hd)"); + for( link = Down(hd); link != hd; link = NextDown(link) ) + { Child(y, link); + if( is_definite(type(y)) ) break; + } + if( link == hd ) + { debug0(DGF, D, "FindSplitInGalley failing, no definite component; hd ="); + ifdebug(DGF, D, DebugObject(hd)); + Error(22, 1, "FindSplit: missing galley component", INTERN, &fpos(hd)); + } + while( type(y) != SPLIT ) switch( type(y) ) + { + case VCAT: + case ONE_ROW: + case WIDE: + case HIGH: + case HSHIFT: + case VSHIFT: + case VCONTRACT: + case VLIMITED: + case VEXPAND: + + Child(y, Down(y)); + break; + + + case CLOSURE: + case NULL_CLOS: + case PAGE_LABEL: + case HCAT: + case WORD: + case QWORD: + case ACAT: + case ROW_THR: + case COL_THR: + case ONE_COL: + case SCALE: + case KERN_SHRINK: + case HSCALE: + case VSCALE: + case HCOVER: + case VCOVER: + case HCONTRACT: + case HLIMITED: + case HEXPAND: + case START_HVSPAN: + case START_HSPAN: + case START_VSPAN: + case HSPAN: + case VSPAN: + case ROTATE: + case BACKGROUND: + case INCGRAPHIC: + case SINCGRAPHIC: + case PLAIN_GRAPHIC: + case GRAPHIC: + + debug0(DGF, D, "FindSplitInGalley(hd) failing, hd ="); + ifdebug(DGF, D, DebugObject(hd)); + Error(22, 2, "FindSplitInGalley failed", INTERN, &fpos(y),Image(type(y))); + break; + + + default: + + assert1(FALSE, "FindSplitInGalley:", Image(type(y))); + break; + + } + debug0(DGF, D, "FindSplitInGalley returning."); + return y; +} /* end FindSplitInGalley */ + +/*@::Promote()@***************************************************************/ +/* */ +/* Promote(hd, stop_link, dest_index, join_after) */ +/* */ +/* Promote components of galley hd into its destination (dest), up to but */ +/* not including the one linked to hd by link stop_link, which always */ +/* follows a component. No size adjustments are made, except that when */ +/* two col_thr nodes are merged, a COLM adjustment is made to the result. */ +/* */ +/* If the galley is ending here, Promote inserts a gap at the end of it. */ +/* Whether to make this a joining gap or not is a tricky question which */ +/* Promote answers by referring to join_after. */ +/* */ +/*****************************************************************************/ + +void Promote(OBJECT hd, OBJECT stop_link, OBJECT dest_index, BOOLEAN join_after) +{ + /* these two variables refer to the root galley only */ + static BOOLEAN first = TRUE; /* TRUE when the first component not written */ + static OBJECT page_label=nilobj; /* current page label object */ + + OBJECT dest, link, y, z, tmp1, tmp2, why; FULL_CHAR *label_string; + int dim; + debug1(DGS, DD, "Promote(%s, stop_link)", SymName(actual(hd))); + + assert( type(hd) == HEAD, "Promote: hd!" ); + assert( type(stop_link) == LINK || stop_link == hd, "Promote: stop_link!" ); + assert( stop_link != Down(hd), "Promote: stop_link == Down(hd)!" ); + type(dest_index) = RECEIVING; + dest = actual(dest_index); + + /* insert final gap if galley is ending */ + if( stop_link != hd ) + { Child(y, stop_link); + assert( type(y) == GAP_OBJ, "Promote: missing GAP_OBJ!" ); + stop_link = NextDown(stop_link); + } + else + { New(y, GAP_OBJ); + FposCopy(fpos(y), fpos(hd)); + hspace(y) = 0; vspace(y) = 1; + /* SetGap(gap(y), FALSE, FALSE, seen_nojoin(hd), FIXED_UNIT, NO_MODE, 0); */ + /* SetGap(gap(y), FALSE, FALSE, threaded(dest), FIXED_UNIT, NO_MODE, 0); */ + /* SetGap(gap(y), FALSE, FALSE, TRUE, FIXED_UNIT, NO_MODE, 0); */ + /* ClearGap(gap(y)); */ + SetGap(gap(y), FALSE, FALSE, join_after, FIXED_UNIT, NO_MODE, 0); + Link(stop_link, y); + } + + /* if optimizing, add to dummy paragraph containing components and gaps */ + if( opt_components(hd) != nilobj ) + { OBJECT last, tmp; + + debug1(DOG, DD, "Promote(%s) optimizing:", SymName(actual(hd))); + if( LastDown(opt_components(hd))!=opt_components(hd) && !opt_gazumped(hd) ) + { + Child(last, LastDown(opt_components(hd))); + } + else last = nilobj; + for( link = Down(hd); link != stop_link; link = NextDown(link) ) + { Child(y, link); + if( type(y) == GAP_OBJ ) + { + if( last == nilobj ) + { + /* do nothing, gap cannot separate definite objects */ + debug1(DOG, DD, " skipping initial GAP_OBJ %s", EchoGap(&gap(y))); + } + else if( type(last) == GAP_OBJ ) + { + /* previous gap must have preceded an indefinite, so overwrite it */ + FposCopy(fpos(last), fpos(y)); + debug2(DOG, DD, " overwriting GAP_OBJ %s with %s", + EchoGap(&gap(last)), EchoGap(&gap(y))); + GapCopy(gap(last), gap(y)); + if( Down(last) != last ) DisposeChild(Down(last)); + if( Down(y) != y ) + { Child(tmp, Down(y)); + tmp = CopyObject(tmp, no_fpos); + Link(last, tmp); + } + join(gap(last)) = TRUE; /* irrelevant but improves debug output */ + } + else + { + /* previous was definite, so this gap must be stored */ + opt_gazumped(hd) = FALSE; + New(last, GAP_OBJ); + FposCopy(fpos(last), fpos(y)); + GapCopy(gap(last), gap(y)); + join(gap(last)) = TRUE; /* irrelevant but improves debug output */ + hspace(last) = 1; + vspace(last) = 0; + Link(opt_components(hd), last); + debug1(DOG, DD, " adding GAP_OBJ %s", EchoGap(&gap(last))); + } + } + else if( is_word(type(y)) ) + { + /* definite, must be stored */ + opt_gazumped(hd) = FALSE; + last = MakeWord(type(y), string(y), &fpos(y)); + back(last, COLM) = back(y, gall_dir(hd)); + fwd(last, COLM) = fwd(y, gall_dir(hd)); + word_font(last) = word_font(y); + word_colour(last) = word_colour(y); + word_language(last) = word_language(y); + word_hyph(last) = word_hyph(y); + Link(opt_components(hd), last); + debug2(DOG, DD, " adding %s \"%s\"", Image(type(last)), string(last)); + } + else if( is_indefinite(type(y)) ) + { + /* indefinite, always skip these */ + /* *** + New(z, NULL_CLOS); + FposCopy(fpos(z), fpos(y)); + back(z, COLM) = 0; + fwd(z, COLM) = 0; + Link(opt_components(hd), z); + debug1(DOG, DD, " adding %s", KW_NULL); + *** */ + } + else if( is_definite(type(y)) ) + { + /* definite other than WORD, add it */ + opt_gazumped(hd) = FALSE; + last = MakeWord(QWORD, AsciiToFull("w"), &fpos(y)); + back(last, COLM) = back(y, gall_dir(hd)); + fwd(last, COLM) = fwd(y, gall_dir(hd)); + Link(opt_components(hd), last); + debug1(DOG, DD, " adding word for %s", EchoObject(y)); + } + } + debug1(DOG, DD, "Promote(%s) end optimizing", SymName(actual(hd))); + } + + /* error if promoting a seen_nojoin galley into a threaded destination */ + if( seen_nojoin(hd) && gall_dir(hd) == ROWM && threaded(dest) ) + Error(22, 3, "galley %s must have a single column mark", + FATAL, &fpos(hd), SymName(actual(hd))); + + /* make nojoin status clear by adding an extra gap at start if needed */ + if( gall_dir(hd) == ROWM && !external_ver(dest) && seen_nojoin(hd) && + join(gap(y)) ) + { OBJECT prnt, extra_null, extra_gap; + + /* add nojoin gap at start */ + Parent(prnt, Up(dest)); /* can't be threaded */ + assert( type(prnt) == VCAT, "Promote: nojoin case, can't find VCAT" ); + New(extra_null, NULL_CLOS); + back(extra_null, COLM) = fwd(extra_null, COLM) = 0; + back(extra_null, ROWM) = fwd(extra_null, ROWM) = 0; + New(extra_gap, GAP_OBJ); + hspace(extra_gap) = vspace(extra_gap) = 0; + SetGap(gap(extra_gap), FALSE, FALSE, FALSE, FIXED_UNIT, EDGE_MODE, 0); + Link(Down(prnt), extra_gap); + Link(Down(prnt), extra_null); + debug0(DGS, DD, " Promote adding extra nojoin gap"); + /* join(gap(y)) = FALSE; */ + } + + + /* if promoting out of root galley, do special things */ + if( actual(dest) == PrintSym ) + { CONSTRAINT c; + link = hd; + while( NextDown(link) != stop_link ) + { Child(y, NextDown(link)); + debug2(DGS, DD, "root promote %s %s", Image(type(y)), + is_definite(type(y)) ? STR_EMPTY : EchoObject(y)); + if( type(y) == SPLIT ) Child(y, DownDim(y, ROWM)); + switch( type(y) ) + { + + case SCALE_IND: + case COVER_IND: + case PRECEDES: + + DisposeChild(NextDown(link)); + break; + + + case UNATTACHED: + + assert( Down(y) != y, "FlushRootGalley: UNATTACHED!" ); + Child(z, Down(y)); + assert( type(z) == HEAD, "FlushRootGalley: unattached HEAD!" ); + if( sized(z) ) + { + /* galley is part flushed, leave it here */ + link = NextDown(link); + } + else if( foll_or_prec(z) == GALL_PREC ) + { + /* galley is preceding or foll_or_prec, send to CrossSequence */ + OBJECT t; + type(y) = GALL_PREC; + pinpoint(y) = nilobj; + Child(t, Down(z)); + actual(y) = CrossMake(whereto(z), t, GALL_PREC); + DisposeChild(Down(y)); + CrossSequence(actual(y)); + DisposeChild(NextDown(link)); + } + else + { + /* galley was never attached, print message and kill it */ + Error(22, 4, "galley %s deleted (never attached)", + WARN, &fpos(z), SymName(actual(z))); + debug1(DGF, D, "never-attached galley %s:", EchoFilePos(&fpos(z))); + ifdebug(DGF, D, DebugObject(z)); + KillGalley(z, FALSE); + /* *** + link = NextDown(link); + *** */ + } + break; + + + case EXPAND_IND: + + /* expand @HExpand or @VExpand to occupy everything possible */ + dim = type(actual(y)) == HEXPAND ? COLM : ROWM; + Constrained(actual(y), &c, dim, &why); + if( constrained(c) ) + { FULL_LENGTH b = back(actual(y), dim); + FULL_LENGTH f = fwd(actual(y), dim); + EnlargeToConstraint(&b, &f, &c); + debug1(DSA, D, "Promote %s AdjustSize", Image(type(actual(y)))); + AdjustSize(actual(y), b, f, dim); + } + DisposeChild(NextDown(link)); + break; + + + case PAGE_LABEL_IND: + + if( page_label != nilobj ) + { DisposeObject(page_label); + page_label = nilobj; + } + Child(z, Down(y)); + assert( type(z) == PAGE_LABEL, "Promote: type(z) != PAGE_LABEL!" ); + assert( Down(z) != z, "Promote: PAGE_LABEL Down(z) == z!" ); + Child(page_label, Down(z)); + DeleteLink(Up(page_label)); + DisposeChild(NextDown(link)); + break; + + + case CROSS_PREC: + case CROSS_FOLL: + case CROSS_FOLL_OR_PREC: + case CROSS_TARG: + + debug2(DGS, DD, "root promote %s %s", Image(type(y)), EchoObject(y)); + /* NB NO BREAK */ + + + case GALL_PREC: + case GALL_FOLL: + case GALL_FOLL_OR_PREC: + case GALL_TARG: + + CrossSequence(actual(y)); + DisposeChild(NextDown(link)); + break; + + + 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 ROW_THR: + + case CLOSURE: + case NULL_CLOS: + case PAGE_LABEL: + case CROSS: + case FORCE_CROSS: + + /* print this component */ + debug0(DGS, DD, "root promote definite or indefinite"); + if( !is_indefinite(type(y)) && size(y, ROWM) != 0 ) + { + /* fix horizontally; work out which fonts needed */ + SetLengthDim(COLM); + FixAndPrintObject(y, back(y, COLM), back(y, COLM), fwd(y, COLM), + COLM, FALSE, 0, 0); + + /* print prefatory or page separating material, including fonts */ + label_string = page_label != nilobj && is_word(type(page_label)) ? + string(page_label) : AsciiToFull("?"); + debug1(DGS, DD, "root promote definite; label_string = %s", + label_string); + debug1(DCR, D, "label_string = %s", label_string); + if( first ) + { PrintBeforeFirst(size(hd, COLM), size(y, ROWM), label_string); + first = FALSE; + } + else PrintBetween(size(hd, COLM), size(y, ROWM), label_string); + if( page_label != nilobj ) + { DisposeObject(page_label); + page_label = nilobj; + } + + /* fix and print vertically */ + debug1(DGF,D, " Promote calling FixAndPrint %s", Image(type(y))); + debug3(DGP,D, " Promote calling FixAndPrint %s %s,%s", dimen(ROWM), + EchoLength(back(y,ROWM)), EchoLength(fwd(y, ROWM))); + SetLengthDim(ROWM); + FixAndPrintObject(y, back(y,ROWM), back(y, ROWM), fwd(y, ROWM), + ROWM, FALSE, size(y, ROWM), 0); + + } + DisposeChild(NextDown(link)); + + /* scavenge any filter files now not needed */ + FilterScavenge(FALSE); + break; + + + case GAP_OBJ: + + DisposeChild(NextDown(link)); + break; + + + default: + + assert1(FALSE, "Promote:", Image(type(y))); + break; + + } + } + debug0(DGS, DD, "Promote returning (root galley)."); + return; + } + + /* prepare the promotion */ + if( external_ver(dest) && gall_dir(hd) == ROWM ) + { if( threaded(dest) ) + { Parent(tmp1, UpDim(dest, COLM)); + assert( type(tmp1) == COL_THR, "Promote: tmp1 not COL_THR!" ); + y = FindSplitInGalley(hd); + assert( type(y) == SPLIT, "Promote: FindSplitInGalley!" ); + Child(tmp2, DownDim(y, COLM)); + assert( type(tmp2) == COL_THR, "Promote: tmp2 not COL_THR!" ); + if( tmp1 != tmp2 ) + { FULL_LENGTH b = find_max(back(tmp1, COLM), back(tmp2, COLM)); + FULL_LENGTH f = find_max(fwd(tmp1, COLM), fwd(tmp2, COLM)); + debug0(DSA, D, "calling AdjustSize(tmp1) from Promote (node merging)"); + AdjustSize(tmp1, b, f, COLM); + debug0(DSA, D, "calling AdjustSize(tmp2) from Promote (node merging)"); + AdjustSize(tmp2, b, f, COLM); + MergeNode(tmp1, tmp2); + } + } + link = Up(dest_index); + } + else if( external_hor(dest) && gall_dir(hd) == COLM ) + { link = Up(dest_index); + } + else + { for( link = hd; NextDown(link) != stop_link; ) + { Child(y, NextDown(link)); + if( is_index(type(y)) ) + MoveLink(NextDown(link), Up(dest_index), PARENT); + else link = NextDown(link); + } + assert( Down(hd) != stop_link, "Promote: Down(hd) == stop_link!" ); + assert( UpDim(dest, ROWM) == UpDim(dest, COLM), "Promote: dims!" ); + link = Up(dest); + } + + /* promote components */ + TransferLinks(Down(hd), stop_link, link); + + debug0(DGS, DD, "Promote returning."); +} /* end Promote */ + + +/*@::MakeDead(), KillGalley()@************************************************/ +/* */ +/* static MakeDead(y) */ +/* */ +/* Convert object y into a DEAD object and remove it to the dead store. */ +/* */ +/*****************************************************************************/ + +static void MakeDead(OBJECT y) +{ static int dead_count = 0; /* number of DEAD objects seen */ + static OBJECT dead_store = nilobj; /* where DEAD objects are kept */ + + debug1(DGS, DDD, "MakeDead( %s )", Image(type(y))); + if( dead_store == nilobj ) New(dead_store, ACAT); + type(y) = DEAD; + MoveLink(Up(y), dead_store, PARENT); + if( dead_count >= 150 ) + { DisposeChild(Down(dead_store)); + } + else dead_count++; + debug1(DGS, DDD, "MakeDead returning (dead_count = %d).", dead_count); +} /* end MakeDead */ + + +/*****************************************************************************/ +/* */ +/* KillGalley(hd, optimize) */ +/* */ +/* Kill galley hd, which may be sized or unsized. The index of hd must */ +/* be UNATTACHED; it is moved out of its present location to a secret spot. */ +/* */ +/* If hd is to be optimized, generate all the stuff for the cross */ +/* reference database. However, don't do this if optimize is FALSE, for */ +/* in that case hd is defective in some way and not optimizable. */ +/* */ +/*****************************************************************************/ + +void KillGalley(OBJECT hd, BOOLEAN optimize) +{ OBJECT prnt, link, y, z; + debug2(DGF, D, "[ KillGalley(Galley %s into %s)", + SymName(actual(hd)), SymName(whereto(hd))); + assert( type(hd) == HEAD && Up(hd) != hd, "KillGalley: precondition!" ); + Parent(prnt, Up(hd)); + assert( type(prnt) == UNATTACHED, "KillGalley: UNATTACHED precondition!" ); + assert( Up(prnt) != prnt, "KillGalley: prnt!" ); + + /* delete any ready_galls that might be hanging about */ + if( ready_galls(hd) != nilobj ) + { DisposeObject(ready_galls(hd)); + ready_galls(hd) = nilobj; + } + + /* delete every remaining component */ + for( link = hd; NextDown(link) != hd; ) + { Child(y, NextDown(link)); + switch( type(y) ) + { + case RECEIVING: while( Down(y) != y ) + { Child(z, Down(y)); + DetachGalley(z); + } + DeleteNode(y); + break; + + case RECEPTIVE: assert( Down(y) == y, "KillGalley: RECEPTIVE!" ); + DeleteNode(y); + break; + + case UNATTACHED: assert( Down(y) != y, "KillGalley: UNATTACHED!" ); + Child(z, Down(y)); KillGalley(z, FALSE); + break; + + case HEAD: assert(FALSE, "KillGalley: head"); + break; + + default: DisposeChild(NextDown(link)); + break; + } + } + + /* perform optimization calculations if required */ + if( optimize && opt_components(hd) != nilobj ) + CalculateOptimize(hd); + + /* move index into dead_store */ + MakeDead(prnt); + debug0(DGF, D, "] KillGalley returning."); +} /* end KillGalley */ + + +/*@::FreeGalley()@************************************************************/ +/* */ +/* FreeGalley(hd, stop_link, inners, relocate_link, sym) */ +/* */ +/* Free galley hd up to but not including stop_link. *Inners is well- */ +/* defined, either nilobj or an ACAT of galleys to be flushed. */ +/* */ +/* Relocate_link defines what to do with any galley attached to one of the */ +/* freed targets. If it is non-nilobj, galley hd is searched onwards from */ +/* it to see if a target can be found there. If so, the galley is */ +/* relocated to just before that point. If not, or if relocate_link is */ +/* nilobj, the galley is freed and added to *inners for flushing. If the */ +/* whereto() of such galley is sym, it is freed, not relocated, because the */ +/* cause of this call to FreeGalley is also targeted to sym, and it will */ +/* consume all possible targets of sym. */ +/* */ +/*****************************************************************************/ + +void FreeGalley(OBJECT hd, OBJECT stop_link, OBJECT *inners, +OBJECT relocate_link, OBJECT sym) +{ OBJECT link, y, z, zlink, srch, index; + assert( type(hd) == HEAD && sized(hd), "FreeGalley: pre!"); + assert( Up(hd) != hd, "FreeGalley: Up(hd)!" ); + assert( *inners == nilobj || type(*inners) == ACAT, "FreeGalley: ACAT!" ); + debug3(DGA, D, "[ FreeGalley(Galley %s into %s); rl %s nilobj", + SymName(actual(hd)), SymName(whereto(hd)), + relocate_link == nilobj ? "==" : "!="); + + /* close targets and move or flush any inner galleys */ + for( link = Down(hd); link != stop_link; link = NextDown(link) ) + { Child(y, link); + if( type(y) == RECEIVING && actual(actual(y)) == InputSym ) + Error(22, 5, "forcing galley after input point", WARN, &fpos(actual(y))); + else if( type(y) == RECEIVING ) + { + /* either relocate or free each galley */ + for( zlink = Down(y); zlink != y; ) + { Child(z, zlink); + zlink = NextDown(zlink); + assert( type(z) == HEAD, "FreeGalley/RECEIVING: type(z) != HEAD!" ); + debug1(DGA, D, "FreeGalley examining galley %s", SymName(actual(z))); + if( relocate_link != nilobj && whereto(z) != sym && + (srch = SearchGalley(relocate_link, whereto(z), TRUE, + FALSE, TRUE, FALSE)) != nilobj ) + { + if( opt_components(z) != nilobj ) GazumpOptimize(z, actual(y)); + debug2(DGA, D, " FreeGalley relocating %s to just before %s", + SymName(actual(z)), SymName(whereto(z))); + DetachGalley(z); + Parent(index, Up(z)); + MoveLink(Up(index), Up(srch), PARENT); /* just before new dest */ + } + else + { debug1(DGA, D, " FreeGalley freeing galley %s", SymName(actual(z))); + FreeGalley(z, z, inners, nilobj, sym); + if( *inners == nilobj ) New(*inners, ACAT); + Link(*inners, y); + } + } + non_blocking(y) = TRUE; + } + else if( type(y) == RECEPTIVE ) + { non_blocking(y) = TRUE; + } + } + debug0(DGA, D, "] FreeGalley returning."); +} /* end FreeGalley */ + + +/*@::SetTarget()@*************************************************************/ +/* */ +/* SetTarget(hd) */ +/* */ +/* Search for the target of unsized galley hd, and set the following: */ +/* */ +/* whereto(hd) The symbol which is this galley's target */ +/* foll_or_prec(hd) GALL_FOLL, GALL_PREC, GALL_FOLL_OR_PREC */ +/* force_gall(hd) TRUE is this is a forcing galley */ +/* */ +/*****************************************************************************/ + +void SetTarget(OBJECT hd) +{ OBJECT x, y, link, cr, lpar, rpar, env; + BOOLEAN copied; + debug1(DGS, DD, "SetTarget(%s)", SymName(actual(hd))); + assert( type(hd) == HEAD, "SetTarget: type(hd) != HEAD!" ); + Child(x, Down(hd)); + assert( type(x) == CLOSURE, "SetTarget: type(x) != CLOSURE!" ); + assert( has_target(actual(x)), "SetTarget: x has no target!" ); + + /* search the parameters of x for @Target */ + cr = nilobj; + for( link = Down(x); link != x; link = NextDown(link) ) + { Child(y, link); + if( type(y) == PAR && is_target(actual(y)) ) + { assert( Down(y) != y, "SetTarget: Down(PAR)!" ); + Child(cr, Down(y)); + break; + } + } + + /* search the children of actual(x) for a default value of @Target */ + if( cr == nilobj ) + for( link = Down(actual(x)); link != actual(x); link = NextDown(link) ) + { Child(y, link); + if( is_target(y) ) + { cr = sym_body(y); + break; + } + } + assert(cr != nilobj, "SetTarget: cr == nilobj!"); + + /* if cr is not a cross-reference, expand it until it is */ + copied = FALSE; + if( !is_cross(type(cr)) ) + { OBJECT nbt[2], nft[2], ntarget, ncrs, nenclose; + nbt[COLM] = nft[COLM] = nbt[ROWM] = nft[ROWM] = nilobj; + ntarget = ncrs = nenclose = nilobj; + cr = CopyObject(cr, &fpos(x)); + copied = TRUE; + env = GetEnv(x); + cr = Manifest(cr, env, &InitialStyle, nbt, nft, &ntarget, &ncrs, + FALSE, FALSE, &nenclose, TRUE); + } + + /* check that cr is now a cross-reference object */ + debug1(DGS, DD, "SetTarget examining %s", EchoObject(cr)); + debug1(DGS, DD, " type(cr) = %s", Image( (int) type(cr)) ); + if( !is_cross(type(cr)) ) + Error(22, 6, "target of %s is not a cross reference", + FATAL, &fpos(cr), SymName(actual(x))); + + /* determine which symbol is the target of this galley */ + Child(lpar, Down(cr)); + if( type(lpar) != CLOSURE ) + Error(22, 7, "left parameter of %s is not a symbol", + FATAL, &fpos(lpar), KW_CROSS); + whereto(hd) = actual(lpar); + + /* determine the direction from the right parameter */ + Child(rpar, NextDown(Down(cr))); + if( !is_word(type(rpar)) ) + { + Error(22, 8, "replacing %s%s? by %s%s%s", WARN, &fpos(rpar), + SymName(actual(lpar)), KW_CROSS, + SymName(actual(lpar)), KW_CROSS, KW_FOLLOWING); + foll_or_prec(hd) = GALL_FOLL; + } + else if( StringEqual(string(rpar), KW_PRECEDING) ) + foll_or_prec(hd) = GALL_PREC; + else if( StringEqual(string(rpar), KW_FOLLOWING) ) + foll_or_prec(hd) = GALL_FOLL; + else if( StringEqual(string(rpar), KW_FOLL_OR_PREC) ) + foll_or_prec(hd) = GALL_FOLL_OR_PREC; + else + { + Error(22, 9, "replacing %s%s%s by %s%s%s", + WARN, &fpos(rpar), SymName(actual(lpar)), KW_CROSS, + string(rpar), SymName(actual(lpar)), KW_CROSS, KW_FOLLOWING); + foll_or_prec(hd) = GALL_FOLL; + } + + /* determine whether this is a forcing galley */ + force_gall(hd) = force_target(actual(hd)) || type(cr) == FORCE_CROSS; + + if( copied ) DisposeObject(cr); +} /* end SetTarget */ + + +/*@::CheckComponentOrder()@***************************************************/ +/* */ +/* int CheckComponentOrder(preceder, follower) */ +/* */ +/* Check the ordering relation between components preceder and follower, */ +/* and return its current status: */ +/* */ +/* CLEAR follower definitely follows preceder, and always will; */ +/* PROMOTE follower is not prevented from following preceder; */ +/* CLOSE follower must move down its galley to follow preceder; */ +/* BLOCK follower cannot be guaranteed to follow preceder. */ +/* */ +/*****************************************************************************/ + +int CheckComponentOrder(OBJECT preceder, OBJECT follower) +{ OBJECT prec_galley, foll_galley, z; int res; + debug2(DGS, DD, "CheckComponentOrder( %s, %s )", + EchoObject(preceder), EchoObject(follower)); + Parent(prec_galley, Up(preceder)); + Parent(foll_galley, Up(follower)); + if( prec_galley == foll_galley ) + { res = CLOSE; + for( z = Up(follower); z != foll_galley; z = pred(z, CHILD) ) + if( z == Up(preceder) ) + { res = CLEAR; + break; + } + } + else + { res = PROMOTE; + while( Up(prec_galley) != prec_galley ) + { Parent(z, Up(prec_galley)); /* index of galley */ + Parent(prec_galley, Up(z)); /* enclosing galley */ + if( prec_galley == foll_galley ) + { res = BLOCK; + break; + } + } + } + debug1(DGS, DD, "CheckComponentOrder returning %s", Image(res)); + return res; +} /* end CheckComponentOrder */ |