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

plow: convert K&R function definitions to ANSI C 

Convert the old-style (K&R) function definitions in plow/ 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.

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 dd13fcb777
commit 0c7d357a6d
No known key found for this signature in database
GPG Key ID: 588785BFDFB01ABD
11 changed files with 345 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
plow/PlowCmd.c
View File

@ -81,9 +81,9 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
#define PLOWPLOW 9 /* Implicit when direction specified */ #define PLOWPLOW 9 /* Implicit when direction specified */
void void
CmdPlow(w, cmd) CmdPlow(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
int xdelta, ydelta, absX, absY; int xdelta, ydelta, absX, absY;
int option, dir, distance; int option, dir, distance;
@ -334,9 +334,9 @@ usage2:
*/ */
void void
CmdStraighten(w, cmd) CmdStraighten(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
Rect editBox; Rect editBox;
int dir; int dir;
@ -394,9 +394,9 @@ usage:
*/ */
void void
CmdPlowTest(w, cmd) CmdPlowTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
PlowTest(w, cmd); PlowTest(w, cmd);
} }

40
plow/PlowJogs.c
View File

@ -97,9 +97,9 @@ extern void plowProcessJog();
*/ */
void void
plowCleanupJogs(area, changedArea) plowCleanupJogs(
Rect *area; Rect *area,
Rect *changedArea; Rect *changedArea)
{ {
Edge edge; Edge edge;
@ -167,9 +167,9 @@ plowCleanupJogs(area, changedArea)
*/ */
void void
plowProcessJog(edge, area) plowProcessJog(
Edge *edge; Edge *edge,
Rect *area; Rect *area)
{ {
Rect r; Rect r;
@ -218,8 +218,8 @@ plowProcessJog(edge, area)
*/ */
int int
plowJogPropagateLeft(edge) plowJogPropagateLeft(
Edge *edge; Edge *edge)
{ {
if (DebugIsSet(plowDebugID, plowDebJogs)) if (DebugIsSet(plowDebugID, plowDebJogs))
plowDebugEdge(edge, (RuleTableEntry *) NULL, "plowJogPropagateLeft"); plowDebugEdge(edge, (RuleTableEntry *) NULL, "plowJogPropagateLeft");
@ -254,9 +254,9 @@ plowJogPropagateLeft(edge)
*/ */
int int
plowProcessJogFunc(edge, area) plowProcessJogFunc(
Edge *edge; /* Edge found by shadow search */ Edge *edge, /* Edge found by shadow search */
Rect *area; /* Area in which jogs are being eliminated */ Rect *area) /* Area in which jogs are being eliminated */
{ {
LinkedRect *lr; LinkedRect *lr;
Rect r, lhs; Rect r, lhs;
@ -418,8 +418,8 @@ plowProcessJogFunc(edge, area)
*/ */
int int
plowJogTopProc(outline) plowJogTopProc(
Outline *outline; Outline *outline)
{ {
/* Stop if we're no longer adjacent to space */ /* Stop if we're no longer adjacent to space */
if (TiGetTypeExact(outline->o_outside) != TT_SPACE) if (TiGetTypeExact(outline->o_outside) != TT_SPACE)
@ -465,8 +465,8 @@ plowJogTopProc(outline)
} }
int int
plowJogBotProc(outline) plowJogBotProc(
Outline *outline; Outline *outline)
{ {
/* Stop if we're no longer adjacent to space */ /* Stop if we're no longer adjacent to space */
if (TiGetTypeExact(outline->o_inside) != TT_SPACE) if (TiGetTypeExact(outline->o_inside) != TT_SPACE)
@ -534,9 +534,9 @@ plowJogBotProc(outline)
*/ */
int int
plowJogDragLHS(edge, newx) plowJogDragLHS(
Edge *edge; /* Edge potentially on the LHS of the jog */ Edge *edge, /* Edge potentially on the LHS of the jog */
int newx; /* Move the edge to this position */ int newx) /* Move the edge to this position */
{ {
LinkedRect *lr; LinkedRect *lr;
@ -583,8 +583,8 @@ plowJogDragLHS(edge, newx)
*/ */
int int
plowJogMoveFunc(edge) plowJogMoveFunc(
Edge *edge; Edge *edge)
{ {
Edge *origEdge = jogEdge; Edge *origEdge = jogEdge;

174
plow/PlowMain.c
View File

@ -186,11 +186,11 @@ extern void plowYankCreate();
*/ */
void void
PlowSetBound(def, area, rootDef, rootArea) PlowSetBound(
CellDef *def; /* Def in which bounding area applies */ CellDef *def, /* Def in which bounding area applies */
Rect *area; /* Area in 'def' coordinates */ Rect *area, /* Area in 'def' coordinates */
CellDef *rootDef; /* Display bounding area in windows with this root */ CellDef *rootDef, /* Display bounding area in windows with this root */
Rect *rootArea; /* Area in 'rootDef' coordinates */ Rect *rootArea) /* Area in 'rootDef' coordinates */
{ {
static bool firstTime = TRUE; static bool firstTime = TRUE;
PlowBoundary *pb; PlowBoundary *pb;
@ -267,9 +267,9 @@ PlowClearBound()
*/ */
void void
PlowRedrawBound(window, plane) PlowRedrawBound(
MagWindow *window; /* Window in which to redraw. */ MagWindow *window, /* Window in which to redraw. */
Plane *plane; /* Non-space tiles on this plane indicate Plane *plane) /* Non-space tiles on this plane indicate
* areas where highlights need to be * areas where highlights need to be
* redisplayed. * redisplayed.
*/ */
@ -305,7 +305,10 @@ PlowRedrawBound(window, plane)
} }
int int
plowBoundAlways1(Tile *tile, TileType dinfo, ClientData clientdata) plowBoundAlways1(
Tile *tile,
TileType dinfo,
ClientData clientdata)
{ {
return 1; return 1;
} }
@ -329,10 +332,10 @@ plowBoundAlways1(Tile *tile, TileType dinfo, ClientData clientdata)
*/ */
void void
PlowStraighten(def, area, direction) PlowStraighten(
CellDef *def; /* Def whose jogs we should straighten */ CellDef *def, /* Def whose jogs we should straighten */
Rect *area; /* Area in which jogs are to be straightened */ Rect *area, /* Area in which jogs are to be straightened */
int direction; /* Pull all jogs in this direction to straighten them */ int direction) /* Pull all jogs in this direction to straighten them */
{ {
Rect changedArea, changedUserArea, yankArea; Rect changedArea, changedUserArea, yankArea;
bool saveCheckBoundary; bool saveCheckBoundary;
@ -435,10 +438,10 @@ PlowStraighten(def, area, direction)
*/ */
bool bool
PlowSelection(def, pdistance, direction) PlowSelection(
CellDef *def; /* Cell being plowed */ CellDef *def, /* Cell being plowed */
int *pdistance; /* Distance to plow */ int *pdistance, /* Distance to plow */
int direction; /* One of GEO_NORTH, GEO_SOUTH, GEO_WEST, or GEO_EAST */ int direction) /* One of GEO_NORTH, GEO_SOUTH, GEO_WEST, or GEO_EAST */
{ {
Rect changedArea; Rect changedArea;
bool firstTime; bool firstTime;
@ -555,10 +558,10 @@ Plow(
*/ */
void void
plowUpdate(def, direction, pChangedArea) plowUpdate(
CellDef *def; CellDef *def,
int direction; int direction,
Rect *pChangedArea; Rect *pChangedArea)
{ {
Rect changedUserArea; Rect changedUserArea;
TileTypeBitMask *m; TileTypeBitMask *m;
@ -825,10 +828,10 @@ plowPropagateRect(
*/ */
bool bool
plowPropagateSel(def, pdistance, changedArea) plowPropagateSel(
CellDef *def; /* Def being plowed */ CellDef *def, /* Def being plowed */
int *pdistance; /* Distance to plow */ int *pdistance, /* Distance to plow */
Rect *changedArea; /* Set to bounding box around area modified */ Rect *changedArea) /* Set to bounding box around area modified */
{ {
#ifndef NO_RUSAGE #ifndef NO_RUSAGE
struct rusage t1, t2; struct rusage t1, t2;
@ -988,10 +991,10 @@ plowPropagateSel(def, pdistance, changedArea)
*/ */
int int
plowSelPaintBox(rect, type, pSelBox) plowSelPaintBox(
Rect *rect; Rect *rect,
TileType type; TileType type,
Rect *pSelBox; Rect *pSelBox)
{ {
Rect editRect; Rect editRect;
@ -1001,11 +1004,11 @@ plowSelPaintBox(rect, type, pSelBox)
} }
int int
plowSelCellBox(selUse, realUse, transform, pSelBox) plowSelCellBox(
CellUse *selUse; CellUse *selUse,
CellUse *realUse; CellUse *realUse,
Transform *transform; Transform *transform,
Rect *pSelBox; Rect *pSelBox)
{ {
GeoInclude(&realUse->cu_bbox, pSelBox); GeoInclude(&realUse->cu_bbox, pSelBox);
return (0); return (0);
@ -1030,10 +1033,10 @@ plowSelCellBox(selUse, realUse, transform, pSelBox)
*/ */
int int
plowSelPaintPlow(rect, type, distance) plowSelPaintPlow(
Rect *rect; Rect *rect,
TileType type; TileType type,
int distance; int distance)
{ {
int plowSelPaintAdd(); int plowSelPaintAdd();
Rect editRect, plowRect, plowLHS, plowRHS; Rect editRect, plowRect, plowLHS, plowRHS;
@ -1067,8 +1070,8 @@ plowSelPaintPlow(rect, type, distance)
} }
int int
plowSelPaintAdd(edge) plowSelPaintAdd(
Edge *edge; Edge *edge)
{ {
int saveFlags = edge->e_flags; int saveFlags = edge->e_flags;
@ -1098,11 +1101,11 @@ plowSelPaintAdd(edge)
*/ */
int int
plowSelCellPlow(selUse, realUse, transform, distance) plowSelCellPlow(
CellUse *selUse; /* Cell in selection */ CellUse *selUse, /* Cell in selection */
CellUse *realUse; /* Corresponding cell in def being plowed */ CellUse *realUse, /* Corresponding cell in def being plowed */
Transform *transform; /* UNUSED */ Transform *transform, /* UNUSED */
int distance; /* Plow distance */ int distance) /* Plow distance */
{ {
int plowFindSelCell(); int plowFindSelCell();
ClientData save; ClientData save;
@ -1117,9 +1120,9 @@ plowSelCellPlow(selUse, realUse, transform, distance)
} }
int int
plowFindSelCell(yankUse, editUse) plowFindSelCell(
CellUse *yankUse; /* Cell in the plow yank buffer */ CellUse *yankUse, /* Cell in the plow yank buffer */
CellUse *editUse; /* Cell from the original cell def */ CellUse *editUse) /* Cell from the original cell def */
{ {
Edge edge; Edge edge;
@ -1180,8 +1183,8 @@ plowFindSelCell(yankUse, editUse)
*/ */
void void
PlowExtendJogHorizon(edge) PlowExtendJogHorizon(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
int horizonTop, horizonBot, eTop, eBot; int horizonTop, horizonBot, eTop, eBot;
Tile *tpR, *tpL; Tile *tpR, *tpL;
@ -1319,8 +1322,8 @@ restartbot:
*/ */
void void
plowSetTrans(direction) plowSetTrans(
int direction; int direction)
{ {
plowDirection = direction; plowDirection = direction;
switch (direction) switch (direction)
@ -1361,10 +1364,10 @@ plowSetTrans(direction)
*/ */
bool bool
plowPastBoundary(def, edge, pmove) plowPastBoundary(
CellDef *def; /* Def being plowed */ CellDef *def, /* Def being plowed */
Edge *edge; /* Edge being moved */ Edge *edge, /* Edge being moved */
int *pmove; /* Updated to be the maximum distance by int *pmove) /* Updated to be the maximum distance by
* which something moves in an illegal area. * which something moves in an illegal area.
*/ */
{ {
@ -1422,9 +1425,9 @@ plowPastBoundary(def, edge, pmove)
*/ */
int int
plowInitialPaint(edge, xnew) plowInitialPaint(
Edge *edge; Edge *edge,
int xnew; int xnew)
{ {
edge->e_newx = xnew; edge->e_newx = xnew;
edge->e_flags = E_ISINITIAL; edge->e_flags = E_ISINITIAL;
@ -1450,9 +1453,9 @@ plowInitialPaint(edge, xnew)
*/ */
int int
plowInitialCell(use, plowRect) plowInitialCell(
CellUse *use; CellUse *use,
Rect *plowRect; Rect *plowRect)
{ {
int xmove; int xmove;
Edge edge; Edge edge;
@ -1518,9 +1521,9 @@ plowInitialCell(use, plowRect)
*/ */
void void
plowProcessEdge(edge, changedArea) plowProcessEdge(
Edge *edge; /* Edge to be processed (in plowYankDef) */ Edge *edge, /* Edge to be processed (in plowYankDef) */
Rect *changedArea; /* Include any additional area changed in this area */ Rect *changedArea) /* Include any additional area changed in this area */
{ {
int amountToMove = edge->e_newx - edge->e_x; int amountToMove = edge->e_newx - edge->e_x;
RuleTableEntry *rte; RuleTableEntry *rte;
@ -1649,8 +1652,8 @@ worktodo:
*/ */
int int
plowApplySearchRules(edge) plowApplySearchRules(
Edge *edge; Edge *edge)
{ {
PlowRule *widthRules, *rules; PlowRule *widthRules, *rules;
RuleTableEntry *rte; RuleTableEntry *rte;
@ -1742,10 +1745,10 @@ plowApplySearchRules(edge)
*/ */
PlowRule * PlowRule *
plowBuildWidthRules(edge, bbox, phalo) plowBuildWidthRules(
Edge *edge; /* Edge being moved */ Edge *edge, /* Edge being moved */
Rect *bbox; /* Bounding box of def being plowed */ Rect *bbox, /* Bounding box of def being plowed */
int *phalo; /* Update *phalo to be the max of its initial value int *phalo) /* Update *phalo to be the max of its initial value
* and each of the widths we compute for the rules * and each of the widths we compute for the rules
* we return. * we return.
*/ */
@ -1829,8 +1832,8 @@ retry:
*/ */
void void
plowMoveEdge(edge) plowMoveEdge(
Edge *edge; /* Edge to be moved */ Edge *edge) /* Edge to be moved */
{ {
Plane *plane = plowYankDef->cd_planes[edge->e_pNum]; Plane *plane = plowYankDef->cd_planes[edge->e_pNum];
Tile *delayed = NULL; /* delayed free to extend lifetime */ Tile *delayed = NULL; /* delayed free to extend lifetime */
@ -1948,9 +1951,9 @@ plowMoveEdge(edge)
*/ */
Tile * Tile *
plowSplitY(tp, y) plowSplitY(
Tile *tp; Tile *tp,
int y; int y)
{ {
Tile *newTile; Tile *newTile;
@ -1986,7 +1989,10 @@ plowSplitY(tp, y)
*/ */
void void
plowMergeTop(Tile **delay1, Tile *tp, Plane *plane) plowMergeTop(
Tile **delay1,
Tile *tp,
Plane *plane)
{ {
Tile *tpRT = RT(tp); Tile *tpRT = RT(tp);
@ -1999,7 +2005,10 @@ plowMergeTop(Tile **delay1, Tile *tp, Plane *plane)
} }
void void
plowMergeBottom(Tile **delay1, Tile *tp, Plane *plane) plowMergeBottom(
Tile **delay1,
Tile *tp,
Plane *plane)
{ {
Tile *tpLB = LB(tp); Tile *tpLB = LB(tp);
@ -2259,9 +2268,12 @@ plowYankCreate()
#ifndef NO_RUSAGE #ifndef NO_RUSAGE
void void
plowShowTime(t1, t2, nqueued, nprocessed, nmoved) plowShowTime(
struct rusage *t1, *t2; struct rusage *t1,
int nqueued, nprocessed, nmoved; struct rusage *t2,
int nqueued,
int nprocessed,
int nmoved)
{ {
double secs, usecs; double secs, usecs;

18
plow/PlowQueue.c
View File

@ -72,9 +72,9 @@ int plowTooFar; /* # times we reduced plow size */
*/ */
void void
plowQueueInit(bbox, dist) plowQueueInit(
Rect *bbox; /* Bounding box for the cell being plowed */ Rect *bbox, /* Bounding box for the cell being plowed */
int dist; /* Distance the plow moves */ int dist) /* Distance the plow moves */
{ {
Edge **pptr, **pend; Edge **pptr, **pend;
int pNum; int pNum;
@ -151,8 +151,8 @@ plowQueueDone()
&& (e1)->e_rtype == (e2)->e_rtype) && (e1)->e_rtype == (e2)->e_rtype)
int int
plowQueueAdd(eadd) plowQueueAdd(
Edge *eadd; /* Edge added to queue. We assume that Edge *eadd) /* Edge added to queue. We assume that
* e_ltype and e_rtype have been set to * e_ltype and e_rtype have been set to
* the types on the LHS and RHS of this * the types on the LHS and RHS of this
* edge, respectively. * edge, respectively.
@ -455,8 +455,8 @@ done:
*/ */
bool bool
plowQueueLeftmost(edge) plowQueueLeftmost(
Edge *edge; Edge *edge)
{ {
Edge *enew, **pp, **plast; Edge *enew, **pp, **plast;
int pNum; int pNum;
@ -530,8 +530,8 @@ plowQueueLeftmost(edge)
*/ */
bool bool
plowQueueRightmost(edge) plowQueueRightmost(
Edge *edge; Edge *edge)
{ {
Edge *enew, **pp, **plast; Edge *enew, **pp, **plast;
int pNum; int pNum;

26
plow/PlowRandom.c
View File

@ -82,8 +82,8 @@ void plowGenRect();
*/ */
void void
PlowRandomTest(def) PlowRandomTest(
CellDef *def; CellDef *def)
{ {
#ifdef notdef #ifdef notdef
static char *tempgood = "/tmp/PlowGoodaXXXXX"; static char *tempgood = "/tmp/PlowGoodaXXXXX";
@ -189,7 +189,10 @@ PlowRandomTest(def)
*/ */
int int
plowFindFirstError(Tile *tile, TileType dinfo, ClientData clientdata) plowFindFirstError(
Tile *tile,
TileType dinfo,
ClientData clientdata)
{ {
return (1); return (1);
} }
@ -215,9 +218,9 @@ plowFindFirstError(Tile *tile, TileType dinfo, ClientData clientdata)
*/ */
void void
plowGenRect(bbox, r) plowGenRect(
Rect *bbox; /* Bounding box of the cell being plowed */ Rect *bbox, /* Bounding box of the cell being plowed */
Rect *r; /* Fill in this rectangle */ Rect *r) /* Fill in this rectangle */
{ {
int temp; int temp;
@ -259,8 +262,9 @@ plowGenRect(bbox, r)
*/ */
int int
plowGenRandom(lo, hi) plowGenRandom(
int lo, hi; /* Inclusive bounds for the integer we'll generate */ int lo,
int hi)
{ {
int range = hi - lo + 1; int range = hi - lo + 1;
#if defined(SYSV) || defined(EMSCRIPTEN) #if defined(SYSV) || defined(EMSCRIPTEN)
@ -290,9 +294,9 @@ plowGenRandom(lo, hi)
*/ */
bool bool
plowFileDiff(file1, file2) plowFileDiff(
char *file1; char *file1,
char *file2; char *file2)
{ {
char b1[BUFSIZ], b2[BUFSIZ]; char b1[BUFSIZ], b2[BUFSIZ];
int f1 = -1, f2 = -1; int f1 = -1, f2 = -1;

90
plow/PlowRules1.c
View File

@ -77,8 +77,8 @@ bool plowSliverApplyRules();
*/ */
void void
prClearUmbra(edge) prClearUmbra(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
TileTypeBitMask rhsTypes; TileTypeBitMask rhsTypes;
struct applyRule ar; struct applyRule ar;
@ -123,9 +123,9 @@ prClearUmbra(edge)
*/ */
void void
prUmbra(edge, rules) prUmbra(
Edge *edge; /* Edge being moved */ Edge *edge, /* Edge being moved */
PlowRule *rules; /* List of rules */ PlowRule *rules) /* List of rules */
{ {
PlowRule *pr; PlowRule *pr;
struct applyRule ar; struct applyRule ar;
@ -215,9 +215,9 @@ prUmbra(edge, rules)
*/ */
void void
prPenumbraTop(edge, rules) prPenumbraTop(
Edge *edge; /* Edge being moved */ Edge *edge, /* Edge being moved */
PlowRule *rules; /* Rules to apply (must be non-NULL) */ PlowRule *rules) /* Rules to apply (must be non-NULL) */
{ {
PlowRule *pr; PlowRule *pr;
struct applyRule ar; struct applyRule ar;
@ -238,9 +238,9 @@ prPenumbraTop(edge, rules)
} }
int int
prPenumbraBot(edge, rules) prPenumbraBot(
Edge *edge; /* Edge being moved */ Edge *edge, /* Edge being moved */
PlowRule *rules; /* Rules to apply (must be non-NULL) */ PlowRule *rules) /* Rules to apply (must be non-NULL) */
{ {
TileTypeBitMask insideTypes; TileTypeBitMask insideTypes;
PlowRule *pr; PlowRule *pr;
@ -301,9 +301,9 @@ prPenumbraBot(edge, rules)
*/ */
int int
plowPenumbraTopProc(outline, ar) plowPenumbraTopProc(
Outline *outline; /* Segment along penumbra border */ Outline *outline, /* Segment along penumbra border */
struct applyRule *ar; /* Info needed for shadow search */ struct applyRule *ar) /* Info needed for shadow search */
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
PlowRule *pr = ar->ar_rule; PlowRule *pr = ar->ar_rule;
@ -355,9 +355,9 @@ plowPenumbraTopProc(outline, ar)
} }
int int
plowPenumbraBotProc(outline, ar) plowPenumbraBotProc(
Outline *outline; /* Segment along penumbra border */ Outline *outline, /* Segment along penumbra border */
struct applyRule *ar; /* Info needed for shadow search */ struct applyRule *ar) /* Info needed for shadow search */
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
PlowRule *pr = ar->ar_rule; PlowRule *pr = ar->ar_rule;
@ -425,9 +425,9 @@ plowPenumbraBotProc(outline, ar)
*/ */
int int
plowPenumbraRule(impactedEdge, ar) plowPenumbraRule(
Edge *impactedEdge; /* Edge found by shadow search */ Edge *impactedEdge, /* Edge found by shadow search */
struct applyRule *ar; /* Edge causing the shadow search, and struct applyRule *ar) /* Edge causing the shadow search, and
* the design rule to apply. * the design rule to apply.
*/ */
{ {
@ -478,9 +478,9 @@ plowPenumbraRule(impactedEdge, ar)
*/ */
int int
prSliverTop(edge, rules) prSliverTop(
Edge *edge; Edge *edge,
PlowRule *rules; PlowRule *rules)
{ {
PlowRule *pr; PlowRule *pr;
struct applyRule ar; struct applyRule ar;
@ -532,9 +532,9 @@ prSliverTop(edge, rules)
} }
int int
prSliverBot(edge, rules) prSliverBot(
Edge *edge; Edge *edge,
PlowRule *rules; PlowRule *rules)
{ {
TileTypeBitMask insideTypes; TileTypeBitMask insideTypes;
PlowRule *pr; PlowRule *pr;
@ -619,9 +619,9 @@ prSliverBot(edge, rules)
*/ */
int int
plowSliverTopMove(outline, ar) plowSliverTopMove(
Outline *outline; /* Segment of outline being followed */ Outline *outline, /* Segment of outline being followed */
struct applyRule *ar; struct applyRule *ar)
{ {
int howfar = ar->ar_moving->e_newx - ar->ar_moving->e_x; int howfar = ar->ar_moving->e_newx - ar->ar_moving->e_x;
Edge edge; Edge edge;
@ -649,13 +649,13 @@ plowSliverTopMove(outline, ar)
} }
int int
plowSliverBotMove(outline, ar) plowSliverBotMove(
Outline *outline; /* Segment of outline being followed. Outline *outline, /* Segment of outline being followed.
* The sense of "inside" and "outside" * The sense of "inside" and "outside"
* is reversed from that when handling * is reversed from that when handling
* the top half of the penumbra. * the top half of the penumbra.
*/ */
struct applyRule *ar; struct applyRule *ar)
{ {
int howfar = ar->ar_moving->e_newx - ar->ar_moving->e_x; int howfar = ar->ar_moving->e_newx - ar->ar_moving->e_x;
Edge edge; Edge edge;
@ -712,9 +712,9 @@ plowSliverBotMove(outline, ar)
*/ */
int int
plowSliverTopExtent(outline, ar) plowSliverTopExtent(
Outline *outline; /* Segment of outline being followed */ Outline *outline, /* Segment of outline being followed */
struct applyRule *ar; struct applyRule *ar)
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
int newx, xmove, ret = 0; int newx, xmove, ret = 0;
@ -818,9 +818,9 @@ plowSliverTopExtent(outline, ar)
} }
int int
plowSliverBotExtent(outline, ar) plowSliverBotExtent(
Outline *outline; /* Segment of outline being followed */ Outline *outline, /* Segment of outline being followed */
struct applyRule *ar; struct applyRule *ar)
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
int newx, xmove, ret = 0; int newx, xmove, ret = 0;
@ -956,10 +956,10 @@ plowSliverBotExtent(outline, ar)
*/ */
bool bool
plowSliverApplyRules(ar, far, farDist) plowSliverApplyRules(
struct applyRule *ar; struct applyRule *ar,
TileType far; TileType far,
int farDist; int farDist)
{ {
TileType near = ar->ar_moving->e_ltype; TileType near = ar->ar_moving->e_ltype;
PlowRule *pr; PlowRule *pr;
@ -1002,9 +1002,9 @@ plowSliverApplyRules(ar, far, farDist)
*/ */
int int
plowApplyRule(impactedEdge, ar) plowApplyRule(
Edge *impactedEdge; /* Edge found by shadow search */ Edge *impactedEdge, /* Edge found by shadow search */
struct applyRule *ar; /* Edge causing the shadow search, and struct applyRule *ar) /* Edge causing the shadow search, and
* the design rule to apply. * the design rule to apply.
*/ */
{ {

102
plow/PlowRules2.c
View File

@ -66,8 +66,8 @@ int plowDragEdgeProc();
*/ */
void void
prFixedLHS(edge) prFixedLHS(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
int distance = edge->e_newx - edge->e_x; int distance = edge->e_newx - edge->e_x;
Tile *tpL; Tile *tpL;
@ -99,8 +99,8 @@ restart:
} }
int int
prFixedRHS(edge) prFixedRHS(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
int distance = edge->e_newx - edge->e_x; int distance = edge->e_newx - edge->e_x;
Tile *tpR, *tp; Tile *tpR, *tp;
@ -207,8 +207,8 @@ restart:
*/ */
void void
prFixedPenumbraTop(edge) prFixedPenumbraTop(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
struct applyRule ar; struct applyRule ar;
PlowRule *pr; PlowRule *pr;
@ -237,8 +237,8 @@ prFixedPenumbraTop(edge)
} }
int int
prFixedPenumbraBot(edge) prFixedPenumbraBot(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
struct applyRule ar; struct applyRule ar;
PlowRule *pr; PlowRule *pr;
@ -289,8 +289,8 @@ prFixedPenumbraBot(edge)
*/ */
void void
prFixedDragStubs(edge) prFixedDragStubs(
Edge *edge; /* Edge being moved; RHS is fixed-width */ Edge *edge) /* Edge being moved; RHS is fixed-width */
{ {
int distance = edge->e_newx - edge->e_x; int distance = edge->e_newx - edge->e_x;
Tile *tpL; Tile *tpL;
@ -343,12 +343,12 @@ restart:
*/ */
int int
plowDragEdgeProc(lhsEdge, movingEdge) plowDragEdgeProc(
Edge *lhsEdge; /* Edge on LHS; the caller has already Edge *lhsEdge, /* Edge on LHS; the caller has already
* determined that this edge has not * determined that this edge has not
* already moved far enough. * already moved far enough.
*/ */
Edge *movingEdge; /* RHS of this edge is fixed-width */ Edge *movingEdge) /* RHS of this edge is fixed-width */
{ {
PlowRule *pr; PlowRule *pr;
int xsep, width; int xsep, width;
@ -412,8 +412,8 @@ plowDragEdgeProc(lhsEdge, movingEdge)
*/ */
void void
prContactLHS(edge) prContactLHS(
Edge *edge; /* Edge being moved (LHS is contact) */ Edge *edge) /* Edge being moved (LHS is contact) */
{ {
int pNum; int pNum;
PlaneMask connPlanes = DBConnPlanes[edge->e_ltype]; PlaneMask connPlanes = DBConnPlanes[edge->e_ltype];
@ -429,8 +429,8 @@ prContactLHS(edge)
} }
int int
prContactRHS(edge) prContactRHS(
Edge *edge; /* Edge being moved (RHS is contact) */ Edge *edge) /* Edge being moved (RHS is contact) */
{ {
int pNum; int pNum;
PlaneMask connPlanes = DBConnPlanes[edge->e_rtype]; PlaneMask connPlanes = DBConnPlanes[edge->e_rtype];
@ -467,8 +467,8 @@ prContactRHS(edge)
*/ */
void void
prCoverTop(edge) prCoverTop(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
TileType ltype, rtype; TileType ltype, rtype;
PlowRule *pr; PlowRule *pr;
@ -505,8 +505,8 @@ prCoverTop(edge)
} }
int int
prCoverBot(edge) prCoverBot(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
TileType ltype, rtype; TileType ltype, rtype;
PlowRule *pr; PlowRule *pr;
@ -562,8 +562,8 @@ prCoverBot(edge)
*/ */
void void
prIllegalTop(edge) prIllegalTop(
Edge *edge; Edge *edge)
{ {
TileTypeBitMask insideTypes; TileTypeBitMask insideTypes;
struct applyRule ar; struct applyRule ar;
@ -592,8 +592,8 @@ prIllegalTop(edge)
} }
int int
prIllegalBot(edge) prIllegalBot(
Edge *edge; Edge *edge)
{ {
TileTypeBitMask insideTypes; TileTypeBitMask insideTypes;
struct applyRule ar; struct applyRule ar;
@ -642,9 +642,9 @@ prIllegalBot(edge)
*/ */
int int
plowCoverTopProc(outline, ar) plowCoverTopProc(
Outline *outline; Outline *outline,
struct applyRule *ar; struct applyRule *ar)
{ {
Edge edge; Edge edge;
int ret = 0; int ret = 0;
@ -678,9 +678,9 @@ plowCoverTopProc(outline, ar)
} }
int int
plowCoverBotProc(outline, ar) plowCoverBotProc(
Outline *outline; Outline *outline,
struct applyRule *ar; struct applyRule *ar)
{ {
Edge edge; Edge edge;
int ret = 0; int ret = 0;
@ -741,9 +741,9 @@ plowCoverBotProc(outline, ar)
*/ */
int int
plowIllegalTopProc(outline, ar) plowIllegalTopProc(
Outline *outline; Outline *outline,
struct applyRule *ar; struct applyRule *ar)
{ {
TileType badType = TiGetTypeExact(outline->o_inside), leftType; TileType badType = TiGetTypeExact(outline->o_inside), leftType;
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
@ -786,9 +786,9 @@ found_bad:
} }
int int
plowIllegalBotProc(outline, ar) plowIllegalBotProc(
Outline *outline; Outline *outline,
struct applyRule *ar; struct applyRule *ar)
{ {
TileType badType = TiGetTypeExact(outline->o_outside), leftType; TileType badType = TiGetTypeExact(outline->o_outside), leftType;
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
@ -853,8 +853,8 @@ found_bad:
*/ */
void void
prFindCells(edge) prFindCells(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
BPlane *cellPlane = plowYankDef->cd_cellPlane; BPlane *cellPlane = plowYankDef->cd_cellPlane;
struct applyRule ar; struct applyRule ar;
@ -890,8 +890,8 @@ prFindCells(edge)
*/ */
void void
prCell(edge) prCell(
Edge *edge; /* Cell edge being moved */ Edge *edge) /* Cell edge being moved */
{ {
Rect cellArea, shadowArea; Rect cellArea, shadowArea;
CellUse *use = edge->e_use; CellUse *use = edge->e_use;
@ -962,10 +962,10 @@ prCell(edge)
*/ */
int int
plowCellDragPaint(tile, dinfo, ar) plowCellDragPaint(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
struct applyRule *ar; struct applyRule *ar)
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
int distance = movingEdge->e_newx - movingEdge->e_x; int distance = movingEdge->e_newx - movingEdge->e_x;
@ -1016,9 +1016,9 @@ plowCellDragPaint(tile, dinfo, ar)
*/ */
int int
plowCellPushPaint(impactedEdge, ar) plowCellPushPaint(
Edge *impactedEdge; /* Edge found by shadow search */ Edge *impactedEdge, /* Edge found by shadow search */
struct applyRule *ar; /* Describes edge being moved and search area */ struct applyRule *ar) /* Describes edge being moved and search area */
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
int xsep, newx; int xsep, newx;
@ -1057,9 +1057,9 @@ plowCellPushPaint(impactedEdge, ar)
*/ */
int int
plowFoundCell(use, ar) plowFoundCell(
CellUse *use; CellUse *use,
struct applyRule *ar; struct applyRule *ar)
{ {
Edge *movingEdge = ar->ar_moving; Edge *movingEdge = ar->ar_moving;
int xmove, xsep; int xmove, xsep;

58
plow/PlowRules3.c
View File

@ -37,8 +37,9 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
extern int plowApplyRule(); extern int plowApplyRule();
/* Forward declarations */ /* Forward declarations */
struct inarg;
int plowInSliverProc(); int plowInSliverProc();
int scanDown(), scanUp(); int scanDown(struct inarg *inarg, TileType type, bool canMoveInargEdge), scanUp(struct inarg *inarg, TileType type, bool canMoveInargEdge);
int scanDownError(), scanUpError(); int scanDownError(), scanUpError();
/* Argument passed to above filter functions */ /* Argument passed to above filter functions */
@ -47,7 +48,8 @@ struct inarg
Rect ina_area; /* Area to search for violations */ Rect ina_area; /* Area to search for violations */
Edge *ina_moving; /* Edge causing this search */ Edge *ina_moving; /* Edge causing this search */
TileType ina_t0; /* See comments in the procedures */ TileType ina_t0; /* See comments in the procedures */
int (*ina_proc)(); /* Apply to look for rule violations */ int (*ina_proc)(struct inarg *, TileType, bool);
/* Apply to look for rule violations */
/* Used while appling design rules */ /* Used while appling design rules */
PlowRule *ina_rule; /* Plowing design rule being applied */ PlowRule *ina_rule; /* Plowing design rule being applied */
@ -74,8 +76,8 @@ struct inarg
*/ */
void void
prInSliver(edge) prInSliver(
Edge *edge; /* Edge being moved */ Edge *edge) /* Edge being moved */
{ {
struct inarg inarg; struct inarg inarg;
Rect edgeBorder; Rect edgeBorder;
@ -111,10 +113,10 @@ prInSliver(edge)
} }
int int
plowInSliverProc(tile, dinfo, inarg) plowInSliverProc(
Tile *tile; Tile *tile,
TileType dinfo; /* (unused) */ TileType dinfo, /* (unused) */
struct inarg *inarg; struct inarg *inarg)
{ {
Edge *movingEdge = inarg->ina_moving; Edge *movingEdge = inarg->ina_moving;
#ifdef notdef #ifdef notdef
@ -199,10 +201,10 @@ plowInSliverProc(tile, dinfo, inarg)
} }
int int
scanDown(inarg, type, canMoveInargEdge) scanDown(
struct inarg *inarg; struct inarg *inarg,
TileType type; TileType type,
bool canMoveInargEdge; bool canMoveInargEdge)
{ {
TileType ltype = inarg->ina_moving->e_ltype; TileType ltype = inarg->ina_moving->e_ltype;
Edge *movingEdge = inarg->ina_moving; Edge *movingEdge = inarg->ina_moving;
@ -256,9 +258,9 @@ scanDown(inarg, type, canMoveInargEdge)
} }
int int
scanDownError(tile, inarg) scanDownError(
Tile *tile; Tile *tile,
struct inarg *inarg; struct inarg *inarg)
{ {
Rect atomRect; Rect atomRect;
int incursion; int incursion;
@ -294,10 +296,10 @@ scanDownError(tile, inarg)
} }
int int
scanUp(inarg, type, canMoveInargEdge) scanUp(
struct inarg *inarg; struct inarg *inarg,
TileType type; TileType type,
bool canMoveInargEdge; bool canMoveInargEdge)
{ {
TileType ltype = inarg->ina_moving->e_ltype; TileType ltype = inarg->ina_moving->e_ltype;
Edge *movingEdge = inarg->ina_moving; Edge *movingEdge = inarg->ina_moving;
@ -351,9 +353,9 @@ scanUp(inarg, type, canMoveInargEdge)
} }
int int
scanUpError(tile, inarg) scanUpError(
Tile *tile; Tile *tile,
struct inarg *inarg; struct inarg *inarg)
{ {
Rect atomRect; Rect atomRect;
int incursion; int incursion;
@ -390,12 +392,12 @@ scanUpError(tile, inarg)
} }
int int
plowSrFinalArea(plane, area, okTypes, proc, cdata) plowSrFinalArea(
Plane *plane; Plane *plane,
Rect *area; Rect *area,
TileTypeBitMask *okTypes; TileTypeBitMask *okTypes,
int (*proc)(); int (*proc)(),
ClientData cdata; ClientData cdata)
{ {
return (DBSrPaintArea((Tile *) NULL, plane, area, okTypes, proc, cdata)); return (DBSrPaintArea((Tile *) NULL, plane, area, okTypes, proc, cdata));
} }

42
plow/PlowSearch.c
View File

@ -279,10 +279,10 @@ plowSrShadow(
*/ */
int int
plowShadowRHS(tp, s, bottomLeft) plowShadowRHS(
Tile *tp; /* Tile whose RHS is to be followed */ Tile *tp, /* Tile whose RHS is to be followed */
struct shadow *s; /* Shadow search argument */ struct shadow *s, /* Shadow search argument */
int bottomLeft; /* Bottom of 'tp', clipped to area */ int bottomLeft) /* Bottom of 'tp', clipped to area */
{ {
Tile *tpR; Tile *tpR;
int bottom, left; int bottom, left;
@ -434,10 +434,10 @@ plowSrShadowInitial(
*/ */
int int
plowShadowInitialRHS(tp, s, bottomLeft) plowShadowInitialRHS(
Tile *tp; /* Tile whose RHS is to be followed */ Tile *tp, /* Tile whose RHS is to be followed */
struct shadow *s; /* Shadow search argument */ struct shadow *s, /* Shadow search argument */
int bottomLeft; /* Bottom of 'tp', clipped to area */ int bottomLeft) /* Bottom of 'tp', clipped to area */
{ {
Tile *tpR; Tile *tpR;
int bottom, left; int bottom, left;
@ -591,10 +591,10 @@ plowSrShadowBack(
*/ */
int int
plowShadowLHS(tp, s, topRight) plowShadowLHS(
Tile *tp; /* Tile whose LHS is to be followed */ Tile *tp, /* Tile whose LHS is to be followed */
struct shadow *s; /* Shadow search argument */ struct shadow *s, /* Shadow search argument */
int topRight; /* Top of 'tp', clipped to area */ int topRight) /* Top of 'tp', clipped to area */
{ {
Tile *tpL; Tile *tpL;
int top, right; int top, right;
@ -674,14 +674,14 @@ plowShadowLHS(tp, s, topRight)
*/ */
int int
plowAtomize(pNum, rect, proc, cdata) plowAtomize(
int pNum; /* Plane from plowYankDef to search */ int pNum, /* Plane from plowYankDef to search */
Rect *rect; /* LHS is the geometrical edge we search; each Rect *rect, /* LHS is the geometrical edge we search; each
* Edge found will have an e_newx coordinate * Edge found will have an e_newx coordinate
* equal to the RHS of this rect. * equal to the RHS of this rect.
*/ */
int (*proc)(); /* Procedure to apply to each Edge */ int (*proc)(), /* Procedure to apply to each Edge */
ClientData cdata; /* Additional argument to (*proc)() */ ClientData cdata) /* Additional argument to (*proc)() */
{ {
Tile *tpL, *tpR; Tile *tpL, *tpR;
Plane *plane = plowYankDef->cd_planes[pNum]; Plane *plane = plowYankDef->cd_planes[pNum];
@ -889,8 +889,8 @@ plowSrOutline(
*/ */
void void
plowSrOutlineInit(outline) plowSrOutlineInit(
Outline *outline; Outline *outline)
{ {
Plane *plane = plowYankDef->cd_planes[outline->o_pNum]; Plane *plane = plowYankDef->cd_planes[outline->o_pNum];
Tile *in, *out; Tile *in, *out;
@ -1054,8 +1054,8 @@ plowSrOutlineInit(outline)
*/ */
void void
plowSrOutlineNext(outline) plowSrOutlineNext(
Outline *outline; Outline *outline)
{ {
Tile *tpL, *tpR; Tile *tpL, *tpR;

61
plow/PlowTech.c
View File

@ -177,10 +177,10 @@ PlowDRCInit()
/*ARGSUSED*/ /*ARGSUSED*/
bool bool
PlowDRCLine(sectionName, argc, argv) PlowDRCLine(
char *sectionName; /* Unused */ char *sectionName, /* Unused */
int argc; int argc,
char *argv[]; char *argv[])
{ {
int which; int which;
static const struct static const struct
@ -233,9 +233,9 @@ PlowDRCLine(sectionName, argc, argv)
*/ */
int int
plowWidthRule(argc, argv) plowWidthRule(
int argc; int argc,
char *argv[]; char *argv[])
{ {
char *layers = argv[1]; char *layers = argv[1];
int distance = atoi(argv[2]); int distance = atoi(argv[2]);
@ -314,9 +314,9 @@ plowWidthRule(argc, argv)
*/ */
int int
plowSpacingRule(argc, argv) plowSpacingRule(
int argc; int argc,
char *argv[]; char *argv[])
{ {
char *layers1 = argv[1], *layers2 = argv[2]; char *layers1 = argv[1], *layers2 = argv[2];
int distance = atoi(argv[3]); int distance = atoi(argv[3]);
@ -458,9 +458,9 @@ plowSpacingRule(argc, argv)
*/ */
int int
plowEdgeRule(argc, argv) plowEdgeRule(
int argc; int argc,
char *argv[]; char *argv[])
{ {
char *layers1 = argv[1], *layers2 = argv[2]; char *layers1 = argv[1], *layers2 = argv[2];
int distance = atoi(argv[3]); int distance = atoi(argv[3]);
@ -693,8 +693,8 @@ PlowDRCFinal()
*/ */
PlowRule * PlowRule *
plowTechOptimizeRule(ruleList) plowTechOptimizeRule(
PlowRule *ruleList; PlowRule *ruleList)
{ {
PlowRule *pCand, *pCandLast, *pr; PlowRule *pCand, *pCandLast, *pr;
TileTypeBitMask tmpMask; TileTypeBitMask tmpMask;
@ -819,10 +819,10 @@ PlowTechInit()
*/ */
bool bool
PlowTechLine(sectionName, argc, argv) PlowTechLine(
char *sectionName; /* Unused */ char *sectionName, /* Unused */
int argc; int argc,
char *argv[]; char *argv[])
{ {
TileTypeBitMask types; TileTypeBitMask types;
@ -945,7 +945,10 @@ void plowScaleDown(PlowRule *pr, int scalefactor)
*/ */
void void
DRCPlowScale(int scaled, int scalen, bool adjustmax) DRCPlowScale(
int scaled,
int scalen,
bool adjustmax)
{ {
PlowRule *pr; PlowRule *pr;
TileType i, j; TileType i, j;
@ -997,9 +1000,9 @@ DRCPlowScale(int scaled, int scalen, bool adjustmax)
*/ */
void void
plowTechPrintRule(pr, f) plowTechPrintRule(
PlowRule *pr; PlowRule *pr,
FILE *f; FILE *f)
{ {
fprintf(f, "\tDISTANCE=%d, PLANE=%s, FLAGS=", fprintf(f, "\tDISTANCE=%d, PLANE=%s, FLAGS=",
pr->pr_dist, DBPlaneLongName(pr->pr_pNum)); pr->pr_dist, DBPlaneLongName(pr->pr_pNum));
@ -1015,10 +1018,10 @@ plowTechPrintRule(pr, f)
} }
void void
plowTechShowTable(table, header, f) plowTechShowTable(
PlowRule *table[TT_MAXTYPES][TT_MAXTYPES]; PlowRule *table[TT_MAXTYPES][TT_MAXTYPES],
char *header; char *header,
FILE *f; FILE *f)
{ {
PlowRule *pr; PlowRule *pr;
TileType i, j; TileType i, j;
@ -1036,8 +1039,8 @@ plowTechShowTable(table, header, f)
} }
void void
plowTechShow(f) plowTechShow(
FILE *f; FILE *f)
{ {
plowTechShowTable(plowWidthRulesTbl, "Width Rules", f); plowTechShowTable(plowWidthRulesTbl, "Width Rules", f);
plowTechShowTable(plowSpacingRulesTbl, "Spacing Rules", f); plowTechShowTable(plowSpacingRulesTbl, "Spacing Rules", f);

40
plow/PlowTest.c
View File

@ -130,9 +130,9 @@ const struct
}; };
void void
PlowTest(w, cmd) PlowTest(
MagWindow *w; MagWindow *w,
TxCommand *cmd; TxCommand *cmd)
{ {
pCmd plowCmd, plowGetCommand(); pCmd plowCmd, plowGetCommand();
Rect editArea, dummyRect, rootBox, area2; Rect editArea, dummyRect, rootBox, area2;
@ -414,8 +414,8 @@ PlowTest(w, cmd)
*/ */
pCmd pCmd
plowGetCommand(cmd) plowGetCommand(
TxCommand *cmd; TxCommand *cmd)
{ {
int plowIndex; int plowIndex;
@ -497,9 +497,9 @@ plowDebugInit()
*/ */
int int
plowShowShadow(edge, def) plowShowShadow(
Edge *edge; Edge *edge,
CellDef *def; CellDef *def)
{ {
char mesg[512]; char mesg[512];
int scaleFactor = 10; int scaleFactor = 10;
@ -537,9 +537,9 @@ plowShowShadow(edge, def)
*/ */
void void
plowTestJog(def, area) plowTestJog(
CellDef *def; CellDef *def,
Rect *area; Rect *area)
{ {
extern CellUse *plowYankUse; extern CellUse *plowYankUse;
extern Rect plowYankedArea; extern Rect plowYankedArea;
@ -613,10 +613,10 @@ plowTestJog(def, area)
*/ */
void void
plowDebugEdge(edge, rtePtr, mesg) plowDebugEdge(
Edge *edge; Edge *edge,
RuleTableEntry *rtePtr; RuleTableEntry *rtePtr,
char *mesg; char *mesg)
{ {
int scaleFactor = 10; int scaleFactor = 10;
Rect edgeArea; Rect edgeArea;
@ -721,9 +721,9 @@ again:
*/ */
int int
plowShowOutline(outline, clipArea) plowShowOutline(
Outline *outline; Outline *outline,
Rect *clipArea; Rect *clipArea)
{ {
static char *dirNames[] = { static char *dirNames[] = {
"center", "north", "northeast", "east", "center", "north", "northeast", "east",
@ -815,8 +815,8 @@ plowShowOutline(outline, clipArea)
*/ */
void void
plowDisplay(dodef) plowDisplay(
bool dodef; bool dodef)
{ {
if (dodef) if (dodef)
DBWAreaChanged(plowDummyUse->cu_def, &TiPlaneRect, DBWAreaChanged(plowDummyUse->cu_def, &TiPlaneRect,