/* * database.h -- * * Definitions for the database module. * This file defines everything that is visible to clients * outside the database 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. * * ********************************************************************* * * Needs to include: magic.h, tile.h * * rcsid "$Header: /usr/cvsroot/magic-8.0/database/database.h.in,v 1.8 2010/08/25 17:33:55 tim Exp $" */ #ifndef _MAGIC__DATABASE__DATABASE_H #define _MAGIC__DATABASE__DATABASE_H #ifndef _MAGIC__TILES__TILE_H #include "tiles/tile.h" #endif #ifndef _MAGIC__UTILS__HASH_H #include "utils/hash.h" #endif #ifndef _MAGIC__UTILS__STACK_H #include "utils/stack.h" #endif #ifndef _MAGIC__BPLANE__BPLANE_H #include "bplane/bplane.h" #endif /* ----------------------- Tunable constants -------------------------- */ #define MAXPLANES 64 /* Maximum number of planes per cell */ /* * The "unnamed" cell. * This is visible only within Magic, and just determines the * name by which the initial cell-without-a-name appears. */ #define UNNAMED "(UNNAMED)" /* --------------------- Tile types and masks ------------------------- */ typedef int TileType; /* * Tile types are small integers (currently from 0 to TT_MAXTYPES-1). * They are used in constructing TileTypeBitMask bitmasks with the * operators defined below. A TileTypeBitMask contains one bit for * each possible TileType. * * A negative value of TileType implies an error condition when received * from a routine returning a TileType. Care should be taken to ensure * that a negative TileType is never used to index an array! * * The last TT_RESERVEDTYPES tile types are reserved for use by clients. * Because unsigned chars are used to hold tile types (PaintResultType), * this number should not be increased without changing the definition * of PaintResultType later in this file. * * (Magic v.7.1) Macros are generated by script scripts/makedbh, * with each macro appropriately constructed for the value of * TT_MAXTYPES. * * Each addition of a word to the bitmask increases computation * time on all plane operations in magic! Choose the smallest number * required for the technology files used. The obvious reasonable values * to choose are 96, 192, 256, or 512, corresponding to word array sizes * of 3, 6, 8, and 16, respectively. */ #define TT_MAXTYPES 256 /* See above! */ #define TT_RESERVEDTYPES 2 /* See above! */ /* * Note that the value of 5 for TT_WORDSHIFT effectively requires that * bits-per-word equal 32 or havoc is likely to result. */ #define TT_BPW (8 * sizeof (unsigned int)) #define TT_WORDMASK (TT_BPW - 1) #define TT_WORDSHIFT 5 /* LOG2(TT_BPW) */ #define TT_MASKWORDS ((TT_MAXTYPES + TT_BPW - 1) / TT_BPW) typedef struct { unsigned int tt_words[TT_MASKWORDS]; } TileTypeBitMask; /* * Here's a brief note about how to interpret TileTypeBitMasks: * The default TT_MAXTYPES = 256 translates to 8 words. As an * example, to examine TileTypeBitMask DBConnectTbl[65] * (in this example DBTypeLongNameTbl[65]="metal1"). In gdb, * use "print /x DBConnectTbl[65]" to get: * * $2 = {tt_words = {0x59800000, 0xc8cc22a6, 0x8000003b, 0xff800008, \ * 0x38f, 0x0, 0x0, 0x0}} * * The first word represents types 0-31 (lsb to msb, respectively), * the second work represents types 32-63, and so forth. From this * result we see that metal1 (type 65) connects to types 23, 24, 27, * 28, and 30 (from the 1st word), 33, 34, 37, 39, 41, and so on. * A quick check of DBTypeLongNameTbl[] shows that these types are * ndc, pdc, psc, nsc, and so forth. */ /* * Although some tile types are assigned on a technology-specific basis, * certain types are independent of the technology used, and are * defined below: */ #define TT_SPACE 0 /* Space tile */ #define TT_PAINTBASE 1 /* First non-space type */ #define TT_CHECKPAINT 1 /* DRC -- paint has changed */ #define TT_CHECKSUBCELL 2 /* DRC -- subcells have changed */ #define TT_ERROR_P 3 /* DRC -- paint error */ #define TT_ERROR_S 4 /* DRC -- subcell error */ #define TT_ERROR_PS 5 /* DRC -- */ #define TT_MAGNET 6 /* magnet for interactive router */ #define TT_FENCE 7 /* fence for interactive router */ #define TT_ROTATE 8 /* rotate for interactive router */ #define TT_SELECTBASE TT_MAGNET /* First selectable type */ #define TT_TECHDEPBASE 9 /* First technology-dependent type */ #define TT_DIAGONAL 0x40000000 /* Bit set for non-manhattan tiles */ #define TT_SIDE 0x20000000 /* Temporary bit set: 1 = right */ #define TT_DIRECTION 0x10000000 /* Bit set for tile split direction */ #define TT_LEFTMASK 0x00003fff /* Type for left side of split */ #define TT_RIGHTMASK 0x0fffc000 /* Type for right side of split */ /* Pseudo type signifying unexpanded subcells. Never painted. - Only used in a few places, e.g. TouchingTypes() and mzrouter spacing arrays. */ #define TT_SUBCELL TT_MAXTYPES /* The following type is used in the paint result tables to save space. */ #if TT_MAXTYPES > 256 typedef unsigned short PaintResultType; #else typedef unsigned char PaintResultType; #endif /* Which word in a mask contains the bit for type 't'? */ #define ttWord(t) ((t) >> TT_WORDSHIFT) /* Which bit in the above word is for type 't'? */ #define ttBit(t) ((t) & TT_WORDMASK) /* Mask for above word with only bit 't' set */ #define ttMask(t) ((unsigned int)1 << ttBit(t)) /* Operations for manipulating TileTypeBitMasks */ #define TTMaskSetType(m, t) ((m)->tt_words[ttWord(t)] |= ttMask(t)) #define TTMaskClearType(m, t) ((m)->tt_words[ttWord(t)] &= ~ttMask(t)) #define TTMaskHasType(m, t) (((m)->tt_words[ttWord(t)] & ttMask(t)) != 0) #define TTMaskSetOnlyType(m, t) (TTMaskZero(m), TTMaskSetType(m, t)) /* ---------------------- Planes and masks ---------------------------- */ /* * Plane numbers are also small integers. Certain planes are * technology-specific, but others are always present independent * of the technology used. * * Note that the CELL plane and the DRC_CHECK plane are invisible * as far as normal painting operations are concerned, but that the * DRC_CHECK plane does get written out to the .cad file. * * The following macros are used for converting between plane numbers * and masks of same. */ #if (MAXPLANES <= 32) #define PlaneMask int #else #define PlaneMask dlong #endif #define PlaneNumToMaskBit(p) ((PlaneMask)1 << (p)) #define PlaneMaskHasPlane(m, p) (((m) & PlaneNumToMaskBit(p)) != 0) #define PL_MAXTYPES MAXPLANES /* Maximum number of planes per cell */ #define PL_ROUTER 0 /* Used by the router and plow modules */ #define PL_DRC_CHECK 1 /* DRC plane for CHECK tiles */ #define PL_DRC_ERROR 2 /* DRC plane for ERROR tiles */ #define PL_M_HINT 3 /* magnet hints for irouter */ #define PL_F_HINT 4 /* fence hints for irouter */ #define PL_R_HINT 5 /* rotate hints for irouter */ #define PL_SELECTBASE PL_M_HINT /* First plane with selectable types */ #define PL_TECHDEPBASE 6 /* First technology-dependent plane */ #define PL_PAINTBASE 1 /* Base of paint planes */ /* --------------------------- Labels --------------------------------- */ /* * The body of a tile may have a list of labels associated with it. * Each label contains a location that indicates the point at which the * label is supposed to appear attached. This location must be within * the tile on whose list the label appears. * * Note that structure parts lab_size, lab_rotate, lab_bbox, * and lab_offset are all used only by the outline fonts, when * the value of lab_font is not -1. */ typedef struct label { TileType lab_type; /* Type of material to which this label * is attached. This material, or * other materials that connect it, * must be present everywhere under * the area of the label (Magic * enforces this). If there isn't * any such material, lab_type is * TT_SPACE. */ Rect lab_rect; /* Area of paint to which label is * attached. */ Point lab_corners[4]; /* The four corners of the label. Values * are in (database units / 8), and * indicate the relative distance from * the center of lab_rect. */ Rect lab_bbox; /* Area of the label itself, in surface * coordinates (if font is not -1). This * is derived from lab_corners[] and * cached in lab_bbox; */ int lab_just; /* Justification (GEO_NORTH, etc.) */ signed char lab_font; /* Font used for label. -1 is the default * X11 font; other values are indexes into * the font tables. */ int lab_size; /* Scale of font relative to database, * in (database units / 8) */ short lab_rotate; /* Rotation of label, in degrees */ Point lab_offset; /* Offset relative to origin point, in * units of (database units / 8) */ unsigned short lab_flags; /* Information, especially for * marking port labels */ unsigned int lab_port; /* Port number, if label is a port */ struct label *lab_next; /* Next label in list */ char lab_text[4]; /* Actual text of label. This field * is just a place-holder: the actual * field will be large enough to * contain the label name. This * MUST be the last field in the * structure. */ } Label; /* * Label flags bit fields */ #define PORT_DIR_MASK 0x00000f /* Mask of all port directions */ #define PORT_DIR_NORTH 0x000001 /* Port allows connection to north */ #define PORT_DIR_EAST 0x000002 /* Port allows connection to east */ #define PORT_DIR_SOUTH 0x000004 /* Port allows connection to south */ #define PORT_DIR_WEST 0x000008 /* Port allows connection to west */ #define PORT_CLASS_MASK 0x070 /* Mask of all port classes */ #define PORT_CLASS_DEFAULT 0x000 /* Port takes default class */ #define PORT_CLASS_INPUT 0x010 /* Port is a digital input */ #define PORT_CLASS_OUTPUT 0x020 /* Port is a digital output */ #define PORT_CLASS_TRISTATE 0x030 /* Port is a tri-state output */ #define PORT_CLASS_BIDIRECTIONAL 0x040 /* Port is analog or digital */ /* bidirectional */ #define PORT_CLASS_FEEDTHROUGH 0x050 /* Port touches no active */ /* devices */ #define PORT_USE_MASK 0x0780 /* Mask of all port uses */ #define PORT_USE_DEFAULT 0x0000 /* Port takes default use */ #define PORT_USE_SIGNAL 0x0080 /* Port is a digital signal */ #define PORT_USE_ANALOG 0x0100 /* Port is an analog signal */ #define PORT_USE_POWER 0x0180 /* Port is a power rail */ #define PORT_USE_GROUND 0x0200 /* Port is a ground rail */ #define PORT_USE_CLOCK 0x0280 /* Port is a digital clock */ #define PORT_USE_RESET 0x0300 /* Port is a digital reset */ #define PORT_USE_SCAN 0x0380 /* Port is a digital scan */ #define PORT_USE_TIEOFF 0x0400 /* Port is a tie-off */ #define PORT_SHAPE_MASK 0x1800 /* Mask of all port shapes */ #define PORT_SHAPE_DEFAULT 0x0000 /* Port takes default shape */ #define PORT_SHAPE_ABUT 0x0800 /* Port is an abutment shape */ #define PORT_SHAPE_RING 0x1000 /* Port is a ring shape */ #define PORT_SHAPE_THRU 0x1800 /* Port is a feedthrough shape */ #define PORT_VISITED 0x2000 /* Bit for checking if a port */ /* has been previously visited. */ #define LABEL_STICKY 0x4000 /* Label does not change layers */ #define LABEL_GENERATE 0x8000 /* Auto-generated label */ /* * Macros for dealing with label rectangles. */ #define LABELTOUCHPOINT(p, r) \ ((p)->p_x >= (r)->r_xbot && (p)->p_x <= (r)->r_xtop \ && (p)->p_y >= (r)->r_ybot && (p)->p_y <= (r)->r_ytop) /* ------------------- Cell definitions and uses ---------------------- */ /* * There are two structures used for cells: * * CellDef -- one for the definition of the cell * CellUse -- one for each instantiation of the cell. * * The CellDef is shared by all of the CellUses of that cell. */ typedef struct celldef { unsigned int cd_flags; /* See definitions below */ Rect cd_bbox; /* Bounding box for cell */ Rect cd_extended; /* Bounding box, including labels */ char *cd_file; /* File containing cell definition */ #ifdef FILE_LOCKS int cd_fd; /* File descriptor for obtaining and * holding advisory locks. */ #endif char *cd_name; /* Name of cell */ struct celluse *cd_parents; /* NULL-terminated list of all uses */ BPlane *cd_cellPlane; /* Instance locations */ Plane *cd_planes[MAXPLANES]; /* Tiles */ ClientData cd_client; /* This space for rent */ int cd_timestamp; /* Unique integer identifying last * time that paint, labels, or subcell * placements changed in this def. */ Label *cd_labels; /* Label list for this cell */ Label *cd_lastLabel; /* Last label in list for this cell. */ char *cd_technology; /* Name of technology for this cell * (Not yet used.) */ ClientData cd_props; /* Private data used to maintain * lists of properties. Properties * are name-value pairs and provide * a flexible way of extending the * data that is stored in a CellDef. */ ClientData cd_filler; /* UNUSED */ HashTable cd_idHash; /* Maps cell use ids to cell uses. * Indexed by cell use id; value * is a pointer to the CellUse. */ TileTypeBitMask cd_types; /* Types of tiles in the cell */ } CellDef; /* * Cell definition flags: * CDAVAILABLE means cell has been loaded from disk into main store. * CDMODIFIED means cell has been changed since last write to disk. * This bit applies only to the real contents of the cell (paint, * labels, and subcell placements), and not to hint information * like child bounding box guesses and child timestamps. * CDNOTFOUND means we failed to find the cell on disk once, so * don't give any more error messages about it. * CDINTERNAL means that this cell is used internally by Magic (e.g. * for DRC checking or channel decomposition or selection) and * has nothing to do with the user's layout. Many things don't * apply to internal cells (such as design-rule checking). * CDGETNEWSTAMP means the cell has been modified since the * last time a timestamp was assigned to it, so it needs * to have a new stamp assigned. * CDSTAMPSCHANGED means that a timestamp has changed in one or * more children of this cell. * CDBOXESCHANGED means that bounding boxes of one or more children * have changed. * CDFIXEDBBOX means that this cell has been declared to be a * pre-extracted subcircuit, so the bounding box should not * be altered. * CDNOEDIT means that the cell cannot be edited because its file * is read-only or (if FILE_LOCKS enabled) locked by another user. * CDPROCESSED means that the cell bounding box has been calculated * and should not be calculated again. * CDFLATGDS is set when the "calma flatten" option is chosen and * a cell is small and does not call any instances itself. * The flag is used to identify the cell and remove it after GDS * input processing. * CDFLATTENED is set when a cell marked CDFLATGDS is used. Cells * that are never used are not removed after processing. * CDPROCESSEDGDS is set when the cell read from the GDS stream file * is added to the magic database. The flag is used to identify * whether the cell has been processed when forcing the GDS * stream data to be read in post-order. * CDPRELOADED is similar to CDPROCESSEDGDS but is used in cases * other than forced post-order reading, such as flattening * or flatten-by-name. * CDVENDORGDS indicates that the cell was read from a GDS stream * with the option "gds readonly true". * CDVISITED indicates that at least one instance of the cell was * already output during a file write. * CDDEREFERENCE is a flag indicating that when loading or expanding * children of a cell, the path should be ignored and the cell * path should be searched for the location. * CDFIXEDSTAMP is a flag indicating that the cell has a fixed * timestamp that should not be modified. This should be used * with caution as it messes with the usual timestamp tracking, * but is useful for preparing libraries all cells of which have * the same timestamp value. * CDNOEXTRACT is used by incremental extraction to flag cells that * are up-to-date and do not need to be re-extracted. * CDDONTUSE is used during extraction to flag cells that have no * contents and should be ignored. */ #define CDAVAILABLE 0x00001 #define CDMODIFIED 0x00002 #define CDNOTFOUND 0x00004 #define CDINTERNAL 0x00008 #define CDGETNEWSTAMP 0x00010 #define CDSTAMPSCHANGED 0x00020 #define CDBOXESCHANGED 0x00040 #define CDFIXEDBBOX 0x00080 #define CDNOEDIT 0x00100 #define CDPROCESSED 0x00200 #define CDFLATGDS 0x00400 #define CDFLATTENED 0x00800 #define CDPROCESSEDGDS 0x01000 #define CDPRELOADED 0x02000 #define CDVENDORGDS 0x04000 #define CDVISITED 0x08000 #define CDDEREFERENCE 0x10000 #define CDFIXEDSTAMP 0x20000 #define CDNOEXTRACT 0x40000 #define CDDONTUSE 0x80000 #include "database/arrayinfo.h" /* ArrayInfo */ /* * Since a cell may be used in an orientation different from that * in which it was defined, each cell use contains a transform * that will generate coordinates in the world of the parent from * the coordinates in the world of the child. Cells may also be * arrayed. Note: arraying occurs before the transformation, then * the entire array is transformed. */ typedef struct celluse { /* Binning plane element struct header---must go first! */ void *cu_bpLinks[BP_NUM_LINKS]; /* link fields */ Rect cu_bbox; /* Bounding box of this use, with * arraying taken into account, in * coordinates of the parent def. */ /* End of BPlane header */ Rect cu_extended; /* Bounding box of this use, including * the area of rendered text labels. */ unsigned int cu_expandMask; /* Mask of windows in which this use * is expanded. */ unsigned char cu_flags; /* See definitions below */ Transform cu_transform; /* Transform to parent coordinates */ char *cu_id; /* Unique identifier of this use */ ArrayInfo cu_array; /* Arraying information */ CellDef *cu_def; /* The definition of the cell */ struct celluse *cu_nextuse; /* Next in list of uses of our def, * or NULL for end of list. */ CellDef *cu_parent; /* Cell def containing this use */ ClientData cu_client; /* This space for rent */ } CellUse; /* CellUse flags */ /* CU_LOCKED means that the cell use is locked, and cannot be * moved, copied, edited, rotated, etc. */ #define CU_LOCKED 0x01 /* CU_SELECT_* are used only with the select cell def. They indicate * that the selection has been made via a "select chunk" * or "select net" command, and should be treated accordingly. */ #define CU_SELECT_NET 0x02 #define CU_SELECT_CHUNK 0x04 /* CU_SUB_EXTRACTED is a temporary flag indicating that the substrate * of the use has been extracted and the extraction * does not need to be repeated for this use. */ #define CU_SUB_EXTRACTED 0x08 /* Character prefix used to denote a locked cell use in a .mag file */ #define CULOCKCHAR '*' #define cu_xlo cu_array.ar_xlo #define cu_ylo cu_array.ar_ylo #define cu_xhi cu_array.ar_xhi #define cu_yhi cu_array.ar_yhi #define cu_xsep cu_array.ar_xsep #define cu_ysep cu_array.ar_ysep /* * xMask special values. Note that the usual form of xMask specifies * a single-bit value (1, 2, 4, etc.) representing one window from * which a command originated. Any number that is not a power of 2 * may be used to define a special criterion for determining whether * or not to descend into a cell during a tree search, in routine * DBDescendSubcell(). */ #define CU_DESCEND_ALL 0 /* Descend all subcells */ #define CU_DESCEND_SPECIAL 0x0003 /* Descend marked subcells only */ #define CU_DESCEND_NO_SUBCKT 0x0005 /* Descend no subcircuits */ #define CU_DESCEND_NO_VENDOR 0x0006 /* Descend no vendor-GDS subcells */ #define CU_DESCEND_NO_LOCK 0x0007 /* Descend unlocked subcells only */ #define CU_DESCEND_NONE 0x0009 /* Descend no subcells */ #define CU_DESCEND_PROP_FLAT 0x000a /* Descend by property string "flatten" */ /* * Declare tile type structure for non-manhattan geometry */ typedef struct diagonaltilebody { TileType type_l; TileType type_r; unsigned char split_dir; /* (0 = /, 1 = \) */ } DiagonalTileBody; /* * Structure containing painting information to be passed to the paint * procedure when a diagonal tile is encountered. */ typedef struct diag_info { const PaintResultType *resultTbl; bool dir; bool side; } DiagInfo; /* This would normally go in geometry.h except that it uses TileType. */ /* Used in selOps.c but also passed back to CmdRS.c for select command. */ typedef struct extRectList { TileType r_type; Rect r_r; struct extRectList *r_next; } ExtRectList; /* -------------------- Search context information -------------------- */ /* Search contexts are used in hierarchical searches */ typedef struct { CellUse *scx_use; /* Pointer to cell use currently searched */ int scx_x, scx_y; /* X and Y array elementS if scx_use is array */ Rect scx_area; /* Area searched in scx_use->cu_def coords */ Transform scx_trans; /* Composite transform from coordinates * of the cell use (scx_use) all the way * back to those of the "root" of the * search. */ } SearchContext; /* ------------------- Pathname of a terminal (label) ----------------- */ /* The following structure is used to build hierarchical label names */ typedef struct { char *tp_first; /* Pointer to first character in pathname */ char *tp_next; /* Pointer to next character to be filled in */ char *tp_last; /* Pointer to last available character slot * in pathname. */ } TerminalPath; /* --------------- Contexts for hierarchical tile searches ------------ */ /* * The TreeContext is the glue which holds together the SearchContext * of a given search (which varies depending on where in the search we * happen to be) and the TreeFilter (see below) which does not. */ typedef struct treeContext { SearchContext *tc_scx; /* Search context (varies) */ int tc_plane; /* Current plane of search */ struct treeFilter *tc_filter; /* Constant search criteria */ } TreeContext; /* * The TreeFilter is that portion of the argument to the * filter procedures associated with tree searches that does * not change during the entire search, but serves mainly to * pass the search criteria down to the filter functions. */ typedef struct treeFilter { int (*tf_func)(); /* Client's filter function */ ClientData tf_arg; /* Client's argument to pass to filter */ const TileTypeBitMask *tf_mask; /* Only process tiles with these types */ int tf_xmask; /* Expand mask */ PlaneMask tf_planes; /* Mask of planes which will be visited */ TileType tf_dinfo; /* Info for processing triangular areas */ unsigned char tf_flags; /* Flags to apply to search (see below) */ TerminalPath *tf_tpath; /* Buffer to hold hierarchical label names */ } TreeFilter; /* Definition of tf_flags values */ #define TF_LABEL_DISPLAY 0x01 /* Search for labels using the area * of the label itself */ #define TF_LABEL_ATTACH 0x02 /* Search for labels using the area * of paint to which the label is * attached */ #define TF_LABEL_ATTACH_NOT_NE 0x04 /* Same as above, ignore tile NE corner */ #define TF_LABEL_ATTACH_NOT_NW 0x08 /* Same as above, ignore tile NW corner */ #define TF_LABEL_ATTACH_NOT_SE 0x10 /* Same as above, ignore tile SE corner */ #define TF_LABEL_ATTACH_NOT_SW 0x20 /* Same as above, ignore tile SW corner */ #define TF_LABEL_ATTACH_CORNER 0x3C /* Mask of the four types above */ /* To do: Make the tpath entries dynamically allocated */ #define FLATTERMSIZE 4096 /* Used for generating flattened labels */ /* ------------ Information used in connectivity searches --------------*/ /* The following structure is used to hold several pieces of information * that must be passed through multiple levels of search function. This * structure is used by DBSrConnect, DBTreeCopyConnect, SimTreeCopyConnect, * and DBTreeCopyConnectDCS. */ struct conSrArg { CellDef *csa_def; /* Definition being searched. */ int csa_pNum; /* Index of plane being searched */ const TileTypeBitMask *csa_connect; /* Table indicating what connects * to what. */ int (*csa_clientFunc)(); /* Client function to call. */ ClientData csa_clientData; /* Argument for clientFunc. */ ClientData csa_clientDefault; /* Value to reset tiles' ClientData to. */ bool csa_clear; /* FALSE means pass 1, TRUE * means pass 2. */ Rect csa_bounds; /* Area that limits search. */ }; typedef struct { Rect area; /* Area to process */ const TileTypeBitMask *connectMask; /* Connection mask for search */ TileType dinfo; /* Info about triangular search areas */ } conSrArea; struct conSrArg2 { CellUse *csa2_use; /* Destination use */ const TileTypeBitMask *csa2_connect;/* Table indicating what connects * to what. */ SearchContext *csa2_topscx; /* Original top-level search context */ int csa2_xMask; /* Cell window mask for search */ const Rect *csa2_bounds; /* Area that limits the search */ Stack *csa2_stack; /* Stack of full csa2_list entries */ conSrArea *csa2_list; /* List of areas to process */ int csa2_top; /* Index of next area to process */ int csa2_lasttop; /* Previous top index */ }; #define CSA2_LIST_SIZE 65536 /* Number of entries per list */ /* -------------- Undo information passed to DBPaintPlane ------------- */ typedef struct { CellDef *pu_def; /* Cell definition being modified */ int pu_pNum; /* Index of plane within cell def */ } PaintUndoInfo; /* ---------------------- Codes for paint/erase ----------------------- */ /* The following are obsolete and will go away */ #define ERASE 0 /* Erase type from existing tiles */ #define PAINT 1 /* Paint type over existing tiles */ #define WRITE 2 /* Write type unconditionally */ /* ---------------------- Codes for cell printing ---------------------- */ #define SELF 0 #define PARENTS 1 #define CHILDREN 2 #define CHILDINST 3 #define ALLCELLS 4 #define TOPCELLS 5 #define MODIFIED 6 #define OTHER 7 /* -------------------- More codes for painting ------------------------*/ #define PAINT_NORMAL 0 /* Normal paint procedure */ #define PAINT_MARK 1 /* Mark tiles that are painted */ #define PAINT_XOR 2 /* Use with XOR function to prevent double-painting */ /* -------------------- Exported procedure headers -------------------- */ /* Painting/erasing */ extern void DBPaint(); extern void DBErase(); extern int DBSrPaintArea(); extern int DBPaintPlane0(); extern int DBPaintPlaneActive(); extern int DBPaintPlaneWrapper(); extern int DBPaintPlaneMark(); extern int DBPaintPlaneXor(); extern int DBPaintPlaneByProc(); extern int DBPaintPlaneMergeOnce(); extern void DBPaintMask(); extern void DBEraseMask(); extern void DBClearPaintPlane(); extern void DBLockContact(); extern void DBUnlockContact(); #define DBPaintPlane(a, b, c, d) DBPaintPlane0(a, b, c, d, PAINT_NORMAL) #define DBMergeNMTiles(a, b, c) DBMergeNMTiles0(a, b, c, FALSE) extern int DBNMPaintPlane0(); #define DBNMPaintPlane(a, b, c, d, e) DBNMPaintPlane0(a, b, c, d, e, PAINT_NORMAL) /* I/O */ extern bool DBCellRead(); extern bool DBTestOpen(); extern char *DBGetTech(); extern bool DBCellWrite(); extern CellDef *DBCellReadArea(); extern void DBFileRecovery(); extern bool DBWriteBackup(); extern bool DBReadBackup(); extern void DBRemoveBackup(); extern void DBPathSubstitute(); /* Labels */ extern Label *DBPutLabel(); extern Label *DBPutFontLabel(); extern void DBFontLabelSetBBox(); extern bool DBEraseGlobLabel(); extern bool DBEraseLabel(); extern void DBEraseLabelAll(); extern void DBEraseLabelsByContent(); extern void DBRemoveLabel(); extern void DBReOrientLabel(); extern void DBAdjustLabels(); /* Technology initialization */ extern void DBTechInit(); extern bool DBTechSetTech(); extern void DBTechInitVersion(); extern bool DBTechSetVersion(); extern bool DBTechAddPlane(const char *sectionName, int argc, char *argv[]); extern bool DBTechAddType(); extern bool DBTechAddAlias(); extern void DBTechFinalType(); extern bool DBTechAddConnect(); extern bool DBTechAddContact(); extern bool DBTechAddCompose(); extern TileType DBTechNameType(), DBTechNoisyNameType(); extern int DBTechNamePlane(), DBTechNoisyNamePlane(); extern PlaneMask DBTechNameMask(), DBTechNoisyNameMask(); extern PlaneMask DBTechTypesToPlanes(); extern bool DBTechTypesOnPlane(); extern void DBTechInitPlane(void); extern void DBTypeInit(); extern void DBTechInitType(); extern void DBTechInitCompose(); extern void DBTechFinalCompose(); extern void DBTechInitContact(); extern void DBTechFinalContact(); extern void DBTechFinalConnect(); extern void DBTechInitConnect(); /* Cell symbol table */ extern void DBCellInit(); extern void DBCellPrint(); extern void DBUsePrint(); extern void DBTopPrint(); extern CellDef *DBCellLookDef(); extern CellDef *DBCellNewDef(); extern CellDef *DBCellDefAlloc(); extern bool DBCellRenameDef(); extern bool DBCellDeleteDef(); extern void DBCellDefFree(); extern int DBCellSrDefs(); extern CellUse *DBCellNewUse(); extern bool DBCellDeleteUse(); extern CellUse *DBCellFindDup(); extern void DBLockUse(); extern void DBUnlockUse(); extern void DBOrientUse(); extern void DBAbutmentUse(); /* Cell selection */ extern CellUse *DBSelectCell(); extern CellUse *DBFindUse(); /* Insertion/deletion of cell uses into the cell tile plane of a parent */ extern void DBPlaceCell(); extern void DBPlaceCellNoModify(); extern void DBDeleteCell(); extern void DBDeleteCellNoModify(); extern void DBClearCellPlane(); /* Insertion/deletion of cell uses into the name space of a parent */ extern bool DBLinkCell(); extern void DBUnLinkCell(); /* Deletion of cell defs */ extern void DBUndoReset(); /* Bounding boxes and arrays */ extern bool DBBoundPlane(); extern void DBComputeUseBbox(); extern void DBReComputeBbox(); extern void DBReComputeBboxVert(); extern void DBMakeArray(); extern void DBSetArray(); extern void DBSetTrans(); extern void DBArrayOverlap(); extern void DBComputeArrayArea(); extern Transform *DBGetArrayTransform(); extern char *DBPrintUseId(SearchContext *scx, char *name, int size, bool display_only); /* Massive copying */ extern void DBCellCopyPaint(); extern void DBCellCopyAllPaint(); extern void DBCellCheckCopyAllPaint(); extern void DBCellCopyLabels(); extern void DBCellCopyAllLabels(); extern void DBCellCopyGlobLabels(); extern void DBCellCopyCells(); extern void DBCellCopyAllCells(); extern void DBFlatCopyMaskHints(); extern Plane *DBCellGenerateSubstrate(); extern Plane *DBCellGenerateSimpleSubstrate(); /* Contact image handling */ extern TileType DBPlaneToResidue(); extern TileType DBTechFindStacking(); extern bool DBIsContact(); extern PlaneMask DBLayerPlanes(); extern TileTypeBitMask *DBResidueMask(); extern void DBFullResidueMask(); /* Miscellaneous */ extern void DBCellClearDef(); extern void DBCellCopyDefBody(); extern void DBExpandAll(), DBExpand(); extern bool DBIsAncestor(); extern void DBCellSetAvail(); extern void DBCellClearAvail(); extern bool DBCellGetModified(); extern void DBCellSetModified(); extern void DBFixMismatch(); extern void DBTreeCopyConnect(); extern void DBSeeTypesAll(); extern void DBUpdateStamps(); extern void DBEnumerateTypes(); extern Plane *DBNewPlane(); extern bool DBDescendSubcell(); extern void DBCellCopyMaskHints(); extern void DBFlattenInPlace(); extern void DBCellFlattenAllCells(); extern PaintResultType (*DBNewPaintTable())[TT_MAXTYPES][TT_MAXTYPES]; typedef int (*IntProc)(); IntProc DBNewPaintPlane(); /* Diagnostic */ extern void DBTechPrintTypes(); extern void DBTechPrintCanonicalType(); /* Deallocation */ extern void DBClearCellPlane(); extern void DBClearPaintPlane(); extern void DBFreeCellPlane(); extern void DBFreePaintPlane(); /* Cell properties */ extern void DBPropPut(); extern ClientData DBPropGet(); extern int DBPropEnum(); extern void DBPropClearAll(); /* Searching */ extern int DBTreeSrTiles(); extern int DBTreeSrUniqueTiles(); extern int DBNoTreeSrTiles(); extern int DBTreeSrLabels(); extern int DBTreeSrCells(); extern int DBSrRoots(); extern int DBCellEnum(); extern int DBArraySr(); extern bool DBNearestLabel(); extern int DBSrLabelLoc(); extern TileType DBTransformDiagonal(); extern int dbcUnconnectFunc(Tile *tile, ClientData clientData); /* (notused) */ extern int dbSrConnectFunc(Tile *tile, ClientData clientData); /* (struct conSrArg *csa) */ extern int dbSrConnectStartFunc(Tile *tile, ClientData clientData); /* cb_database_srpaintarea_t (Tile **pTile) */ /* C99 compat */ extern void DBEraseValid(); extern void DBPaintValid(); extern void DBTreeCountPaint(); extern void DBOpenOnly(); extern int DBLoadFont(); extern int DBNameToFont(); extern int DBFontChar(); extern void DBFontInitCurves(); extern void DBUndoEraseLabel(); extern void DBUndoPutLabel(); extern bool DBCellRename(); extern bool DBCellDelete(); extern int DBCellSrArea(); extern int DBSrCellPlaneArea(BPlane *plane, const Rect *rect, int (*func)(), ClientData arg); extern int DBMoveCell(); extern bool DBReLinkCell(); extern int DBBoundCellPlane(); extern Label *DBCheckLabelsByContent(); extern void DBMaskAddStacking(); extern bool DBIsChild(); extern void DBScaleEverything(); extern bool DBScalePoint(); extern int DBScaleCell(); extern TileType DBTechNameTypes(); extern void DBTreeFindUse(); extern void DBGenerateUniqueIds(); extern void DBSelectionUniqueIds(); extern TileType DBInvTransformDiagonal(); extern bool DBIsSubcircuit(); extern int DBSrPaintNMArea(); extern int DBTreeSrNMTiles(); extern void DRCOffGridError(); extern int dbCellUsePrintFunc(); extern int dbTechContactResidues(); extern TileType dbTechNewStackedType(); extern void dbUndoEdit(); extern void DBSplitTile(); extern int DBSrCellUses(); extern TileType DBTechNameTypeExact(); extern void dbInstanceUnplace(); extern int dbIsPrimary(); extern void dbTechMatchResidues(); extern void DBUndoInit(); extern void DBResetTilePlane(); extern void DBNewYank(); extern int DBSrPaintClient(); extern int DBSrConnect(); extern int DBSrConnectOnePlane(); extern char *dbFgets(); extern void DBAdjustLabelsNew(); extern bool DBScaleValue(); extern int DBMergeNMTiles0(); extern int DBSearchLabel(); extern int dbCellUniqueTileSrFunc(); extern void DBWDrawFontLabel(); extern void DBCellCopyManhattanPaint(); extern bool dbScalePlane(); extern int DBPaintPlaneVert(); /* -------------------------- Layer locking ------------------------------*/ extern TileTypeBitMask DBActiveLayerBits; /* Layers that are locked */ extern TileTypeBitMask DBTechActiveLayerBits; /* Layers that are marked as * locked in the techfile */ #define LOCKLAYERCHAR '-' /* Layer names beginning with this are locked */ #define LockedLayer(tiletype) (!TTMaskHasType(&DBActiveLayerBits, tiletype)) /* ---------- Internal units to Lambda conversion factor ---------------- */ extern int DBLambda[2]; /* -------------------- Exported magic file suffix -------------------- */ extern char *DBSuffix; /* Suffix appended to all Magic cell names */ /* -------------------- User Interface Stuff -------------------------- */ extern unsigned char DBVerbose; /* If 0, don't print any messages */ /* If 1, print only error messages */ /* If 2, print errors and warnings */ /* If > 2, print all messages */ #define DB_VERBOSE_NONE 0 #define DB_VERBOSE_ERR 1 #define DB_VERBOSE_WARN 2 #define DB_VERBOSE_ALL 3 /* ------------------ Exported technology variables ------------------- */ /*** *** The following variables should be considered *** read-only to all clients of the database module. ***/ /* Name, version, and description of the current technology */ extern char *DBTechName; extern char *DBTechVersion; extern char *DBTechDescription; /* * Predefined masks of tile types. * The number of built-in types is just TT_TECHDEPBASE. */ extern TileTypeBitMask DBZeroTypeBits; /* All zeroes */ extern TileTypeBitMask DBAllTypeBits; /* All ones */ extern TileTypeBitMask DBBuiltinLayerBits; /* All built-in types */ extern TileTypeBitMask DBAllButSpaceBits; /* All but space */ extern TileTypeBitMask DBAllButSpaceAndDRCBits; /* All but space and drc */ extern TileTypeBitMask DBSpaceBits; /* Space only */ /* * Number of tile types, including those specied by the technology * file and those built-in to Magic, but not including those automatically * generated to represent contact images. Also, a mask of those * types contained in the technology file. */ extern int DBNumUserLayers; extern TileTypeBitMask DBUserLayerBits; /* Including space */ /* Total number of Magic tile types in this technology */ extern int DBNumTypes; /* Total number of tile planes */ extern int DBNumPlanes; /* Abbreviations */ #define NT TT_MAXTYPES #define NP PL_MAXTYPES /* Alias names for groups of types defined in the tech file */ extern HashTable DBTypeAliasTable; /* Gives the official long name of each plane: */ extern const char *DBPlaneLongNameTbl[NP]; /* Gives a short name for each plane: */ extern const char *DBPlaneShortName(); /* Gives for each plane a mask of all tile types stored in that plane: */ extern TileTypeBitMask DBPlaneTypes[NP]; /* Similar to DBPlaneTypes[], but no type appears on more than one plane. * Effectively, the reverse lookup of DBPlane(type) (DBTypePlaneTbl[type]). */ extern TileTypeBitMask DBHomePlaneTypes[NP]; /* Gives a TileTypeBitMask for everything that connects to a type. * Bit x is set in mask DBConnectTbl[y] if any image of x connects * to any image of y. */ extern TileTypeBitMask DBConnectTbl[NT]; /* Complement of above: everything not connected to a type */ extern TileTypeBitMask DBNotConnectTbl[NT]; /* * Gives a TileTypeBitMask of all types that correspond to a given * layer. Used for contacts that have images in more than one * plane. */ extern TileTypeBitMask DBLayerTypeMaskTbl[NT]; /* * Gives a plane mask of all planes that have tiles that connect to * tiles of a given type. This is only used for contacts; it tells * which other planes contain images of the contact. A tile's own * plane is never included in its plane mask. Non-contact types * always have 0 DBConnPlanes entries. */ extern PlaneMask DBConnPlanes[NT]; /* * Similar to DBConnPlanes[], but this time it is non-zero * for those planes to which each type connects, exclusive * of its home plane and those planes to which it connects as a * contact. These planes needn't be adjacent. For example, a * p-well is connected to p-substrate diffusion that overlaps it; * also, p well contacts connect to a p-well. This information * is currently used only in the circuit extractor. */ extern PlaneMask DBAllConnPlanes[NT]; /* * Each TileType has a home plane. The TileType only appears on * its home plane. The only exception is TT_SPACE, which can appear * on any plane. (For debugging, there may be other cases). * * DBTypePlaneTbl gives the home plane for a given TileType, * and DBTypePlaneMaskTbl gives a mask of the planes on which * it appears (all planes for TT_SPACE, one plane for others). */ extern int DBTypePlaneTbl[TT_MAXTYPES]; extern PlaneMask DBTypePlaneMaskTbl[TT_MAXTYPES]; /* Gives the long name for each tile type: */ extern const char *DBTypeLongNameTbl[TT_MAXTYPES]; /* Gives a short name for a tile type: */ extern const char *DBTypeShortName(TileType type); /* * The following give masks of all planes that may be affected * when material of a given type is painted/erased: */ extern PlaneMask DBTypePaintPlanesTbl[TT_MAXTYPES]; extern PlaneMask DBTypeErasePlanesTbl[TT_MAXTYPES]; /* * Gives the resulting tile type when one tile type is painted over * another in a given plane: * * newType = DBPaintResult[pNum][paintType][oldType] */ extern PaintResultType DBPaintResultTbl[NP][NT][NT]; /* * Gives the resulting tile type when one tile type is erased over * another in a given plane: * * newType = DBEraseResult[pNum][paintType][oldType] */ extern PaintResultType DBEraseResultTbl[NP][NT][NT]; /* * A simple table using TT_CHECKPAINT, which does not exist on * paintable planes, to force a paint result that is always a * tiletype that does not exist on the plane. Used for generating * non-Manhattan geometry. */ extern PaintResultType DBSpecialResultTbl[NT]; /* * Gives the resulting tile type when one tile type is 'written' * over a given plane. This corresponds to the case where the * written type replaces the old tile without regard to the type * of the old tile. * * paintType = DBWriteResultTbl[paintType][oldType] */ extern PaintResultType DBWriteResultTbl[NT][NT]; /* --------------------- Exported macros ------------------------------ */ /* * Macros for reading the paint/erase tables: * resultType = DBStdPaintEntry(oldType, paintType, planeNum) * resultType = DBStdEraseEntry(oldType, paintType, planeNum) */ #define DBStdPaintEntry(h,t,p) (DBPaintResultTbl[p][t][h]) #define DBStdEraseEntry(h,t,p) (DBEraseResultTbl[p][t][h]) /* * Macros for constructing the pointer to pass to DBPaintPlane * as the result table. */ #define DBStdPaintTbl(t,p) (&DBPaintResultTbl[p][t][0]) #define DBStdEraseTbl(t,p) (&DBEraseResultTbl[p][t][0]) #define DBStdWriteTbl(t) (&DBWriteResultTbl[t][0]) #define DBSpecialPaintTbl (&DBSpecialResultTbl[0]) /* * int DBPlane(type) TileType type; * Returns the home plane of 'type'. */ #define DBPlane(type) (DBTypePlaneTbl[type]) /* * char *DBTypeLongName(type) TileType type; * Returns the long name of 'type'. */ #define DBTypeLongName(type) (DBTypeLongNameTbl[type]) /* * char *DBPlaneLongName(p) int p; * Returns the long name of plane 'plane'. */ #define DBPlaneLongName(p) (DBPlaneLongNameTbl[p]) /* * bool DBConnectsTo(t1, t2) TileType t1, t2; * Returns TRUE if types 't1' and 't2' are electrically connected. */ #define DBConnectsTo(t1, t2) (TTMaskHasType(&DBConnectTbl[t1], t2)) /* * bool DBTypesOnSamePlane(t1, t2) TileType t1, t2; * Returns TRUE if types 't1' and 't2' exist on the same plane. */ #define DBTypesOnSamePlane(t1, t2) \ (DBTypePlaneMaskTbl[t1] & DBTypePlaneMaskTbl[t2]) /* * bool DBPaintOnPlane(t, p) TileType t; int p; * bool DBEraseOnPlane(t, p) TileType t; int p; * * Return TRUE if tile type 't' has any effect on plane 'p' * when being painted/erased. */ #define DBPaintOnPlane(t, p) (PlaneMaskHasPlane(DBTypePaintPlanesTbl[t], p)) #define DBEraseOnPlane(t, p) (PlaneMaskHasPlane(DBTypeErasePlanesTbl[t], p)) /* * bool DBPaintOnTypePlanes(t1, t2) TileType t1, t2; * bool DBEraseOnTypePlanes(t1, t2) TileType t1, t2; * * Return TRUE if tile type 't1' has any effect on planes defined * for type 't2' when being painted/erased. */ #define DBPaintOnTypePlanes(t1, t2) \ (DBTypePaintPlanesTbl[t1] & DBTypePlaneMaskTbl[t2]) #define DBEraseOnTypePlanes(t1, t2) \ (DBTypePaintPlanesTbl[t1] & DBTypePlaneMaskTbl[t2]) /* * bool DBTypeOnPlane(t, p) TileType t; int p; * Returns TRUE if tile type 't' exists on plane 'p'. */ #define DBTypeOnPlane(t, p) (PlaneMaskHasPlane(DBTypePlaneMaskTbl[t], p)) /* --------- Tile types and masks (auto-generated by makedbh) ------------ */