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

372 lines
13 KiB
C
Raw Blame History

/*
* CIFint.h --
*
* Defines things shared internally by the cif module of Magic,
* but not generally needed outside the cif module.
*
* *********************************************************************
* * Copyright (C) 1985, 1990 Regents of the University of California. *
* * Permission to use, copy, modify, and distribute this *
* * software and its documentation for any purpose and without *
* * fee is hereby granted, provided that the above copyright *
* * notice appear in all copies. The University of California *
* * makes no representations about the suitability of this *
* * software for any purpose. It is provided "as is" without *
* * express or implied warranty. Export of this software outside *
* * of the United States of America may require an export license. *
* *********************************************************************
*
* rcsid "$Header: /usr/cvsroot/magic-8.0/cif/CIFint.h,v 1.3 2008/12/04 17:10:29 tim Exp $"
*/
#ifndef _CIFINT_H
#define _CIFINT_H
#include "database/database.h"
/* The main data structure used in the cif module is a description
* of how to generate CIF layers from the Magic tiles. There may
* be several different styles for generating CIF from the same Magic
* information, e.g. for fabricating at different geometries. Each
* of these CIF styles involves three kinds of data. A "CIFStyle"
* record gives overall information such as the number of layers.
* One "CIFLayer" gives overall information for each layer, and
* then a list of one or more "CIFOp" records describes a sequence
* of geometrical operations to perform to generate the layer. This
* data structure is built up by reading the technology file.
*/
/* A CIFOp starts from a partially-completed CIF layer, does something
* to it, which may possibly involve some existing layers or temporary
* layers, and creates the next stage of the partially-completed
* CIF layer. Example operations are to AND with some existing paint,
* or to grow by a certain amount.
*/
typedef struct bloat_data
{
int bl_plane; /* Plane on which a bloat or squares
* operation is valid. If -1, then the bloat
* types are CIF types.
*/
int bl_distance[TT_MAXTYPES];
} BloatData;
typedef struct bridge_data
{
int br_width; /* Minimum width rule for bridge */
} BridgeData;
typedef struct squares_data
{
int sq_border;
int sq_size;
int sq_sep;
int sq_gridx; /* Only used for "squares-grid" */
int sq_gridy; /* Only used for "squares-grid" */
} SquaresData;
typedef struct slots_data
{
int sl_sborder; /* short tile side */
int sl_ssize;
int sl_ssep;
int sl_lborder; /* long tile side */
int sl_lsize;
int sl_lsep;
int sl_offset;
int sl_start;
} SlotsData;
typedef struct cifop
{
TileTypeBitMask co_paintMask;/* Zero or more paint layers to consider. */
TileTypeBitMask co_cifMask; /* Zero or more other CIF layers. */
int co_opcode; /* Which geometric operation to use. See
* below for the legal ones.
*/
int co_distance; /* Grow or shrink distance (if needed). */
ClientData co_client; /* Pointer to a BloatData, SquaresData,
* SlotsData, or BridgeData structure,
* or NULL.
*/
struct cifop *co_next; /* Next in list of operations to perform. */
} CIFOp;
/* The opcodes defined so far are:
*
* CIFOP_AND - AND current results with the layers indicated by
* the masks.
* CIFOP_ANDNOT - Wherever there is material indicated by the masks,
* erase those areas from the current results.
* CIFOP_OR - OR current results with the layers indicated by
* the masks.
* CIFOP_GROW - Grow the current results uniformly by co_distance.
* CIFOP_GROW_G - Grow the current results to snap to the indicated grid.
* CIFOP_GROWMIN - Grow result such that no dimension is less than co_distance.
* CIFOP_SHRINK - Shrink the current results uniformly by co_distance.
* CIFOP_BLOAT - Find layers in paintMask, then bloat selectively
* according to bl_distance, and OR the results into
* the current plane
* CIFOP_SQUARES - Generates a pattern of squares (used for making
* contact vias. Each square is co_distance large,
* the squares are separated from each other by
* co_distance, and they are inside the edge of
* the material by at least co_distance.
* CIFOP_SLOTS - Generate a pattern of rectangles (used for making
* slots and slot vias). Similar to squares except
* for different dimensions in short and long tile
* dimensions. "0" for the long size indicates that
* the slot should extend the length of the tile
* minus the long-side border length.
* CIFOP_BLOATMAX - Like CIFOP_BLOAT, except whole side of tile gets
* bloated by same amount, which is max bloat from
* anywhere along side. Bloats can be negative.
* CIFOP_BLOATMIN - Same as CIFOP_BLOAT, except use min bloat from
* anywhere along side.
* CIFOP_BLOATALL - Added 3/21/05---bloat to encompass all connected
* material of the indicated type(s).
* CIFOP_BBOX - Added 4/2/05---create a single rectangle encompassing
* the cell bounding box. This involves no magic type
* layers but may itself be acted upon with grow/shrink
* rules.
* CIFOP_BOUNDARY - Added 6/5/19---map the FIXED_BBOX property bounding
* box coordinates into CIF layer geometry.
* CIFOP_NET - Added 11/3/08---pull an entire electrical net into
* the CIF layer, selectively picking layers.
* CIFOP_MAXRECT - Reduce all areas to the largest internal fitting
* rectangle.
* CIFOP_COPYUP - Added 5/5/16---make and keep a copy the resulting layer,
* which will be painted into parent cells instead of the
* current cell. This replaces the "fault" method.
* CIFOP_CLOSE - Added 11/25/19---close up areas smaller than indicated
* CIFOP_BRIDGE - Added 6/11/20---Bridge across catecorner gaps
* CIFOP_BRIDGELIM - Added 27/07/20---Bridge across catecorner gaps, but with limiting layers
* CIFOP_MASKHINTS - Added 12/14/20---Add geometry from cell properties, if any.
*/
#define CIFOP_AND 1
#define CIFOP_OR 2
#define CIFOP_GROW 3
#define CIFOP_GROWMIN 4
#define CIFOP_GROW_G 5
#define CIFOP_SHRINK 6
#define CIFOP_BLOAT 7
#define CIFOP_SQUARES 8
#define CIFOP_SLOTS 9
#define CIFOP_BLOATMAX 10
#define CIFOP_BLOATMIN 11
#define CIFOP_BLOATALL 12
#define CIFOP_ANDNOT 13
#define CIFOP_SQUARES_G 14
#define CIFOP_BBOX 15
#define CIFOP_BOUNDARY 16
#define CIFOP_NET 17
#define CIFOP_MAXRECT 18
#define CIFOP_COPYUP 19
#define CIFOP_CLOSE 20
#define CIFOP_BRIDGE 21
#define CIFOP_BRIDGELIM 22
#define CIFOP_MASKHINTS 23
/* Added by Tim 10/21/2004 */
/* The following structure is used to pass information on how to draw
* contact subcell arrays for a specific magic contact tile type. For
* the GDS write routine, the GDS file (FILE *) is passed as the client
* data.
*/
typedef struct cifsquaresinfo
{
SquaresData *csi_squares; /* Information on how to generate squares */
TileType csi_type; /* Magic contact tile type */
ClientData csi_client; /* Used to pass output file info. */
} CIFSquaresInfo;
/* The following data structure contains all the information about
* a particular CIF layer.
*/
typedef struct
{
char *cl_name; /* Name of layer. */
CIFOp *cl_ops; /* List of operations. If NULL, layer is
* determined entirely by cl_initial.
*/
int cl_growDist; /* Largest distance material may move in
* this layer from its original Magic
* position, due to grows. Expressed
* in CIF units. If this layer uses temp
* layers, this distance must include grows
* from the temp layers.
*/
int cl_shrinkDist; /* Same as above, except for shrinks. */
int cl_flags; /* Bunches of flags: see below. */
int cl_calmanum; /* Number (0-63) of this layer for output as
* Calma (GDS-II stream format), or -1 if
* this layer should not be output.
*/
int cl_calmatype; /* Data type (0-63) for Calma output, or -1
* if this layer should not be output.
*/
int min_width; /* the minimum width rule in centi-microns
* for the layer. This is used by Grow Sliver
* to generate drc correct parent slivers
*/
#ifdef THREE_D
int cl_renderStyle; /* Style to render CIF layer with */
float cl_height; /* (rendered) height of CIF layer above substrate */
float cl_thick; /* (rendered) thickness of CIF layer */
#endif
} CIFLayer;
/* The CIFLayer flags are:
*
* CIF_TEMP: Means that this is a temporary layer used to build
* up CIF information. It isn't output in the CIF file.
* CIF_LABEL: This layer is used to generate fixed labels in the
* output file.
*/
#define CIF_TEMP 1
#define CIF_LABEL 2
/* The following data structure describes a complete set of CIF
* layers. The number of CIF layers (MAXCIFLAYERS) must not be
* greater than the number of tile types (TT_MAXTYPES)!!
*/
#define MAXCIFLAYERS (TT_MAXTYPES - 1)
typedef struct cifkeep
{
struct cifkeep *cs_next;
char *cs_name;
} CIFKeep;
typedef struct cifstyle
{
char cs_status; /* Status: Loaded, not loaded, or pending. */
char *cs_name; /* Name used for this kind of CIF. */
int cs_nLayers; /* Number of layers. */
int cs_radius; /* Radius of interaction for hierarchical
* processing (expressed in Magic units).
*/
int cs_stepSize; /* If non-zero, user-specified step size
* for hierarchical processing (in Magic
* units).
*/
int cs_gridLimit; /* The limit of grid scaling. This limits
* the use of "scalegrid" to prevent Magic
* from generating geometry smaller than the
* process minimum grid.
*/
int cs_scaleFactor; /* Number of CIF units per Magic unit.
* CIF units are usually centimicrons, but
* see cs_expander below.
*/
int cs_reducer; /* Reduction factor (used only to reduce
* number of zeroes in CIF files and make
* file more readable). Default of 1.
* Unused for GDS input/output.
*/
int cs_expander; /* cs_scaleFactor / cs_expander = scale in
* centimicrons. Default of 1. Value 10
* means cs_scaleFactor is measured in
* nanometers (millimicrons)
*/
TileTypeBitMask cs_yankLayers;
/* For hierarchical processing, only these
* Magic types need to be yanked.
*/
TileTypeBitMask cs_hierLayers;
/* For hierarchical processing, only these
* CIF layers need to be generated.
*/
int cs_labelLayer[TT_MAXTYPES];
/* Each entry corresponds to one Magic layer,
* and gives index of CIF real layer to use
* for labels attached to this Magic layer.
* -1 means no known CIF layer for this Magic
* layer.
*/
int cs_portLayer[TT_MAXTYPES];
/* Similar to cs_labelLayer, to distinguish
* between output types used for "normal"
* text and those used specifically for ports.
*/
CIFLayer *cs_layers[MAXCIFLAYERS];
/* Describes how to generate each layer.*/
int cs_flags; /* bitmask of boolean-valued output options */
} CIFStyle;
/* values for cs_flags */
#define CWF_PERMISSIVE_LABELS 0x01
#define CWF_GROW_SLIVERS 0x02
#define CWF_ANGSTROMS 0x04
#define CWF_GROW_EUCLIDEAN 0x08
#define CWF_SEE_NO_VENDOR 0x10 /* Hide magic's GDS from vendor cells */
#define CWF_NO_ERRORS 0x20 /* Do not generate error msgs and fdbk */
#define CWF_STRING_LIMIT 0x40 /* Use older Calma format character limit */
/* procedures */
extern bool CIFNameToMask();
extern void CIFGenSubcells();
extern void CIFGenArrays();
extern void CIFGen();
extern void CIFClearPlanes();
extern Plane *CIFGenLayer();
extern void CIFInitCells();
extern int cifHierCopyFunc();
extern int cifHierCopyMaskHints();
extern void CIFLoadStyle();
extern void CIFCopyMaskHints();
/* Shared variables and structures: */
extern Plane *CIFPlanes[]; /* Normal place to store CIF. */
extern CIFKeep *CIFStyleList; /* List of all CIF styles. */
extern CIFStyle *CIFCurStyle; /* Current style being used. */
extern CIFStyle *CIFDRCStyle; /* CIF style for DRC checking (optional) */
extern CellUse *CIFComponentUse; /* Flatten stuff in here if needed. */
extern CellDef *CIFComponentDef; /* Corresponds to CIFComponentUse. */
extern CellUse *CIFDummyUse; /* Used to dummy up a CellUse for a
* def.
*/
/* Valid values of CIFWarningLevel (see cif.h) */
typedef enum {CIF_WARN_DEFAULT, CIF_WARN_NONE, CIF_WARN_ALIGN,
CIF_WARN_LIMIT, CIF_WARN_REDIRECT, CIF_WARN_END} CIFWarningTypes;
/* Statistics counters: */
extern int CIFTileOps;
extern int CIFHierTileOps;
extern int CIFRects;
extern int CIFHierRects;
/* Tables used for painting and erasing CIF. */
extern PaintResultType CIFPaintTable[], CIFEraseTable[];
/* Procedures and variables for reporting errors. */
extern int CIFErrorLayer;
extern CellDef *CIFErrorDef;
extern void CIFError();
/* The following determines the tile type used to hold the CIF
* information on its paint plane.
*/
#define CIF_SOLIDTYPE 1
extern TileTypeBitMask CIFSolidBits;
#endif /* _CIFINT_H */
Reference in New Issue View Git Blame Copy Permalink