mirror of
https://github.com/RTimothyEdwards/magic.git
synced 2026-08-29 17:39:28 +02:00
R. Timothy Edwards
516c9d7635
and forcing it to be passed as an argument to all the callback functions for the search routines that require it. Magic now compiles and runs with the new code, but there are a number of known issues that need to be fixed up. Committing now so that I can rebase on the last update to the master branch.
1448 lines
36 KiB
C
1448 lines
36 KiB
C
/*
|
|
* ExtTest.c --
|
|
*
|
|
* Circuit extraction.
|
|
* Interface for testing.
|
|
*
|
|
* *********************************************************************
|
|
* * 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/ExtTest.c,v 1.3 2009/05/13 15:03:16 tim Exp $";
|
|
#endif /* not lint */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "utils/magic.h"
|
|
#include "utils/utils.h"
|
|
#include "utils/geometry.h"
|
|
#include "utils/styles.h"
|
|
#include "tiles/tile.h"
|
|
#include "utils/hash.h"
|
|
#include "database/database.h"
|
|
#include "utils/malloc.h"
|
|
#include "windows/windows.h"
|
|
#include "graphics/graphics.h"
|
|
#include "dbwind/dbwind.h"
|
|
#include "utils/main.h"
|
|
#include "commands/commands.h"
|
|
#include "textio/textio.h"
|
|
#include "textio/txcommands.h"
|
|
#include "debug/debug.h"
|
|
#include "extract/extract.h"
|
|
#include "extract/extractInt.h"
|
|
|
|
int extDebAreaEnum;
|
|
int extDebArray;
|
|
int extDebHardWay;
|
|
int extDebHierCap;
|
|
int extDebHierAreaCap;
|
|
int extDebLabel;
|
|
int extDebNeighbor;
|
|
int extDebNoArray;
|
|
int extDebNoFeedback;
|
|
int extDebNoHard;
|
|
int extDebNoSubcell;
|
|
int extDebLength;
|
|
int extDebPerim;
|
|
int extDebResist;
|
|
int extDebVisOnly;
|
|
int extDebYank;
|
|
|
|
/*
|
|
* The following are used for selective redisplay while debugging
|
|
* the circuit extractor.
|
|
*/
|
|
Rect extScreenClip;
|
|
CellDef *extCellDef;
|
|
MagWindow *extDebugWindow;
|
|
|
|
/* The width of an edge in pixels when it is displayed */
|
|
int extEdgePixels = 4;
|
|
|
|
/* Forward declarations */
|
|
int extShowInter();
|
|
void extShowTech();
|
|
void extDispInit();
|
|
bool extShowRect();
|
|
void extMore();
|
|
|
|
void extShowTrans(char *, TileTypeBitMask *, FILE *);
|
|
void extShowMask(TileTypeBitMask *, FILE *);
|
|
void extShowPlanes(PlaneMask, FILE *);
|
|
void extShowConnect(char *, TileTypeBitMask *, FILE *);
|
|
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* ExtractTest --
|
|
*
|
|
* Command interface for testing circuit extraction.
|
|
* Usage:
|
|
* *extract
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* Extracts the current cell, writing a file named
|
|
* currentcellname.ext.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ExtractTest(w, cmd)
|
|
MagWindow *w;
|
|
TxCommand *cmd;
|
|
{
|
|
extern long extSubtreeTotalArea;
|
|
extern long extSubtreeInteractionArea;
|
|
extern long extSubtreeClippedArea;
|
|
static Plane *interPlane = (Plane *) NULL;
|
|
static long areaTotal = 0, areaInteraction = 0, areaClipped = 0;
|
|
long a1, a2;
|
|
int n, halo, bloat;
|
|
CellUse *selectedCell;
|
|
Rect editArea;
|
|
char *addr, *name;
|
|
typedef enum { CLRDEBUG, CLRLENGTH, DRIVER, DUMP, INTERACTIONS,
|
|
INTERCOUNT, EXTPARENTS, RECEIVER, SETDEBUG, SHOWDEBUG,
|
|
SHOWPARENTS, SHOWTECH, STATS, STEP, TIME } cmdType;
|
|
static const struct
|
|
{
|
|
const char *cmd_name;
|
|
cmdType cmd_val;
|
|
} cmds[] = {
|
|
{"clrdebug", CLRDEBUG},
|
|
{"clrlength", CLRLENGTH},
|
|
{"driver", DRIVER},
|
|
{"dump", DUMP},
|
|
{"interactions", INTERACTIONS},
|
|
{"intercount", INTERCOUNT},
|
|
{"parents", EXTPARENTS},
|
|
{"receiver", RECEIVER},
|
|
{"setdebug", SETDEBUG},
|
|
{"showdebug", SHOWDEBUG},
|
|
{"showparents", SHOWPARENTS},
|
|
{"showtech", SHOWTECH},
|
|
{"stats", STATS},
|
|
{"step", STEP},
|
|
{"times", TIME},
|
|
{0}
|
|
};
|
|
|
|
if (cmd->tx_argc == 1)
|
|
{
|
|
Plane *savePlane;
|
|
|
|
selectedCell = CmdGetSelectedCell((Transform *) NULL);
|
|
if (selectedCell == NULL)
|
|
{
|
|
TxError("No cell selected\n");
|
|
return;
|
|
}
|
|
|
|
extDispInit(selectedCell->cu_def, w);
|
|
savePlane = ExtCell(selectedCell->cu_def, selectedCell->cu_def->cd_name, FALSE);
|
|
ExtRevertSubstrate(selectedCell->cu_def, savePlane);
|
|
return;
|
|
}
|
|
|
|
n = LookupStruct(cmd->tx_argv[1], (const LookupTable *) cmds, sizeof cmds[0]);
|
|
if (n < 0)
|
|
{
|
|
TxError("Unrecognized subcommand: %s\n", cmd->tx_argv[1]);
|
|
TxError("Valid subcommands:");
|
|
for (n = 0; cmds[n].cmd_name; n++)
|
|
TxError(" %s", cmds[n].cmd_name);
|
|
TxError("\n");
|
|
return;
|
|
}
|
|
|
|
switch (cmds[n].cmd_val)
|
|
{
|
|
case STATS:
|
|
areaTotal += extSubtreeTotalArea;
|
|
areaInteraction += extSubtreeInteractionArea;
|
|
areaClipped += extSubtreeClippedArea;
|
|
TxPrintf("Extraction statistics (recent/total):\n");
|
|
TxPrintf("Total area of all cells = %ld / %ld\n",
|
|
extSubtreeTotalArea, areaTotal);
|
|
a1 = extSubtreeTotalArea;
|
|
a2 = areaTotal;
|
|
if (a1 == 0) a1 = 1;
|
|
if (a2 == 0) a2 = 1;
|
|
TxPrintf(
|
|
"Total interaction area processed = %ld (%.2f%%) / %ld (%.2f%%)\n",
|
|
extSubtreeInteractionArea,
|
|
((double) extSubtreeInteractionArea) / ((double) a1) * 100.0,
|
|
areaInteraction,
|
|
((double) areaInteraction) / ((double) a2) * 100.0);
|
|
TxPrintf(
|
|
"Clipped interaction area= %ld (%.2f%%) / %ld (%.2f%%)\n",
|
|
extSubtreeClippedArea,
|
|
((double) extSubtreeClippedArea) / ((double) a1) * 100.0,
|
|
areaClipped,
|
|
((double) areaClipped) / ((double) a2) * 100.0);
|
|
extSubtreeTotalArea = 0;
|
|
extSubtreeInteractionArea = 0;
|
|
extSubtreeClippedArea = 0;
|
|
break;
|
|
case INTERACTIONS:
|
|
if (interPlane == NULL)
|
|
interPlane = DBNewPlane((ClientData) TT_SPACE);
|
|
halo = 1, bloat = 0;
|
|
if (cmd->tx_argc > 2) halo = atoi(cmd->tx_argv[2]) + 1;
|
|
if (cmd->tx_argc > 3) bloat = atoi(cmd->tx_argv[3]);
|
|
ExtFindInteractions(EditCellUse->cu_def, halo, bloat, interPlane);
|
|
(void) DBSrPaintArea((Tile *) NULL, interPlane, &TiPlaneRect,
|
|
&DBAllButSpaceBits, extShowInter, (ClientData) NULL);
|
|
DBClearPaintPlane(interPlane);
|
|
break;
|
|
case INTERCOUNT:
|
|
halo = 1;
|
|
if (cmd->tx_argc > 2)
|
|
halo = atoi(cmd->tx_argv[2]);
|
|
if (cmd->tx_argc > 3)
|
|
{
|
|
FILE *f = fopen(cmd->tx_argv[3], "w");
|
|
if (f == NULL)
|
|
{
|
|
perror(cmd->tx_argv[3]);
|
|
break;
|
|
}
|
|
ExtInterCount((CellUse *) w->w_surfaceID, halo, f);
|
|
fclose(f);
|
|
}
|
|
else
|
|
{
|
|
ExtInterCount((CellUse *) w->w_surfaceID, halo, stdout);
|
|
}
|
|
break;
|
|
case TIME:
|
|
if (cmd->tx_argc > 2)
|
|
{
|
|
FILE *f = fopen(cmd->tx_argv[2], "w");
|
|
if (f == NULL)
|
|
{
|
|
perror(cmd->tx_argv[2]);
|
|
break;
|
|
}
|
|
ExtTimes((CellUse *) w->w_surfaceID, f);
|
|
fclose(f);
|
|
}
|
|
else
|
|
{
|
|
ExtTimes((CellUse *) w->w_surfaceID, stdout);
|
|
}
|
|
break;
|
|
case EXTPARENTS:
|
|
if (ToolGetEditBox(&editArea))
|
|
ExtParentArea(EditCellUse, &editArea, TRUE);
|
|
break;
|
|
|
|
case DUMP:
|
|
if (cmd->tx_argc != 2 && cmd->tx_argc != 3)
|
|
{
|
|
TxError("Usage: *extract dump filename|-\n");
|
|
break;
|
|
}
|
|
ExtDumpCaps(cmd->tx_argc > 2 ? cmd->tx_argv[2] : "-");
|
|
break;
|
|
|
|
case DRIVER:
|
|
if (cmd->tx_argc != 3)
|
|
{
|
|
TxError("Usage: *extract driver terminalname\n");
|
|
break;
|
|
}
|
|
ExtSetDriver(cmd->tx_argv[2]);
|
|
break;
|
|
case RECEIVER:
|
|
if (cmd->tx_argc != 3)
|
|
{
|
|
TxError("Usage: *extract receiver terminalname\n");
|
|
break;
|
|
}
|
|
ExtSetReceiver(cmd->tx_argv[2]);
|
|
break;
|
|
case CLRLENGTH:
|
|
TxPrintf("Clearing driver/receiver length list\n");
|
|
ExtLengthClear();
|
|
break;
|
|
|
|
case SHOWPARENTS:
|
|
if (ToolGetEditBox(&editArea))
|
|
ExtParentArea(EditCellUse, &editArea, FALSE);
|
|
break;
|
|
case SETDEBUG:
|
|
DebugSet(extDebugID, cmd->tx_argc - 2, &cmd->tx_argv[2], TRUE);
|
|
break;
|
|
case CLRDEBUG:
|
|
DebugSet(extDebugID, cmd->tx_argc - 2, &cmd->tx_argv[2], FALSE);
|
|
break;
|
|
|
|
case SHOWDEBUG:
|
|
DebugShow(extDebugID);
|
|
break;
|
|
case SHOWTECH:
|
|
extShowTech(cmd->tx_argc > 2 ? cmd->tx_argv[2] : "-");
|
|
break;
|
|
case STEP:
|
|
TxPrintf("Current interaction step size is %d\n",
|
|
ExtCurStyle->exts_stepSize);
|
|
if (cmd->tx_argc > 2)
|
|
{
|
|
ExtCurStyle->exts_stepSize = atoi(cmd->tx_argv[2]);
|
|
TxPrintf("New interaction step size is %d\n",
|
|
ExtCurStyle->exts_stepSize);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
int
|
|
extShowInter(tile, dinfo, clientdata)
|
|
Tile *tile;
|
|
TileType dinfo; /* (unused) */
|
|
ClientData clientdata; /* (unused) */
|
|
{
|
|
Rect r;
|
|
|
|
TiToRect(tile, &r);
|
|
DBWFeedbackAdd(&r, "interaction", EditCellUse->cu_def,
|
|
1, STYLE_MEDIUMHIGHLIGHTS);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extShowTech --
|
|
*
|
|
* Display the technology-specific tables maintained for circuit
|
|
* extraction in a human-readable format. Intended mainly for
|
|
* debugging technology files. If the argument 'name' is "-",
|
|
* the output is to the standard output; otherwise, it is to
|
|
* the file whose name is 'name'.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* None.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
extShowTech(name)
|
|
char *name;
|
|
{
|
|
FILE *out;
|
|
TileType t, s;
|
|
int p;
|
|
EdgeCap *e;
|
|
|
|
if (strcmp(name, "-") == 0)
|
|
out = stdout;
|
|
else
|
|
{
|
|
out = fopen(name, "w");
|
|
if (out == NULL)
|
|
{
|
|
perror(name);
|
|
return;
|
|
}
|
|
}
|
|
|
|
extShowTrans("Transistor", &ExtCurStyle->exts_deviceMask, out);
|
|
|
|
fprintf(out, "\nNode resistance and capacitance:\n");
|
|
fprintf(out, "type R-ohm/sq AreaC-ff/l**2\n");
|
|
for (t = TT_TECHDEPBASE; t < DBNumTypes; t++)
|
|
fprintf(out, "%-8.8s %8d %9lf\n",
|
|
DBTypeShortName(t),
|
|
ExtCurStyle->exts_resistByResistClass[
|
|
ExtCurStyle->exts_typeToResistClass[t]],
|
|
ExtCurStyle->exts_areaCap[t]);
|
|
|
|
fprintf(out, "\nTypes contributing to resistive perimeter:\n");
|
|
fprintf(out, "type R-type boundary types\n");
|
|
for (t = TT_TECHDEPBASE; t < DBNumTypes; t++)
|
|
{
|
|
fprintf(out, "%-8.8s ", DBTypeShortName(t));
|
|
fprintf(out, "%7d ", ExtCurStyle->exts_typeToResistClass[t]);
|
|
extShowMask(&ExtCurStyle->exts_typesResistChanged[t], out);
|
|
fprintf(out, "\n");
|
|
}
|
|
|
|
fprintf(out, "\nSidewall capacitance:\n");
|
|
for (t = TT_TECHDEPBASE; t < DBNumTypes; t++)
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (ExtCurStyle->exts_perimCap[t][s] != (CapValue) 0)
|
|
fprintf(out, " %-8.8s %-8.8s %8lf\n",
|
|
DBTypeShortName(t), DBTypeShortName(s),
|
|
ExtCurStyle->exts_perimCap[t][s]);
|
|
|
|
fprintf(out, "\nInternodal overlap capacitance:\n");
|
|
fprintf(out, "\n (by plane)\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapPlanes , p))
|
|
{
|
|
fprintf(out, " %-10.10s: types=", DBPlaneShortName(p));
|
|
extShowMask(&ExtCurStyle->exts_overlapTypes [p], out);
|
|
fprintf(out, "\n");
|
|
}
|
|
}
|
|
fprintf(out, "\n (by type)\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
if (!TTMaskIsZero(&ExtCurStyle->exts_overlapOtherTypes[t]))
|
|
{
|
|
fprintf(out, " %-10.10s: planes=", DBTypeShortName(t));
|
|
extShowPlanes(ExtCurStyle->exts_overlapOtherPlanes[t], out);
|
|
fprintf(out, "\n overlapped types=");
|
|
extShowMask(&ExtCurStyle->exts_overlapOtherTypes[t], out);
|
|
fprintf(out, "\n");
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (ExtCurStyle->exts_overlapCap[t][s] != (CapValue) 0)
|
|
fprintf(out, " %-10.10s: %8lf\n",
|
|
DBTypeShortName(s), ExtCurStyle->exts_overlapCap[t][s]);
|
|
}
|
|
|
|
fprintf(out, "\nSidewall-coupling/sidewall-overlap capacitance:\n");
|
|
fprintf(out, "\n (by plane)\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sidePlanes, p))
|
|
{
|
|
fprintf(out, " %-10.10s: ", DBPlaneShortName(p));
|
|
extShowMask(&ExtCurStyle->exts_sideTypes[p], out);
|
|
fprintf(out, "\n");
|
|
}
|
|
}
|
|
fprintf(out, "\n (by type)\n");
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (!TTMaskIsZero(&ExtCurStyle->exts_sideEdges[s]))
|
|
{
|
|
fprintf(out, " %-10.10s: ", DBTypeShortName(s));
|
|
extShowMask(&ExtCurStyle->exts_sideEdges[s], out);
|
|
fprintf(out, "\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
if (!TTMaskIsZero(&ExtCurStyle->exts_sideCoupleOtherEdges[s][t]))
|
|
{
|
|
fprintf(out, " edge mask=");
|
|
extShowMask(&ExtCurStyle->exts_sideCoupleOtherEdges[s][t], out);
|
|
fprintf(out, "\n");
|
|
}
|
|
if (!TTMaskIsZero(&ExtCurStyle->exts_sideOverlapOtherTypes[s][t]))
|
|
{
|
|
fprintf(out, " overlap mask=");
|
|
extShowMask(&ExtCurStyle->exts_sideOverlapOtherTypes[s][t],
|
|
out);
|
|
fprintf(out, "\n");
|
|
}
|
|
if ((e = ExtCurStyle->exts_sideCoupleCap[s][t]))
|
|
for ( ; e; e = e->ec_next)
|
|
{
|
|
fprintf(out, " COUPLE: ");
|
|
extShowMask(&e->ec_near, out);
|
|
fprintf(out, " || ");
|
|
extShowMask(&e->ec_far, out);
|
|
fprintf(out, ": %lf\n", e->ec_cap);
|
|
}
|
|
if ((e = ExtCurStyle->exts_sideOverlapCap[s][t]))
|
|
for ( ; e; e = e->ec_next)
|
|
{
|
|
fprintf(out, " OVERLAP: ");
|
|
extShowMask(&e->ec_near, out);
|
|
fprintf(out, ": %lf\n", e->ec_cap);
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(out, "\n\nSidewall coupling halo = %d\n", ExtCurStyle->exts_sideCoupleHalo );
|
|
|
|
extShowConnect("\nNode connectivity", ExtCurStyle->exts_nodeConn, out);
|
|
extShowConnect("\nResistive region connectivity", ExtCurStyle->exts_resistConn, out);
|
|
extShowConnect("\nTransistor connectivity", ExtCurStyle->exts_deviceConn, out);
|
|
|
|
if (out != stdout)
|
|
(void) fclose(out);
|
|
}
|
|
|
|
void
|
|
extShowTrans(name, mask, out)
|
|
char *name;
|
|
TileTypeBitMask *mask;
|
|
FILE *out;
|
|
{
|
|
TileType t;
|
|
|
|
fprintf(out, "%s types: ", name);
|
|
extShowMask(mask, out);
|
|
fprintf(out, "\n");
|
|
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
if (TTMaskHasType(mask, t))
|
|
{
|
|
ExtDevice *devptr;
|
|
|
|
for (devptr = ExtCurStyle->exts_device[t]; devptr; devptr = devptr->exts_next)
|
|
{
|
|
fprintf(out, " %-8.8s %d terminals: ",
|
|
DBTypeShortName(t), devptr->exts_deviceSDCount);
|
|
extShowMask(&devptr->exts_deviceSDTypes[0], out);
|
|
fprintf(out, "\n\tcap (gate-sd/gate-ch) = %lf/%lf\n",
|
|
devptr->exts_deviceSDCap,
|
|
devptr->exts_deviceGateCap);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
extShowConnect(hdr, connectsTo, out)
|
|
char *hdr;
|
|
TileTypeBitMask *connectsTo;
|
|
FILE *out;
|
|
{
|
|
TileType t;
|
|
|
|
fprintf(out, "%s\n", hdr);
|
|
for (t = TT_TECHDEPBASE; t < DBNumTypes; t++)
|
|
if (!TTMaskEqual(&connectsTo[t], &DBZeroTypeBits))
|
|
{
|
|
fprintf(out, " %-8.8s: ", DBTypeShortName(t));
|
|
extShowMask(&connectsTo[t], out);
|
|
fprintf(out, "\n");
|
|
}
|
|
}
|
|
|
|
void
|
|
extShowMask(m, out)
|
|
TileTypeBitMask *m;
|
|
FILE *out;
|
|
{
|
|
TileType t;
|
|
bool first = TRUE;
|
|
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
if (TTMaskHasType(m, t))
|
|
{
|
|
if (!first)
|
|
fprintf(out, ",");
|
|
first = FALSE;
|
|
fprintf(out, "%s", DBTypeShortName(t));
|
|
}
|
|
}
|
|
|
|
void
|
|
extShowPlanes(m, out)
|
|
PlaneMask m;
|
|
FILE *out;
|
|
{
|
|
int pNum;
|
|
bool first = TRUE;
|
|
|
|
for (pNum = PL_TECHDEPBASE; pNum < DBNumPlanes; pNum++)
|
|
if (PlaneMaskHasPlane(m, pNum))
|
|
{
|
|
if (!first)
|
|
fprintf(out, ",");
|
|
first = FALSE;
|
|
fprintf(out, "%s", DBPlaneShortName(pNum));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extDispInit --
|
|
*
|
|
* Initialize the screen information to be used during
|
|
* extraction debugging.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* Initializes extDebugWindow, extScreenClip, and extCellDef.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
extDispInit(def, w)
|
|
CellDef *def;
|
|
MagWindow *w;
|
|
{
|
|
extDebugWindow = w;
|
|
extCellDef = def;
|
|
extScreenClip = w->w_screenArea;
|
|
GeoClip(&extScreenClip, &GrScreenRect);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extShowEdge --
|
|
*
|
|
* Display the edge described by the Boundary 'bp' on the display,
|
|
* with text string 's' on the text terminal. Prompt with '--next--'
|
|
* to allow a primitive sort of 'more' processing.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* Updates the display.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
extShowEdge(s, bp)
|
|
char *s;
|
|
Boundary *bp;
|
|
{
|
|
Rect extScreenRect, edgeRect;
|
|
int style = STYLE_PURPLE1;
|
|
|
|
edgeRect = bp->b_segment;
|
|
WindSurfaceToScreen(extDebugWindow, &edgeRect, &extScreenRect);
|
|
if (extScreenRect.r_ybot == extScreenRect.r_ytop)
|
|
{
|
|
extScreenRect.r_ybot -= extEdgePixels/2;
|
|
extScreenRect.r_ytop += extEdgePixels - extEdgePixels/2;
|
|
}
|
|
else /* extScreenRect.r_xtop == extScreenRect.r_xbot */
|
|
{
|
|
extScreenRect.r_xbot -= extEdgePixels/2;
|
|
extScreenRect.r_xtop += extEdgePixels - extEdgePixels/2;
|
|
}
|
|
|
|
if (DebugIsSet(extDebugID, extDebVisOnly))
|
|
{
|
|
Rect r;
|
|
|
|
r = extScreenRect;
|
|
GeoClip(&r, &extScreenClip);
|
|
if (r.r_xtop <= r.r_xbot || r.r_ytop <= r.r_ybot)
|
|
return;
|
|
}
|
|
|
|
TxPrintf("%s: ", s);
|
|
GrLock(extDebugWindow, TRUE);
|
|
GrClipBox(&extScreenRect, style);
|
|
GrUnlock(extDebugWindow);
|
|
(void) GrFlush();
|
|
extMore();
|
|
GrLock(extDebugWindow, TRUE);
|
|
GrClipBox(&extScreenRect, STYLE_ORANGE1);
|
|
GrUnlock(extDebugWindow);
|
|
(void) GrFlush();
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
*
|
|
* extShowTile --
|
|
*
|
|
* Display the tile 'tp' on the display by highlighting it. Also show
|
|
* the text string 's' on the terminal. Prompt with '--next--' to allow
|
|
* a primitive sort of more processing.
|
|
*
|
|
* Results:
|
|
* None.
|
|
*
|
|
* Side effects:
|
|
* Updates the display.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
extShowTile(tile, s, style_index)
|
|
Tile *tile;
|
|
char *s;
|
|
int style_index;
|
|
{
|
|
Rect tileRect;
|
|
static int styles[] = { STYLE_PALEHIGHLIGHTS, STYLE_DOTTEDHIGHLIGHTS };
|
|
|
|
TiToRect(tile, &tileRect);
|
|
if (!extShowRect(&tileRect, styles[style_index]))
|
|
return;
|
|
|
|
TxPrintf("%s: ", s);
|
|
extMore();
|
|
(void) extShowRect(&tileRect, STYLE_ERASEHIGHLIGHTS);
|
|
}
|
|
|
|
bool
|
|
extShowRect(r, style)
|
|
Rect *r;
|
|
int style;
|
|
{
|
|
Rect extScreenRect;
|
|
|
|
WindSurfaceToScreen(extDebugWindow, r, &extScreenRect);
|
|
if (DebugIsSet(extDebugID, extDebVisOnly))
|
|
{
|
|
Rect rclip;
|
|
|
|
rclip = extScreenRect;
|
|
GeoClip(&rclip, &extScreenClip);
|
|
if (rclip.r_xtop <= rclip.r_xbot || rclip.r_ytop <= rclip.r_ybot)
|
|
return (FALSE);
|
|
}
|
|
|
|
GrLock(extDebugWindow, TRUE);
|
|
GrClipBox(&extScreenRect, style);
|
|
GrUnlock(extDebugWindow);
|
|
(void) GrFlush();
|
|
return (TRUE);
|
|
}
|
|
|
|
void
|
|
extMore()
|
|
{
|
|
char line[100];
|
|
|
|
TxPrintf("--next--"); (void) fflush(stdout);
|
|
(void) TxGetLine(line, sizeof line);
|
|
}
|
|
|
|
void
|
|
extNewYank(name, puse, pdef)
|
|
char *name;
|
|
CellUse **puse;
|
|
CellDef **pdef;
|
|
{
|
|
DBNewYank(name, puse, pdef);
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
* Dump parasitic capacitance extraction information to a file
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ExtDumpCapsToFile(f)
|
|
FILE *f;
|
|
{
|
|
TileType t, s, r;
|
|
EdgeCap *e;
|
|
int p, found;
|
|
|
|
fprintf(f, "Parasitic extraction capacitance values\n");
|
|
|
|
fprintf(f, "\n1) Area caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
if (ExtCurStyle->exts_areaCap[t] > 0.0)
|
|
fprintf(f, "%s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
ExtCurStyle->exts_areaCap[t]);
|
|
}
|
|
|
|
fprintf(f, "\n2) Perimeter caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
if (ExtCurStyle->exts_perimCap[t][s] > 0.0)
|
|
fprintf(f, "%s | %s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
ExtCurStyle->exts_perimCap[t][s]);
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n3) Overlap caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
if (ExtCurStyle->exts_overlapCap[t][s] > 0.0)
|
|
fprintf(f, "%s | %s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
ExtCurStyle->exts_overlapCap[t][s]);
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n4) Side coupling caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
for (e = ExtCurStyle->exts_sideCoupleCap[t][s]; e; e = e->ec_next) {
|
|
fprintf(f, "%s | %s: %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
e->ec_cap);
|
|
fprintf(f, " near: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_near, r))
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
fprintf(f, "\n far: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_far, r))
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
fprintf(f, "\n planes: ");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(e->ec_pmask, p))
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
fprintf(f, "\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n5) Side overlap caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
for (e = ExtCurStyle->exts_sideOverlapCap[t][s]; e; e = e->ec_next) {
|
|
fprintf(f, "%s | %s: %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
e->ec_cap);
|
|
fprintf(f, " near: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_near, r))
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
fprintf(f, "\n far: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_far, r))
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
fprintf(f, "\n planes: ");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(e->ec_pmask, p))
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
fprintf(f, "\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n6) (Check) Perimeter cap mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_perimCapMask[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "\n7) (Check) Overlap plane mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapPlanes, p))
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
fprintf(f, "\n");
|
|
|
|
fprintf(f, "\n8) (Check) Overlap types mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapTypes[p], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
found = 1;
|
|
fprintf(f, " %s: ", DBPlaneLongNameTbl[p]);
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "\n9) (Check) Overlap other types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapOtherTypes[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "\n10) (Check) Overlap other planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapOtherPlanes[t], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "\n11) (Check) Overlap shield types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapShieldTypes[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n12) (Check) Overlap shield planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapShieldPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n13) (Check) Side couple other edges mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideCoupleOtherEdges[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n14) (Check) Side overlap other planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sideOverlapOtherPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n15) (Check) Side overlap other types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideOverlapOtherTypes[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n16) (Check) Side overlap shield planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sideOverlapShieldPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n17) (Check) Side planes mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sidePlanes, p))
|
|
fprintf(f, " %s", DBPlaneLongNameTbl[p]);
|
|
fprintf(f, "\n");
|
|
|
|
fprintf(f, "\n18) (Check) Side types mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideTypes[p], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s: ", DBPlaneLongNameTbl[p]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "\n19) (Check) Side edges mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideTypes[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
fprintf(f, " %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
fprintf(f, " %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) fprintf(f, "\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* ----------------------------------------------------------------------------
|
|
* ExtDumpCaps ---
|
|
* Debugging tool. Dump information about all parasitics
|
|
* ----------------------------------------------------------------------------
|
|
*/
|
|
|
|
void
|
|
ExtDumpCaps(filename)
|
|
char *filename;
|
|
{
|
|
TileType t, s, r;
|
|
EdgeCap *e;
|
|
int p, found;
|
|
|
|
if (strcmp(filename, "-"))
|
|
{
|
|
FILE *f;
|
|
f = fopen(filename, "w");
|
|
if (f == NULL)
|
|
{
|
|
TxError("Cannot open file %s for writing\n", filename);
|
|
return;
|
|
}
|
|
ExtDumpCapsToFile(f);
|
|
fclose(f);
|
|
return;
|
|
}
|
|
|
|
TxPrintf("Parasitic extraction capacitance values\n");
|
|
|
|
TxPrintf("\n1) Area caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
if (ExtCurStyle->exts_areaCap[t] > 0.0)
|
|
TxPrintf("%s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
ExtCurStyle->exts_areaCap[t]);
|
|
}
|
|
|
|
TxPrintf("\n2) Perimeter caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
if (ExtCurStyle->exts_perimCap[t][s] > 0.0)
|
|
TxPrintf("%s | %s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
ExtCurStyle->exts_perimCap[t][s]);
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n3) Overlap caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
if (ExtCurStyle->exts_overlapCap[t][s] > 0.0)
|
|
TxPrintf("%s | %s %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
ExtCurStyle->exts_overlapCap[t][s]);
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n4) Side coupling caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
for (e = ExtCurStyle->exts_sideCoupleCap[t][s]; e; e = e->ec_next) {
|
|
TxPrintf("%s | %s: %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
e->ec_cap);
|
|
TxPrintf(" near: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_near, r))
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
TxPrintf("\n far: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_far, r))
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
TxPrintf("\n planes: ");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(e->ec_pmask, p))
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
TxPrintf("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n5) Side overlap caps\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
for (e = ExtCurStyle->exts_sideOverlapCap[t][s]; e; e = e->ec_next) {
|
|
TxPrintf("%s | %s: %3.3f\n",
|
|
DBTypeLongNameTbl[t],
|
|
DBTypeLongNameTbl[s],
|
|
e->ec_cap);
|
|
TxPrintf(" near: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_near, r))
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
TxPrintf("\n far: ");
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&e->ec_far, r))
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
TxPrintf("\n planes: ");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(e->ec_pmask, p))
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
TxPrintf("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n6) (Check) Perimeter cap mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_perimCapMask[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
|
|
TxPrintf("\n7) (Check) Overlap plane mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapPlanes, p))
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
TxPrintf("\n");
|
|
|
|
TxPrintf("\n8) (Check) Overlap types mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapTypes[p], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
found = 1;
|
|
TxPrintf(" %s: ", DBPlaneLongNameTbl[p]);
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
|
|
TxPrintf("\n9) (Check) Overlap other types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapOtherTypes[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
|
|
TxPrintf("\n10) (Check) Overlap other planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapOtherPlanes[t], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
|
|
TxPrintf("\n11) (Check) Overlap shield types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_overlapShieldTypes[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n12) (Check) Overlap shield planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_overlapShieldPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n13) (Check) Side couple other edges mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideCoupleOtherEdges[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n14) (Check) Side overlap other planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sideOverlapOtherPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n15) (Check) Side overlap other types mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (r = 0; r < DBNumTypes; r++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideOverlapOtherTypes[t][s], r))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[r]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n16) (Check) Side overlap shield planes mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
{
|
|
found = 0;
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sideOverlapShieldPlanes[t][s], p))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s | %s: ",
|
|
DBTypeLongNameTbl[t], DBTypeLongNameTbl[s]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|
|
|
|
TxPrintf("\n17) (Check) Side planes mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
if (PlaneMaskHasPlane(ExtCurStyle->exts_sidePlanes, p))
|
|
TxPrintf(" %s", DBPlaneLongNameTbl[p]);
|
|
TxPrintf("\n");
|
|
|
|
TxPrintf("\n18) (Check) Side types mask\n");
|
|
for (p = PL_TECHDEPBASE; p < DBNumPlanes; p++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideTypes[p], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s: ", DBPlaneLongNameTbl[p]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
|
|
TxPrintf("\n19) (Check) Side edges mask\n");
|
|
for (t = 0; t < DBNumTypes; t++)
|
|
{
|
|
found = 0;
|
|
for (s = 0; s < DBNumTypes; s++)
|
|
if (TTMaskHasType(&ExtCurStyle->exts_sideTypes[t], s))
|
|
{
|
|
if (found == 0)
|
|
{
|
|
TxPrintf(" %s: ", DBTypeLongNameTbl[t]);
|
|
found = 1;
|
|
}
|
|
TxPrintf(" %s", DBTypeLongNameTbl[s]);
|
|
}
|
|
if (found != 0) TxPrintf("\n");
|
|
}
|
|
}
|