luke
/
magic
mirror of https://github.com/RTimothyEdwards/magic.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

router: convert K&R function definitions to ANSI C 

Convert the old-style (K&R) function definitions in router/ to ANSI C
prototypes, formatted in the project's convention: the return type on its
own line and each parameter on its own line, indented four spaces, with
the original parameter comments retained.

Updates the router headers (router.h, routerInt.h) and adds forward
typedefs for the netlist types (NLTermLoc, NLTerm, NLNet) named by the new
prototypes.

Builds cleanly under GCC 16 / C23 (with the -std=gnu17 build change).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Andreas Wendleder 2026-06-10 03:49:15 +02:00
parent fc95cacba2
commit 561ea8135e
No known key found for this signature in database
GPG Key ID: 588785BFDFB01ABD
16 changed files with 374 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
router/router.h
View File

@ -26,6 +26,16 @@
#include "database/database.h" #include "database/database.h"
#include "utils/geometry.h" #include "utils/geometry.h"
/* Forward declaration to avoid pulling in utils/netlist.h */
struct nlNetList;
typedef struct nlNetList NLNetList;
struct nlTermLoc;
typedef struct nlTermLoc NLTermLoc;
struct nlTerm;
typedef struct nlTerm NLTerm;
struct nlNet;
typedef struct nlNet NLNet;
/* Masks of directions */ /* Masks of directions */
#define DIRTOMASK(d) (1 << (d)) #define DIRTOMASK(d) (1 << (d))
#define DIRMASKHASDIR(m, d) ((m) & DIRTOMASK(d)) #define DIRMASKHASDIR(m, d) ((m) & DIRTOMASK(d))
@ -185,9 +195,9 @@ extern void RtrMilestoneDone();
extern void RtrChannelDensity(); extern void RtrChannelDensity();
extern void RtrChannelRoute(); extern void RtrChannelRoute();
extern void RtrChannelCleanObstacles(); extern void RtrChannelCleanObstacles();
extern void RtrStemProcessAll(); extern void RtrStemProcessAll(CellUse *use, NLNetList *netList, bool doWarn, bool (*func)());
extern void RtrPaintBack(); extern void RtrPaintBack();
extern bool RtrStemAssignExt(); extern bool RtrStemAssignExt(CellUse *use, bool doWarn, NLTermLoc *loc, NLTerm *term, NLNet *net);
extern void RtrPinsInit(); extern void RtrPinsInit();
extern void RtrHazards(); extern void RtrHazards();
extern void RtrPinsLink(); extern void RtrPinsLink();

4
router/routerInt.h
View File

@ -38,8 +38,8 @@ extern int rtrPinArrayInit();
extern int rtrPinArrayLink(); extern int rtrPinArrayLink();
extern int rtrSidePassToClient(); extern int rtrSidePassToClient();
extern int rtrSideProcess(); extern int rtrSideProcess();
extern int rtrXDist(); extern int rtrXDist(Tile *tiles[], int x, bool isRight);
extern int rtrYDist(); extern int rtrYDist(Tile *tiles[], Point *point, bool up, Plane *plane);
extern int rtrStemContactLine(); extern int rtrStemContactLine();
extern int rtrStemTypes(); extern int rtrStemTypes();
extern int rtrSrTraverse(); extern int rtrSrTraverse();

42
router/rtrChannel.c
View File

@ -89,9 +89,9 @@ extern void rtrChannelObstaclePins();
*/ */
void void
RtrChannelRoute(ch, pCount) RtrChannelRoute(
GCRChannel *ch; GCRChannel *ch,
int *pCount; int *pCount)
{ {
GCRChannel *flipped, *flipped_again, *copy; GCRChannel *flipped, *flipped_again, *copy;
int errs1, errs2; int errs1, errs2;
@ -214,11 +214,11 @@ bottom:
*/ */
void void
RtrChannelBounds(loc, pLength, pWidth, origin) RtrChannelBounds(
Rect *loc; /* Area the channel is to occupy */ Rect *loc, /* Area the channel is to occupy */
int *pLength; /* Filled in with # columns in channel */ int *pLength, /* Filled in with # columns in channel */
int *pWidth; /* Filled in with # rows in channel */ int *pWidth, /* Filled in with # rows in channel */
Point *origin; /* Filled in with coords of (0,0) grid point Point *origin) /* Filled in with coords of (0,0) grid point
* (one grid line below and to left of first * (one grid line below and to left of first
* usable grid point) * usable grid point)
*/ */
@ -285,9 +285,9 @@ RtrChannelBounds(loc, pLength, pWidth, origin)
*/ */
void void
RtrChannelObstacles(use, ch) RtrChannelObstacles(
CellUse *use; CellUse *use,
GCRChannel * ch; GCRChannel * ch)
{ {
int l, w, up = RtrSubcellSepUp, down = RtrSubcellSepDown; int l, w, up = RtrSubcellSepUp, down = RtrSubcellSepDown;
TileTypeBitMask allObs; TileTypeBitMask allObs;
@ -342,8 +342,8 @@ RtrChannelObstacles(use, ch)
*/ */
void void
rtrChannelObstaclePins(ch) rtrChannelObstaclePins(
GCRChannel *ch; GCRChannel *ch)
{ {
short **res; short **res;
int row, col, end; int row, col, end;
@ -412,10 +412,10 @@ rtrChannelObstaclePins(ch)
*/ */
int int
rtrChannelObstacleMark(tile, dinfo, cxp) rtrChannelObstacleMark(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
TreeContext *cxp; TreeContext *cxp)
{ {
short **mcol, *mrow, *mrowend, mask; short **mcol, *mrow, *mrowend, mask;
GCRChannel *ch = (GCRChannel *) cxp->tc_filter->tf_arg; GCRChannel *ch = (GCRChannel *) cxp->tc_filter->tf_arg;
@ -514,8 +514,8 @@ rtrChannelObstacleMark(tile, dinfo, cxp)
*/ */
void void
RtrChannelDensity(ch) RtrChannelDensity(
GCRChannel *ch; GCRChannel *ch)
{ {
short *hdens, *vdens, *rptr; short *hdens, *vdens, *rptr;
int col, density; int col, density;
@ -587,8 +587,8 @@ RtrChannelDensity(ch)
*/ */
void void
RtrChannelCleanObstacles(ch) RtrChannelCleanObstacles(
GCRChannel *ch; GCRChannel *ch)
{ {
short *rptr; short *rptr;
int row, rtop; int row, rtop;

62
router/rtrCmd.c
View File

@ -76,9 +76,9 @@ bool RtrMazeStems = FALSE; /* Set by default to original behavior */
*/ */
void void
CmdGARouterTest(w, cmd) CmdGARouterTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
GATest(w, cmd); GATest(w, cmd);
} }
@ -103,9 +103,9 @@ CmdGARouterTest(w, cmd)
*/ */
void void
CmdGRouterTest(w, cmd) CmdGRouterTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
GlTest(w, cmd); GlTest(w, cmd);
} }
@ -130,9 +130,9 @@ CmdGRouterTest(w, cmd)
*/ */
void void
CmdIRouterTest(w, cmd) CmdIRouterTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
IRTest(w, cmd); IRTest(w, cmd);
} }
@ -157,9 +157,9 @@ CmdIRouterTest(w, cmd)
*/ */
void void
CmdMZRouterTest(w, cmd) CmdMZRouterTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
MZTest(w, cmd); MZTest(w, cmd);
} }
@ -188,9 +188,9 @@ CmdMZRouterTest(w, cmd)
*/ */
void void
CmdChannel(w, cmd) CmdChannel(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
Rect newBox; Rect newBox;
CellDef *def, *RtrDecomposeName(); CellDef *def, *RtrDecomposeName();
@ -227,10 +227,10 @@ CmdChannel(w, cmd)
} }
int int
cmdChannelFunc(tile, dinfo, clientdata) cmdChannelFunc(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
ClientData clientdata; /* (unused) */ ClientData clientdata) /* (unused) */
{ {
Rect area, rootArea; Rect area, rootArea;
@ -258,9 +258,9 @@ cmdChannelFunc(tile, dinfo, clientdata)
*/ */
void void
CmdGaRoute(w, cmd) CmdGaRoute(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
typedef enum { CHANNEL, GEN, HELP, NOWARN, RESET, ROUTE, WARN } cmdType; typedef enum { CHANNEL, GEN, HELP, NOWARN, RESET, ROUTE, WARN } cmdType;
static char *chanTypeName[] = { "NORMAL", "HRIVER", "VRIVER" }; static char *chanTypeName[] = { "NORMAL", "HRIVER", "VRIVER" };
@ -459,9 +459,9 @@ badChanCmd:
*/ */
void void
CmdIRoute(w, cmd) CmdIRoute(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
IRCommand(w,cmd); IRCommand(w,cmd);
@ -506,9 +506,9 @@ CmdIRoute(w, cmd)
#define ROUTERMAZESTEMS 19 #define ROUTERMAZESTEMS 19
void void
CmdRoute(w, cmd) CmdRoute(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
int option; int option;
GCRChannel *ch; GCRChannel *ch;
@ -782,9 +782,9 @@ usage2:
*/ */
void void
CmdSeeFlags(w, cmd) CmdSeeFlags(
MagWindow * w; MagWindow * w,
TxCommand *cmd; TxCommand *cmd)
{ {
Rect rootRect; Rect rootRect;
Point point; Point point;

103
router/rtrDcmpose.c
View File

@ -75,7 +75,7 @@ Rect RouteArea;
/* Forward declarations */ /* Forward declarations */
extern int rtrSrCells(); extern int rtrSrCells();
extern void rtrRoundRect(); extern void rtrRoundRect(Rect *r, int sepUp, int sepDown, bool doRoundUp);
extern void rtrHashKill(); extern void rtrHashKill();
extern void rtrSplitToArea(); extern void rtrSplitToArea();
extern void rtrMarkChannel(); extern void rtrMarkChannel();
@ -104,10 +104,10 @@ bool rtrUseCorner();
*/ */
CellDef * CellDef *
RtrDecomposeName(routeUse, area, name) RtrDecomposeName(
CellUse *routeUse; /* Cell to be decomposed */ CellUse *routeUse, /* Cell to be decomposed */
Rect *area; /* Confine channels to this area */ Rect *area, /* Confine channels to this area */
char *name; /* Name of netlist if non-NULL; otherwise, use the char *name) /* Name of netlist if non-NULL; otherwise, use the
* name of the current netlist or that of routeUse * name of the current netlist or that of routeUse
* as described above. * as described above.
*/ */
@ -164,10 +164,10 @@ RtrDecomposeName(routeUse, area, name)
*/ */
CellDef * CellDef *
RtrDecompose(routeUse, area, netList) RtrDecompose(
CellUse *routeUse; CellUse *routeUse,
Rect *area; Rect *area,
NLNetList *netList; NLNetList *netList)
{ {
SearchContext scx; SearchContext scx;
CellDef *cdTo; CellDef *cdTo;
@ -312,9 +312,9 @@ RtrFindChannelDef()
*/ */
int int
rtrSrCells(scx, targetDef) rtrSrCells(
SearchContext *scx; /* The cell to be painted */ SearchContext *scx, /* The cell to be painted */
CellDef *targetDef; /* The def into which the silhouette is painted */ CellDef *targetDef) /* The def into which the silhouette is painted */
{ {
CellDef *def = scx->scx_use->cu_def; CellDef *def = scx->scx_use->cu_def;
Rect rootBbox, gridBbox; Rect rootBbox, gridBbox;
@ -367,10 +367,11 @@ rtrSrCells(scx, targetDef)
*/ */
void void
rtrRoundRect(r, sepUp, sepDown, doRoundUp) rtrRoundRect(
Rect *r; Rect *r,
int sepUp, sepDown; int sepUp,
bool doRoundUp; int sepDown,
bool doRoundUp)
{ {
int halfGrid = RtrGridSpacing / 2; int halfGrid = RtrGridSpacing / 2;
@ -425,8 +426,8 @@ rtrRoundRect(r, sepUp, sepDown, doRoundUp)
*/ */
void void
rtrHashKill(ht) rtrHashKill(
HashTable *ht; HashTable *ht)
{ {
HashEntry *he; HashEntry *he;
HashSearch hs; HashSearch hs;
@ -454,9 +455,9 @@ rtrHashKill(ht)
*/ */
void void
rtrSplitToArea(area, def) rtrSplitToArea(
Rect *area; /* Routing area */ Rect *area, /* Routing area */
CellDef *def; /* Def holding routing results */ CellDef *def) /* Def holding routing results */
{ {
Tile *tile; Tile *tile;
Point p; Point p;
@ -522,10 +523,10 @@ rtrSplitToArea(area, def)
*/ */
int int
rtrSrClear(tile, dinfo, area) rtrSrClear(
Tile *tile; Tile *tile,
TileType dinfo; TileType dinfo,
Rect *area; Rect *area)
{ {
/* Clear all */ /* Clear all */
rtrCLEAR(tile, -1); rtrCLEAR(tile, -1);
@ -581,10 +582,10 @@ rtrSrClear(tile, dinfo, area)
*/ */
int int
rtrSrFunc(tile, dinfo, plane) rtrSrFunc(
Tile *tile; /* Candidate cell tile */ Tile *tile, /* Candidate cell tile */
TileType dinfo; /* Split tile information (unused) */ TileType dinfo, /* Split tile information (unused) */
Plane *plane; /* Plane in which searches take place */ Plane *plane) /* Plane in which searches take place */
{ {
Tile *tiles[3]; Tile *tiles[3];
Point p; Point p;
@ -639,11 +640,11 @@ rtrSrFunc(tile, dinfo, plane)
*/ */
bool bool
rtrUseCorner(point, corner, plane, tiles) rtrUseCorner(
Point *point; /* Point at which a cell corner is found */ Point *point, /* Point at which a cell corner is found */
int corner; /* Selects NE, NW, SE, or SW cell corner */ int corner, /* Selects NE, NW, SE, or SW cell corner */
Plane *plane; /* Plane to be searched for tiles */ Plane *plane, /* Plane to be searched for tiles */
Tile *tiles[]; /* Return pointers to found space tiles */ Tile *tiles[]) /* Return pointers to found space tiles */
{ {
Point p0, p1; Point p0, p1;
Tile * tile; Tile * tile;
@ -723,11 +724,11 @@ rtrUseCorner(point, corner, plane, tiles)
*/ */
void void
rtrMarkChannel(plane, tiles, point, corner) rtrMarkChannel(
Plane *plane; /* Plane for searching */ Plane *plane, /* Plane for searching */
Tile *tiles[]; /* Bordering space tiles */ Tile *tiles[], /* Bordering space tiles */
Point *point; /* Coordinates of corner */ Point *point, /* Coordinates of corner */
int corner; /* Corner of tile to process */ int corner) /* Corner of tile to process */
{ {
int xDist, yDist, d1, d2, lastY; int xDist, yDist, d1, d2, lastY;
Tile *tile, *new; Tile *tile, *new;
@ -846,11 +847,11 @@ rtrMarkChannel(plane, tiles, point, corner)
*/ */
int int
rtrYDist(tiles, point, up, plane) rtrYDist(
Tile *tiles[]; /* Start tile in [1]. Put bottom tile in [0] */ Tile *tiles[], /* Start tile in [1]. Put bottom tile in [0] */
Point *point; /* Point from which distance is measure */ Point *point, /* Point from which distance is measure */
bool up; /* TRUE if search up, FALSE if down */ bool up, /* TRUE if search up, FALSE if down */
Plane *plane; /* Cell plane for search */ Plane *plane) /* Cell plane for search */
{ {
Tile *current = tiles[1], *next; Tile *current = tiles[1], *next;
int x, yStart, flag; int x, yStart, flag;
@ -954,10 +955,10 @@ rtrYDist(tiles, point, up, plane)
*/ */
int int
rtrXDist(tiles, x, isRight) rtrXDist(
Tile *tiles[]; /* Space tiles bordering the corner */ Tile *tiles[], /* Space tiles bordering the corner */
int x; /* Starting x for distance calculation */ int x, /* Starting x for distance calculation */
bool isRight; /* TRUE if right, FALSE if left */ bool isRight) /* TRUE if right, FALSE if left */
{ {
int l0, l1; int l0, l1;
@ -987,7 +988,11 @@ rtrXDist(tiles, x, isRight)
*/ */
void void
rtrMerge(Tile **delay1, Tile *tup, Tile *tdn, Plane *plane) rtrMerge(
Tile **delay1,
Tile *tup,
Tile *tdn,
Plane *plane)
{ {
Tile *side; Tile *side;

22
router/rtrFdback.c
View File

@ -82,12 +82,12 @@ int rtrFNum; /* Says which list is active */
*/ */
void void
RtrChannelError(ch, col, track, msg, net) RtrChannelError(
GCRChannel *ch; /* Channel where error occurred. */ GCRChannel *ch, /* Channel where error occurred. */
int col; /* Column where error occurred. */ int col, /* Column where error occurred. */
int track; /* Track where error occurred. */ int track, /* Track where error occurred. */
char *msg; /* Message identifying error. */ char *msg, /* Message identifying error. */
NLNet *net; /* Net where error occurred */ NLNet *net) /* Net where error occurred */
{ {
Rect box; Rect box;
Point old, new; Point old, new;
@ -170,9 +170,9 @@ rtrFBClear()
*/ */
void void
rtrFBAdd(r, t) rtrFBAdd(
Rect * r; Rect * r,
char * t; char * t)
{ {
RtrFB * new; RtrFB * new;
@ -201,8 +201,8 @@ rtrFBAdd(r, t)
*/ */
void void
RtrFBPaint(num) RtrFBPaint(
int num; /* Selects which list to use */ int num) /* Selects which list to use */
{ {
RtrFB *temp; RtrFB *temp;

40
router/rtrHazards.c
View File

@ -45,7 +45,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
/* Forward declarations */ /* Forward declarations */
extern void rtrFindEnds(); extern void rtrFindEnds();
extern void rtrFlag(); extern void rtrFlag(GCRChannel * ch, int cl, int cr, int rb, int rt, bool isHoriz);
/* /*
@ -84,8 +84,8 @@ extern void rtrFlag();
*/ */
void void
RtrHazards(ch) RtrHazards(
GCRChannel *ch; /* The channel to be flagged */ GCRChannel *ch) /* The channel to be flagged */
{ {
short **map, **rtrHeights(), **rtrWidths(), **height, **width; short **map, **rtrHeights(), **rtrWidths(), **height, **width;
short *hcol, *wcol, *mcol; short *hcol, *wcol, *mcol;
@ -231,8 +231,8 @@ RtrHazards(ch)
*/ */
short ** short **
rtrHeights(ch) rtrHeights(
GCRChannel * ch; /* Channel to be processed */ GCRChannel * ch) /* Channel to be processed */
{ {
short **heights, *obstacles, *hcol; short **heights, *obstacles, *hcol;
int i, row; int i, row;
@ -303,8 +303,8 @@ rtrHeights(ch)
*/ */
short ** short **
rtrWidths(ch) rtrWidths(
GCRChannel * ch; GCRChannel * ch)
{ {
short **widths, **map; short **widths, **map;
int col, i; int col, i;
@ -377,13 +377,13 @@ rtrWidths(ch)
*/ */
void void
rtrFindEnds(ch, isHoriz, bot, top, lo, hi) rtrFindEnds(
GCRChannel *ch; GCRChannel *ch,
int isHoriz; /* 1 if to find horizontal ends */ int isHoriz, /* 1 if to find horizontal ends */
int bot; /* Low range to be scanned */ int bot, /* Low range to be scanned */
int top; /* High range to be scanned */ int top, /* High range to be scanned */
int *lo; /* Low range of result. Also starting col or row. */ int *lo, /* Low range of result. Also starting col or row. */
int *hi; /* High range of result */ int *hi) /* High range of result */
{ {
int col, row; int col, row;
short **map; short **map;
@ -488,11 +488,13 @@ gotVL:
*/ */
void void
rtrFlag(ch, cl, cr, rb, rt, isHoriz) rtrFlag(
GCRChannel * ch; /* Channel whose flag array is to be set */ GCRChannel * ch, /* Channel whose flag array is to be set */
int cl, cr; /* Left and right limits of columns to be set */ int cl,
int rb, rt; /* Bottom and top limits of rows to be set */ int cr,
bool isHoriz; /* TRUE if left/right flags, else top/bottom */ int rb,
int rt,
bool isHoriz) /* TRUE if left/right flags, else top/bottom */
{ {
int extra, limit, r, c; int extra, limit, r, c;
short ** map; short ** map;

18
router/rtrMain.c
View File

@ -86,9 +86,9 @@ Point RtrOrigin = { 0, 0 };
*/ */
void void
Route(routeUse, routeArea) Route(
CellUse *routeUse; CellUse *routeUse,
Rect *routeArea; Rect *routeArea)
{ {
CellDef *channelDef; CellDef *channelDef;
int errs, numNets; int errs, numNets;
@ -171,13 +171,13 @@ done:
*/ */
int int
rtrMakeChannel(tile, dinfo, clipBox) rtrMakeChannel(
Tile *tile; /* Potential channel tile; we create a channel whose Tile *tile, /* Potential channel tile; we create a channel whose
* area is equal to that of this tile if the type of * area is equal to that of this tile if the type of
* this tile is TT_SPACE. * this tile is TT_SPACE.
*/ */
TileType dinfo; /* Split tile information (unused) */ TileType dinfo, /* Split tile information (unused) */
Rect *clipBox; /* If non-NULL, clip the channel area to this box */ Rect *clipBox) /* If non-NULL, clip the channel area to this box */
{ {
int length, width; int length, width;
HashEntry *entry; HashEntry *entry;
@ -256,8 +256,8 @@ RtrRunStats()
} }
void void
RtrMilestoneStart(event) RtrMilestoneStart(
char *event; char *event)
{ {
rtrMilestoneName = event; rtrMilestoneName = event;
TxPrintf("%s: ", event); TxPrintf("%s: ", event);

50
router/rtrPaint.c
View File

@ -72,9 +72,9 @@ bool rtrDoVia();
*/ */
void void
RtrPaintBack(ch, def) RtrPaintBack(
GCRChannel * ch; GCRChannel * ch,
CellDef *def; CellDef *def)
{ {
if(RtrDoMMax) /*Change poly to metal where possible */ if(RtrDoMMax) /*Change poly to metal where possible */
rtrMaxMetal(ch); rtrMaxMetal(ch);
@ -102,9 +102,9 @@ RtrPaintBack(ch, def)
*/ */
void void
rtrPaintRows(def, ch) rtrPaintRows(
CellDef *def; /* Def into which paint will go */ CellDef *def, /* Def into which paint will go */
GCRChannel *ch; /* Channel being painted */ GCRChannel *ch) /* Channel being painted */
{ {
TileType curType, nextType; TileType curType, nextType;
short **result, code; short **result, code;
@ -230,9 +230,9 @@ rtrPaintRows(def, ch)
*/ */
void void
rtrPaintColumns(def, ch) rtrPaintColumns(
CellDef * def; CellDef * def,
GCRChannel * ch; GCRChannel * ch)
{ {
TileType curType; /* Describes what kind of material currently TileType curType; /* Describes what kind of material currently
* occupies the column. It's either RtrMetalType, * occupies the column. It's either RtrMetalType,
@ -339,10 +339,10 @@ rtrPaintColumns(def, ch)
*/ */
bool bool
rtrDoVia(ch, col, row) rtrDoVia(
GCRChannel *ch; /* The channel undergoing display */ GCRChannel *ch, /* The channel undergoing display */
int col; /* The x coordinate of the location considered */ int col, /* The x coordinate of the location considered */
int row; /* The y coordinate of the location considered */ int row) /* The y coordinate of the location considered */
{ {
short up, down, left, right, mask; short up, down, left, right, mask;
short **result, code; short **result, code;
@ -430,8 +430,8 @@ rtrDoVia(ch, col, row)
*/ */
void void
rtrMaxMetal(ch) rtrMaxMetal(
GCRChannel * ch; GCRChannel * ch)
{ {
bool needLowX, needHiX, hasLowX, hasHiX, active, cross; bool needLowX, needHiX, hasLowX, hasHiX, active, cross;
int x, y, i, bottom, top; int x, y, i, bottom, top;
@ -569,10 +569,10 @@ rtrMaxMetal(ch)
*/ */
bool bool
rtrMetalOkay(ch, col, dir) rtrMetalOkay(
GCRChannel *ch; /* The originating channel for the search */ GCRChannel *ch, /* The originating channel for the search */
int col; /* The crossing column in the originating channel */ int col, /* The crossing column in the originating channel */
int dir; /* Direction of the crossing NORTH or SOUTH */ int dir) /* Direction of the crossing NORTH or SOUTH */
{ {
GCRChannel *newCh; GCRChannel *newCh;
GCRPin *pin; GCRPin *pin;
@ -622,9 +622,9 @@ rtrMetalOkay(ch, col, dir)
*/ */
void void
RtrPaintContact(def, area) RtrPaintContact(
CellDef *def; /* Cell in which to paint contact. */ CellDef *def, /* Cell in which to paint contact. */
Rect *area; /* Area in which to paint the contact. */ Rect *area) /* Area in which to paint the contact. */
{ {
Rect larger; Rect larger;
@ -659,9 +659,9 @@ RtrPaintContact(def, area)
*/ */
void void
RtrPaintStats(type, distance) RtrPaintStats(
TileType type; TileType type,
int distance; int distance)
{ {
if (distance < 0) distance = -distance; if (distance < 0) distance = -distance;

56
router/rtrPin.c
View File

@ -79,8 +79,8 @@ void rtrPinShow(GCRPin *);
*/ */
void void
RtrPinsInit(ch) RtrPinsInit(
GCRChannel *ch; GCRChannel *ch)
{ {
rtrPinArrayInit(ch, GEO_NORTH, ch->gcr_tPins, ch->gcr_length); rtrPinArrayInit(ch, GEO_NORTH, ch->gcr_tPins, ch->gcr_length);
rtrPinArrayInit(ch, GEO_SOUTH, ch->gcr_bPins, ch->gcr_length); rtrPinArrayInit(ch, GEO_SOUTH, ch->gcr_bPins, ch->gcr_length);
@ -89,11 +89,11 @@ RtrPinsInit(ch)
} }
int int
rtrPinArrayInit(ch, side, pins, nPins) rtrPinArrayInit(
GCRChannel *ch; GCRChannel *ch,
int side; int side,
GCRPin *pins; GCRPin *pins,
int nPins; int nPins)
{ {
GCRPin *pin, *linked; GCRPin *pin, *linked;
GCRChannel *adjacent; GCRChannel *adjacent;
@ -212,10 +212,10 @@ rtrPinArrayInit(ch, side, pins, nPins)
*/ */
GCRPin * GCRPin *
RtrPointToPin(ch, side, point) RtrPointToPin(
GCRChannel *ch; /* The channel containing the point */ GCRChannel *ch, /* The channel containing the point */
int side; /* Side of ch that point lies on */ int side, /* Side of ch that point lies on */
Point *point; /* The point to be converted to a pin */ Point *point) /* The point to be converted to a pin */
{ {
int coord; int coord;
@ -286,8 +286,8 @@ RtrPointToPin(ch, side, point)
*/ */
bool bool
RtrPinsBlock(ch) RtrPinsBlock(
GCRChannel *ch; GCRChannel *ch)
{ {
bool changed; bool changed;
@ -305,13 +305,13 @@ RtrPinsBlock(ch)
} }
bool bool
rtrPinArrayBlock(ch, pins, opins, nPins) rtrPinArrayBlock(
GCRChannel *ch; /* Channel pins belong to */ GCRChannel *ch, /* Channel pins belong to */
GCRPin *pins; /* Processing this side of channel */ GCRPin *pins, /* Processing this side of channel */
GCRPin *opins; /* Pins on opposite side; used only if ch is a GCRPin *opins, /* Pins on opposite side; used only if ch is a
* river-routing channel. * river-routing channel.
*/ */
int nPins; /* Number of internal pins (not counting pins[0]) */ int nPins) /* Number of internal pins (not counting pins[0]) */
{ {
bool changed, isRiver = (ch->gcr_type != CHAN_NORMAL); bool changed, isRiver = (ch->gcr_type != CHAN_NORMAL);
GCRPin *pin, *opin, *linked; GCRPin *pin, *opin, *linked;
@ -364,8 +364,8 @@ rtrPinArrayBlock(ch, pins, opins, nPins)
*/ */
void void
RtrPinsLink(ch) RtrPinsLink(
GCRChannel *ch; GCRChannel *ch)
{ {
rtrPinArrayLink(ch->gcr_tPins, ch->gcr_length); rtrPinArrayLink(ch->gcr_tPins, ch->gcr_length);
rtrPinArrayLink(ch->gcr_bPins, ch->gcr_length); rtrPinArrayLink(ch->gcr_bPins, ch->gcr_length);
@ -374,9 +374,9 @@ RtrPinsLink(ch)
} }
int int
rtrPinArrayLink(pins, nPins) rtrPinArrayLink(
GCRPin *pins; GCRPin *pins,
int nPins; int nPins)
{ {
GCRPin *pin, *lastPin, *lastValid; GCRPin *pin, *lastPin, *lastValid;
@ -465,8 +465,8 @@ void rtrPinShow(pin)
*/ */
void void
RtrPinsFixStems(ch) RtrPinsFixStems(
GCRChannel *ch; GCRChannel *ch)
{ {
rtrPinArrayFixStems(ch->gcr_tPins, ch->gcr_length); rtrPinArrayFixStems(ch->gcr_tPins, ch->gcr_length);
rtrPinArrayFixStems(ch->gcr_bPins, ch->gcr_length); rtrPinArrayFixStems(ch->gcr_bPins, ch->gcr_length);
@ -475,9 +475,9 @@ RtrPinsFixStems(ch)
} }
int int
rtrPinArrayFixStems(pins, nPins) rtrPinArrayFixStems(
GCRPin *pins; GCRPin *pins,
int nPins; int nPins)
{ {
GCRPin *pin, *lastPin; GCRPin *pin, *lastPin;

42
router/rtrSide.c
View File

@ -151,15 +151,15 @@ int rtrSideLookCellsFunc();
*/ */
int int
rtrEnumSides(use, area, minChannelWidth, func, cdata) rtrEnumSides(
CellUse *use; /* Enumerate sides of use->cu_def */ CellUse *use, /* Enumerate sides of use->cu_def */
Rect *area; /* Only consider sides inside this area; Rect *area, /* Only consider sides inside this area;
* this does not include sides along the * this does not include sides along the
* border. * border.
*/ */
int minChannelWidth; /* See above */ int minChannelWidth, /* See above */
int (*func)(); /* Applied to each Side found */ int (*func)(), /* Applied to each Side found */
ClientData cdata; /* Passed to (*func)() */ ClientData cdata) /* Passed to (*func)() */
{ {
/* Create the yank buffer if it doesn't exist */ /* Create the yank buffer if it doesn't exist */
if (rtrSideTransUse == NULL) if (rtrSideTransUse == NULL)
@ -213,11 +213,11 @@ rtrEnumSides(use, area, minChannelWidth, func, cdata)
*/ */
int int
rtrSideProcess(use, side, area, trans) rtrSideProcess(
CellUse *use; /* Enumerating Sides of use->cu_def */ CellUse *use, /* Enumerating Sides of use->cu_def */
int side; /* Which sides (GEO_NORTH, etc) of cells to process */ int side, /* Which sides (GEO_NORTH, etc) of cells to process */
Rect *area; /* Find sides in this area (in use->cu_def coords) */ Rect *area, /* Find sides in this area (in use->cu_def coords) */
Transform *trans; /* Transform from use->cu_def coords to those of the Transform *trans) /* Transform from use->cu_def coords to those of the
* cell tile plane where we actually try to find Sides. * cell tile plane where we actually try to find Sides.
*/ */
{ {
@ -285,10 +285,10 @@ rtrSideProcess(use, side, area, trans)
*/ */
int int
rtrSideInitClient(tile, dinfo, client) rtrSideInitClient(
Tile *tile; Tile *tile,
TileType dinfo; TileType dinfo,
ClientData client; ClientData client)
{ {
if (IsSplit(tile)) if (IsSplit(tile))
if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE) if (TiGetLeftType(tile) != TT_SPACE && TiGetRightType(tile) != TT_SPACE)
@ -321,10 +321,10 @@ rtrSideInitClient(tile, dinfo, client)
*/ */
int int
rtrEnumSidesFunc(tile, dinfo, clientdata) rtrEnumSidesFunc(
Tile *tile; Tile *tile,
TileType dinfo; TileType dinfo,
ClientData clientdata; /* (unused) */ ClientData clientdata) /* (unused) */
{ {
int ybot, ytop, yprev, sep, x, origin; int ybot, ytop, yprev, sep, x, origin;
Tile *tp, *tpB; Tile *tp, *tpB;
@ -487,8 +487,8 @@ rtrEnumSidesFunc(tile, dinfo, clientdata)
*/ */
int int
rtrSidePassToClient(side) rtrSidePassToClient(
Side *side; Side *side)
{ {
side->side_search.r_ybot = side->side_line.r_ybot; side->side_search.r_ybot = side->side_line.r_ybot;
side->side_search.r_ytop = side->side_line.r_ytop; side->side_search.r_ytop = side->side_line.r_ytop;

130
router/rtrStem.c
View File

@ -131,11 +131,11 @@ bool RtrComputeJogs();
*/ */
void void
RtrStemProcessAll(use, netList, doWarn, func) RtrStemProcessAll(
CellUse *use; CellUse *use,
NLNetList *netList; NLNetList *netList,
bool doWarn; bool doWarn,
bool (*func)(); bool (*func)())
{ {
NLTermLoc *loc, *locFirst, *locPrev, *locNext; NLTermLoc *loc, *locFirst, *locPrev, *locNext;
Rect errArea; Rect errArea;
@ -236,12 +236,12 @@ out:
*/ */
bool bool
RtrStemAssignExt(use, doWarn, loc, term, net) RtrStemAssignExt(
CellUse *use; /* Cell being routed (for feedback) */ CellUse *use, /* Cell being routed (for feedback) */
bool doWarn; /* If TRUE, leave feedback for each bad loc */ bool doWarn, /* If TRUE, leave feedback for each bad loc */
NLTermLoc *loc; /* Location being assigned */ NLTermLoc *loc, /* Location being assigned */
NLTerm *term; /* For nterm_name */ NLTerm *term, /* For nterm_name */
NLNet *net; /* For marking pin */ NLNet *net) /* For marking pin */
{ {
TileType type = loc->nloc_label->lab_type; TileType type = loc->nloc_label->lab_type;
int dirMask, termWidth, pins; int dirMask, termWidth, pins;
@ -403,7 +403,10 @@ fail:
/* Routine to expand rectangle into touching tiles of a label's type. */ /* Routine to expand rectangle into touching tiles of a label's type. */
int int
rtrStemExpandFunc(Tile *t, TileType dinfo, TreeContext *cxp) rtrStemExpandFunc(
Tile *t,
TileType dinfo,
TreeContext *cxp)
{ {
SearchContext *scx = cxp->tc_scx; SearchContext *scx = cxp->tc_scx;
Rect rsrc; Rect rsrc;
@ -465,10 +468,10 @@ rtrStemExpandFunc(Tile *t, TileType dinfo, TreeContext *cxp)
*/ */
GCRPin * GCRPin *
rtrStemTip(loc, si, use) rtrStemTip(
NLTermLoc *loc; /* Location whose stem tip is being found */ NLTermLoc *loc, /* Location whose stem tip is being found */
StemInfo *si; /* Stem information */ StemInfo *si, /* Stem information */
CellUse *use; CellUse *use)
{ {
Point plo, phi; Point plo, phi;
int *lo, *hi; int *lo, *hi;
@ -546,11 +549,11 @@ rtrAbort(Tile *tile,
*/ */
GCRPin * GCRPin *
rtrStemTryPin(loc, dir, p, use) rtrStemTryPin(
NLTermLoc *loc; /* Try to assign the GCRPin for p to this loc */ NLTermLoc *loc, /* Try to assign the GCRPin for p to this loc */
int dir; /* Direction away from loc that p lies */ int dir, /* Direction away from loc that p lies */
Point *p; /* Crossing point to try */ Point *p, /* Crossing point to try */
CellUse *use; CellUse *use)
{ {
Point pSearch; Point pSearch;
GCRChannel *ch; GCRChannel *ch;
@ -651,11 +654,11 @@ rtrStemTryPin(loc, dir, p, use)
*/ */
bool bool
rtrTreeSrArea(loc, dir, p, use) rtrTreeSrArea(
NLTermLoc *loc; /* Terminal location under consideration */ NLTermLoc *loc, /* Terminal location under consideration */
int dir; /* Direction away from loc that p lies */ int dir, /* Direction away from loc that p lies */
Point *p; /* Point at channel boundary */ Point *p, /* Point at channel boundary */
CellUse *use; /* Parent cell use */ CellUse *use) /* Parent cell use */
{ {
Rect tmp, tmp1, tmp2; Rect tmp, tmp1, tmp2;
Point contact, jog, start; Point contact, jog, start;
@ -719,11 +722,11 @@ rtrTreeSrArea(loc, dir, p, use)
} }
bool bool
rtrSrArea(dir,use,tmp,delta) rtrSrArea(
int dir; int dir,
CellUse *use; CellUse *use,
Rect *tmp; Rect *tmp,
int delta; int delta)
{ {
SearchContext scx; SearchContext scx;
TileTypeBitMask r1mask, r2mask; TileTypeBitMask r1mask, r2mask;
@ -821,10 +824,10 @@ rtrSrArea(dir,use,tmp,delta)
*/ */
void void
rtrStemRange(loc, dir, si) rtrStemRange(
NLTermLoc *loc; /* Terminal we're trying to find a stem for */ NLTermLoc *loc, /* Terminal we're trying to find a stem for */
int dir; /* Direction away from loc that we're searching */ int dir, /* Direction away from loc that we're searching */
StemInfo *si; /* Fill this in if this direction looks best so far */ StemInfo *si) /* Fill this in if this direction looks best so far */
{ {
Rect *area = &loc->nloc_rect; Rect *area = &loc->nloc_rect;
Point start, near, center; Point start, near, center;
@ -899,9 +902,10 @@ rtrStemRange(loc, dir, si)
*/ */
int int
rtrStemContactLine(lo, hi, origin) rtrStemContactLine(
int lo, hi; /* Bottom and top, or left and right of terminal */ int lo,
int origin; /* Coordinate of routing grid origin */ int hi,
int origin) /* Coordinate of routing grid origin */
{ {
int center; int center;
@ -936,10 +940,10 @@ rtrStemContactLine(lo, hi, origin)
*/ */
GCRChannel * GCRChannel *
rtrStemSearch(center, dir, point) rtrStemSearch(
Point *center; Point *center,
int dir; int dir,
Point *point; Point *point)
{ {
Tile *tile; Tile *tile;
GCRChannel *ch; GCRChannel *ch;
@ -1012,9 +1016,9 @@ rtrStemSearch(center, dir, point)
*/ */
bool bool
RtrStemPaintExt(use, loc) RtrStemPaintExt(
CellUse *use; CellUse *use,
NLTermLoc *loc; /* Terminal whose stem is to be painted */ NLTermLoc *loc) /* Terminal whose stem is to be painted */
{ {
TileTypeBitMask startMask; /* Possible layers for first part of stem */ TileTypeBitMask startMask; /* Possible layers for first part of stem */
TileTypeBitMask finalMask; /* Possible layers for last part of stem */ TileTypeBitMask finalMask; /* Possible layers for last part of stem */
@ -1135,18 +1139,18 @@ failure:
*/ */
bool bool
rtrStemMask(routeUse, loc, flags, startMask, finalMask) rtrStemMask(
CellUse *routeUse; /* Cell being routed */ CellUse *routeUse, /* Cell being routed */
NLTermLoc *loc; /* Terminal */ NLTermLoc *loc, /* Terminal */
int flags; /* Blockage flags in the channel at the int flags, /* Blockage flags in the channel at the
* crossing point. If a layer is marked * crossing point. If a layer is marked
* as blocked in these flags, it is excluded * as blocked in these flags, it is excluded
* from finalMask since the channel router * from finalMask since the channel router
* will not have used it for routing a * will not have used it for routing a
* signal. * signal.
*/ */
TileTypeBitMask *startMask; /* Possible types for terminal */ TileTypeBitMask *startMask, /* Possible types for terminal */
TileTypeBitMask *finalMask; /* Possible types for stem tip */ TileTypeBitMask *finalMask) /* Possible types for stem tip */
{ {
Rect tmp; Rect tmp;
@ -1193,9 +1197,11 @@ rtrStemMask(routeUse, loc, flags, startMask, finalMask)
} }
int int
rtrStemTypes(startMask, finalMask, startType, finalType) rtrStemTypes(
TileTypeBitMask *startMask, *finalMask; TileTypeBitMask *startMask,
TileType *startType, *finalType; TileTypeBitMask *finalMask,
TileType *startType,
TileType *finalType)
{ {
if (!TTMaskHasType(finalMask, RtrMetalType)) if (!TTMaskHasType(finalMask, RtrMetalType))
{ {
@ -1240,20 +1246,20 @@ rtrStemTypes(startMask, finalMask, startType, finalType)
*/ */
bool bool
RtrComputeJogs(loc, stem, dir, contact, jog, start, width) RtrComputeJogs(
NLTermLoc *loc; /* Terminal whose stem is to be painted */ NLTermLoc *loc, /* Terminal whose stem is to be painted */
Point *stem; /* Point intersecting channel*/ Point *stem, /* Point intersecting channel*/
int dir; int dir,
Point *contact; /* A second grid point, where a contact can Point *contact, /* A second grid point, where a contact can
* be placed if necessary. This is a the * be placed if necessary. This is a the
* nearest grid crossing to crossing outside * nearest grid crossing to crossing outside
* the channel. * the channel.
*/ */
Point *jog; /* Where the stem crosses the first usable Point *jog, /* Where the stem crosses the first usable
* grid line as it runs out from the cell. * grid line as it runs out from the cell.
*/ */
Point *start; /* Somewhere along terminal area */ Point *start, /* Somewhere along terminal area */
int width; int width)
{ {
Rect *area; Rect *area;
area = &loc->nloc_rect; area = &loc->nloc_rect;

13
router/rtrTech.c
View File

@ -129,10 +129,10 @@ RtrTechInit()
*/ */
bool bool
RtrTechLine(sectionName, argc, argv) RtrTechLine(
char *sectionName; /* Name of this section. */ char *sectionName, /* Name of this section. */
int argc; /* Number of fields on line. */ int argc, /* Number of fields on line. */
char *argv[]; /* Values of fields. */ char *argv[]) /* Values of fields. */
{ {
TileTypeBitMask mask; TileTypeBitMask mask;
int type, width, i, distance; int type, width, i, distance;
@ -403,8 +403,9 @@ RtrTechFinal()
*/ */
int int
RtrTechScale(scaled, scalen) RtrTechScale(
int scaled, scalen; int scaled,
int scalen)
{ {
int i; int i;

49
router/rtrTravers.c
View File

@ -114,32 +114,31 @@ struct rtrTileStack
*/ */
int int
rtrSrTraverse(def, startArea, mask, connect, bounds, func, clientData) rtrSrTraverse(
CellDef *def; /* Cell definition in which to carry out CellDef *def, /* Cell definition in which to carry out
* the connectivity search. Only paint * the connectivity search. Only paint
* in this definition is considered. * in this definition is considered.
*/ */
Rect *startArea; /* Area to search for an initial tile. Only Rect *startArea, /* Area to search for an initial tile. Only
* tiles OVERLAPPING the area are considered. * tiles OVERLAPPING the area are considered.
* This area should have positive x and y * This area should have positive x and y
* dimensions. * dimensions.
*/ */
TileTypeBitMask *mask; /* Only tiles of one of these types are used TileTypeBitMask *mask, /* Only tiles of one of these types are used
* as initial tiles. * as initial tiles.
*/ */
TileTypeBitMask *connect; /* Pointer to a table indicating what tile TileTypeBitMask *connect, /* Pointer to a table indicating what tile
* types connect to what other tile types. * types connect to what other tile types.
* Each entry gives a mask of types that * Each entry gives a mask of types that
* connect to tiles of a given type. * connect to tiles of a given type.
*/ */
Rect *bounds; /* Area, in coords of scx->scx_use->cu_def, Rect *bounds, /* Area, in coords of scx->scx_use->cu_def,
* that limits the search: only tiles * that limits the search: only tiles
* overalapping this area will be returned. * overalapping this area will be returned.
* Use TiPlaneRect to search everywhere. * Use TiPlaneRect to search everywhere.
*/ */
int (*func)(); /* Function to apply at each connected tile. */ int (*func)(), /* Function to apply at each connected tile. */
ClientData clientData; /* Client data for above function. */ ClientData clientData) /* Client data for above function. */
{ {
struct conSrArg csa; struct conSrArg csa;
struct rtrTileStack ts; struct rtrTileStack ts;
@ -199,10 +198,10 @@ rtrSrTraverse(def, startArea, mask, connect, bounds, func, clientData)
} }
int int
rtrSrTraverseStartFunc(tile, dinfo, tad) rtrSrTraverseStartFunc(
Tile *tile; /* This will be the starting tile. */ Tile *tile, /* This will be the starting tile. */
TileType dinfo; /* Split tile information (unused) */ TileType dinfo, /* Split tile information (unused) */
TileAndDinfo *tad; /* We store tile's address here. */ TileAndDinfo *tad) /* We store tile's address here. */
{ {
/* Simplified approach to split tiles: Use split tiles with one /* Simplified approach to split tiles: Use split tiles with one
@ -257,10 +256,10 @@ rtrSrTraverseStartFunc(tile, dinfo, tad)
#define IGNORE_BOTTOM 8 #define IGNORE_BOTTOM 8
int int
rtrSrTraverseFunc(tile, dinfo, ts) rtrSrTraverseFunc(
Tile *tile; /* Tile that is connected. */ Tile *tile, /* Tile that is connected. */
TileType dinfo; /* Split tile information (unused) */ TileType dinfo, /* Split tile information (unused) */
struct rtrTileStack *ts; /* Contains information about the search. */ struct rtrTileStack *ts) /* Contains information about the search. */
{ {
Tile *t2; Tile *t2;
Rect tileArea; Rect tileArea;
@ -451,10 +450,10 @@ rtrSrTraverseFunc(tile, dinfo, ts)
*/ */
int int
rtrExamineTile(tile, dinfo, cdata) rtrExamineTile(
Tile *tile; Tile *tile,
TileType dinfo; TileType dinfo,
ClientData cdata; ClientData cdata)
{ {
TileType ttype; TileType ttype;
@ -496,10 +495,10 @@ rtrExamineTile(tile, dinfo, cdata)
*/ */
int int
rtrExamineStack(tile, dinfo, ts) rtrExamineStack(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
struct rtrTileStack *ts; struct rtrTileStack *ts)
{ {
int i; int i;
Tile *tp[3]; Tile *tp[3];

76
router/rtrVia.c
View File

@ -108,13 +108,13 @@ int rtrExamineStack(); /* Examines the tile stack for
/* ARGSUSED */ /* ARGSUSED */
int int
rtrFollowLocFunc(rect, name, label, area) rtrFollowLocFunc(
Rect *rect; /* Area of the terminal, edit cell coords. */ Rect *rect, /* Area of the terminal, edit cell coords. */
char *name; /* Name of the terminal (ignored). */ char *name, /* Name of the terminal (ignored). */
Label *label; /* Pointer to the label, used to find out Label *label, /* Pointer to the label, used to find out
* what layer the label's attached to. * what layer the label's attached to.
*/ */
Rect *area; /* We GeoInclude into this all the areas of Rect *area) /* We GeoInclude into this all the areas of
* all the tiles we delete. * all the tiles we delete.
*/ */
{ {
@ -150,10 +150,10 @@ rtrFollowLocFunc(rect, name, label, area)
/* ARGSUSED */ /* ARGSUSED */
int int
rtrFollowName(name, firstInNet, area) rtrFollowName(
char *name; /* Name of terminal. */ char *name, /* Name of terminal. */
bool firstInNet; /* Ignored by this procedure. */ bool firstInNet, /* Ignored by this procedure. */
Rect *area; /* Passed through as ClientData to Rect *area) /* Passed through as ClientData to
* rtrFollowLocFunc. * rtrFollowLocFunc.
*/ */
{ {
@ -182,10 +182,10 @@ rtrFollowName(name, firstInNet, area)
*/ */
int int
rtrCheckTypes(tile, dinfo, cdata) rtrCheckTypes(
Tile *tile; Tile *tile,
TileType dinfo; TileType dinfo,
ClientData cdata; ClientData cdata)
{ {
int type; int type;
int lastType = *(int *)cdata; int lastType = *(int *)cdata;
@ -226,10 +226,10 @@ rtrCheckTypes(tile, dinfo, cdata)
*/ */
void void
rtrExtend(tile,area,stub) rtrExtend(
Tile *tile; /* Tile adjacent to via */ Tile *tile, /* Tile adjacent to via */
Rect *area; /* Area occupied by via */ Rect *area, /* Area occupied by via */
Rect *stub; /* Extension of routing material Rect *stub) /* Extension of routing material
into area of via */ into area of via */
{ {
if ( (TOP(tile) == area->r_ybot) || (BOTTOM(tile) == area->r_ytop) ) if ( (TOP(tile) == area->r_ybot) || (BOTTOM(tile) == area->r_ytop) )
@ -264,10 +264,10 @@ rtrExtend(tile,area,stub)
*/ */
int int
rtrStubGen(tile, dinfo, si) rtrStubGen(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
struct srinfo *si; struct srinfo *si)
{ {
Rect area; Rect area;
struct paintlist *pl; struct paintlist *pl;
@ -311,10 +311,10 @@ rtrStubGen(tile, dinfo, si)
int int
rtrReferenceTile(tile, dinfo, si) rtrReferenceTile(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
struct srinfo *si; struct srinfo *si)
{ {
si->si_tile = tile; si->si_tile = tile;
rtrExtend(tile, si->si_varea, &si->si_extend); rtrExtend(tile, si->si_varea, &si->si_extend);
@ -342,9 +342,9 @@ rtrReferenceTile(tile, dinfo, si)
*/ */
void void
rtrViaCheck(area, def) rtrViaCheck(
Rect *area; Rect *area,
CellDef *def; CellDef *def)
{ {
Rect r; Rect r;
int type, plane; int type, plane;
@ -423,12 +423,12 @@ rtrViaCheck(area, def)
*/ */
void void
rtrListArea(tile, oldType, newType, deltax, deltay) rtrListArea(
Tile *tile; Tile *tile,
int oldType; int oldType,
int newType; int newType,
int deltax; int deltax,
int deltay; int deltay)
{ {
struct arealist *ap; struct arealist *ap;
@ -469,8 +469,8 @@ rtrListArea(tile, oldType, newType, deltax, deltay)
*/ */
int int
rtrListVia(tile) rtrListVia(
Tile *tile; Tile *tile)
{ {
struct vialist *vp; struct vialist *vp;
@ -501,8 +501,8 @@ rtrListVia(tile)
*/ */
int int
RtrViaMinimize(def) RtrViaMinimize(
CellDef *def; CellDef *def)
{ {
Rect area; Rect area;
struct vialist *vp; struct vialist *vp;

4
router/tclroute.c
View File

@ -44,8 +44,8 @@ extern void CmdIRouterTest(), CmdMZRouterTest();
*/ */
int int
Tclroute_Init(interp) Tclroute_Init(
Tcl_Interp *interp; Tcl_Interp *interp)
{ {
SectionID invsec; SectionID invsec;