magic/mzrouter/mzBlock.c

/*
 * mzBlock.c --
 *
 * Construction of blockage planes.
 *
 *     ********************************************************************* 
 *     * Copyright (C) 1988, 1990 Michael H. Arnold and the Regents of the *
 *     * University of California.                                         * 
 *     * Permission to use, copy, modify, and distribute this              * 
 *     * software and its documentation for any purpose and without        * 
 *     * fee is hereby granted, provided that the above copyright          * 
 *     * notice appear in all copies.  The University of California        * 
 *     * makes no representations about the suitability of this            * 
 *     * software for any purpose.  It is provided "as is" without         * 
 *     * express or implied warranty.  Export of this software outside     * 
 *     * of the United States of America may require an export license.    * 
 *     *********************************************************************
 *
 * A blockage plane is used to determine the legal areas for routing.
 * Each point on the interior of a space tile in a blockage plane is
 * a legal position to place the lower-left corner of a piece of wiring.
 *
 * To build a blockage plane, each solid mask tile in the 
 * layout is bloated in
 * all four directions and painted into the blockage plane.  To the
 * top and right, it is only bloated by the minimum separation from
 * that tile to routing on that plane (s).  To the bottom and left,
 * though, it is bloated by this distance PLUS one less than the
 * minimum width of routing on that layer (w-1):
 *
 *
 *
 *		  s+w-1			 s
 *		<------->	        <-->
 *		+---------------------------+	^
 *		|			    |	| s
 *		|	+---------------+   |	v
 *		|	|. . . . . . . .|   |
 *		|	| . . tile. . .	|   |
 *		|	|. . . . . . . .|   |
 *		|	+---------------+   |	^
 *		|			    |	|
 *		|   blockage		    |	| s+w-1
 *		|			    |	|
 *		+---------------------------+	v
 *
 * Blockage planes are kept for each routeLayer and routeContact.  They
 * are part of ther RouteType datastructure.
 *
 * There are two blockage planes for each routeType.  One is merged into
 * maximal horizontal strips, and the other
 * into maximal vertical strips.  (To be done---there's no reason to
 * have separate routines for maximal vertical strips;  just use max
 * horizontal strips routines with x and y appropriately swapped).
 *
 * Start and destination nodes are treated differently, by considering
 * the areas in which a route's lower left corner can be placed that will
 * let the route terminate without DRC errors.  This is the following:
 *
 *		    w-1		        w-1	
 *		  <----->	      <---->
 *		        +-------------+-----+	^
 *		        |. . . . . . .|. . .|	| w-1
 *		        | . . . . . . | . . |	| 
 *		  +-----+. . . . . . .+-----+	v
 *		  |	| . . . . . . . . . |
 *		  |	|. . .tile . . . . .|
 *		  |	| . . . . . . . . . |
 *		  +-----+-------------+-----+	^
 *		        | 	      |	     	|
 *		        |	      |	     	| w-1
 *		        +-------------+      	v
 *
 * The upper-right corner of the tile is a keep-out area, where a route
 * would violate width rules.  The rest of the tile is valid for placement
 * of a route's lower left corner, as well as two extension areas to the
 * left and bottom.
 *
 * (to be done)---Both start and dest areas should not trim back the
 * upper corners of tiles that are connected to other start/dest tiles,
 * since that would leave unnecessary holes in the routable areas.
 * Not doing this tends to cause troubles when the start/dest nodes are
 * broken up into many tiles.
 */

#ifndef lint
static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/mzrouter/mzBlock.c,v 1.2 2010/10/22 15:02:15 tim Exp $";
#endif  /* not lint */

#include <stdio.h>

#include "utils/magic.h"
#include "utils/geometry.h"
#include "utils/geofast.h"
#include "tiles/tile.h"
#include "utils/hash.h"
#include "database/database.h"
#include "utils/signals.h"
#include "textio/textio.h"
#include "windows/windows.h"
#include "dbwind/dbwind.h"
#include "utils/malloc.h"
#include "utils/list.h"
#include "debug/debug.h"
#include "textio/textio.h"
#include "utils/heap.h"
#include "mzrouter/mzrouter.h"
#include "mzrouter/mzInternal.h"

/* Forward declarations */
extern void mzPaintBlockType();


/*
 * ----------------------------------------------------------------------------
 *
 * mzBuildMaskDataBlocks --
 *
 * Build blockage info from paint in buildArea.
 *
 * The design rules are used 
 * to build a map of blocked areas in blockage planes of RouteTypes.
 * This map will consist of TT_SPACE tiles, where a zero-width
 * path will yield a 
 * legal route when flushed out to wire width paint, and various
 * types of block tiles.   Multiple block types are needed to handle route 
 * termination at the destination node properly.
 *
 * TT_BLOCKED and TT_SAMENODE are generated from the mask data
 * (SAMENODE areas are only blocked by the destination node itself).
 *
 * In addition to blockage planes for route layers, there are
 * blockage planes for contacts, assumed to connect two planes.  
 * Both planes of mask information 
 * are effectively AND-ed together to form the blockage plane for
 * that type of contact.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Paints into Blockage planes in RouteTypes
 *
 * ----------------------------------------------------------------------------
 */

void
mzBuildMaskDataBlocks(buildArea)
    Rect *buildArea;	/* Area over which blockage planes will be built */
{
    Rect searchArea;
    int pNum;
    int mzPaintSameNodeFunc();	/* Fwd declaration */

    /* search area  = build area + context */
    searchArea.r_xbot = buildArea->r_xbot - mzContextRadius;
    searchArea.r_ybot = buildArea->r_ybot - mzContextRadius;
    searchArea.r_xtop = buildArea->r_xtop + mzContextRadius;
    searchArea.r_ytop = buildArea->r_ytop + mzContextRadius;

    /* Paint SAMENODE on all destination areas		 */
    /* (all areas that were painted into mzDestAreasUse->cu_def) */

    for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
    {
	DBSrPaintArea((Tile *)NULL, mzDestAreasUse->cu_def->cd_planes[pNum],
		&searchArea, &DBAllButSpaceAndDRCBits,
		mzPaintSameNodeFunc, (ClientData)buildArea);
    }

    /* Build the blockage planes on all layers, ignore unexpanded subcells
     * (unexpanded in reference window)
     */
    {
	int mzBuildBlockFunc();
	SearchContext scx;

	scx.scx_area = searchArea;
	scx.scx_trans = GeoIdentityTransform;
	scx.scx_use = mzRouteUse;

	(void) DBTreeSrTiles(
			     &scx, 
			     &DBAllButSpaceAndDRCBits, 
			     mzCellExpansionMask,
			     mzBuildBlockFunc, 
			     (ClientData) buildArea);
    }

    /* Add blocks at unexpanded subcells on all blockage planes 
     *
     * NOTE: A 0 expansion mask is special cased since 
     *     the mzrotuer interpets a 0 mask to mean all subcells are 
     *     expanded,
     *     while DBTreeSrCells() takes a 0 mask to mean all subcells are
     *     unexpanded.
     */

    if(mzCellExpansionMask != 0)
    {
	int mzBlockSubcellsFunc();
	SearchContext scx;

	scx.scx_area = searchArea;
	scx.scx_trans = GeoIdentityTransform;
	scx.scx_use = mzRouteUse;

	DBTreeSrCells(
		      &scx,
		      mzCellExpansionMask,
		      mzBlockSubcellsFunc,
		      (ClientData) buildArea);
    }
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzBuildBlockFunc --
 *
 * Filter function called via DBTreeSrTiles on behalf of mzBuildBlock()
 * above, for each solid tile in the area of interest.  Paints TT_BLOCKED
 * (TT_SAMENODE if the tile is marked) areas on each of the planes 
 * affected by this tile.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into Blockage Planes in RouteType structures.
 *
 * ----------------------------------------------------------------------------
 */

int
mzBuildBlockFunc(tile, cxp)

    Tile *tile;
    TreeContext *cxp;
{
    SearchContext *scx = cxp->tc_scx;
    Rect *buildArea = (Rect *) (cxp->tc_filter->tf_arg);
    Rect r, rDest;

    /* Transform to result coordinates */
    TITORECT(tile, &r);
    GEOCLIP(&r, &scx->scx_area);
    GEOTRANSRECT(&scx->scx_trans, &r, &rDest);

    mzPaintBlockType(&rDest, TiGetType(tile), buildArea, TT_BLOCKED);
    return (0);
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzBlockSubcellsFunc --
 *
 * Filter function called via DBTreeSrTiles on behalf of mzBuildBlock()
 * above, for each unexpanded subcell in the area of interest, 
 * a "blocked" area (TT_BLOCKED) is painted on each blockage plane for
 * the bounding box of the subcell, bloated by the maximum design rule
 * spacing on that plane.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into Blockage Planes in RouteType structures.
 *
 * ----------------------------------------------------------------------------
 */

int
mzBlockSubcellsFunc(scx, cdarg)
    SearchContext *scx;
    ClientData cdarg;
{
    Rect r, rDest;
    Rect *buildArea = (Rect *) cdarg;

    /* Transform bounding box to result coords */
    r = scx->scx_use->cu_def->cd_bbox;
    GEOTRANSRECT(&scx->scx_trans, &r, &rDest);

    if((int)(scx->scx_use->cu_client) != MZ_EXPAND_DEST)
    /* cell over part of dest node, paint normal blocks onto affected
     * planes.
     * (area is bloated by appropriate spacing on each affected plane)
     */
    {
	mzPaintBlockType(&rDest, TT_SUBCELL, buildArea, TT_BLOCKED);
    }
    else
    /* cell is over part of dest node, paint samenode blocks */
    {
	mzPaintBlockType(&rDest, TT_SUBCELL, buildArea, TT_SAMENODE);
    }

    return (0);
}

/*
 * ----------------------------------------------------------------------------
 *
 * mzPaintSameNodeFunc --
 *
 * Add TT_SAMENODE paint into the route layer block plane for each
 * tile found in mzDestAreasUse->cu_def
 *
 * Results:
 *	Always return 0 to keep the search going.
 *
 * ----------------------------------------------------------------------------
 */

int
mzPaintSameNodeFunc(Tile *t, Rect *buildArea)
{
    Rect r;
    TileType ttype;

    ttype = TiGetType(t);
    TiToRect(t, &r);

    mzPaintBlockType(&r, ttype, buildArea, TT_SAMENODE);

    return 0;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzPaintBlockType --
 *
 * Add "blockType" paint appropriate to data tile of given location
 * and type to blockage planes of all relevant routeTypes.
 *
 * The blockage tiles painted are bloated versions of the data tiles.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Modifies blockage planes in RouteType structures.
 *
 * ----------------------------------------------------------------------------
 */

void
mzPaintBlockType(r, type, buildArea, blockType)
    Rect *r;
    TileType type;
    Rect *buildArea;
    TileType blockType;
{
    RouteType *rT;
    TileType locBlockType;

    /* process routeTypes  */
    for (rT=mzActiveRTs; rT!=NULL; rT=rT->rt_nextActive)
    {
	Rect rblock;

	/* Added by Tim 7/28/06 --- Ignore those planes that don't interact! */

	if (!(DBTypePlaneMaskTbl[type] & DBTypePlaneMaskTbl[rT->rt_tileType]))
	    continue;

	/* if there is a constraint between RouteType and type, paint a block */

	locBlockType = blockType;

	if (rT->rt_bloatBot[type] >= 0)
	{
	    int bot, top;

	    /* If we're painting TT_BLOCKED, make sure we're not painting */
	    /* on top of a start or dest area (has TT_SAMENODE)	  */

	    if (blockType != TT_SAMENODE)
	    {
		RouteContact *rC;
		Tile *tp = rT->rt_hBlock->pl_hint;
		GOTOPOINT(tp, &r->r_ll);
		if (TiGetType(tp) == TT_SAMENODE)
		{
		    /* This can fail to paint a proper blockage on a	*/
		    /* contact plane when the terminal is in one plane	*/
		    /* and the blocking route is on the other.  So, if	*/
		    /* painting into a contact plane, check that the	*/
		    /* tile in the residue layer that is "type" is also	*/
		    /* covered in TT_SAMENODE, or this is a block.	*/

		    if (DBIsContact(rT->rt_tileType))
		    {
			for (rC = mzRouteContacts; rC != NULL; rC = rC->rc_next)
			{
			    if (rC->rc_routeType.rt_tileType == rT->rt_tileType)
			    {
				Tile *tp2;
				if (rC->rc_rLayer1->rl_routeType.rt_tileType == type)
				{
				    tp2 = rC->rc_rLayer1->
						rl_routeType.rt_hBlock->pl_hint;
				    GOTOPOINT(tp2, &r->r_ll);
				    if (TiGetType(tp) == TT_SAMENODE) break;
				}
				else if (rC->rc_rLayer2->rl_routeType.rt_tileType
						== type)
				{
				    tp2 = rC->rc_rLayer2->
						rl_routeType.rt_hBlock->pl_hint;
				    GOTOPOINT(tp2, &r->r_ll);
				    if (TiGetType(tp) == TT_SAMENODE) break;
				}
			    }
			}
			if (rC != NULL) continue;
		    }
		    else
			continue;
		}
	    }
	    else
	    {
		/* If the tile type is a contact of the same 
		 * type as the route type, draw a block layer, not SAMENODE.
		 * This prevents the maze router from attempting to place
		 * a contact too close to an existing one, causing a DRC
		 * error.
		 */
		if ((DBIsContact(type)) && (rT->rt_tileType == type))
		    locBlockType = TT_BLOCKED;
	    }

	    /* Compute blockage rectangle */
	    bot = rT->rt_bloatBot[type];
	    top = rT->rt_bloatTop[type];

	    if (locBlockType != TT_SAMENODE)
	    {
		rblock.r_xbot = r->r_xbot - bot;
		rblock.r_ybot = r->r_ybot - bot;

		rblock.r_xtop = r->r_xtop + top;
		rblock.r_ytop = r->r_ytop + top;
	    }
	    else
	    {
		int wless = bot - top + 1;

		/* SAMENODE:  valid route can start in one of	*/
		/* two overlapping rectangles as computed	*/
		/* below.  The left and bottom sides are	*/
		/* extended by the route width, but the		*/
		/* corners are prohibited.			*/

		rblock.r_xbot = r->r_xbot - wless;
		rblock.r_ybot = r->r_ybot;

		rblock.r_xtop = r->r_xtop;
		rblock.r_ytop = r->r_ytop - wless;

		GEOCLIP(&rblock, buildArea);
		if (!GEO_RECTNULL(&rblock))
		{
		    DBPaintPlane(rT->rt_hBlock, &rblock, 
				mzBlockPaintTbl[blockType],
				(PaintUndoInfo *) NULL);
		    DBPaintPlaneVert(rT->rt_vBlock, &rblock, 
		 		mzBlockPaintTbl[blockType],
		 		(PaintUndoInfo *) NULL);
		}

		rblock.r_xbot = r->r_xbot;
		rblock.r_ybot = r->r_ybot - wless;

		rblock.r_xtop = r->r_xtop - wless;
		rblock.r_ytop = r->r_ytop;
	    }

	    /* clip to build area */

	    GEOCLIP(&rblock, buildArea);
	    if (!GEO_RECTNULL(&rblock))
	    {
		/* and paint it */

		DBPaintPlane(rT->rt_hBlock, &rblock, 
				mzBlockPaintTbl[locBlockType],
				(PaintUndoInfo *) NULL);
		DBPaintPlaneVert(rT->rt_vBlock, &rblock, 
		 		mzBlockPaintTbl[locBlockType],
		 		(PaintUndoInfo *) NULL);
	    }
	}
    }

    return;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzBuildFenceBlocks -- 
 *
 * Blocks regions of fence parity opposite of the destination-point.
 * (Fence boundaries can not be crossed).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Blockage Planes modified.
 *
 * ----------------------------------------------------------------------------
 */

void
mzBuildFenceBlocks(buildArea)
    Rect *buildArea;		/* Area over which planes modified */
{
    int mzBuildFenceBlocksFunc();
    Rect searchArea;


    /* search area  = build area + context */
    searchArea.r_xbot = buildArea->r_xbot - mzContextRadius;
    searchArea.r_ybot = buildArea->r_ybot - mzContextRadius;
    searchArea.r_xtop = buildArea->r_xtop + mzContextRadius;
    searchArea.r_ytop = buildArea->r_ytop + mzContextRadius;

    /* If route inside fence, gen blocks at space tiles.
     * if route outside fence, gen blocks at fence tiles.
     */
    if(mzInsideFence)
    {
	DBSrPaintArea(NULL,	/* no hint tile */
		      mzHFencePlane, 
		      &searchArea, 
		      &DBSpaceBits,
		      mzBuildFenceBlocksFunc, 
		      (ClientData) buildArea);
    }
    else
    {
	DBSrPaintArea(NULL,	/* no hint tile */
		      mzHFencePlane, 
		      &searchArea, 
		      &DBAllButSpaceBits,
		      mzBuildFenceBlocksFunc, 
		      (ClientData) buildArea);
    }

    return;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzBuildFenceBlocksFunc --
 *
 * Called by DBSrPaintArea for tile in given area on fence plane where routing
 * is prohibited.  These areas are blocked,
 * adjusting for wire width on each blockage plane.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into blockage planes.
 *
 * ----------------------------------------------------------------------------
 */

int
mzBuildFenceBlocksFunc(tile, buildArea)
    Tile *tile;
    Rect *buildArea; /* clip to this area before painting */
{
    RouteType *rT;
    int d;
    Rect r, rAdjusted; 
    TileType tt = TiGetType(tile);

    /* Get boundary of tile */
    TITORECT(tile, &r);

    for (rT=mzActiveRTs; rT!=NULL; rT=rT->rt_nextActive)
    {
	/* Added by Tim 7/28/06 --- Ignore those planes that don't interact! */
	/* Revised 8/22/06---Fence tiles are supposed to block all layers!   */

	// if (!(DBTypePlaneMaskTbl[tt] & DBTypePlaneMaskTbl[rT->rt_tileType]))
	//    continue;

	/* adjust to compensate for wire width */
	d = rT->rt_effWidth - 1;
	rAdjusted.r_xbot = r.r_xbot - d;
	rAdjusted.r_xtop = r.r_xtop;
	rAdjusted.r_ybot = r.r_ybot - d;
	rAdjusted.r_ytop = r.r_ytop;

	/* clip to area being generated. */
	GEOCLIP(&rAdjusted, buildArea);

	/* Paint into blockage planes */
	DBPaintPlane(rT->rt_hBlock, 
		     &rAdjusted, 
		     mzBlockPaintTbl[TT_BLOCKED], 
		     (PaintUndoInfo *) NULL);
	DBPaintPlaneVert(rT->rt_vBlock, 
	 		 &rAdjusted, 
	 		 mzBlockPaintTbl[TT_BLOCKED], 
	 		 (PaintUndoInfo *) NULL);
    }
   
    /* return 0 - to continue search */
    return(0);
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzExtendBlockBoundsR --
 *
 * Generate blockage information around given rect.
 * Info required for radius of twice the bounds-increment around the rect.
 * The gen area is broken down into areas which have not already been gened.
 * Blockage info is generated for these subregions.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Paints into Blockage planes in RouteTypes
 *	Updates bounds plane.
 *
 * ----------------------------------------------------------------------------
 */

void
mzExtendBlockBoundsR(rect)
    Rect *rect;
{
    Rect area;
    TileTypeBitMask genMask;
    /* Generate twice the required bounds increment, so we don't have
     * to regenerate as soon as we move from the center of the newly
     * generated region. 
     */
    int genBoundsIncrement = mzBoundsIncrement * 2;
    int mzExtendBlockFunc();

    /* keep stats */
    mzBlockGenCalls++;

    /* mark area about rect in which blockage plane required to be present */
    area.r_xbot = rect->r_xbot - genBoundsIncrement;
    area.r_ybot = rect->r_ybot - genBoundsIncrement;
    area.r_xtop = rect->r_xtop + genBoundsIncrement;
    area.r_ytop = rect->r_ytop + genBoundsIncrement;


    DBPaintPlane(mzHBoundsPlane, 
	    &area,
	    mzBoundsPaintTbl[TT_GENBLOCK],
	    (PaintUndoInfo *) NULL);

    /* Generate blockage planes under each GENBLOCK tile = regions in
     * new area where blockage planes not previously generated 
    */
    TTMaskZero(&genMask);
    TTMaskSetType(&genMask,TT_GENBLOCK);
    DBSrPaintArea(NULL,         /* no hint tile */ 
       mzHBoundsPlane,
       &area,
       &genMask,
       mzExtendBlockFunc,
       (ClientData) NULL);

    /* Paint area INBOUNDS in both bounds planes 
     *(blockage planes now generated here) 
     */
    DBPaintPlane(mzHBoundsPlane, 
	    &area,
	    mzBoundsPaintTbl[TT_INBOUNDS],
	    (PaintUndoInfo *) NULL);
    DBPaintPlaneVert(mzVBoundsPlane, 
 	    &area,
 	    mzBoundsPaintTbl[TT_INBOUNDS],
 	    (PaintUndoInfo *) NULL);

    return;
}

#define RECT_AREA(r) \
    ((double)(r.r_xtop - r.r_xbot)*(double)(r.r_ytop - r.r_ybot))


/*
 * ----------------------------------------------------------------------------
 *
 * mzExtendBlockFunc --
 *
 * Called by DBSrPaintArea for rectangles where blockage info must be 
 * generated.
 *
 * Results:
 *	Return 0 always (to continue the search)
 *
 * Side effects:
 *	Paints into Blockage planes in RouteTypes
 *
 * ----------------------------------------------------------------------------
 */

int
mzExtendBlockFunc(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    Rect area;

    /* Get location of tile */
    TITORECT(tile, &area);

    /* Don't actually generate blocks outside of user supplied
     * route area hint.
     */
    if(mzBoundsHint)
    {
	GEOCLIP(&area,mzBoundsHint);
	if((area.r_xbot > area.r_xtop) || (area.r_ybot > area.r_ytop))
	/*no overlap just return */
	{
	    return 0;
	}
    }

    /* Grow clip area by 2 units to take care of boundary conditions. */
    area.r_xbot -= 2;
    area.r_xtop += 2;
    area.r_ybot -= 2;
    area.r_ytop += 2;

    mzBuildMaskDataBlocks(&area);
    mzBuildFenceBlocks(&area);

    /* keep stats */
    mzBlockGenArea += RECT_AREA(area);

    /* return 0 to continue search */
    return 0;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzExtendBlockBounds --
 *
 * Generate blockage information around given point.
 * Info required for radius of twice the bounds-increment around the point.
 * The gen area is broken down into areas which have not already been gened.
 * Blockage info is generated for these subregions.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Paints into Blockage planes in RouteTypes
 *	Updates bounds plane.
 *
 * ----------------------------------------------------------------------------
 */

void
mzExtendBlockBounds(point)
    Point *point;
{
    Rect rect;
    
    rect.r_ll = *point;
    rect.r_ur = *point;

    mzExtendBlockBoundsR(&rect);

    return;
}

/* 
 * This struc is used to store generated walks, since it is necessary
 * to defer painting walks until all are generated.
 */
typedef struct
{
    RouteType * w_rT;
    Rect 	w_rect;
    TileType	w_type;
} Walk;

/* global used to store walks prior to painting them */
List *mzWalkList;


/*
 * ----------------------------------------------------------------------------
 *
 * mzBuildDestAreaBlocks --
 *
 * Generate blockage information around all dest areas, and do special dest
 * area processing (generation of dest area blocks and walks).  In addition
 * dest area alignment coords are added to the alignment structures.
 *
 * TT_DEST_AREA and TT_*_WALK regions are generated from the special dest area
 * cell.  Dest areas are regions to connect to and walks are regions blocked
 * only by dest nodes and directly adjacent to a dest area.  Walks are 
 * routed through by special termination code.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Modifies blockage planes.
 *	Modifies alignment strucs.
 *	Updates bounds plane.
 *
 * ----------------------------------------------------------------------------
 */

void
mzBuildDestAreaBlocks()
{
    int mzDestAreaFunc();
    int mzDestWalksFunc();
    int mzLRCWalksFunc();
    int mzUDCWalksFunc();
    SearchContext scx;

    /* initialize global walk list */
    mzWalkList = NULL;

    /* Compute bounding box for dest areas cell */
    DBReComputeBbox(mzDestAreasUse->cu_def);

    /* Process dest areas in dest area cell one by one.  
     *     - generates normal blockage info.
     *     - paints dest area into appropriate blockage planes.
     *     - generates alignments.
     *     - generates list of walks.
     *     
     * Walks are not actually painted yet because existing 
     * walks can interfere with the generation of new ones.
     */

    scx.scx_area = mzBoundingRect;
    scx.scx_trans = GeoIdentityTransform;
    scx.scx_use = mzDestAreasUse;
	
    /* clip area to bounding box to avoid overflow during transforms */
    GEOCLIP(&(scx.scx_area), &(mzDestAreasUse->cu_def->cd_bbox));

    (void) DBTreeSrTiles( &scx, &DBAllButSpaceAndDRCBits, 
			     0, mzDestAreaFunc, (ClientData) NULL);

    (void) DBTreeSrTiles( &scx, &DBAllButSpaceAndDRCBits, 
			     0, mzDestWalksFunc, (ClientData) NULL);

    (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 
			     0, mzUDCWalksFunc, (ClientData) NULL);

    (void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 
			     0, mzLRCWalksFunc, (ClientData) NULL);

    /* Paint walks into blockage planes (and dealloc walk list) */

    {
	List *l;

	for(l = mzWalkList; l!= NULL; l=LIST_TAIL(l))
	{
	    Walk *walk = (Walk *) LIST_FIRST(l);

	    /* Diagnostic---something is wrong here! */
	    if (walk->w_type > TT_MAXROUTETYPES)
	    {
		TxError("Fatal: Bad destination walk!\n");
	 	continue;	/* Try to go on anyway */
	    }
		
	    DBPaintPlane(walk->w_rT->rt_hBlock, 
			 &(walk->w_rect),
			 mzBlockPaintTbl[walk->w_type],
			 (PaintUndoInfo *) NULL);

	    DBPaintPlaneVert(walk->w_rT->rt_vBlock, 
			     &(walk->w_rect),
			     mzBlockPaintTbl[walk->w_type],
			     (PaintUndoInfo *) NULL);
	}

	ListDeallocC(mzWalkList);
    }
    return;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzDestAreaFunc --
 *
 * Pregenerate blockage info around the destination area
 *
 * Results:
 *	Returns 0 on success.  In case we are stymied by an incomplete
 *	techfile entry for the maze router, return with 1 to stop the
 *	whole process.
 *
 * Side effects:
 *	Generates blockage info.
 *
 * ----------------------------------------------------------------------------
 */

int
mzDestAreaFunc(tile, cxp)
    Tile *tile;
    TreeContext *cxp;
{
    SearchContext *scx = cxp->tc_scx;
    TileType type = TiGetType(tile);
    Rect r, rect;
    RouteType *rT;

    /* Transform to result coordinates */
    TITORECT(tile, &r);
    GEOTRANSRECT(&scx->scx_trans, &r, &rect);

    mzExtendBlockBoundsR(&rect);

    /* find route type for this dest area */

    rT = mzActiveRTs;
    while ((rT != NULL) && (rT->rt_tileType != type))
	rT = rT->rt_nextActive;

    /* This can happen if the techfile does not completely define */
    /* the gaRoute info. . .					  */
    if (rT == NULL)
	return 1;
	
    /* Draw the routable destination area (see comments at top of file). */

    r.r_xtop = rect.r_xtop - rT->rt_width;
    r.r_ytop = rect.r_ytop;
    r.r_xbot = rect.r_xbot;
    r.r_ybot = rect.r_ybot - rT->rt_width;

    /* paint dest area into blockage planes of appropriate route type */
    DBPaintPlane(rT->rt_hBlock, &r, mzBlockPaintTbl[TT_DEST_AREA],
			(PaintUndoInfo *) NULL);

    DBPaintPlaneVert(rT->rt_vBlock, &r, mzBlockPaintTbl[TT_DEST_AREA],
			(PaintUndoInfo *) NULL);

    r.r_xtop = rect.r_xtop;
    r.r_ytop = rect.r_ytop - rT->rt_width;
    r.r_xbot = rect.r_xbot - rT->rt_width;
    r.r_ybot = rect.r_ybot;

    /* paint dest area into blockage planes of appropriate route type */
    DBPaintPlane(rT->rt_hBlock, &r, mzBlockPaintTbl[TT_DEST_AREA],
			(PaintUndoInfo *) NULL);

    DBPaintPlaneVert(rT->rt_vBlock, &r, mzBlockPaintTbl[TT_DEST_AREA],
			(PaintUndoInfo *) NULL);

    /* continue with next dest area */
    return 0;
}

/*
 * ----------------------------------------------------------------------------
 *
 * mzDestWalksFunc --
 *
 * Generate walks around each destination area tile, showing the router
 * the direct "walk" into the destination area from points around the
 * perimeter.  This prevents the routing algorithm from having to blindly
 * find the exact destination area;  it only has to get close enough to
 * be told how to paint a path directly to the destination node.
 *
 * Results:
 *	Returns 0 on success.  In case we are stymied by an incomplete
 *	techfile entry for the maze router, return with 1 to stop the
 *	whole process.
 *
 * Side effects:
 *	Generates walk tiles in the blockage planes
 *
 * ----------------------------------------------------------------------------
 */

int
mzDestWalksFunc(tile, cxp)
    Tile *tile;
    TreeContext *cxp;
{
    SearchContext *scx = cxp->tc_scx;
    TileType type = TiGetType(tile);
    Rect r, rect;
    RouteType *rT;
    int mzHWalksFunc();
    int mzVWalksFunc();
    int mzUDCWalksFunc();
    int mzLRCWalksFunc();
    TileTypeBitMask destAreaMask;

    /* Transform to result coordinates */
    TITORECT(tile, &r);
    GEOTRANSRECT(&scx->scx_trans, &r, &rect);

    /* find route type for this dest area */

    rT = mzActiveRTs;
    while ((rT != NULL) && (rT->rt_tileType != type))
	rT = rT->rt_nextActive;

    /* This can happen if the techfile does not completely define */
    /* the gaRoute info. . .					  */
    if (rT == NULL)
	return 1;
	
     /* Generate alignments and walks for dest areas.
      *
      * Since the above dest area may be partially blocked, the blockage
      * planes are searched for DEST_AREA tiles underneath
      * the dest area painted above to build lists of dest tiles.
      *
      * walks are accumulated into a list for painting after ALL walks
      * have been calculated.
      *
      */

    TTMaskSetOnlyType(&destAreaMask, TT_DEST_AREA);

    DBSrPaintArea(NULL,	/* no hint tile */
		      rT->rt_hBlock, &rect, 
		      &destAreaMask, mzHWalksFunc, 
		      (ClientData) rT);

    DBSrPaintArea(NULL,	/* no hint tile */
		      rT->rt_vBlock, &rect, 
		      &destAreaMask, mzVWalksFunc, 
		      (ClientData) rT);

    DBSrPaintArea(NULL,	/* no hint tile */
		      rT->rt_hBlock, &rect, 
		      &destAreaMask, mzLRCWalksFunc, 
		      (ClientData) rT);

    DBSrPaintArea(NULL,	/* no hint tile */
		      rT->rt_vBlock, &rect, 
		      &destAreaMask, mzUDCWalksFunc, 
		      (ClientData) rT);

    /* continue with next dest area */
    return 0;
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzHWalksFunc --
 *
 * Generate walks to top and bottom, and alignment y-coords for TT_DESTAREA
 * (Walks are added to list for painting after search completes.)
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Adds to walks list and alignment structure.
 *
 * ----------------------------------------------------------------------------
 */

int
mzHWalksFunc(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    RouteType *rT = (RouteType *) cdarg;

    /* Add dest area coordinates to dest alignment structure */
    {
	mzNLInsert(&mzXAlignNL, LEFT(tile));
	mzNLInsert(&mzXAlignNL, RIGHT(tile));
    }

    /* compute LEFT_WALK(s) */
    {
	Walk *walk;
	Tile *tLeft = BL(tile);
	
	/* Build walks for blocks to left of tile */
	while(BOTTOM(tLeft)<TOP(tile))
	{
	    if(TiGetType(tLeft)==TT_SAMENODE)
	    {
		walk = (Walk *) mallocMagic((unsigned) (sizeof(Walk)));
		walk->w_rT = rT; 
		walk->w_type = TT_LEFT_WALK;
		walk->w_rect.r_ybot = MAX(BOTTOM(tile),BOTTOM(tLeft));
		walk->w_rect.r_ytop = MIN(TOP(tile),TOP(tLeft));
		walk->w_rect.r_xtop = RIGHT(tLeft);
		walk->w_rect.r_xbot = MAX(LEFT(tLeft),
					   RIGHT(tLeft)-mzMaxWalkLength);
		LIST_ADD(walk, mzWalkList);
	    }
	    
	    /* move to next tile up */
	    tLeft = RT(tLeft);
	}
    }

    /* compute RIGHT_WALK */
    {
	Walk *walk;
	Tile *tRight = TR(tile);

	/* Build walks for blocks to right of tile */
	while(TOP(tRight)>BOTTOM(tile))
	{
	   if(TiGetType(tRight)==TT_SAMENODE)
	   {
	       walk = (Walk *) mallocMagic((unsigned) (sizeof(Walk)));
	       walk->w_rT = rT; 
	       walk->w_type = TT_RIGHT_WALK;
	       walk->w_rect.r_ybot = MAX(BOTTOM(tile),BOTTOM(tRight));
	       walk->w_rect.r_ytop = MIN(TOP(tile),TOP(tRight));
	       walk->w_rect.r_xbot = LEFT(tRight);
	       walk->w_rect.r_xtop = MIN(RIGHT(tRight), 
					  LEFT(tRight)+mzMaxWalkLength);
	       LIST_ADD(walk, mzWalkList);
	   }

	   /* move to next tile down */
	   tRight = LB(tRight);
       }
    }
   
    /* return 0 - to continue search */
    return(0);
}



/*
 * ----------------------------------------------------------------------------
 *
 * mzVWalksFunc --
 *
 * Generate walks to top and bottom, and alignment y-coords for TT_DESTAREA
 * (Walks are added to list for painting after search completes.)
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Adds to walks list and alignment structure.
 *
 * ----------------------------------------------------------------------------
 */

int
mzVWalksFunc(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    RouteType  *rT = (RouteType *) cdarg;

    /* Add dest area coordinates to dest alignment structure */
    {
	mzNLInsert(&mzYAlignNL, BOTTOM(tile));
	mzNLInsert(&mzYAlignNL, TOP(tile));
    }

    /* compute BOTTOM_WALK */
    {
	Walk *walk;
	Tile *tBelow = LB(tile);
	
	/* Build walks for blocks to below tile */
	while(LEFT(tBelow)<RIGHT(tile))
	{
	    if(TiGetType(tBelow)==TT_SAMENODE)
	    {
		walk = (Walk *) mallocMagic((unsigned) (sizeof(Walk)));
		walk->w_rT = rT;
		walk->w_type = TT_BOTTOM_WALK;
		walk->w_rect.r_xbot = MAX(LEFT(tile),LEFT(tBelow));
		walk->w_rect.r_xtop = MIN(RIGHT(tile),RIGHT(tBelow));
		walk->w_rect.r_ytop = TOP(tBelow);
		walk->w_rect.r_ybot = MAX(BOTTOM(tBelow),
					   TOP(tBelow)-mzMaxWalkLength);
		LIST_ADD(walk, mzWalkList);
	    }

	    /* move to next tile to left */
	    tBelow = TR(tBelow);
	}
    }

    /* compute TOP_WALK */
    {
	Walk *walk;
	Tile *tAbove = RT(tile);
	
	
	/* Build walks for blocks above tile */
	while(RIGHT(tAbove)>LEFT(tile))
	{
	    if(TiGetType(tAbove)==TT_SAMENODE)
	    {
		walk = (Walk *) mallocMagic((unsigned) (sizeof(Walk)));
		walk->w_rT = rT;
		walk->w_type = TT_TOP_WALK;
		walk->w_rect.r_xbot = MAX(LEFT(tile),LEFT(tAbove));;
		walk->w_rect.r_xtop = MIN(RIGHT(tile),RIGHT(tAbove));
		walk->w_rect.r_ybot = BOTTOM(tAbove);
		walk->w_rect.r_ytop = MIN(TOP(tAbove), 
					   BOTTOM(tAbove)+mzMaxWalkLength);
		LIST_ADD(walk, mzWalkList);
	    }

	    /* move to next tile to right */
	    tAbove = BL(tAbove);
	}
    }
   
    /* return 0 - to continue search */
    return(0);
}

/* 
 *  Structure to pass data between mzLRCWalksFunc, mzUDCWalksFunc, and mzCWalksFunc2
 */
typedef struct walkContactFuncData
{
    Rect		*wd_bounds;	/* dest area bounds */
    RouteLayer 		*wd_rL;		/* Route layer of walk_contact */
    int			wd_walk;	/* TT_ABOVE_*_WALK or TT_BELOW_*_WALK */
} WalkContactFuncData;


/*
 * ----------------------------------------------------------------------------
 *
 * mzLRCWalksFunc --
 *
 * Search dest area for regions where contacts are ok, and paint
 * CONTACT_WALK(s) there in adjacent layers.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into adjacent blocakge planes.
 *
 * ----------------------------------------------------------------------------
 */

int
mzLRCWalksFunc(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    RouteType *rT = (RouteType *) cdarg; /* RouteType of this dest area */
    RouteContact *rC;	
    Rect rect;
    int walkType;

    /* set rect to boundary of this dest area */
    TITORECT(tile, &rect);

    /* process contact types that can connect to this dest area */
    for (rC = mzRouteContacts; rC != NULL; rC = rC->rc_next)
    {
	RouteLayer *rLOther = NULL; 

	/* skip inactive contact types */
	if (!(rC->rc_routeType.rt_active)) continue;

	/* Find layer connecting to dest area FROM */
	if (&(rC->rc_rLayer1->rl_routeType) == rT)
	{
	    rLOther = rC->rc_rLayer2;
	    walkType = TT_ABOVE_LR_WALK;
	}
	else if (&(rC->rc_rLayer2->rl_routeType) == rT)
	{
	    rLOther = rC->rc_rLayer1;
	    walkType = TT_BELOW_LR_WALK;
	}

	/* If current contact type (RC) permits connection to dest area, 
	 * insert CONTACT_WALK(s) into blockage planes for other layer.
	 */
	if (rLOther)
	{
	    /* process contact-OK tiles in blockage plane for this contact */
	    int mzCWalksFunc2();
	    WalkContactFuncData wD;
	    TileTypeBitMask contactOKMask;

	    TTMaskSetOnlyType(&contactOKMask, TT_SPACE);
	    TTMaskSetType(&contactOKMask, TT_SAMENODE);

	    wD.wd_bounds = &rect; 
	    wD.wd_rL = rLOther;
	    wD.wd_walk = walkType;

	    /* search for OK places for contact in the horizontal plane	*/
	    /* and paint them.						*/

	    DBSrPaintArea(NULL,	/* no hint tile */
			      rC->rc_routeType.rt_hBlock,
			      &rect, 
			      &contactOKMask,
			      mzCWalksFunc2, 
			      (ClientData) &wD);
	}
    }
    
    /* return 0 - to continue search */
    return(0);
}

/*
 * ----------------------------------------------------------------------------
 *
 * mzUDCWalksFunc --
 *
 * Search dest area for regions where contacts are ok, and paint
 * CONTACT_WALK(s) there in adjacent layers.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into adjacent blocakge planes.
 *
 * ----------------------------------------------------------------------------
 */

int
mzUDCWalksFunc(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    RouteType *rT = (RouteType *) cdarg; /* RouteType of this dest area */
    RouteContact *rC;	
    Rect rect;
    int walkType;

    /* set rect to boundary of this dest area */
    TITORECT(tile, &rect);

    /* process contact types that can connect to this dest area */
    for (rC = mzRouteContacts; rC != NULL; rC = rC->rc_next)
    {
	RouteLayer *rLOther = NULL; 

	/* skip inactive contact types */
	if (!(rC->rc_routeType.rt_active)) continue;

	/* Find layer connecting to dest area FROM */
	if (&(rC->rc_rLayer1->rl_routeType) == rT)
	{
	    rLOther = rC->rc_rLayer2;
	    walkType = TT_ABOVE_UD_WALK;
	}
	else if (&(rC->rc_rLayer2->rl_routeType) == rT)
	{
	    rLOther = rC->rc_rLayer1;
	    walkType = TT_BELOW_UD_WALK;
	}

	/* If current contact type (RC) permits connection to dest area, 
	 * insert CONTACT_WALK(s) into blockage planes for other layer.
	 */
	if (rLOther)
	{
	    /* process contact-OK tiles in blockage plane for this contact */
	    int mzCWalksFunc2();
	    WalkContactFuncData wD;
	    TileTypeBitMask contactOKMask;

	    TTMaskSetOnlyType(&contactOKMask, TT_SPACE);
	    TTMaskSetType(&contactOKMask, TT_SAMENODE);

	    wD.wd_bounds = &rect; 
	    wD.wd_rL = rLOther;
	    wD.wd_walk = walkType;

	    /* search for OK places for contact in the vertical plane	*/
	    /* and paint them.						*/

	    DBSrPaintArea(NULL,	/* no hint tile */
			      rC->rc_routeType.rt_vBlock,
			      &rect, 
			      &contactOKMask,
			      mzCWalksFunc2, 
			      (ClientData) &wD);
	}
    }
    
    /* return 0 - to continue search */
    return(0);
}


/*
 * ----------------------------------------------------------------------------
 *
 * mzCWalksFunc2 --
 *
 * Called for tiles on contact plane where contact is OK that overlap a
 * dest area.  We paint a CONTACT_WALK on the blockage planes for the
 * other routeLayer, the one the contact connects to the dest area.
 *
 * Results:
 *	Returns 0 always.
 *
 * Side effects:
 *	Paints into blockage planes for "other" route layer.
 *
 * ----------------------------------------------------------------------------
 */

int
mzCWalksFunc2(tile, cdarg)
    Tile *tile;
    ClientData cdarg;
{
    WalkContactFuncData *wD = (WalkContactFuncData *) cdarg;
    Rect rect;
    Walk *walk;

    /* rect = tile clipped dest area bounds. */
    TITORECT(tile, &rect);
    GEOCLIP(&rect, wD->wd_bounds);

    /* To-do: check if non-square contacts fit? */

    /* Build walks for contacts above or below the tile */
    {
	walk = (Walk *) mallocMagic((unsigned) (sizeof(Walk)));
	walk->w_rT = &(wD->wd_rL->rl_routeType);
	walk->w_type = wD->wd_walk;
	walk->w_rect = rect;
	LIST_ADD(walk, mzWalkList);
    }

    /* return 0 - to continue search */
    return(0);
}