489 lines
14 KiB
C
489 lines
14 KiB
C
/*
|
|
* ExtInteraction.c --
|
|
*
|
|
* Circuit extraction.
|
|
* Finds interaction areas.
|
|
*
|
|
* *********************************************************************
|
|
* * Copyright (C) 1985, 1990 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. *
|
|
* *********************************************************************
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/extract/ExtInter.c,v 1.1.1.1 2008/02/03 20:43:50 tim Exp $";
|
|
#endif /* not lint */
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "utils/magic.h"
|
|
#include "utils/geometry.h"
|
|
#include "utils/geofast.h"
|
|
#include "utils/undo.h"
|
|
#include "tiles/tile.h"
|
|
#include "utils/hash.h"
|
|
#include "database/database.h"
|
|
#include "utils/malloc.h"
|
|
#include "textio/textio.h"
|
|
#include "debug/debug.h"
|
|
#include "extract/extract.h"
|
|
#include "extract/extractInt.h"
|
|
#include "utils/signals.h"
|
|
#include "utils/styles.h"
|
|
|
|
/* Local data */
|
|
CellUse *extInterUse = (CellUse *) NULL; /* Subtree being processed */
|
|
Plane *extInterPlane; /* Paint into this plane */
|
|
int extInterHalo; /* Elements closer than this
|
|
* constitute an interaction.
|
|
*/
|
|
int extInterBloat; /* Bloat by this much when
|
|
* painting into result plane.
|
|
*/
|
|
|
|
/* Forward declarations */
|
|
int extInterOverlapSubtree();
|
|
int extInterOverlapTile();
|
|
int extInterSubtree();
|
|
int extInterSubtreeClip();
|
|
int extInterSubtreeElement();
|
|
int extInterSubtreeTile();
|
|
int extInterSubtreePaint();
|
|
|
|
#define BLOATBY(r, h) ( (r)->r_xbot -= (h), (r)->r_ybot -= (h), \
|
|
(r)->r_xtop += (h), (r)->r_ytop += (h) )
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* ExtFindInteractions --
|
|
*
|
|
* Paint into the supplied tile plane 'resultPlane' TT_ERROR_P tiles
|
|
* for each area in the CellDef 'def' that must be processed for
|
|
* interactions.
|
|
*
|
|
* Each interaction arises from paint in two different subtrees
|
|
* being less than (but not equal to) 'halo' units away from
|
|
* each other. In this definition, a subtree refers to a single
|
|
* CellUse, which may be either a single cell or an entire array.
|
|
*
|
|
* If 'bloat' is non-zero, each interaction area is bloated by
|
|
* this amount when being painted into the result plane.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* Paints into the plane 'resultPlane'.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ExtFindInteractions(def, halo, bloatby, resultPlane)
|
|
CellDef *def; /* Find interactions among children of def */
|
|
int halo; /* Interaction is elements closer than halo */
|
|
int bloatby; /* Bloat each interaction area by this amount when
|
|
* painting into resultPlane.
|
|
*/
|
|
Plane *resultPlane; /* Paint interaction areas into this plane */
|
|
{
|
|
SearchContext scx;
|
|
|
|
UndoDisable();
|
|
extInterPlane = resultPlane;
|
|
extInterHalo = halo;
|
|
extInterBloat = bloatby;
|
|
extParentUse->cu_def = def;
|
|
scx.scx_use = extParentUse;
|
|
scx.scx_trans = GeoIdentityTransform;
|
|
scx.scx_area = def->cd_bbox;
|
|
|
|
/*
|
|
* Process each child subtree.
|
|
* This involves comparing all the paint in the subtree
|
|
* with all the paint in all other subtrees up to, but
|
|
* not including, the subtree under consideration.
|
|
*/
|
|
extInterUse = (CellUse *) NULL;
|
|
(void) DBCellSrArea(&scx, extInterSubtree, (ClientData) NULL);
|
|
|
|
/*
|
|
* Process parent paint if there were any subcells.
|
|
* We compare each paint rectangle with all the paint in
|
|
* all the subtrees, to see if there is an overlap.
|
|
*/
|
|
if (extInterUse)
|
|
{
|
|
extInterUse = (CellUse *) NULL;
|
|
(void) DBCellSrArea(&scx, extInterSubtreePaint, (ClientData) def);
|
|
}
|
|
UndoEnable();
|
|
}
|
|
|
|
int
|
|
extInterSubtreePaint(scx, def)
|
|
SearchContext *scx;
|
|
CellDef *def;
|
|
{
|
|
Rect r;
|
|
int pNum;
|
|
|
|
r = scx->scx_use->cu_bbox;
|
|
BLOATBY(&r, extInterHalo);
|
|
for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
|
|
(void) DBSrPaintArea((Tile *) NULL, def->cd_planes[pNum], &r,
|
|
&DBAllButSpaceAndDRCBits, extInterSubtreeTile, (ClientData) NULL);
|
|
|
|
return (2);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extInterSubtree --
|
|
*
|
|
* Called for each immediate child use of the cell being processed
|
|
* for interactions. Our job is to process all the paint in this
|
|
* use against all other subtrees overlapping this one.
|
|
*
|
|
* Results:
|
|
* Returns 2 to abort after the first array element.
|
|
*
|
|
* Side effects:
|
|
* Sets extInterUse to scx->scx_use.
|
|
* Children may paint into extInterPlane.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extInterSubtree(scx)
|
|
SearchContext *scx;
|
|
{
|
|
CellUse *oldUse = extInterUse;
|
|
SearchContext parentScx;
|
|
|
|
extInterUse = scx->scx_use;
|
|
if (oldUse)
|
|
{
|
|
/* Find all other subtrees overlapping this cell */
|
|
parentScx.scx_area = scx->scx_use->cu_bbox;
|
|
BLOATBY(&parentScx.scx_area, extInterHalo);
|
|
parentScx.scx_trans = GeoIdentityTransform;
|
|
parentScx.scx_use = extParentUse;
|
|
(void) DBCellSrArea(&parentScx, extInterSubtreeClip, (ClientData) scx);
|
|
}
|
|
return (2);
|
|
}
|
|
|
|
int
|
|
extInterSubtreeClip(overlapScx, scx)
|
|
SearchContext *overlapScx, *scx;
|
|
{
|
|
Rect r, r2;
|
|
|
|
/* Only search as far as extInterUse */
|
|
if (overlapScx->scx_use == extInterUse)
|
|
return (2);
|
|
|
|
/*
|
|
* Only process the overlap between overlapScx and scx,
|
|
* bloating both by extInterHalo.
|
|
*/
|
|
r = overlapScx->scx_use->cu_bbox;
|
|
BLOATBY(&r, extInterHalo);
|
|
r2 = scx->scx_use->cu_bbox;
|
|
BLOATBY(&r2, extInterHalo);
|
|
GEOCLIP(&r, &r2);
|
|
|
|
(void) DBArraySr(scx->scx_use, &r, extInterSubtreeElement,
|
|
(ClientData) &r);
|
|
return (2);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extInterSubtreeElement --
|
|
*
|
|
* Called for each element in the array forming the use passed to
|
|
* extInterSubtree(). See extInterSubtree() for comments.
|
|
*
|
|
* Results:
|
|
* Returns 0 always.
|
|
*
|
|
* Side effects:
|
|
* See ExtFindInteractions.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extInterSubtreeElement(use, trans, x, y, r)
|
|
CellUse *use;
|
|
Transform *trans;
|
|
int x, y;
|
|
Rect *r;
|
|
{
|
|
SearchContext scx;
|
|
Transform tinv;
|
|
|
|
scx.scx_use = use;
|
|
scx.scx_trans = *trans;
|
|
scx.scx_x = x;
|
|
scx.scx_y = y;
|
|
GEOINVERTTRANS(trans, &tinv);
|
|
GEOTRANSRECT(&tinv, r, &scx.scx_area);
|
|
(void) DBTreeSrTiles(&scx, &DBAllButSpaceAndDRCBits, 0,
|
|
extInterSubtreeTile, (ClientData) NULL);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extInterSubtreeTile --
|
|
*
|
|
* Called for each tile in the subtree being processed by
|
|
* extInterSubtree(). Transform this tile to root coordinates,
|
|
* bloating by extInterHalo, and then call extInterOverlapSubtree
|
|
* to process all the other subtrees for paint overlapping
|
|
* this bloated area. If the argument 'cxp' is non-NULL, we
|
|
* use cxp->tc_scx->scx_trans to transform the area of tile to
|
|
* root coordinates; otherwise, we don't transform it at all.
|
|
*
|
|
* Results:
|
|
* Returns 0 always.
|
|
*
|
|
* Side effects:
|
|
* See extInterOverlapTile.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extInterSubtreeTile(tile, cxp)
|
|
Tile *tile;
|
|
TreeContext *cxp;
|
|
{
|
|
SearchContext newscx;
|
|
Rect r;
|
|
|
|
TITORECT(tile, &r);
|
|
BLOATBY(&r, extInterHalo);
|
|
if (cxp)
|
|
{
|
|
GEOTRANSRECT(&cxp->tc_scx->scx_trans, &r, &newscx.scx_area);
|
|
}
|
|
else newscx.scx_area = r;
|
|
newscx.scx_trans = GeoIdentityTransform;
|
|
newscx.scx_use = extParentUse;
|
|
(void) DBCellSrArea(&newscx, extInterOverlapSubtree, (ClientData) NULL);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extInterOverlapSubtree --
|
|
*
|
|
* Called for each subcell of the root that overlaps the piece
|
|
* of paint found by extInterSubtreeTile() above. We stop
|
|
* as soon as we see extInterUse; otherwise, search all the
|
|
* cells in the subtree rooted at scx->scx_use for paint
|
|
* overlapping scx->scx_area.
|
|
*
|
|
* Results:
|
|
* Returns 2 if we see extInterUse; otherwise, returns 0.
|
|
*
|
|
* Side effects:
|
|
* Paints into the plane 'resultPlane'; see extInterOverlapTile.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extInterOverlapSubtree(scx)
|
|
SearchContext *scx;
|
|
{
|
|
if (extInterUse == scx->scx_use)
|
|
return (2);
|
|
|
|
(void) extTreeSrPaintArea(scx, extInterOverlapTile, (ClientData) NULL);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extInterOverlapTile --
|
|
*
|
|
* Called for each piece of paint overlapping the piece found
|
|
* by extInterSubtreeTile(). Bloat the found piece by extInterHalo,
|
|
* then clip to the area of the overlapping piece of paint in root
|
|
* coordinates. If the result is non-empty, paint it into the
|
|
* plane extInterPlane.
|
|
*
|
|
* Results:
|
|
* Returns 0 always.
|
|
*
|
|
* Side effects:
|
|
* Paints into the plane 'resultPlane'.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extInterOverlapTile(tile, cxp)
|
|
Tile *tile;
|
|
TreeContext *cxp;
|
|
{
|
|
SearchContext *scx = cxp->tc_scx;
|
|
Rect r, rootr;
|
|
|
|
TITORECT(tile, &r);
|
|
BLOATBY(&r, extInterHalo);
|
|
GEOCLIP(&r, &scx->scx_area);
|
|
if (GEO_RECTNULL(&r))
|
|
return (0);
|
|
|
|
GEOTRANSRECT(&scx->scx_trans, &r, &rootr);
|
|
BLOATBY(&rootr, extInterBloat);
|
|
DBPaintPlane(extInterPlane, &rootr, DBStdWriteTbl(TT_ERROR_P),
|
|
(PaintUndoInfo *) NULL);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
*-----------------------------------------------------------------------------
|
|
*
|
|
* extTreeSrPaintArea --
|
|
*
|
|
* Recursively search downward from the supplied CellUse for
|
|
* all paint tiles.
|
|
*
|
|
* The procedure should be of the following form:
|
|
*
|
|
* int
|
|
* func(tile, scx, cdata)
|
|
* Tile *tile;
|
|
* SearchContext *scx;
|
|
* ClientData cdata;
|
|
* {
|
|
* }
|
|
*
|
|
* The SearchContext is stored in cxp->tc_scx, and the user's arg is stored
|
|
* in cxp->tc_filter->tf_arg.
|
|
*
|
|
* In the above, the scx transform is the net transform from the coordinates
|
|
* of tile to "world" coordinates (or whatever coordinates the initial
|
|
* transform supplied to extTreeSrTiles was a transform to). Func returns
|
|
* 0 under normal conditions. If 1 is returned, it is a request to
|
|
* abort the search.
|
|
*
|
|
* *** WARNING ***
|
|
*
|
|
* The client procedure should not modify any of the paint planes in
|
|
* the cells visited by extTreeSrTiles, because we use DBSrPaintArea
|
|
* as our paint-tile enumeration function.
|
|
*
|
|
* Results:
|
|
* 0 is returned if the search finished normally. 1 is returned
|
|
* if the search was aborted.
|
|
*
|
|
* Side effects:
|
|
* Whatever side effects are brought about by applying the
|
|
* procedure supplied.
|
|
*
|
|
*-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
int
|
|
extTreeSrPaintArea(scx, func, cdarg)
|
|
SearchContext *scx; /* Pointer to search context specifying
|
|
* a cell use to search, an area in the
|
|
* coordinates of the cell's def, and a
|
|
* transform back to "root" coordinates.
|
|
*/
|
|
int (*func)(); /* Function to apply at each qualifying tile */
|
|
ClientData cdarg; /* Client data for above function */
|
|
{
|
|
int extTreeSrFunc();
|
|
CellDef *def = scx->scx_use->cu_def;
|
|
TreeContext context;
|
|
TreeFilter filter;
|
|
int pNum;
|
|
|
|
if ((def->cd_flags & CDAVAILABLE) == 0)
|
|
{
|
|
bool dereference = (def->cd_flags & CDDEREFERENCE) ? TRUE : FALSE;
|
|
if (!DBCellRead(def, (char *) NULL, TRUE, dereference, NULL)) return 0;
|
|
}
|
|
|
|
filter.tf_func = func;
|
|
filter.tf_arg = cdarg;
|
|
context.tc_scx = scx;
|
|
context.tc_filter = &filter;
|
|
|
|
/*
|
|
* Apply the function first to any of the tiles in the planes
|
|
* for this CellUse's CellDef that match the mask.
|
|
*/
|
|
for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
|
|
if (DBSrPaintArea((Tile *) NULL, def->cd_planes[pNum],
|
|
&scx->scx_area, &DBAllButSpaceAndDRCBits, func,
|
|
(ClientData) &context))
|
|
return (1);
|
|
|
|
/* Visit our children recursively */
|
|
return (DBCellSrArea(scx, extTreeSrFunc, (ClientData) &filter));
|
|
}
|
|
|
|
/*
|
|
* extTreeSrFunc --
|
|
*
|
|
* Filter procedure applied to subcells by extTreeSrPaintArea().
|
|
*/
|
|
|
|
int
|
|
extTreeSrFunc(scx, fp)
|
|
SearchContext *scx;
|
|
TreeFilter *fp;
|
|
{
|
|
CellDef *def = scx->scx_use->cu_def;
|
|
TreeContext context;
|
|
int pNum;
|
|
|
|
if ((def->cd_flags & CDAVAILABLE) == 0)
|
|
{
|
|
bool dereference = (def->cd_flags & CDDEREFERENCE) ? TRUE : FALSE;
|
|
if (!DBCellRead(def, (char *) NULL, TRUE, dereference, NULL)) return (0);
|
|
}
|
|
|
|
context.tc_scx = scx;
|
|
context.tc_filter = fp;
|
|
|
|
/*
|
|
* Apply the function first to any of the tiles in the planes
|
|
* for this CellUse's CellDef that match the mask.
|
|
*/
|
|
for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
|
|
if (DBSrPaintArea((Tile *) NULL, def->cd_planes[pNum],
|
|
&scx->scx_area, &DBAllButSpaceAndDRCBits,
|
|
fp->tf_func, (ClientData) &context))
|
|
return (1);
|
|
|
|
/* Visit our children recursively */
|
|
return (DBCellSrArea(scx, extTreeSrFunc, (ClientData) fp));
|
|
}
|
|
|