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

K&R: cif/*.c bulk function implementation conversion 

Beware of the MISMATCH with the prototype found in original
source, with the type declaration below.

External call sites checked to confirm argument order is
correct with the argument name order.

// nedges <> dir
bool
cifOrient(edges, nedges, dir)
    CIFPath *edges[],          /* Array of edges to be categorized. */
    int dir[],                 /* Array to hold directions. */
    int nedges)                        /* Size of arrays. */

// spacing <> border
int
CIFGetContactSize(type, edge, spacing, border)
    TileType type,
    int *edge,
    int *border,
    int *spacing)

K&R obsolete syntax removal for C23 compatibility series
This commit is contained in:
Darryl L. Miles 2024-10-04 11:34:19 +01:00 committed by Tim Edwards
parent ff412b74d8
commit 2f7f76bf9c
11 changed files with 527 additions and 511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

314
cif/CIFgen.c
View File

@ -100,9 +100,9 @@ extern void cifGenClip(Rect *area, Rect *expanded, Rect *clip);
*/ */
int int
cifPaintFunc(tile, table) cifPaintFunc(
Tile *tile; Tile *tile,
PaintResultType *table; /* Used for painting. */ PaintResultType *table) /* Used for painting. */
{ {
Rect area; Rect area;
@ -133,8 +133,8 @@ cifPaintFunc(tile, table)
*/ */
void void
SetBoxGrid(area) SetBoxGrid(
Rect *area; Rect *area)
{ {
int limit; int limit;
int delta; int delta;
@ -209,8 +209,8 @@ SetBoxGrid(area)
*/ */
int int
SetValueGrid(value) SetValueGrid(
int value; int value)
{ {
int limit; int limit;
int delta; int delta;
@ -242,9 +242,9 @@ SetValueGrid(value)
*/ */
void void
SetMinBoxGrid(area, width) SetMinBoxGrid(
Rect *area; Rect *area,
int width; int width)
{ {
int wtest; int wtest;
int wtot; int wtot;
@ -296,9 +296,9 @@ SetMinBoxGrid(area, width)
*/ */
int int
cifGrowMinFunc(tile, table) cifGrowMinFunc(
Tile *tile; Tile *tile,
PaintResultType *table; /* Table to be used for painting. */ PaintResultType *table) /* Table to be used for painting. */
{ {
Rect area, parea; Rect area, parea;
int locDist, width, height, h; int locDist, width, height, h;
@ -471,9 +471,9 @@ cifGrowMinFunc(tile, table)
*/ */
int int
cifGrowGridFunc(tile, table) cifGrowGridFunc(
Tile *tile; Tile *tile,
PaintResultType *table; /* Table to be used for painting. */ PaintResultType *table) /* Table to be used for painting. */
{ {
Rect area; Rect area;
int remainder; int remainder;
@ -547,9 +547,9 @@ cifGrowGridFunc(tile, table)
#define STOP_ES 0x80 #define STOP_ES 0x80
int int
cifGrowEuclideanFunc(tile, table) cifGrowEuclideanFunc(
Tile *tile; Tile *tile,
PaintResultType *table; /* Table to be used for painting. */ PaintResultType *table) /* Table to be used for painting. */
{ {
Tile *tp; Tile *tp;
Rect area, rtmp; Rect area, rtmp;
@ -760,9 +760,9 @@ cifGrowEuclideanFunc(tile, table)
*/ */
int int
cifGrowFunc(tile, table) cifGrowFunc(
Tile *tile; Tile *tile,
PaintResultType *table; /* Table to be used for painting. */ PaintResultType *table) /* Table to be used for painting. */
{ {
Rect area; Rect area;
TileType oldType = TiGetTypeExact(tile); TileType oldType = TiGetTypeExact(tile);
@ -889,9 +889,9 @@ cifGrowFunc(tile, table)
*/ */
int int
cifBloatFunc(tile, clientData) cifBloatFunc(
Tile *tile; Tile *tile,
ClientData clientData; ClientData clientData)
{ {
Rect tileArea, cifArea, bloat; Rect tileArea, cifArea, bloat;
TileType oldType, type, topLeftType, bottomRightType; TileType oldType, type, topLeftType, bottomRightType;
@ -1216,9 +1216,9 @@ endbloat:
*/ */
int int
cifProcessResetFunc(tile, clientData) cifProcessResetFunc(
Tile *tile; Tile *tile,
ClientData clientData; /* unused */ ClientData clientData) /* unused */
{ {
tile->ti_client = (ClientData) CIF_UNPROCESSED; tile->ti_client = (ClientData) CIF_UNPROCESSED;
return 0; return 0;
@ -1265,9 +1265,9 @@ cifProcessSelectiveResetFunc(tile, clipArea)
*/ */
int int
cifFoundFunc(tile, BloatStackPtr) cifFoundFunc(
Tile *tile; Tile *tile,
Stack **BloatStackPtr; Stack **BloatStackPtr)
{ {
PUSHTILE(tile, *BloatStackPtr); PUSHTILE(tile, *BloatStackPtr);
return 0; return 0;
@ -1301,9 +1301,9 @@ typedef struct _bloatStruct {
*/ */
int int
cifBloatAllFunc(tile, bls) cifBloatAllFunc(
Tile *tile; /* The tile to be processed. */ Tile *tile, /* The tile to be processed. */
BloatStruct *bls; BloatStruct *bls)
{ {
Rect area, clipArea; Rect area, clipArea;
TileTypeBitMask *connect; TileTypeBitMask *connect;
@ -1589,8 +1589,8 @@ typedef struct _bridgeCheckStruct {
*/ */
int int
GetEuclideanWidthGrid(width) GetEuclideanWidthGrid(
int width; int width)
{ {
int weuclid; int weuclid;
int delta; int delta;
@ -1647,10 +1647,10 @@ GetEuclideanWidthGrid(width)
*/ */
void void
GetExpandedAreaGrid(wrule, space, area) GetExpandedAreaGrid(
int wrule; int wrule,
bool space; bool space,
Rect *area; Rect *area)
{ {
bool horiz; bool horiz;
bool overlap; bool overlap;
@ -1782,9 +1782,9 @@ GetExpandedAreaGrid(wrule, space, area)
*/ */
int int
cifBridgeFunc1(tile, brs) cifBridgeFunc1(
Tile *tile; Tile *tile,
BridgeStruct *brs; BridgeStruct *brs)
{ {
Plane *plane = brs->plane; Plane *plane = brs->plane;
Rect area; Rect area;
@ -1904,9 +1904,9 @@ cifBridgeFunc1(tile, brs)
*/ */
int int
cifBridgeFunc2(tile, brs) cifBridgeFunc2(
Tile *tile; Tile *tile,
BridgeStruct *brs; BridgeStruct *brs)
{ {
Plane *plane = brs->plane; Plane *plane = brs->plane;
Rect area; Rect area;
@ -2004,9 +2004,9 @@ cifBridgeFunc2(tile, brs)
*/ */
int int
cifBridgeCheckFunc(tile, brcs) cifBridgeCheckFunc(
Tile *tile; Tile *tile,
BridgeCheckStruct *brcs; BridgeCheckStruct *brcs)
{ {
int dir = brcs->direction; int dir = brcs->direction;
Tile *self = brcs->tile; Tile *self = brcs->tile;
@ -2080,13 +2080,13 @@ cifBridgeCheckFunc(tile, brcs)
#define CLOSE_DONE 2 #define CLOSE_DONE 2
int int
cifCloseFunc(tile, plane) cifCloseFunc(
Tile *tile; Tile *tile,
Plane *plane; Plane *plane)
{ {
Rect area, newarea; Rect area, newarea;
int atotal; int atotal;
int cifGatherFunc(Tile *tile, int *atotal, int mode); int cifGatherFunc(Tile *tile, int *atotal, bool mode);
/* If tile is marked, then it has been handled, so ignore it */ /* If tile is marked, then it has been handled, so ignore it */
if (tile->ti_client != (ClientData)CIF_UNPROCESSED) return 0; if (tile->ti_client != (ClientData)CIF_UNPROCESSED) return 0;
@ -2115,10 +2115,10 @@ cifCloseFunc(tile, plane)
} }
int int
cifGatherFunc(tile, atotal, mode) cifGatherFunc(
Tile *tile; Tile *tile,
int *atotal; int *atotal,
bool mode; bool mode)
{ {
Tile *tp; Tile *tp;
TileType type; TileType type;
@ -2292,9 +2292,9 @@ cifSquaresInitFunc(tile, clientData)
*/ */
int int
cifSquaresStripFunc(tile, stripsData) cifSquaresStripFunc(
Tile *tile; Tile *tile,
StripsData *stripsData; StripsData *stripsData)
{ {
bool vertical; bool vertical;
int width, height; int width, height;
@ -2419,9 +2419,9 @@ cifSquaresStripFunc(tile, stripsData)
int int
cifUnconnectFunc(tile, clientData) cifUnconnectFunc(
Tile *tile; Tile *tile,
ClientData clientData; /* unused */ ClientData clientData) /* unused */
{ {
TileType t = TiGetTypeExact(tile); TileType t = TiGetTypeExact(tile);
if (t == TT_SPACE) return 1; if (t == TT_SPACE) return 1;
@ -2449,10 +2449,10 @@ cifUnconnectFunc(tile, clientData)
*/ */
void void
cifRectBoundingBox(op, cellDef, plane) cifRectBoundingBox(
CIFOp *op; CIFOp *op,
CellDef *cellDef; CellDef *cellDef,
Plane *plane; Plane *plane)
{ {
Tile *tile = NULL, *t, *tp; Tile *tile = NULL, *t, *tp;
Rect bbox, area, *maxr; Rect bbox, area, *maxr;
@ -2608,10 +2608,10 @@ cifRectBoundingBox(op, cellDef, plane)
*/ */
void void
cifSquaresFillArea(op, cellDef, plane) cifSquaresFillArea(
CIFOp *op; CIFOp *op,
CellDef *cellDef; CellDef *cellDef,
Plane *plane; Plane *plane)
{ {
Tile *tile, *t, *tp; Tile *tile, *t, *tp;
Rect bbox, area, square, cut, llcut; Rect bbox, area, square, cut, llcut;
@ -2937,10 +2937,10 @@ cifSquaresFillArea(op, cellDef, plane)
*/ */
void void
cifSlotsFillArea(op, cellDef, plane) cifSlotsFillArea(
CIFOp *op; CIFOp *op,
CellDef *cellDef; CellDef *cellDef,
Plane *plane; Plane *plane)
{ {
Tile *tile, *t, *tp; Tile *tile, *t, *tp;
Rect bbox, area, square, cut, llcut; Rect bbox, area, square, cut, llcut;
@ -3306,9 +3306,9 @@ cifSlotsFillArea(op, cellDef, plane)
*/ */
int int
cifBloatMaxFunc(tile, op) cifBloatMaxFunc(
Tile *tile; /* The tile to be processed. */ Tile *tile, /* The tile to be processed. */
CIFOp *op; /* Describes the operation to be performed CIFOp *op) /* Describes the operation to be performed
* (all we care about is the opcode and * (all we care about is the opcode and
* bloat table). * bloat table).
*/ */
@ -3443,9 +3443,9 @@ cifBloatMaxFunc(tile, op)
*/ */
bool bool
inside_triangle(rect, tile) inside_triangle(
Rect *rect; Rect *rect,
Tile *tile; Tile *tile)
{ {
int theight, twidth; int theight, twidth;
dlong f1, f2, f3, f4; dlong f1, f2, f3, f4;
@ -3498,9 +3498,9 @@ inside_triangle(rect, tile)
*/ */
int int
cifContactFunc(tile, csi) cifContactFunc(
Tile *tile; /* Tile to be diced up. */ Tile *tile, /* Tile to be diced up. */
CIFSquaresInfo *csi; /* Describes how to generate squares. */ CIFSquaresInfo *csi) /* Describes how to generate squares. */
{ {
Rect area; Rect area;
int i, nAcross, j, nUp, left, bottom, pitch, halfsize; int i, nAcross, j, nUp, left, bottom, pitch, halfsize;
@ -3576,12 +3576,13 @@ cifContactFunc(tile, csi)
*/ */
int int
cifSlotFunc(area, op, numY, numX, cut, vertical) cifSlotFunc(
Rect *area; /* Area to be diced up */ Rect *area, /* Area to be diced up */
CIFOp *op; /* Describes how to generate squares. */ CIFOp *op, /* Describes how to generate squares. */
int *numY, *numX; /* Return values: # rows and # columns */ int *numY,
Rect *cut; /* initial (lower left) cut area */ int *numX, /* Return values: # rows and # columns */
bool vertical; /* if TRUE, slot is aligned vertically */ Rect *cut, /* initial (lower left) cut area */
bool vertical) /* if TRUE, slot is aligned vertically */
{ {
int i, j, xpitch, ypitch, delta, limit; int i, j, xpitch, ypitch, delta, limit;
int *axtop, *axbot, *aytop, *aybot; int *axtop, *axbot, *aytop, *aybot;
@ -3715,11 +3716,12 @@ calcY:
*/ */
int int
cifSquareFunc(area, op, rows, columns, cut) cifSquareFunc(
Rect *area; /* Area to be diced up */ Rect *area, /* Area to be diced up */
CIFOp *op; /* Describes how to generate squares. */ CIFOp *op, /* Describes how to generate squares. */
int *rows, *columns; /* Return values: # rows and # columns, */ int *rows,
Rect *cut; /* initial (lower left) cut area. */ int *columns, /* Return values: # rows and # columns, */
Rect *cut) /* initial (lower left) cut area. */
{ {
int pitch, delta, limit; int pitch, delta, limit;
bool glimit; bool glimit;
@ -3827,11 +3829,12 @@ sqY:
*/ */
int int
cifSquareGridFunc(area, op, rows, columns, cut) cifSquareGridFunc(
Rect *area; /* Area to be diced up */ Rect *area, /* Area to be diced up */
CIFOp *op; /* Describes how to generate squares. */ CIFOp *op, /* Describes how to generate squares. */
int *rows, *columns; /* Return values: # rows and # columns, */ int *rows,
Rect *cut; /* initial (lower left) cut area. */ int *columns, /* Return values: # rows and # columns, */
Rect *cut) /* initial (lower left) cut area. */
{ {
Rect locarea; Rect locarea;
int left, bottom, right, top, pitch; int left, bottom, right, top, pitch;
@ -3918,13 +3921,13 @@ cifSquareGridFunc(area, op, rows, columns, cut)
*/ */
void void
cifSrTiles(cifOp, area, cellDef, temps, func, cdArg) cifSrTiles(
CIFOp *cifOp; /* Geometric operation being processed. */ CIFOp *cifOp, /* Geometric operation being processed. */
Rect *area; /* Area of Magic paint to consider. */ Rect *area, /* Area of Magic paint to consider. */
CellDef *cellDef; /* CellDef to search for paint. */ CellDef *cellDef, /* CellDef to search for paint. */
Plane *temps[]; /* Planes to use for temporaries. */ Plane *temps[], /* Planes to use for temporaries. */
int (*func)(); /* Search function to pass to DBSrPaintArea. */ int (*func)(), /* Search function to pass to DBSrPaintArea. */
ClientData cdArg; /* Client data for func. */ ClientData cdArg) /* Client data for func. */
{ {
TileTypeBitMask maskBits; TileTypeBitMask maskBits;
TileType t; TileType t;
@ -4005,9 +4008,9 @@ typedef struct _bridgeLimCheckStruct {
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
int int
bridgeLimFound(tile, calcOverlap) bridgeLimFound(
Tile *tile; Tile *tile,
bool calcOverlap; bool calcOverlap)
{ {
if (calcOverlap) if (calcOverlap)
{ {
@ -4027,10 +4030,10 @@ bridgeLimFound(tile, calcOverlap)
*------------------------------------------------------------------------ *------------------------------------------------------------------------
*/ */
int int
bridgeLimSrTiles(brlims, area, calcOverlap) bridgeLimSrTiles(
BridgeLimStruct *brlims; /* Bridge-Lim structure. */ BridgeLimStruct *brlims, /* Bridge-Lim structure. */
Rect *area; /* Area of Magic paint to consider. */ Rect *area, /* Area of Magic paint to consider. */
bool calcOverlap; /* TRUE to calculate the overlap of the limiting tiles in the specified area. */ bool calcOverlap) /* TRUE to calculate the overlap of the limiting tiles in the specified area. */
{ {
TileTypeBitMask maskBits; TileTypeBitMask maskBits;
TileType t; TileType t;
@ -4086,9 +4089,9 @@ bridgeLimSrTiles(brlims, area, calcOverlap)
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
int int
cifBridgeLimFunc0(tile, brlims) cifBridgeLimFunc0(
Tile *tile; Tile *tile,
BridgeLimStruct *brlims; BridgeLimStruct *brlims)
{ {
Plane *plane = brlims->plane; Plane *plane = brlims->plane;
Rect area, parea; Rect area, parea;
@ -4161,9 +4164,9 @@ cifBridgeLimFunc0(tile, brlims)
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
int int
bridgeLimCheckFunc(tile, brlimcs) bridgeLimCheckFunc(
Tile *tile; Tile *tile,
BridgeLimCheckStruct *brlimcs; BridgeLimCheckStruct *brlimcs)
{ {
int dir = brlimcs->direction; int dir = brlimcs->direction;
Tile *self = brlimcs->tile; Tile *self = brlimcs->tile;
@ -4231,9 +4234,9 @@ bridgeLimCheckFunc(tile, brlimcs)
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
int int
bridgeErase(brlims, area) bridgeErase(
BridgeLimStruct *brlims; /* Bridge-lim structure. */ BridgeLimStruct *brlims, /* Bridge-lim structure. */
Rect *area; /* Area of Magic paint to consider. */ Rect *area) /* Area of Magic paint to consider. */
{ {
TileTypeBitMask maskBits; TileTypeBitMask maskBits;
TileType t; TileType t;
@ -4277,9 +4280,9 @@ bridgeErase(brlims, area)
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
int int
cifBridgeLimFunc1(tile, brlims) cifBridgeLimFunc1(
Tile *tile; Tile *tile,
BridgeLimStruct *brlims; BridgeLimStruct *brlims)
{ {
Plane *plane = brlims->plane; Plane *plane = brlims->plane;
Rect area; Rect area;
@ -4438,9 +4441,9 @@ cifBridgeLimFunc1(tile, brlims)
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
int int
cifBridgeLimFunc2(tile, brlims) cifBridgeLimFunc2(
Tile *tile; Tile *tile,
BridgeLimStruct *brlims; BridgeLimStruct *brlims)
{ {
Plane *plane = brlims->plane; Plane *plane = brlims->plane;
Rect area; Rect area;
@ -4571,24 +4574,24 @@ cifBridgeLimFunc2(tile, brlims)
*/ */
Plane * Plane *
CIFGenLayer(op, area, cellDef, origDef, temps, hier, clientdata) CIFGenLayer(
CIFOp *op; /* List of CIFOps telling how to make layer. */ CIFOp *op, /* List of CIFOps telling how to make layer. */
Rect *area; /* Area to consider when generating CIF. Only Rect *area, /* Area to consider when generating CIF. Only
* material in this area will be considered, so * material in this area will be considered, so
* the caller should usually expand his desired * the caller should usually expand his desired
* area by one CIF radius. * area by one CIF radius.
*/ */
CellDef *cellDef; /* CellDef to search when paint layers are CellDef *cellDef, /* CellDef to search when paint layers are
* needed for operation. * needed for operation.
*/ */
CellDef *origDef; /* Original CellDef for which output is being CellDef *origDef, /* Original CellDef for which output is being
* generated (cellDef may be derived from this). * generated (cellDef may be derived from this).
*/ */
Plane *temps[]; /* Temporary layers to be used when needed Plane *temps[], /* Temporary layers to be used when needed
* for operation. * for operation.
*/ */
bool hier; /* TRUE if called from CIFGenSubcells or CIFGenArrays */ bool hier, /* TRUE if called from CIFGenSubcells or CIFGenArrays */
ClientData clientdata; /* ClientData clientdata) /*
* Data that may be passed to the CIF operation * Data that may be passed to the CIF operation
* function. * function.
*/ */
@ -5176,31 +5179,31 @@ CIFGenLayer(op, area, cellDef, origDef, temps, hier, clientdata)
*/ */
void void
CIFGen(cellDef, origDef, area, planes, layers, replace, genAllPlanes, hier, clientdata) CIFGen(
CellDef *cellDef; /* Cell for which CIF is to be generated. */ CellDef *cellDef, /* Cell for which CIF is to be generated. */
CellDef *origDef; /* Original cell, if different from cellDef */ CellDef *origDef, /* Original cell, if different from cellDef */
Rect *area; /* Any CIF overlapping this area (in coords Rect *area, /* Any CIF overlapping this area (in coords
* of cellDef) will be generated. The CIF * of cellDef) will be generated. The CIF
* will be clipped to this area. * will be clipped to this area.
*/ */
Plane **planes; /* Pointer to array of pointers to planes Plane **planes, /* Pointer to array of pointers to planes
* to hold "real" CIF layers that are * to hold "real" CIF layers that are
* generated. Pointers may initially be * generated. Pointers may initially be
* NULL. * NULL.
*/ */
TileTypeBitMask *layers; /* CIF layers to generate. */ TileTypeBitMask *layers, /* CIF layers to generate. */
bool replace; /* TRUE means that the new CIF is to replace bool replace, /* TRUE means that the new CIF is to replace
* anything that was previously in planes. * anything that was previously in planes.
* FALSE means that the new CIF is to be * FALSE means that the new CIF is to be
* OR'ed in with the current contents of * OR'ed in with the current contents of
* planes. * planes.
*/ */
bool genAllPlanes; /* If TRUE, generate a tile plane even for bool genAllPlanes, /* If TRUE, generate a tile plane even for
* those layers not specified as being * those layers not specified as being
* generated in the 'layers' mask above. * generated in the 'layers' mask above.
*/ */
bool hier; /* TRUE if called from CIFGenSubcells or CIFGenArrays */ bool hier, /* TRUE if called from CIFGenSubcells or CIFGenArrays */
ClientData clientdata; /* Data that may be passed along to the ClientData clientdata) /* Data that may be passed along to the
* CIF operation functions. * CIF operation functions.
*/ */
{ {
@ -5290,9 +5293,9 @@ CIFGen(cellDef, origDef, area, planes, layers, replace, genAllPlanes, hier, clie
*/ */
void void
cifClipPlane(plane, clip) cifClipPlane(
Plane *plane; Plane *plane,
Rect *clip; Rect *clip)
{ {
Rect r; Rect r;
@ -5344,12 +5347,13 @@ cifClipPlane(plane, clip)
*/ */
void void
cifGenClip(area, expanded, clip) cifGenClip(
Rect *area; /* Any CIF overlapping this area (in coords Rect *area, /* Any CIF overlapping this area (in coords
* of cellDef) will be generated. The CIF * of cellDef) will be generated. The CIF
* will be clipped to this area. * will be clipped to this area.
*/ */
Rect *expanded, *clip; Rect *expanded,
Rect *clip)
{ {
if (area->r_xbot > TiPlaneRect.r_xbot) if (area->r_xbot > TiPlaneRect.r_xbot)
{ {
@ -5395,8 +5399,8 @@ cifGenClip(area, expanded, clip)
*/ */
void void
CIFClearPlanes(planes) CIFClearPlanes(
Plane **planes; /* Pointer to an array of MAXCIFLAYERS Plane **planes) /* Pointer to an array of MAXCIFLAYERS
* planes. * planes.
*/ */
{ {

135
cif/CIFhier.c
View File

@ -107,7 +107,7 @@ static CIFLayer *CurCifLayer;
*/ */
void void
CIFInitCells() CIFInitCells(void)
{ {
int i; int i;
@ -172,7 +172,7 @@ CIFInitCells()
*/ */
void void
cifHierCleanup() cifHierCleanup(void)
{ {
int i; int i;
@ -232,10 +232,10 @@ typedef struct _maskHintsData
/* DEPRECATED */ /* DEPRECATED */
int int
cifMaskHints(name, value, targetDef) cifMaskHints(
char *name; char *name,
char *value; char *value,
CellDef *targetDef; CellDef *targetDef)
{ {
char *propvalue, *newval; char *propvalue, *newval;
bool propfound; bool propfound;
@ -277,10 +277,10 @@ cifMaskHints(name, value, targetDef)
*/ */
int int
cifFlatMaskHints(name, value, mhd) cifFlatMaskHints(
char *name; char *name,
char *value; char *value,
MaskHintsData *mhd; MaskHintsData *mhd)
{ {
Rect r, newr; Rect r, newr;
char *vptr, *newval, *lastval, *propvalue; char *vptr, *newval, *lastval, *propvalue;
@ -361,9 +361,9 @@ cifFlatMaskHints(name, value, mhd)
*/ */
void void
CIFCopyMaskHints(scx, targetDef) CIFCopyMaskHints(
SearchContext *scx; SearchContext *scx,
CellDef *targetDef; CellDef *targetDef)
{ {
MaskHintsData mhd; MaskHintsData mhd;
@ -392,9 +392,9 @@ CIFCopyMaskHints(scx, targetDef)
*/ */
int int
cifHierCopyMaskHints(scx, clientData) cifHierCopyMaskHints(
SearchContext *scx; SearchContext *scx,
ClientData clientData; ClientData clientData)
{ {
MaskHintsData mhd; MaskHintsData mhd;
@ -431,9 +431,9 @@ cifHierCopyMaskHints(scx, clientData)
*/ */
int int
cifHierCopyFunc(tile, cxp) cifHierCopyFunc(
Tile *tile; /* Pointer to tile to copy. */ Tile *tile, /* Pointer to tile to copy. */
TreeContext *cxp; /* Describes context of search, including TreeContext *cxp) /* Describes context of search, including
* transform and client data. * transform and client data.
*/ */
{ {
@ -500,8 +500,8 @@ cifHierCopyFunc(tile, cxp)
*/ */
int int
cifHierCellFunc(scx) cifHierCellFunc(
SearchContext *scx; /* Describes cell and area in cell. */ SearchContext *scx) /* Describes cell and area in cell. */
{ {
SearchContext newscx; SearchContext newscx;
Rect rootArea; Rect rootArea;
@ -560,9 +560,9 @@ cifHierCellFunc(scx)
*/ */
int int
cifHierErrorFunc(tile, checkArea) cifHierErrorFunc(
Tile *tile; /* Tile that covers area it shouldn't. */ Tile *tile, /* Tile that covers area it shouldn't. */
Rect *checkArea; /* Intersection of this and tile is error. */ Rect *checkArea) /* Intersection of this and tile is error. */
{ {
Rect area; Rect area;
@ -602,9 +602,9 @@ cifHierErrorFunc(tile, checkArea)
*/ */
int int
cifHierCheckFunc(tile, plane) cifHierCheckFunc(
Tile *tile; /* Tile containing CIF. */ Tile *tile, /* Tile containing CIF. */
Plane *plane; /* Plane to check against and modify. */ Plane *plane) /* Plane to check against and modify. */
{ {
Rect area; Rect area;
@ -649,9 +649,9 @@ cifHierCheckFunc(tile, plane)
*/ */
int int
cifHierTempCheckFunc(tile, plane) cifHierTempCheckFunc(
Tile *tile; /* Tile containing CIF. */ Tile *tile, /* Tile containing CIF. */
Plane *plane; /* Plane to check against and modify. */ Plane *plane) /* Plane to check against and modify. */
{ {
Rect area; Rect area;
@ -684,9 +684,9 @@ cifHierTempCheckFunc(tile, plane)
*/ */
int int
cifHierPaintFunc(tile, plane) cifHierPaintFunc(
Tile *tile; Tile *tile,
Plane *plane; /* Plane in which to paint CIF over tile's Plane *plane) /* Plane in which to paint CIF over tile's
* area. * area.
*/ */
{ {
@ -725,8 +725,8 @@ cifHierPaintFunc(tile, plane)
*/ */
void void
cifCheckAndErase(style) cifCheckAndErase(
CIFStyle *style; /* Describes how to make CIF. */ CIFStyle *style) /* Describes how to make CIF. */
{ {
int i; int i;
@ -766,10 +766,10 @@ cifCheckAndErase(style)
*/ */
void void
CIFGenSubcells(def, area, output) CIFGenSubcells(
CellDef *def; /* Parent cell for which CIF is computed. */ CellDef *def, /* Parent cell for which CIF is computed. */
Rect *area; /* All CIF in this area is interesting. */ Rect *area, /* All CIF in this area is interesting. */
Plane **output; /* Array of pointers to planes into which Plane **output) /* Array of pointers to planes into which
* the CIF output will be OR'ed (real CIF * the CIF output will be OR'ed (real CIF
* only). * only).
*/ */
@ -934,13 +934,14 @@ CIFGenSubcells(def, area, output)
*/ */
int int
cifHierElementFuncLow(use, transform, x, y, checkArea) cifHierElementFuncLow(
CellUse *use; /* CellUse being array-checked. */ CellUse *use, /* CellUse being array-checked. */
Transform *transform; /* Transform from this instance to Transform *transform, /* Transform from this instance to
* the parent. * the parent.
*/ */
int x, y; /* Indices of this instance. */ int x,
Rect *checkArea; /* Area (in parent coords) to be int y, /* Indices of this instance. */
Rect *checkArea) /* Area (in parent coords) to be
* CIF-generated. * CIF-generated.
*/ */
{ {
@ -957,13 +958,14 @@ cifHierElementFuncLow(use, transform, x, y, checkArea)
*/ */
int int
cifHierElementFuncHigh(use, transform, x, y, checkArea) cifHierElementFuncHigh(
CellUse *use; /* CellUse being array-checked. */ CellUse *use, /* CellUse being array-checked. */
Transform *transform; /* Transform from this instance to Transform *transform, /* Transform from this instance to
* the parent. * the parent.
*/ */
int x, y; /* Indices of this instance. */ int x,
Rect *checkArea; /* Area (in parent coords) to be int y, /* Indices of this instance. */
Rect *checkArea) /* Area (in parent coords) to be
* CIF-generated. * CIF-generated.
*/ */
{ {
@ -998,13 +1000,14 @@ cifHierElementFuncHigh(use, transform, x, y, checkArea)
/* ARGSUSED */ /* ARGSUSED */
int int
cifHierElementFunc(use, transform, x, y, checkArea) cifHierElementFunc(
CellUse *use; /* CellUse being array-checked. */ CellUse *use, /* CellUse being array-checked. */
Transform *transform; /* Transform from this instance to Transform *transform, /* Transform from this instance to
* the parent. * the parent.
*/ */
int x, y; /* Indices of this instance. */ int x,
Rect *checkArea; /* Area (in parent coords) to be int y, /* Indices of this instance. */
Rect *checkArea) /* Area (in parent coords) to be
* CIF-generated. * CIF-generated.
*/ */
{ {
@ -1062,9 +1065,9 @@ cifHierElementFunc(use, transform, x, y, checkArea)
*/ */
int int
cifGrowSliver(tile, area) cifGrowSliver(
Tile *tile; Tile *tile,
Rect *area; Rect *area)
{ {
int height, width, expand_up, expand_side; int height, width, expand_up, expand_side;
@ -1123,8 +1126,8 @@ cifGrowSliver(tile, area)
*/ */
int int
cifHierPaintArrayFunc(tile) cifHierPaintArrayFunc(
Tile *tile; Tile *tile)
{ {
Rect area; Rect area;
int i, j, xbot, xtop; int i, j, xbot, xtop;
@ -1194,9 +1197,9 @@ cifHierPaintArrayFunc(tile)
*/ */
int int
cifHierArrayFunc(scx, output) cifHierArrayFunc(
SearchContext *scx; /* Information about the search. */ SearchContext *scx, /* Information about the search. */
Plane **output; /* Array of planes to hold results. */ Plane **output) /* Array of planes to hold results. */
{ {
Rect childArea, parentArea, A, B, C, D, expandedArea; Rect childArea, parentArea, A, B, C, D, expandedArea;
CellUse *use; CellUse *use;
@ -1540,10 +1543,10 @@ cifHierArrayFunc(scx, output)
*/ */
void void
CIFGenArrays(def, area, output) CIFGenArrays(
CellDef *def; /* Parent cell for which CIF is computed. */ CellDef *def, /* Parent cell for which CIF is computed. */
Rect *area; /* All CIF in this area is interesting. */ Rect *area, /* All CIF in this area is interesting. */
Plane **output; /* Array of pointers to planes into which Plane **output) /* Array of pointers to planes into which
* the CIF output will be OR'ed (real CIF * the CIF output will be OR'ed (real CIF
* only, temp layers won't appear). If * only, temp layers won't appear). If
* output is NULL, then CIF is stored in * output is NULL, then CIF is stored in

38
cif/CIFmain.c
View File

@ -95,7 +95,7 @@ global int CIFErrorLayer; /* Index of CIF layer associated with errors.*/
*/ */
void void
CIFPrintStats() CIFPrintStats(void)
{ {
TxPrintf("CIF statistics (recent/total):\n"); TxPrintf("CIF statistics (recent/total):\n");
cifTotalTileOps += CIFTileOps; cifTotalTileOps += CIFTileOps;
@ -136,8 +136,8 @@ CIFPrintStats()
*/ */
float float
CIFGetOutputScale(convert) CIFGetOutputScale(
int convert; int convert)
{ {
if (CIFCurStyle == NULL) return 1.0; if (CIFCurStyle == NULL) return 1.0;
@ -159,8 +159,8 @@ CIFGetOutputScale(convert)
*/ */
float float
CIFGetScale(convert) CIFGetScale(
int convert; int convert)
{ {
if (CIFCurStyle == NULL) return 1.0; if (CIFCurStyle == NULL) return 1.0;
@ -185,10 +185,10 @@ CIFGetScale(convert)
*/ */
void void
CIFPrintStyle(dolist, doforall, docurrent) CIFPrintStyle(
bool dolist; /* Return as a list if true */ bool dolist, /* Return as a list if true */
bool doforall; /* Print all known styles if true */ bool doforall, /* Print all known styles if true */
bool docurrent; /* Print current style if true */ bool docurrent) /* Print current style if true */
{ {
CIFKeep *style; CIFKeep *style;
@ -254,8 +254,8 @@ CIFPrintStyle(dolist, doforall, docurrent)
*/ */
void void
CIFSetStyle(name) CIFSetStyle(
char *name; /* Name of the new style. If NULL, just char *name) /* Name of the new style. If NULL, just
* print out the valid styles. * print out the valid styles.
*/ */
{ {
@ -320,10 +320,10 @@ CIFSetStyle(name)
*/ */
bool bool
CIFNameToMask(name, result, depend) CIFNameToMask(
char *name; char *name,
TileTypeBitMask *result; TileTypeBitMask *result,
TileTypeBitMask *depend; TileTypeBitMask *depend)
{ {
int i, j; int i, j;
CIFOp *op; CIFOp *op;
@ -414,11 +414,11 @@ CIFNameToMask(name, result, depend)
*/ */
void void
CIFError(area, message) CIFError(
Rect *area; /* Place in CIFErrorDef where there was a Rect *area, /* Place in CIFErrorDef where there was a
* problem in generating CIFErrorLayer. * problem in generating CIFErrorLayer.
*/ */
char *message; /* Short note about what went wrong. */ char *message) /* Short note about what went wrong. */
{ {
char msg[200]; char msg[200];
@ -452,7 +452,7 @@ CIFError(area, message)
*/ */
int int
CIFOutputScaleFactor() CIFOutputScaleFactor(void)
{ {
if (CIFCurStyle == NULL) return 1; if (CIFCurStyle == NULL) return 1;
return CIFCurStyle->cs_scaleFactor; return CIFCurStyle->cs_scaleFactor;

79
cif/CIFrdcl.c
View File

@ -126,8 +126,8 @@ char *cifSubcellId = NULL;
*/ */
void void
CIFReadCellInit(ptrkeys) CIFReadCellInit(
int ptrkeys; int ptrkeys)
{ {
int i; int i;
@ -162,8 +162,8 @@ CIFReadCellInit(ptrkeys)
*/ */
bool bool
cifForgetCell(cifNum) cifForgetCell(
int cifNum; int cifNum)
{ {
HashEntry *h; HashEntry *h;
@ -196,8 +196,8 @@ cifForgetCell(cifNum)
*/ */
void void
cifUniqueCell(cifNum) cifUniqueCell(
int cifNum; int cifNum)
{ {
HashEntry *h; HashEntry *h;
CellDef *def, *testdef; CellDef *def, *testdef;
@ -256,8 +256,8 @@ cifUniqueCell(cifNum)
*/ */
CellDef * CellDef *
cifFindCell(cifNum) cifFindCell(
int cifNum; /* The CIF number of the desired cell. */ int cifNum) /* The CIF number of the desired cell. */
{ {
HashEntry *h; HashEntry *h;
CellDef *def, *testdef; CellDef *def, *testdef;
@ -299,10 +299,10 @@ cifFindCell(cifNum)
*/ */
void void
CIFScalePlanes(scalen, scaled, planearray) CIFScalePlanes(
int scalen; int scalen,
int scaled; int scaled,
Plane **planearray; Plane **planearray)
{ {
int pNum; int pNum;
Plane *newplane; Plane *newplane;
@ -348,8 +348,9 @@ CIFScalePlanes(scalen, scaled, planearray)
*/ */
void void
CIFInputRescale(n, d) CIFInputRescale(
int n, d; int n,
int d)
{ {
CIFReadStyle *istyle = cifCurReadStyle; CIFReadStyle *istyle = cifCurReadStyle;
CIFReadLayer *cl; CIFReadLayer *cl;
@ -417,7 +418,7 @@ CIFInputRescale(n, d)
*/ */
bool bool
CIFParseStart() CIFParseStart(void)
{ {
int number; int number;
@ -502,9 +503,9 @@ CIFParseStart()
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
int cifCheckPaintFunc(tile, clientData) int cifCheckPaintFunc(
Tile *tile; Tile *tile,
ClientData clientData; ClientData clientData)
{ {
return 1; return 1;
} }
@ -512,9 +513,9 @@ int cifCheckPaintFunc(tile, clientData)
/* Callback function for copying paint from one CIF cell into another */ /* Callback function for copying paint from one CIF cell into another */
int int
cifCopyPaintFunc(tile, cifCopyRec) cifCopyPaintFunc(
Tile *tile; Tile *tile,
CIFCopyRec *cifCopyRec; CIFCopyRec *cifCopyRec)
{ {
int pNum; int pNum;
TileType dinfo; TileType dinfo;
@ -558,9 +559,9 @@ cifCopyPaintFunc(tile, cifCopyRec)
*/ */
int int
cifMaskHintFunc(tile, lrecp) cifMaskHintFunc(
Tile *tile; Tile *tile,
LinkedRect **lrecp; LinkedRect **lrecp)
{ {
Rect r; Rect r;
LinkedRect *newlr; LinkedRect *newlr;
@ -886,9 +887,9 @@ CIFPaintCurrent(filetype)
/* Use CIF layer geometry to define a fixed bounding box for the current cell */ /* Use CIF layer geometry to define a fixed bounding box for the current cell */
int int
cifMakeBoundaryFunc(tile, clientdata) cifMakeBoundaryFunc(
Tile *tile; /* Tile of CIF information. */ Tile *tile, /* Tile of CIF information. */
ClientData clientdata; /* Pass the file type (CIF or CALMA) */ ClientData clientdata) /* Pass the file type (CIF or CALMA) */
{ {
/* It is assumed that there is one rectangle for the boundary. */ /* It is assumed that there is one rectangle for the boundary. */
/* If there are multiple rectangles defined with the boundary */ /* If there are multiple rectangles defined with the boundary */
@ -965,9 +966,9 @@ cifMakeBoundaryFunc(tile, clientdata)
/* Paint CIF layer geometry into the current cell def as magic layer "type" */ /* Paint CIF layer geometry into the current cell def as magic layer "type" */
int int
cifPaintCurrentFunc(tile, type) cifPaintCurrentFunc(
Tile *tile; /* Tile of CIF information. */ Tile *tile, /* Tile of CIF information. */
TileType type; /* Magic type to be painted. */ TileType type) /* Magic type to be painted. */
{ {
Rect area; Rect area;
int pNum; int pNum;
@ -1042,7 +1043,7 @@ cifPaintCurrentFunc(tile, type)
*/ */
bool bool
CIFParseFinish() CIFParseFinish(void)
{ {
if (!cifSubcellBeingRead) if (!cifSubcellBeingRead)
{ {
@ -1097,7 +1098,7 @@ CIFParseFinish()
*/ */
bool bool
CIFParseDelete() CIFParseDelete(void)
{ {
int number; int number;
@ -1139,7 +1140,7 @@ CIFParseDelete()
*/ */
char * char *
cifParseName() cifParseName(void)
{ {
char ch; char ch;
char *bufferp; char *bufferp;
@ -1181,7 +1182,7 @@ cifParseName()
*/ */
bool bool
cifParseUser9() cifParseUser9(void)
{ {
char *name; char *name;
@ -1213,7 +1214,7 @@ cifParseUser9()
*/ */
bool bool
CIFParseCall() CIFParseCall(void)
{ {
int called; int called;
Transform transform; Transform transform;
@ -1280,7 +1281,7 @@ CIFParseCall()
*/ */
bool bool
cifParseUser91() cifParseUser91(void)
{ {
if (cifSubcellId != NULL) if (cifSubcellId != NULL)
{ {
@ -1311,7 +1312,7 @@ cifParseUser91()
*/ */
bool bool
cifParseUser94() cifParseUser94(void)
{ {
Rect rectangle; Rect rectangle;
char *name = NULL; char *name = NULL;
@ -1401,7 +1402,7 @@ cifParseUser94()
*/ */
bool bool
cifParseUser95() cifParseUser95(void)
{ {
/* Modified by BIM 1/8/2018 */ /* Modified by BIM 1/8/2018 */
Rect rectangle; Rect rectangle;
@ -1561,7 +1562,7 @@ cifParseUser95()
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
bool bool
CIFParseUser() CIFParseUser(void)
{ {
char ch; char ch;

29
cif/CIFrdpoly.c
View File

@ -119,10 +119,10 @@ cifLowY(a, b)
*/ */
bool bool
cifOrient(edges, nedges, dir) cifOrient(
CIFPath *edges[]; /* Array of edges to be categorized. */ CIFPath *edges[], /* Array of edges to be categorized. */
int dir[]; /* Array to hold directions. */ int nedges, /* Size of arrays. */
int nedges; /* Size of arrays. */ int dir[]) /* Array to hold directions. */
{ {
Point *p, *q; Point *p, *q;
int n; int n;
@ -179,10 +179,11 @@ cifOrient(edges, nedges, dir)
*/ */
bool bool
cifCross(edge, dir, ybot, ytop) cifCross(
CIFPath *edge; /* Pointer to first of 2 path points in edge */ CIFPath *edge, /* Pointer to first of 2 path points in edge */
int dir; /* Direction of edge */ int dir, /* Direction of edge */
int ybot, ytop; /* Range of interest */ int ybot,
int ytop) /* Range of interest */
{ {
int ebot, etop; int ebot, etop;
@ -223,12 +224,12 @@ cifCross(edge, dir, ybot, ytop)
*/ */
LinkedRect * LinkedRect *
CIFPolyToRects(path, plane, resultTbl, ui, isCalma) CIFPolyToRects(
CIFPath *path; /* Path describing a polygon. */ CIFPath *path, /* Path describing a polygon. */
Plane *plane; /* Plane to draw on */ Plane *plane, /* Plane to draw on */
PaintResultType *resultTbl; PaintResultType *resultTbl,
PaintUndoInfo *ui; PaintUndoInfo *ui,
bool isCalma; /* TRUE for Calma, FALSE for CIF */ bool isCalma) /* TRUE for Calma, FALSE for CIF */
{ {
int npts = 0, n, *dir, curr, wrapno; int npts = 0, n, *dir, curr, wrapno;
int xbot, xtop, ybot, ytop; int xbot, xtop, ybot, ytop;

64
cif/CIFrdpt.c
View File

@ -65,7 +65,7 @@ static char rcsid[] __attribute__ ((unused)) = "$Header: /usr/cvsroot/magic-8.0/
*/ */
bool bool
CIFParseBox() CIFParseBox(void)
{ {
Point center; Point center;
Point direction; Point direction;
@ -176,7 +176,7 @@ CIFParseBox()
*/ */
bool bool
CIFParseFlash() CIFParseFlash(void)
{ {
int diameter; int diameter;
int savescale; int savescale;
@ -236,11 +236,11 @@ CIFParseFlash()
*/ */
void void
CIFPropRecordPath(def, pathheadp, iswire, propname) CIFPropRecordPath(
CellDef *def; CellDef *def,
CIFPath *pathheadp; CIFPath *pathheadp,
bool iswire; bool iswire,
char *propname; char *propname)
{ {
extern float CIFGetOutputScale(int convert); extern float CIFGetOutputScale(int convert);
CIFPath *pathp; CIFPath *pathp;
@ -316,13 +316,13 @@ CIFPropRecordPath(def, pathheadp, iswire, propname)
*/ */
void void
CIFPaintWirePath(pathheadp, width, endcap, plane, ptable, ui) CIFPaintWirePath(
CIFPath *pathheadp; CIFPath *pathheadp,
int width; int width,
bool endcap; bool endcap,
Plane *plane; Plane *plane,
PaintResultType *ptable; PaintResultType *ptable,
PaintUndoInfo *ui; PaintUndoInfo *ui)
{ {
CIFPath *pathp, *previousp, *nextp, *polypath; CIFPath *pathp, *previousp, *nextp, *polypath;
CIFPath *returnpath, *newpath, *savepath; CIFPath *returnpath, *newpath, *savepath;
@ -562,13 +562,13 @@ CIFPaintWirePath(pathheadp, width, endcap, plane, ptable, ui)
*/ */
LinkedRect * LinkedRect *
PaintPolygon(pointlist, number, plane, ptable, ui, keep) PaintPolygon(
Point *pointlist; /* Array of Point structures */ Point *pointlist, /* Array of Point structures */
int number; /* total number of points */ int number, /* total number of points */
Plane *plane; /* Plane structure to paint into */ Plane *plane, /* Plane structure to paint into */
PaintResultType *ptable; /* Paint result table */ PaintResultType *ptable, /* Paint result table */
PaintUndoInfo *ui; /* Undo record */ PaintUndoInfo *ui, /* Undo record */
bool keep; /* Return list of rects if true */ bool keep) /* Return list of rects if true */
{ {
LinkedRect *rectp, *rectlist; LinkedRect *rectp, *rectlist;
CIFPath *newpath, *cifpath = (CIFPath *)NULL; CIFPath *newpath, *cifpath = (CIFPath *)NULL;
@ -617,14 +617,14 @@ PaintPolygon(pointlist, number, plane, ptable, ui, keep)
*/ */
void void
PaintWireList(pointlist, number, width, endcap, plane, ptable, ui) PaintWireList(
Point *pointlist; /* Array of Point structures */ Point *pointlist, /* Array of Point structures */
int number; /* total number of points */ int number, /* total number of points */
int width; /* Route width of path */ int width, /* Route width of path */
bool endcap; /* Whether or not to add 1/2 width endcaps */ bool endcap, /* Whether or not to add 1/2 width endcaps */
Plane *plane; /* Plane structure to paint into */ Plane *plane, /* Plane structure to paint into */
PaintResultType *ptable; /* Paint result table */ PaintResultType *ptable, /* Paint result table */
PaintUndoInfo *ui; /* Undo record */ PaintUndoInfo *ui) /* Undo record */
{ {
CIFPath *newpath, *cifpath = (CIFPath *)NULL; CIFPath *newpath, *cifpath = (CIFPath *)NULL;
int i; int i;
@ -661,7 +661,7 @@ PaintWireList(pointlist, number, width, endcap, plane, ptable, ui)
*/ */
bool bool
CIFParseWire() CIFParseWire(void)
{ {
int width; int width;
CIFPath *pathheadp, *polypath; CIFPath *pathheadp, *polypath;
@ -721,7 +721,7 @@ CIFParseWire()
*/ */
bool bool
CIFParseLayer() CIFParseLayer(void)
{ {
#define MAXCHARS 4 #define MAXCHARS 4
char name[MAXCHARS+1]; char name[MAXCHARS+1];
@ -784,7 +784,7 @@ CIFParseLayer()
*/ */
bool bool
CIFParsePoly() CIFParsePoly(void)
{ {
CIFPath *pathheadp; CIFPath *pathheadp;
LinkedRect *rectp; LinkedRect *rectp;

84
cif/CIFrdtech.c
View File

@ -90,8 +90,9 @@ void CIFReadLoadStyle(char *stylename);
*/ */
bool bool
CIFReadTechLimitScale(ns, ds) CIFReadTechLimitScale(
int ns, ds; int ns,
int ds)
{ {
int gridup, scaledown; int gridup, scaledown;
int scale, limit, mult; int scale, limit, mult;
@ -131,9 +132,9 @@ CIFReadTechLimitScale(ns, ds)
*/ */
int int
CIFReadNameToType(name, newOK) CIFReadNameToType(
char *name; /* Name of a CIF layer. */ char *name, /* Name of a CIF layer. */
bool newOK; /* TRUE means OK to create a new layer if this bool newOK) /* TRUE means OK to create a new layer if this
* name is one we haven't seen before. * name is one we haven't seen before.
*/ */
{ {
@ -196,10 +197,10 @@ CIFReadNameToType(name, newOK)
*/ */
int int
CIFCalmaLayerToCifLayer(layer, datatype, calmaStyle) CIFCalmaLayerToCifLayer(
int layer; /* Calma layer number */ int layer, /* Calma layer number */
int datatype; /* Calma datatype */ int datatype, /* Calma datatype */
CIFReadStyle *calmaStyle; CIFReadStyle *calmaStyle)
{ {
CalmaLayerType clt; CalmaLayerType clt;
HashEntry *he; HashEntry *he;
@ -251,10 +252,10 @@ CIFCalmaLayerToCifLayer(layer, datatype, calmaStyle)
*/ */
void void
CIFParseReadLayers(string, mask, newok) CIFParseReadLayers(
char *string; /* Comma-separated list of CIF layers. */ char *string, /* Comma-separated list of CIF layers. */
TileTypeBitMask *mask; /* Where to store bit mask. */ TileTypeBitMask *mask, /* Where to store bit mask. */
bool newok; /* If TRUE, create new layers if they don't exist */ bool newok) /* If TRUE, create new layers if they don't exist */
{ {
int i; int i;
char *p; char *p;
@ -313,7 +314,7 @@ CIFParseReadLayers(string, mask, newok)
*/ */
void void
cifNewReadStyle() cifNewReadStyle(void)
{ {
int i; int i;
CIFOp *op; CIFOp *op;
@ -353,7 +354,7 @@ cifNewReadStyle()
*/ */
void void
cifReadStyleInit() cifReadStyleInit(void)
{ {
int i; int i;
@ -395,7 +396,7 @@ cifReadStyleInit()
*/ */
void void
CIFReadTechInit() CIFReadTechInit(void)
{ {
CIFReadKeep *style; CIFReadKeep *style;
@ -433,7 +434,7 @@ CIFReadTechInit()
*/ */
void void
CIFReadTechStyleInit() CIFReadTechStyleInit(void)
{ {
cifNReadLayers = 0; cifNReadLayers = 0;
cifCurReadLayer = NULL; cifCurReadLayer = NULL;
@ -460,10 +461,10 @@ CIFReadTechStyleInit()
*/ */
/* ARGSUSED */ /* ARGSUSED */
bool bool
CIFReadTechLine(sectionName, argc, argv) CIFReadTechLine(
char *sectionName; /* Name of this section ("cifinput"). */ char *sectionName, /* Name of this section ("cifinput"). */
int argc; /* Number of fields on line. */ int argc, /* Number of fields on line. */
char *argv[]; /* Values of fields. */ char *argv[]) /* Values of fields. */
{ {
CIFOp *newOp = NULL; CIFOp *newOp = NULL;
CIFReadKeep *newStyle, *p; CIFReadKeep *newStyle, *p;
@ -1051,7 +1052,7 @@ CIFReadTechLine(sectionName, argc, argv)
*/ */
void void
CIFReadTechFinal() CIFReadTechFinal(void)
{ {
/* Reduce the scale by the multiplier, as much as possible while */ /* Reduce the scale by the multiplier, as much as possible while */
/* keeping all CIF input ops in integer units. */ /* keeping all CIF input ops in integer units. */
@ -1095,8 +1096,8 @@ CIFReadTechFinal()
* ---------------------------------------------------------------------------- * ----------------------------------------------------------------------------
*/ */
void void
CIFReadLoadStyle(stylename) CIFReadLoadStyle(
char *stylename; char *stylename)
{ {
SectionID invcifr; SectionID invcifr;
@ -1138,8 +1139,8 @@ CIFReadLoadStyle(stylename)
*/ */
int int
CIFReadGetGrowSize(type) CIFReadGetGrowSize(
TileType type; TileType type)
{ {
CIFReadStyle *istyle = cifCurReadStyle; CIFReadStyle *istyle = cifCurReadStyle;
CIFOp *op; CIFOp *op;
@ -1193,8 +1194,8 @@ CIFReadGetGrowSize(type)
*/ */
float float
CIFGetInputScale(convert) CIFGetInputScale(
int convert; int convert)
{ {
/* Avoid divide-by-0 error if there is no cif input style */ /* Avoid divide-by-0 error if there is no cif input style */
/* in the tech file. */ /* in the tech file. */
@ -1226,10 +1227,10 @@ CIFGetInputScale(convert)
*/ */
void void
CIFPrintReadStyle(dolist, doforall, docurrent) CIFPrintReadStyle(
bool dolist; /* Return as a list if true */ bool dolist, /* Return as a list if true */
bool doforall; /* Return list of all styles if true */ bool doforall, /* Return list of all styles if true */
bool docurrent; /* Return current style if true */ bool docurrent) /* Return current style if true */
{ {
CIFReadKeep *style; CIFReadKeep *style;
@ -1297,8 +1298,8 @@ CIFPrintReadStyle(dolist, doforall, docurrent)
*/ */
void void
CIFSetReadStyle(name) CIFSetReadStyle(
char *name; /* Name of the new style. If NULL, char *name) /* Name of the new style. If NULL,
* just print the name of the current * just print the name of the current
* style. * style.
*/ */
@ -1358,10 +1359,10 @@ CIFSetReadStyle(name)
*/ */
int int
cifParseCalmaNums(str, numArray, numNums) cifParseCalmaNums(
char *str; /* String to parse */ char *str, /* String to parse */
int *numArray; /* Array to fill in */ int *numArray, /* Array to fill in */
int numNums; /* Maximum number of entries in numArray */ int numNums) /* Maximum number of entries in numArray */
{ {
int numFilled, num; int numFilled, num;
@ -1421,9 +1422,10 @@ cifParseCalmaNums(str, numArray, numNums)
*/ */
int int
CIFTechInputScale(n, d, opt) CIFTechInputScale(
int n, d; int n,
bool opt; int d,
bool opt)
{ {
CIFReadStyle *istyle = cifCurReadStyle; CIFReadStyle *istyle = cifCurReadStyle;
CIFReadLayer *cl; CIFReadLayer *cl;

105
cif/CIFrdutils.c
View File

@ -205,9 +205,9 @@ CIFReadWarning(char *format, ...)
*/ */
int int
CIFScaleCoord(cifCoord, snap_type) CIFScaleCoord(
int cifCoord; /* A coordinate in CIF units. */ int cifCoord, /* A coordinate in CIF units. */
int snap_type; /* How to deal with fractional results */ int snap_type) /* How to deal with fractional results */
{ {
int result, scale, remain, denom; int result, scale, remain, denom;
int mult, mfactor; int mult, mfactor;
@ -343,8 +343,8 @@ CIFScaleCoord(cifCoord, snap_type)
*/ */
bool bool
cifIsBlank(ch) cifIsBlank(
int ch; int ch)
{ {
if ( isdigit(ch) || isupper(ch) if ( isdigit(ch) || isupper(ch)
@ -376,7 +376,7 @@ cifIsBlank(ch)
*/ */
void void
CIFSkipBlanks() CIFSkipBlanks(void)
{ {
while (cifIsBlank(PEEK())) { while (cifIsBlank(PEEK())) {
@ -405,7 +405,7 @@ CIFSkipBlanks()
*/ */
void void
CIFSkipSep() CIFSkipSep(void)
{ {
int ch; int ch;
@ -435,7 +435,7 @@ CIFSkipSep()
*/ */
void void
CIFSkipToSemi() CIFSkipToSemi(void)
{ {
int ch; int ch;
@ -464,7 +464,7 @@ CIFSkipToSemi()
*/ */
void void
CIFSkipSemi() CIFSkipSemi(void)
{ {
CIFSkipBlanks(); CIFSkipBlanks();
@ -495,8 +495,8 @@ CIFSkipSemi()
*/ */
bool bool
CIFParseSInteger(valuep) CIFParseSInteger(
int *valuep; int *valuep)
{ {
bool is_signed; bool is_signed;
char buffer[ BUFSIZ ]; char buffer[ BUFSIZ ];
@ -540,8 +540,8 @@ CIFParseSInteger(valuep)
*/ */
bool bool
CIFParseInteger(valuep) CIFParseInteger(
int *valuep; int *valuep)
{ {
if (!CIFParseSInteger(valuep)) if (!CIFParseSInteger(valuep))
@ -581,9 +581,9 @@ CIFParseInteger(valuep)
*/ */
bool bool
CIFParsePoint(pointp, iscale) CIFParsePoint(
Point *pointp; Point *pointp,
int iscale; int iscale)
{ {
int rescale; int rescale;
@ -667,9 +667,9 @@ CIFParsePoint(pointp, iscale)
*/ */
bool bool
CIFParsePath(pathheadpp, iscale) CIFParsePath(
CIFPath **pathheadpp; CIFPath **pathheadpp,
int iscale; int iscale)
{ {
CIFPath *pathtailp, *newpathp; CIFPath *pathtailp, *newpathp;
bool nonManhattan = FALSE; /* diagnostic only */ bool nonManhattan = FALSE; /* diagnostic only */
@ -744,9 +744,9 @@ CIFParsePath(pathheadpp, iscale)
*/ */
bool bool
test_insideness(start, tpoint) test_insideness(
CIFPath *start; CIFPath *start,
Point *tpoint; Point *tpoint)
{ {
Rect tmprect, irect; Rect tmprect, irect;
@ -782,10 +782,11 @@ test_insideness(start, tpoint)
*/ */
bool bool
seg_intersect(tstart, bf, bs, respt) seg_intersect(
CIFPath *tstart; CIFPath *tstart,
Point *bf, *bs; Point *bf,
Point *respt; Point *bs,
Point *respt)
{ {
int afx = tstart->cifp_x; int afx = tstart->cifp_x;
int afy = tstart->cifp_y; int afy = tstart->cifp_y;
@ -848,9 +849,10 @@ seg_intersect(tstart, bf, bs, respt)
*/ */
bool bool
path_intersect(pathHead, start, respt) path_intersect(
CIFPath *pathHead, *start; CIFPath *pathHead,
Point *respt; CIFPath *start,
Point *respt)
{ {
CIFPath *path, *segcrossed, *new; CIFPath *path, *segcrossed, *new;
Point tmppt; Point tmppt;
@ -953,8 +955,8 @@ path_intersect(pathHead, start, respt)
*/ */
bool bool
is_clockwise(pathHead) is_clockwise(
CIFPath *pathHead; CIFPath *pathHead)
{ {
CIFPath *path, *midx = NULL, *last; CIFPath *path, *midx = NULL, *last;
Point *p1, *p2, *p3; Point *p1, *p2, *p3;
@ -1047,11 +1049,11 @@ is_clockwise(pathHead)
*/ */
void void
CIFMakeManhattanPath(pathHead, plane, resultTbl, ui) CIFMakeManhattanPath(
CIFPath *pathHead; CIFPath *pathHead,
Plane *plane; Plane *plane,
PaintResultType *resultTbl; PaintResultType *resultTbl,
PaintUndoInfo *ui; PaintUndoInfo *ui)
{ {
CIFPath *new, *new2, *next, *path; CIFPath *new, *new2, *next, *path;
int xinit, xdiff, xincr, xlast, x; int xinit, xdiff, xincr, xlast, x;
@ -1185,8 +1187,9 @@ CIFMakeManhattanPath(pathHead, plane, resultTbl, ui)
*/ */
int int
CIFEdgeDirection(first, last) CIFEdgeDirection(
CIFPath *first, *last; /* Edge to be categorized. */ CIFPath *first,
CIFPath *last) /* Edge to be categorized. */
{ {
if (first->cifp_x < last->cifp_x) if (first->cifp_x < last->cifp_x)
@ -1233,8 +1236,8 @@ CIFEdgeDirection(first, last)
*/ */
void void
CIFCleanPath(pathHead) CIFCleanPath(
CIFPath *pathHead; CIFPath *pathHead)
{ {
CIFPath *next, *path, *prev, *last; CIFPath *next, *path, *prev, *last;
int dir1, dir2; int dir1, dir2;
@ -1332,8 +1335,8 @@ path_inc:
*/ */
void void
CIFFreePath(path) CIFFreePath(
CIFPath *path; /* Path to be freed. */ CIFPath *path) /* Path to be freed. */
{ {
while (path != NULL) while (path != NULL)
{ {
@ -1361,7 +1364,7 @@ CIFFreePath(path)
*/ */
void void
cifCommandError() cifCommandError(void)
{ {
CIFReadError("unknown command `%c'; ignored.\n" , PEEK()); CIFReadError("unknown command `%c'; ignored.\n" , PEEK());
CIFSkipToSemi(); CIFSkipToSemi();
@ -1386,7 +1389,7 @@ cifCommandError()
*/ */
bool bool
cifParseEnd() cifParseEnd(void)
{ {
TAKE(); TAKE();
CIFSkipBlanks(); CIFSkipBlanks();
@ -1415,7 +1418,7 @@ cifParseEnd()
*/ */
bool bool
cifParseComment() cifParseComment(void)
{ {
int opens; int opens;
int ch; int ch;
@ -1467,8 +1470,8 @@ cifParseComment()
*/ */
Transform * Transform *
CIFDirectionToTrans(point) CIFDirectionToTrans(
Point *point; /* Direction vector from origin. */ Point *point) /* Direction vector from origin. */
{ {
if ((point->p_x != 0) && (point->p_y == 0)) if ((point->p_x != 0) && (point->p_y == 0))
{ {
@ -1507,8 +1510,8 @@ CIFDirectionToTrans(point)
*/ */
bool bool
CIFParseTransform(transformp) CIFParseTransform(
Transform *transformp; Transform *transformp)
{ {
char ch; char ch;
Point point; Point point;
@ -1601,8 +1604,8 @@ CIFParseTransform(transformp)
*/ */
void void
CIFReadFile(file) CIFReadFile(
FILE *file; /* File from which to read CIF. */ FILE *file) /* File from which to read CIF. */
{ {
/* We will use 1-word CIF numbers as keys in this hash table */ /* We will use 1-word CIF numbers as keys in this hash table */
CIFReadCellInit(1); CIFReadCellInit(1);

60
cif/CIFsee.c
View File

@ -76,9 +76,9 @@ typedef struct {
*/ */
int int
cifPaintDBFunc(tile, pld) cifPaintDBFunc(
Tile *tile; /* Tile of CIF information. */ Tile *tile, /* Tile of CIF information. */
PaintLayerData *pld; PaintLayerData *pld)
{ {
Rect area; Rect area;
int pNum; int pNum;
@ -132,14 +132,14 @@ cifPaintDBFunc(tile, pld)
*/ */
void void
CIFPaintLayer(rootDef, area, cifLayer, magicLayer, paintDef) CIFPaintLayer(
CellDef *rootDef; /* Cell for which to generate CIF. Must be CellDef *rootDef, /* Cell for which to generate CIF. Must be
* the rootDef of a window. * the rootDef of a window.
*/ */
Rect *area; /* Area in which to generate CIF. */ Rect *area, /* Area in which to generate CIF. */
char *cifLayer; /* CIF layer to highlight on the screen. */ char *cifLayer, /* CIF layer to highlight on the screen. */
int magicLayer; /* Magic layer to paint with the result */ int magicLayer, /* Magic layer to paint with the result */
CellDef *paintDef; /* CellDef to paint into (may be NULL) */ CellDef *paintDef) /* CellDef to paint into (may be NULL) */
{ {
int oldCount, i; int oldCount, i;
char msg[100]; char msg[100];
@ -217,9 +217,9 @@ CIFPaintLayer(rootDef, area, cifLayer, magicLayer, paintDef)
*/ */
int int
cifSeeFunc(tile, sld) cifSeeFunc(
Tile *tile; /* Tile to be entered as feedback. */ Tile *tile, /* Tile to be entered as feedback. */
SeeLayerData *sld; /* Layer and explanation for the feedback. */ SeeLayerData *sld) /* Layer and explanation for the feedback. */
{ {
Rect area; Rect area;
@ -258,12 +258,12 @@ cifSeeFunc(tile, sld)
*/ */
void void
CIFSeeLayer(rootDef, area, layer) CIFSeeLayer(
CellDef *rootDef; /* Cell for which to generate CIF. Must be CellDef *rootDef, /* Cell for which to generate CIF. Must be
* the rootDef of a window. * the rootDef of a window.
*/ */
Rect *area; /* Area in which to generate CIF. */ Rect *area, /* Area in which to generate CIF. */
char *layer; /* CIF layer to highlight on the screen. */ char *layer) /* CIF layer to highlight on the screen. */
{ {
int oldCount, i; int oldCount, i;
char msg[100]; char msg[100];
@ -348,14 +348,14 @@ CIFSeeLayer(rootDef, area, layer)
*/ */
void void
CIFSeeHierLayer(rootDef, area, layer, arrays, subcells) CIFSeeHierLayer(
CellDef *rootDef; /* Def in which to compute CIF. Must be CellDef *rootDef, /* Def in which to compute CIF. Must be
* the root definition of a window. * the root definition of a window.
*/ */
Rect *area; /* Area in which to generate CIF. */ Rect *area, /* Area in which to generate CIF. */
char *layer; /* CIF layer to be highlighted. */ char *layer, /* CIF layer to be highlighted. */
bool arrays; /* TRUE means show array interactions. */ bool arrays, /* TRUE means show array interactions. */
bool subcells; /* TRUE means show subcell interactions. */ bool subcells) /* TRUE means show subcell interactions. */
{ {
int i, oldCount; int i, oldCount;
SeeLayerData sld; SeeLayerData sld;
@ -426,11 +426,11 @@ typedef struct {
} coverstats; } coverstats;
void void
CIFCoverageLayer(rootDef, area, layer, dolist) CIFCoverageLayer(
CellDef *rootDef; /* Def in which to compute CIF coverage */ CellDef *rootDef, /* Def in which to compute CIF coverage */
Rect *area; /* Area in which to compute coverage */ Rect *area, /* Area in which to compute coverage */
char *layer; /* CIF layer for coverage computation. */ char *layer, /* CIF layer for coverage computation. */
bool dolist; /* If TRUE, report only the value, in decimal */ bool dolist) /* If TRUE, report only the value, in decimal */
{ {
coverstats cstats; coverstats cstats;
int i, scale; int i, scale;
@ -510,9 +510,9 @@ CIFCoverageLayer(rootDef, area, layer, dolist)
} }
int int
cifCoverageFunc(tile, arg) cifCoverageFunc(
Tile *tile; Tile *tile,
ClientData *arg; ClientData *arg)
{ {
coverstats *cstats = (coverstats *)arg; coverstats *cstats = (coverstats *)arg;
Rect r; Rect r;

76
cif/CIFtech.c
View File

@ -85,7 +85,7 @@ bool cifCheckCalmaNum(char *str);
*/ */
void void
cifTechFreeStyle() cifTechFreeStyle(void)
{ {
int i; int i;
CIFOp *op; CIFOp *op;
@ -148,7 +148,7 @@ cifTechFreeStyle()
*/ */
void void
cifTechNewStyle() cifTechNewStyle(void)
{ {
cifTechFreeStyle(); cifTechFreeStyle();
cifTechStyleInit(); cifTechStyleInit();
@ -165,7 +165,7 @@ cifTechNewStyle()
*/ */
void void
cifTechStyleInit() cifTechStyleInit(void)
{ {
int i; int i;
@ -216,18 +216,18 @@ cifTechStyleInit()
*/ */
void void
cifParseLayers(string, style, paintMask, cifMask, spaceOK) cifParseLayers(
char *string; /* List of layers. */ char *string, /* List of layers. */
CIFStyle *style; /* Gives CIF style for parsing string.*/ CIFStyle *style, /* Gives CIF style for parsing string.*/
TileTypeBitMask *paintMask; /* Place to store mask of paint layers. If TileTypeBitMask *paintMask, /* Place to store mask of paint layers. If
* NULL, then only CIF layer names are * NULL, then only CIF layer names are
* considered. * considered.
*/ */
TileTypeBitMask *cifMask; /* Place to store mask of CIF layers. If TileTypeBitMask *cifMask, /* Place to store mask of CIF layers. If
* NULL, then only paint layer names are * NULL, then only paint layer names are
* considered. * considered.
*/ */
int spaceOK; /* are space layers permissible in this cif int spaceOK) /* are space layers permissible in this cif
layer? layer?
*/ */
{ {
@ -357,7 +357,7 @@ okpaint:
*/ */
void void
CIFTechInit() CIFTechInit(void)
{ {
CIFKeep *style; CIFKeep *style;
@ -393,7 +393,7 @@ CIFTechInit()
*/ */
void void
CIFTechStyleInit() CIFTechStyleInit(void)
{ {
CalmaTechInit(); CalmaTechInit();
@ -434,8 +434,9 @@ CIFTechStyleInit()
*/ */
bool bool
CIFTechLimitScale(ns, ds) CIFTechLimitScale(
int ns, ds; int ns,
int ds)
{ {
int gridup, scaledown; int gridup, scaledown;
int scale, limit, expand; int scale, limit, expand;
@ -474,9 +475,9 @@ CIFTechLimitScale(ns, ds)
*/ */
int int
CIFParseScale(true_scale, expander) CIFParseScale(
char *true_scale; char *true_scale,
int *expander; int *expander)
{ {
char *decimal; char *decimal;
short places; short places;
@ -525,10 +526,10 @@ CIFParseScale(true_scale, expander)
*/ */
bool bool
CIFTechLine(sectionName, argc, argv) CIFTechLine(
char *sectionName; /* The name of this section. */ char *sectionName, /* The 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, tempMask, cifMask, bloatLayers; TileTypeBitMask mask, tempMask, cifMask, bloatLayers;
int i, j, l, distance; int i, j, l, distance;
@ -1540,8 +1541,8 @@ bloatCheck:
*/ */
bool bool
cifCheckCalmaNum(str) cifCheckCalmaNum(
char *str; char *str)
{ {
int n = atoi(str); int n = atoi(str);
@ -1577,9 +1578,9 @@ cifCheckCalmaNum(str)
*/ */
void void
cifComputeRadii(layer, des) cifComputeRadii(
CIFLayer *layer; /* Layer for which to compute distances. */ CIFLayer *layer, /* Layer for which to compute distances. */
CIFStyle *des; /* CIF style (used to find temp layer CIFStyle *des) /* CIF style (used to find temp layer
* distances. * distances.
*/ */
{ {
@ -1685,8 +1686,8 @@ cifComputeRadii(layer, des)
*/ */
void void
cifComputeHalo(style) cifComputeHalo(
CIFStyle *style; CIFStyle *style)
{ {
int maxGrow, maxShrink, i; int maxGrow, maxShrink, i;
@ -1755,7 +1756,7 @@ cifComputeHalo(style)
*/ */
void void
CIFTechFinal() CIFTechFinal(void)
{ {
CIFStyle *style = CIFCurStyle; CIFStyle *style = CIFCurStyle;
CIFOp *op; CIFOp *op;
@ -2139,8 +2140,8 @@ CIFTechFinal()
*/ */
void void
CIFLoadStyle(stylename) CIFLoadStyle(
char *stylename; char *stylename)
{ {
SectionID invcif; SectionID invcif;
@ -2188,11 +2189,11 @@ CIFLoadStyle(stylename)
*/ */
int int
CIFGetContactSize(type, edge, spacing, border) CIFGetContactSize(
TileType type; TileType type,
int *edge; int *edge,
int *border; int *spacing,
int *spacing; int *border)
{ {
CIFStyle *style = CIFCurStyle; CIFStyle *style = CIFCurStyle;
CIFOp *op, *sop; CIFOp *op, *sop;
@ -2285,8 +2286,9 @@ CIFGetContactSize(type, edge, spacing, border)
*/ */
void void
CIFTechOutputScale(n, d) CIFTechOutputScale(
int n, d; int n,
int d)
{ {
int i, j, lgcf, lexpand; int i, j, lgcf, lexpand;
CIFStyle *ostyle = CIFCurStyle; CIFStyle *ostyle = CIFCurStyle;

54
cif/CIFwrite.c
View File

@ -118,9 +118,9 @@ bool CIFArrayWriteDisable = FALSE;
*/ */
bool bool
CIFWrite(rootDef, f) CIFWrite(
CellDef *rootDef; /* Pointer to CellDef to be written */ CellDef *rootDef, /* Pointer to CellDef to be written */
FILE *f; /* Open output file */ FILE *f) /* Open output file */
{ {
bool good; bool good;
int oldCount = DBWFeedbackCount; int oldCount = DBWFeedbackCount;
@ -205,8 +205,8 @@ CIFWrite(rootDef, f)
*/ */
int int
cifWriteInitFunc(def) cifWriteInitFunc(
CellDef *def; CellDef *def)
{ {
def->cd_client = (ClientData) 0; def->cd_client = (ClientData) 0;
return (0); return (0);
@ -229,8 +229,8 @@ cifWriteInitFunc(def)
*/ */
int int
cifWriteMarkFunc(use) cifWriteMarkFunc(
CellUse *use; CellUse *use)
{ {
if (use->cu_def->cd_client != (ClientData) 0) return 0; if (use->cu_def->cd_client != (ClientData) 0) return 0;
use->cu_def->cd_client = (ClientData) cifCellNum; use->cu_def->cd_client = (ClientData) cifCellNum;
@ -255,9 +255,9 @@ cifWriteMarkFunc(use)
*/ */
void void
cifOutPreamble(outf, cell) cifOutPreamble(
FILE *outf; FILE *outf,
CellDef *cell; CellDef *cell)
{ {
extern char *MagicVersion; extern char *MagicVersion;
extern char *MagicCompileTime; extern char *MagicCompileTime;
@ -304,8 +304,8 @@ cifOutPreamble(outf, cell)
*/ */
void void
cifOut(outf) cifOut(
FILE *outf; FILE *outf)
{ {
CellDef *def; CellDef *def;
bool needHier; bool needHier;
@ -353,9 +353,9 @@ cifOut(outf)
*/ */
void void
cifOutFunc(def, f) cifOutFunc(
CellDef *def; /* Pointer to cell def to be written */ CellDef *def, /* Pointer to cell def to be written */
FILE *f; /* Open output file */ FILE *f) /* Open output file */
{ {
Rect bigArea; Rect bigArea;
Label *lab; Label *lab;
@ -484,9 +484,9 @@ cifOutFunc(def, f)
*/ */
int int
cifWriteUseFunc(use, f) cifWriteUseFunc(
CellUse *use; CellUse *use,
FILE *f; FILE *f)
{ {
int x, y, topx, topy; int x, y, topx, topy;
int realx, realy; int realx, realy;
@ -582,9 +582,9 @@ cifWriteUseFunc(use, f)
*/ */
int int
cifWriteLabelFunc(tile, f) cifWriteLabelFunc(
Tile *tile; /* Tile to be written out. */ Tile *tile, /* Tile to be written out. */
FILE *f; /* File in which to write. */ FILE *f) /* File in which to write. */
{ {
Rect r; Rect r;
int type; int type;
@ -641,9 +641,9 @@ cifWriteLabelFunc(tile, f)
*/ */
int int
cifWritePaintFunc(tile, f) cifWritePaintFunc(
Tile *tile; /* Tile to be written out. */ Tile *tile, /* Tile to be written out. */
FILE *f; /* File in which to write. */ FILE *f) /* File in which to write. */
{ {
Rect r; Rect r;
@ -722,9 +722,9 @@ cifWritePaintFunc(tile, f)
*/ */
bool bool
CIFWriteFlat(rootDef, f) CIFWriteFlat(
CellDef *rootDef; /* Pointer to CellDef to be written */ CellDef *rootDef, /* Pointer to CellDef to be written */
FILE *f; /* Open output file */ FILE *f) /* Open output file */
{ {
bool good; bool good;
int oldCount = DBWFeedbackCount; int oldCount = DBWFeedbackCount;